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 #ifdef HAVE_ZLIB_H
  47 #include <zlib.h>
  48 #endif
  49 #ifdef HAVE_WCHAR_H
  50 #include <wchar.h>
  51 #endif
  52
  53 #if __GNUC__ >= 2
  54 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  55    as this will allow us to read in and parse 64bit and 32bit ELF files.
  56    Only do this if we believe that the compiler can support a 64 bit
  57    data type.  For now we only rely on GCC being able to do this.  */
  58 #define BFD64
  59 #endif
  60
  61 #include "bfd.h"
  62 #include "bucomm.h"
  63 #include "elfcomm.h"
  64 #include "dwarf.h"
  65
  66 #include "elf/common.h"
  67 #include "elf/external.h"
  68 #include "elf/internal.h"
  69
  70
  71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  72    we can obtain the H8 reloc numbers.  We need these for the
  73    get_reloc_size() function.  We include h8.h again after defining
  74    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  75
  76 #include "elf/h8.h"
  77 #undef _ELF_H8_H
  78
  79 /* Undo the effects of #including reloc-macros.h.  */
  80
  81 #undef START_RELOC_NUMBERS
  82 #undef RELOC_NUMBER
  83 #undef FAKE_RELOC
  84 #undef EMPTY_RELOC
  85 #undef END_RELOC_NUMBERS
  86 #undef _RELOC_MACROS_H
  87
  88 /* The following headers use the elf/reloc-macros.h file to
  89    automatically generate relocation recognition functions
  90    such as elf_mips_reloc_type()  */
  91
  92 #define RELOC_MACROS_GEN_FUNC
  93
  94 #include "elf/aarch64.h"
  95 #include "elf/alpha.h"
  96 #include "elf/arc.h"
  97 #include "elf/arm.h"
  98 #include "elf/avr.h"
  99 #include "elf/bfin.h"
 100 #include "elf/cr16.h"
 101 #include "elf/cris.h"
 102 #include "elf/crx.h"
 103 #include "elf/d10v.h"
 104 #include "elf/d30v.h"
 105 #include "elf/dlx.h"
 106 #include "elf/epiphany.h"
 107 #include "elf/fr30.h"
 108 #include "elf/frv.h"
 109 #include "elf/ft32.h"
 110 #include "elf/h8.h"
 111 #include "elf/hppa.h"
 112 #include "elf/i386.h"
 113 #include "elf/i370.h"
 114 #include "elf/i860.h"
 115 #include "elf/i960.h"
 116 #include "elf/ia64.h"
 117 #include "elf/ip2k.h"
 118 #include "elf/lm32.h"
 119 #include "elf/iq2000.h"
 120 #include "elf/m32c.h"
 121 #include "elf/m32r.h"
 122 #include "elf/m68k.h"
 123 #include "elf/m68hc11.h"
 124 #include "elf/mcore.h"
 125 #include "elf/mep.h"
 126 #include "elf/metag.h"
 127 #include "elf/microblaze.h"
 128 #include "elf/mips.h"
 129 #include "elf/mmix.h"
 130 #include "elf/mn10200.h"
 131 #include "elf/mn10300.h"
 132 #include "elf/moxie.h"
 133 #include "elf/mt.h"
 134 #include "elf/msp430.h"
 135 #include "elf/nds32.h"
 136 #include "elf/nios2.h"
 137 #include "elf/or1k.h"
 138 #include "elf/pj.h"
 139 #include "elf/ppc.h"
 140 #include "elf/ppc64.h"
 141 #include "elf/rl78.h"
 142 #include "elf/rx.h"
 143 #include "elf/s390.h"
 144 #include "elf/score.h"
 145 #include "elf/sh.h"
 146 #include "elf/sparc.h"
 147 #include "elf/spu.h"
 148 #include "elf/tic6x.h"
 149 #include "elf/tilegx.h"
 150 #include "elf/tilepro.h"
 151 #include "elf/v850.h"
 152 #include "elf/vax.h"
 153 #include "elf/visium.h"
 154 #include "elf/x86-64.h"
 155 #include "elf/xc16x.h"
 156 #include "elf/xgate.h"
 157 #include "elf/xstormy16.h"
 158 #include "elf/xtensa.h"
 159
 160 #include "getopt.h"
 161 #include "libiberty.h"
 162 #include "safe-ctype.h"
 163 #include "filenames.h"
 164
 165 #ifndef offsetof
 166 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 167 #endif
 168
 169 char * program_name = "readelf";
 170 static unsigned long archive_file_offset;
 171 static unsigned long archive_file_size;
 172 static bfd_size_type current_file_size;
 173 static unsigned long dynamic_addr;
 174 static bfd_size_type dynamic_size;
 175 static size_t dynamic_nent;
 176 static char * dynamic_strings;
 177 static unsigned long dynamic_strings_length;
 178 static char * string_table;
 179 static unsigned long string_table_length;
 180 static unsigned long num_dynamic_syms;
 181 static Elf_Internal_Sym * dynamic_symbols;
 182 static Elf_Internal_Syminfo * dynamic_syminfo;
 183 static unsigned long dynamic_syminfo_offset;
 184 static unsigned int dynamic_syminfo_nent;
 185 static char program_interpreter[PATH_MAX];
 186 static bfd_vma dynamic_info[DT_ENCODING];
 187 static bfd_vma dynamic_info_DT_GNU_HASH;
 188 static bfd_vma version_info[16];
 189 static Elf_Internal_Ehdr elf_header;
 190 static Elf_Internal_Shdr * section_headers;
 191 static Elf_Internal_Phdr * program_headers;
 192 static Elf_Internal_Dyn *  dynamic_section;
 193 static Elf_Internal_Shdr * symtab_shndx_hdr;
 194 static int show_name;
 195 static int do_dynamic;
 196 static int do_syms;
 197 static int do_dyn_syms;
 198 static int do_reloc;
 199 static int do_sections;
 200 static int do_section_groups;
 201 static int do_section_details;
 202 static int do_segments;
 203 static int do_unwind;
 204 static int do_using_dynamic;
 205 static int do_header;
 206 static int do_dump;
 207 static int do_version;
 208 static int do_histogram;
 209 static int do_debugging;
 210 static int do_arch;
 211 static int do_notes;
 212 static int do_archive_index;
 213 static int is_32bit_elf;
 214
 215 struct group_list
 216 {
 217   struct group_list * next;
 218   unsigned int section_index;
 219 };
 220
 221 struct group
 222 {
 223   struct group_list * root;
 224   unsigned int group_index;
 225 };
 226
 227 static size_t group_count;
 228 static struct group * section_groups;
 229 static struct group ** section_headers_groups;
 230
 231
 232 /* Flag bits indicating particular types of dump.  */
 233 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 234 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 235 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 236 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 237 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 238
 239 typedef unsigned char dump_type;
 240
 241 /* A linked list of the section names for which dumps were requested.  */
 242 struct dump_list_entry
 243 {
 244   char * name;
 245   dump_type type;
 246   struct dump_list_entry * next;
 247 };
 248 static struct dump_list_entry * dump_sects_byname;
 249
 250 /* A dynamic array of flags indicating for which sections a dump
 251    has been requested via command line switches.  */
 252 static dump_type *   cmdline_dump_sects = NULL;
 253 static unsigned int  num_cmdline_dump_sects = 0;
 254
 255 /* A dynamic array of flags indicating for which sections a dump of
 256    some kind has been requested.  It is reset on a per-object file
 257    basis and then initialised from the cmdline_dump_sects array,
 258    the results of interpreting the -w switch, and the
 259    dump_sects_byname list.  */
 260 static dump_type *   dump_sects = NULL;
 261 static unsigned int  num_dump_sects = 0;
 262
 263
 264 /* How to print a vma value.  */
 265 typedef enum print_mode
 266 {
 267   HEX,
 268   DEC,
 269   DEC_5,
 270   UNSIGNED,
 271   PREFIX_HEX,
 272   FULL_HEX,
 273   LONG_HEX
 274 }
 275 print_mode;
 276
 277 /* Versioned symbol info.  */
 278 enum versioned_symbol_info
 279 {
 280   symbol_undefined,
 281   symbol_hidden,
 282   symbol_public
 283 };
 284
 285 static const char *get_symbol_version_string
 286   (FILE *file, int is_dynsym, const char *strtab,
 287    unsigned long int strtab_size, unsigned int si,
 288    Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
 289    unsigned short *vna_other);
 290
 291 #define UNKNOWN -1
 292
 293 #define SECTION_NAME(X)                                         \
 294   ((X) == NULL ? _("<none>")                                    \
 295    : string_table == NULL ? _("<no-name>")                      \
 296    : ((X)->sh_name >= string_table_length ? _("<corrupt>")      \
 297   : string_table + (X)->sh_name))
 298
 299 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 300
 301 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 302   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 303    : get_64bit_elf_symbols (file, section, sym_count))
 304
 305 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 306 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 307    already been called and verified that the string exists.  */
 308 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 309
 310 #define REMOVE_ARCH_BITS(ADDR)                  \
 311   do                                            \
 312     {                                           \
 313       if (elf_header.e_machine == EM_ARM)       \
 314         (ADDR) &= ~1;                           \
 315     }                                           \
 316   while (0)
 317 \f
 318 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
 319    the offset of the current archive member, if we are examining an archive.
 320    Put the retrieved data into VAR, if it is not NULL.  Otherwise allocate a buffer
 321    using malloc and fill that.  In either case return the pointer to the start of
 322    the retrieved data or NULL if something went wrong.  If something does go wrong
 323    and REASON is not NULL then emit an error message using REASON as part of the
 324    context.  */
 325
 326 static void *
 327 get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
 328           bfd_size_type nmemb, const char * reason)
 329 {
 330   void * mvar;
 331   bfd_size_type amt = size * nmemb;
 332
 333   if (size == 0 || nmemb == 0)
 334     return NULL;
 335
 336   /* If the size_t type is smaller than the bfd_size_type, eg because
 337      you are building a 32-bit tool on a 64-bit host, then make sure
 338      that when the sizes are cast to (size_t) no information is lost.  */
 339   if (sizeof (size_t) < sizeof (bfd_size_type)
 340       && (   (bfd_size_type) ((size_t) size) != size
 341           || (bfd_size_type) ((size_t) nmemb) != nmemb))
 342     {
 343       if (reason)
 344         error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
 345                (unsigned long long) nmemb, (unsigned long long) size, reason);
 346       return NULL;
 347     }
 348
 349   /* Check for size overflow.  */
 350   if (amt < nmemb)
 351     {
 352       if (reason)
 353         error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
 354                (unsigned long long) nmemb, (unsigned long long) size, reason);
 355       return NULL;
 356     }
 357
 358   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
 359      attempting to allocate memory when the read is bound to fail.  */
 360   if (amt > current_file_size
 361       || offset + archive_file_offset + amt > current_file_size)
 362     {
 363       if (reason)
 364         error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
 365                (unsigned long long) amt, reason);
 366       return NULL;
 367     }
 368
 369   if (fseek (file, archive_file_offset + offset, SEEK_SET))
 370     {
 371       if (reason)
 372         error (_("Unable to seek to 0x%lx for %s\n"),
 373                (unsigned long) archive_file_offset + offset, reason);
 374       return NULL;
 375     }
 376
 377   mvar = var;
 378   if (mvar == NULL)
 379     {
 380       /* Check for overflow.  */
 381       if (nmemb < (~(bfd_size_type) 0 - 1) / size)
 382         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 383         mvar = malloc ((size_t) amt + 1);
 384
 385       if (mvar == NULL)
 386         {
 387           if (reason)
 388             error (_("Out of memory allocating 0x%llx bytes for %s\n"),
 389                    (unsigned long long) amt, reason);
 390           return NULL;
 391         }
 392
 393       ((char *) mvar)[amt] = '\0';
 394     }
 395
 396   if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
 397     {
 398       if (reason)
 399         error (_("Unable to read in 0x%llx bytes of %s\n"),
 400                (unsigned long long) amt, reason);
 401       if (mvar != var)
 402         free (mvar);
 403       return NULL;
 404     }
 405
 406   return mvar;
 407 }
 408
 409 /* Print a VMA value.  */
 410
 411 static int
 412 print_vma (bfd_vma vma, print_mode mode)
 413 {
 414   int nc = 0;
 415
 416   switch (mode)
 417     {
 418     case FULL_HEX:
 419       nc = printf ("0x");
 420       /* Drop through.  */
 421
 422     case LONG_HEX:
 423 #ifdef BFD64
 424       if (is_32bit_elf)
 425         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 426 #endif
 427       printf_vma (vma);
 428       return nc + 16;
 429
 430     case DEC_5:
 431       if (vma <= 99999)
 432         return printf ("%5" BFD_VMA_FMT "d", vma);
 433       /* Drop through.  */
 434
 435     case PREFIX_HEX:
 436       nc = printf ("0x");
 437       /* Drop through.  */
 438
 439     case HEX:
 440       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 441
 442     case DEC:
 443       return printf ("%" BFD_VMA_FMT "d", vma);
 444
 445     case UNSIGNED:
 446       return printf ("%" BFD_VMA_FMT "u", vma);
 447     }
 448   return 0;
 449 }
 450
 451 /* Display a symbol on stdout.  Handles the display of control characters and
 452    multibye characters (assuming the host environment supports them).
 453
 454    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 455
 456    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 457    padding as necessary.
 458
 459    Returns the number of emitted characters.  */
 460
 461 static unsigned int
 462 print_symbol (int width, const char *symbol)
 463 {
 464   bfd_boolean extra_padding = FALSE;
 465   int num_printed = 0;
 466 #ifdef HAVE_MBSTATE_T
 467   mbstate_t state;
 468 #endif
 469   int width_remaining;
 470
 471   if (width < 0)
 472     {
 473       /* Keep the width positive.  This also helps.  */
 474       width = - width;
 475       extra_padding = TRUE;
 476     }
 477   assert (width != 0);
 478
 479   if (do_wide)
 480     /* Set the remaining width to a very large value.
 481        This simplifies the code below.  */
 482     width_remaining = INT_MAX;
 483   else
 484     width_remaining = width;
 485
 486 #ifdef HAVE_MBSTATE_T
 487   /* Initialise the multibyte conversion state.  */
 488   memset (& state, 0, sizeof (state));
 489 #endif
 490
 491   while (width_remaining)
 492     {
 493       size_t  n;
 494       const char c = *symbol++;
 495
 496       if (c == 0)
 497         break;
 498
 499       /* Do not print control characters directly as they can affect terminal
 500          settings.  Such characters usually appear in the names generated
 501          by the assembler for local labels.  */
 502       if (ISCNTRL (c))
 503         {
 504           if (width_remaining < 2)
 505             break;
 506
 507           printf ("^%c", c + 0x40);
 508           width_remaining -= 2;
 509           num_printed += 2;
 510         }
 511       else if (ISPRINT (c))
 512         {
 513           putchar (c);
 514           width_remaining --;
 515           num_printed ++;
 516         }
 517       else
 518         {
 519 #ifdef HAVE_MBSTATE_T
 520           wchar_t w;
 521 #endif
 522           /* Let printf do the hard work of displaying multibyte characters.  */
 523           printf ("%.1s", symbol - 1);
 524           width_remaining --;
 525           num_printed ++;
 526
 527 #ifdef HAVE_MBSTATE_T
 528           /* Try to find out how many bytes made up the character that was
 529              just printed.  Advance the symbol pointer past the bytes that
 530              were displayed.  */
 531           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 532 #else
 533           n = 1;
 534 #endif
 535           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 536             symbol += (n - 1);
 537         }
 538     }
 539
 540   if (extra_padding && num_printed < width)
 541     {
 542       /* Fill in the remaining spaces.  */
 543       printf ("%-*s", width - num_printed, " ");
 544       num_printed = width;
 545     }
 546
 547   return num_printed;
 548 }
 549
 550 /* Returns a pointer to a static buffer containing a  printable version of
 551    the given section's name.  Like print_symbol, except that it does not try
 552    to print multibyte characters, it just interprets them as hex values.  */
 553
 554 static const char *
 555 printable_section_name (Elf_Internal_Shdr * sec)
 556 {
 557 #define MAX_PRINT_SEC_NAME_LEN 128
 558   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 559   const char * name = SECTION_NAME (sec);
 560   char *       buf = sec_name_buf;
 561   char         c;
 562   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 563
 564   while ((c = * name ++) != 0)
 565     {
 566       if (ISCNTRL (c))
 567         {
 568           if (remaining < 2)
 569             break;
 570
 571           * buf ++ = '^';
 572           * buf ++ = c + 0x40;
 573           remaining -= 2;
 574         }
 575       else if (ISPRINT (c))
 576         {
 577           * buf ++ = c;
 578           remaining -= 1;
 579         }
 580       else
 581         {
 582           static char hex[17] = "0123456789ABCDEF";
 583
 584           if (remaining < 4)
 585             break;
 586           * buf ++ = '<';
 587           * buf ++ = hex[(c & 0xf0) >> 4];
 588           * buf ++ = hex[c & 0x0f];
 589           * buf ++ = '>';
 590           remaining -= 4;
 591         }
 592
 593       if (remaining == 0)
 594         break;
 595     }
 596
 597   * buf = 0;
 598   return sec_name_buf;
 599 }
 600
 601 static const char *
 602 printable_section_name_from_index (unsigned long ndx)
 603 {
 604   if (ndx >= elf_header.e_shnum)
 605     return _("<corrupt>");
 606
 607   return printable_section_name (section_headers + ndx);
 608 }
 609
 610 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 611
 612 static Elf_Internal_Shdr *
 613 find_section (const char * name)
 614 {
 615   unsigned int i;
 616
 617   for (i = 0; i < elf_header.e_shnum; i++)
 618     if (streq (SECTION_NAME (section_headers + i), name))
 619       return section_headers + i;
 620
 621   return NULL;
 622 }
 623
 624 /* Return a pointer to a section containing ADDR, or NULL if no such
 625    section exists.  */
 626
 627 static Elf_Internal_Shdr *
 628 find_section_by_address (bfd_vma addr)
 629 {
 630   unsigned int i;
 631
 632   for (i = 0; i < elf_header.e_shnum; i++)
 633     {
 634       Elf_Internal_Shdr *sec = section_headers + i;
 635       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 636         return sec;
 637     }
 638
 639   return NULL;
 640 }
 641
 642 static Elf_Internal_Shdr *
 643 find_section_by_type (unsigned int type)
 644 {
 645   unsigned int i;
 646
 647   for (i = 0; i < elf_header.e_shnum; i++)
 648     {
 649       Elf_Internal_Shdr *sec = section_headers + i;
 650       if (sec->sh_type == type)
 651         return sec;
 652     }
 653
 654   return NULL;
 655 }
 656
 657 /* Return a pointer to section NAME, or NULL if no such section exists,
 658    restricted to the list of sections given in SET.  */
 659
 660 static Elf_Internal_Shdr *
 661 find_section_in_set (const char * name, unsigned int * set)
 662 {
 663   unsigned int i;
 664
 665   if (set != NULL)
 666     {
 667       while ((i = *set++) > 0)
 668         if (streq (SECTION_NAME (section_headers + i), name))
 669           return section_headers + i;
 670     }
 671
 672   return find_section (name);
 673 }
 674
 675 /* Read an unsigned LEB128 encoded value from p.  Set *PLEN to the number of
 676    bytes read.  */
 677
 678 static inline unsigned long
 679 read_uleb128 (unsigned char *data,
 680               unsigned int *length_return,
 681               const unsigned char * const end)
 682 {
 683   return read_leb128 (data, length_return, FALSE, end);
 684 }
 685
 686 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
 687    This OS has so many departures from the ELF standard that we test it at
 688    many places.  */
 689
 690 static inline int
 691 is_ia64_vms (void)
 692 {
 693   return elf_header.e_machine == EM_IA_64
 694     && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 695 }
 696
 697 /* Guess the relocation size commonly used by the specific machines.  */
 698
 699 static int
 700 guess_is_rela (unsigned int e_machine)
 701 {
 702   switch (e_machine)
 703     {
 704       /* Targets that use REL relocations.  */
 705     case EM_386:
 706     case EM_486:
 707     case EM_960:
 708     case EM_ARM:
 709     case EM_D10V:
 710     case EM_CYGNUS_D10V:
 711     case EM_DLX:
 712     case EM_MIPS:
 713     case EM_MIPS_RS3_LE:
 714     case EM_CYGNUS_M32R:
 715     case EM_SCORE:
 716     case EM_XGATE:
 717       return FALSE;
 718
 719       /* Targets that use RELA relocations.  */
 720     case EM_68K:
 721     case EM_860:
 722     case EM_AARCH64:
 723     case EM_ADAPTEVA_EPIPHANY:
 724     case EM_ALPHA:
 725     case EM_ALTERA_NIOS2:
 726     case EM_AVR:
 727     case EM_AVR_OLD:
 728     case EM_BLACKFIN:
 729     case EM_CR16:
 730     case EM_CRIS:
 731     case EM_CRX:
 732     case EM_D30V:
 733     case EM_CYGNUS_D30V:
 734     case EM_FR30:
 735     case EM_FT32:
 736     case EM_CYGNUS_FR30:
 737     case EM_CYGNUS_FRV:
 738     case EM_H8S:
 739     case EM_H8_300:
 740     case EM_H8_300H:
 741     case EM_IA_64:
 742     case EM_IP2K:
 743     case EM_IP2K_OLD:
 744     case EM_IQ2000:
 745     case EM_LATTICEMICO32:
 746     case EM_M32C_OLD:
 747     case EM_M32C:
 748     case EM_M32R:
 749     case EM_MCORE:
 750     case EM_CYGNUS_MEP:
 751     case EM_METAG:
 752     case EM_MMIX:
 753     case EM_MN10200:
 754     case EM_CYGNUS_MN10200:
 755     case EM_MN10300:
 756     case EM_CYGNUS_MN10300:
 757     case EM_MOXIE:
 758     case EM_MSP430:
 759     case EM_MSP430_OLD:
 760     case EM_MT:
 761     case EM_NDS32:
 762     case EM_NIOS32:
 763     case EM_OR1K:
 764     case EM_PPC64:
 765     case EM_PPC:
 766     case EM_RL78:
 767     case EM_RX:
 768     case EM_S390:
 769     case EM_S390_OLD:
 770     case EM_SH:
 771     case EM_SPARC:
 772     case EM_SPARC32PLUS:
 773     case EM_SPARCV9:
 774     case EM_SPU:
 775     case EM_TI_C6000:
 776     case EM_TILEGX:
 777     case EM_TILEPRO:
 778     case EM_V800:
 779     case EM_V850:
 780     case EM_CYGNUS_V850:
 781     case EM_VAX:
 782     case EM_VISIUM:
 783     case EM_X86_64:
 784     case EM_L1OM:
 785     case EM_K1OM:
 786     case EM_XSTORMY16:
 787     case EM_XTENSA:
 788     case EM_XTENSA_OLD:
 789     case EM_MICROBLAZE:
 790     case EM_MICROBLAZE_OLD:
 791       return TRUE;
 792
 793     case EM_68HC05:
 794     case EM_68HC08:
 795     case EM_68HC11:
 796     case EM_68HC16:
 797     case EM_FX66:
 798     case EM_ME16:
 799     case EM_MMA:
 800     case EM_NCPU:
 801     case EM_NDR1:
 802     case EM_PCP:
 803     case EM_ST100:
 804     case EM_ST19:
 805     case EM_ST7:
 806     case EM_ST9PLUS:
 807     case EM_STARCORE:
 808     case EM_SVX:
 809     case EM_TINYJ:
 810     default:
 811       warn (_("Don't know about relocations on this machine architecture\n"));
 812       return FALSE;
 813     }
 814 }
 815
 816 static int
 817 slurp_rela_relocs (FILE * file,
 818                    unsigned long rel_offset,
 819                    unsigned long rel_size,
 820                    Elf_Internal_Rela ** relasp,
 821                    unsigned long * nrelasp)
 822 {
 823   Elf_Internal_Rela * relas;
 824   size_t nrelas;
 825   unsigned int i;
 826
 827   if (is_32bit_elf)
 828     {
 829       Elf32_External_Rela * erelas;
 830
 831       erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
 832                                                  rel_size, _("32-bit relocation data"));
 833       if (!erelas)
 834         return 0;
 835
 836       nrelas = rel_size / sizeof (Elf32_External_Rela);
 837
 838       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 839                                              sizeof (Elf_Internal_Rela));
 840
 841       if (relas == NULL)
 842         {
 843           free (erelas);
 844           error (_("out of memory parsing relocs\n"));
 845           return 0;
 846         }
 847
 848       for (i = 0; i < nrelas; i++)
 849         {
 850           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 851           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 852           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 853         }
 854
 855       free (erelas);
 856     }
 857   else
 858     {
 859       Elf64_External_Rela * erelas;
 860
 861       erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
 862                                                  rel_size, _("64-bit relocation data"));
 863       if (!erelas)
 864         return 0;
 865
 866       nrelas = rel_size / sizeof (Elf64_External_Rela);
 867
 868       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 869                                              sizeof (Elf_Internal_Rela));
 870
 871       if (relas == NULL)
 872         {
 873           free (erelas);
 874           error (_("out of memory parsing relocs\n"));
 875           return 0;
 876         }
 877
 878       for (i = 0; i < nrelas; i++)
 879         {
 880           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 881           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 882           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 883
 884           /* The #ifdef BFD64 below is to prevent a compile time
 885              warning.  We know that if we do not have a 64 bit data
 886              type that we will never execute this code anyway.  */
 887 #ifdef BFD64
 888           if (elf_header.e_machine == EM_MIPS
 889               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 890             {
 891               /* In little-endian objects, r_info isn't really a
 892                  64-bit little-endian value: it has a 32-bit
 893                  little-endian symbol index followed by four
 894                  individual byte fields.  Reorder INFO
 895                  accordingly.  */
 896               bfd_vma inf = relas[i].r_info;
 897               inf = (((inf & 0xffffffff) << 32)
 898                       | ((inf >> 56) & 0xff)
 899                       | ((inf >> 40) & 0xff00)
 900                       | ((inf >> 24) & 0xff0000)
 901                       | ((inf >> 8) & 0xff000000));
 902               relas[i].r_info = inf;
 903             }
 904 #endif /* BFD64 */
 905         }
 906
 907       free (erelas);
 908     }
 909   *relasp = relas;
 910   *nrelasp = nrelas;
 911   return 1;
 912 }
 913
 914 static int
 915 slurp_rel_relocs (FILE * file,
 916                   unsigned long rel_offset,
 917                   unsigned long rel_size,
 918                   Elf_Internal_Rela ** relsp,
 919                   unsigned long * nrelsp)
 920 {
 921   Elf_Internal_Rela * rels;
 922   size_t nrels;
 923   unsigned int i;
 924
 925   if (is_32bit_elf)
 926     {
 927       Elf32_External_Rel * erels;
 928
 929       erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
 930                                                rel_size, _("32-bit relocation data"));
 931       if (!erels)
 932         return 0;
 933
 934       nrels = rel_size / sizeof (Elf32_External_Rel);
 935
 936       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 937
 938       if (rels == NULL)
 939         {
 940           free (erels);
 941           error (_("out of memory parsing relocs\n"));
 942           return 0;
 943         }
 944
 945       for (i = 0; i < nrels; i++)
 946         {
 947           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 948           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 949           rels[i].r_addend = 0;
 950         }
 951
 952       free (erels);
 953     }
 954   else
 955     {
 956       Elf64_External_Rel * erels;
 957
 958       erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
 959                                                rel_size, _("64-bit relocation data"));
 960       if (!erels)
 961         return 0;
 962
 963       nrels = rel_size / sizeof (Elf64_External_Rel);
 964
 965       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 966
 967       if (rels == NULL)
 968         {
 969           free (erels);
 970           error (_("out of memory parsing relocs\n"));
 971           return 0;
 972         }
 973
 974       for (i = 0; i < nrels; i++)
 975         {
 976           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 977           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 978           rels[i].r_addend = 0;
 979
 980           /* The #ifdef BFD64 below is to prevent a compile time
 981              warning.  We know that if we do not have a 64 bit data
 982              type that we will never execute this code anyway.  */
 983 #ifdef BFD64
 984           if (elf_header.e_machine == EM_MIPS
 985               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 986             {
 987               /* In little-endian objects, r_info isn't really a
 988                  64-bit little-endian value: it has a 32-bit
 989                  little-endian symbol index followed by four
 990                  individual byte fields.  Reorder INFO
 991                  accordingly.  */
 992               bfd_vma inf = rels[i].r_info;
 993               inf = (((inf & 0xffffffff) << 32)
 994                      | ((inf >> 56) & 0xff)
 995                      | ((inf >> 40) & 0xff00)
 996                      | ((inf >> 24) & 0xff0000)
 997                      | ((inf >> 8) & 0xff000000));
 998               rels[i].r_info = inf;
 999             }
1000 #endif /* BFD64 */
1001         }
1002
1003       free (erels);
1004     }
1005   *relsp = rels;
1006   *nrelsp = nrels;
1007   return 1;
1008 }
1009
1010 /* Returns the reloc type extracted from the reloc info field.  */
1011
1012 static unsigned int
1013 get_reloc_type (bfd_vma reloc_info)
1014 {
1015   if (is_32bit_elf)
1016     return ELF32_R_TYPE (reloc_info);
1017
1018   switch (elf_header.e_machine)
1019     {
1020     case EM_MIPS:
1021       /* Note: We assume that reloc_info has already been adjusted for us.  */
1022       return ELF64_MIPS_R_TYPE (reloc_info);
1023
1024     case EM_SPARCV9:
1025       return ELF64_R_TYPE_ID (reloc_info);
1026
1027     default:
1028       return ELF64_R_TYPE (reloc_info);
1029     }
1030 }
1031
1032 /* Return the symbol index extracted from the reloc info field.  */
1033
1034 static bfd_vma
1035 get_reloc_symindex (bfd_vma reloc_info)
1036 {
1037   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1038 }
1039
1040 static inline bfd_boolean
1041 uses_msp430x_relocs (void)
1042 {
1043   return
1044     elf_header.e_machine == EM_MSP430 /* Paranoia.  */
1045     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1046     && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1047         /* TI compiler uses ELFOSABI_NONE.  */
1048         || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1049 }
1050
1051 /* Display the contents of the relocation data found at the specified
1052    offset.  */
1053
1054 static void
1055 dump_relocations (FILE * file,
1056                   unsigned long rel_offset,
1057                   unsigned long rel_size,
1058                   Elf_Internal_Sym * symtab,
1059                   unsigned long nsyms,
1060                   char * strtab,
1061                   unsigned long strtablen,
1062                   int is_rela,
1063                   int is_dynsym)
1064 {
1065   unsigned int i;
1066   Elf_Internal_Rela * rels;
1067
1068   if (is_rela == UNKNOWN)
1069     is_rela = guess_is_rela (elf_header.e_machine);
1070
1071   if (is_rela)
1072     {
1073       if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1074         return;
1075     }
1076   else
1077     {
1078       if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1079         return;
1080     }
1081
1082   if (is_32bit_elf)
1083     {
1084       if (is_rela)
1085         {
1086           if (do_wide)
1087             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1088           else
1089             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1090         }
1091       else
1092         {
1093           if (do_wide)
1094             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1095           else
1096             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1097         }
1098     }
1099   else
1100     {
1101       if (is_rela)
1102         {
1103           if (do_wide)
1104             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1105           else
1106             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1107         }
1108       else
1109         {
1110           if (do_wide)
1111             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1112           else
1113             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1114         }
1115     }
1116
1117   for (i = 0; i < rel_size; i++)
1118     {
1119       const char * rtype;
1120       bfd_vma offset;
1121       bfd_vma inf;
1122       bfd_vma symtab_index;
1123       bfd_vma type;
1124
1125       offset = rels[i].r_offset;
1126       inf    = rels[i].r_info;
1127
1128       type = get_reloc_type (inf);
1129       symtab_index = get_reloc_symindex  (inf);
1130
1131       if (is_32bit_elf)
1132         {
1133           printf ("%8.8lx  %8.8lx ",
1134                   (unsigned long) offset & 0xffffffff,
1135                   (unsigned long) inf & 0xffffffff);
1136         }
1137       else
1138         {
1139 #if BFD_HOST_64BIT_LONG
1140           printf (do_wide
1141                   ? "%16.16lx  %16.16lx "
1142                   : "%12.12lx  %12.12lx ",
1143                   offset, inf);
1144 #elif BFD_HOST_64BIT_LONG_LONG
1145 #ifndef __MSVCRT__
1146           printf (do_wide
1147                   ? "%16.16llx  %16.16llx "
1148                   : "%12.12llx  %12.12llx ",
1149                   offset, inf);
1150 #else
1151           printf (do_wide
1152                   ? "%16.16I64x  %16.16I64x "
1153                   : "%12.12I64x  %12.12I64x ",
1154                   offset, inf);
1155 #endif
1156 #else
1157           printf (do_wide
1158                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1159                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1160                   _bfd_int64_high (offset),
1161                   _bfd_int64_low (offset),
1162                   _bfd_int64_high (inf),
1163                   _bfd_int64_low (inf));
1164 #endif
1165         }
1166
1167       switch (elf_header.e_machine)
1168         {
1169         default:
1170           rtype = NULL;
1171           break;
1172
1173         case EM_AARCH64:
1174           rtype = elf_aarch64_reloc_type (type);
1175           break;
1176
1177         case EM_M32R:
1178         case EM_CYGNUS_M32R:
1179           rtype = elf_m32r_reloc_type (type);
1180           break;
1181
1182         case EM_386:
1183         case EM_486:
1184           rtype = elf_i386_reloc_type (type);
1185           break;
1186
1187         case EM_68HC11:
1188         case EM_68HC12:
1189           rtype = elf_m68hc11_reloc_type (type);
1190           break;
1191
1192         case EM_68K:
1193           rtype = elf_m68k_reloc_type (type);
1194           break;
1195
1196         case EM_960:
1197           rtype = elf_i960_reloc_type (type);
1198           break;
1199
1200         case EM_AVR:
1201         case EM_AVR_OLD:
1202           rtype = elf_avr_reloc_type (type);
1203           break;
1204
1205         case EM_OLD_SPARCV9:
1206         case EM_SPARC32PLUS:
1207         case EM_SPARCV9:
1208         case EM_SPARC:
1209           rtype = elf_sparc_reloc_type (type);
1210           break;
1211
1212         case EM_SPU:
1213           rtype = elf_spu_reloc_type (type);
1214           break;
1215
1216         case EM_V800:
1217           rtype = v800_reloc_type (type);
1218           break;
1219         case EM_V850:
1220         case EM_CYGNUS_V850:
1221           rtype = v850_reloc_type (type);
1222           break;
1223
1224         case EM_D10V:
1225         case EM_CYGNUS_D10V:
1226           rtype = elf_d10v_reloc_type (type);
1227           break;
1228
1229         case EM_D30V:
1230         case EM_CYGNUS_D30V:
1231           rtype = elf_d30v_reloc_type (type);
1232           break;
1233
1234         case EM_DLX:
1235           rtype = elf_dlx_reloc_type (type);
1236           break;
1237
1238         case EM_SH:
1239           rtype = elf_sh_reloc_type (type);
1240           break;
1241
1242         case EM_MN10300:
1243         case EM_CYGNUS_MN10300:
1244           rtype = elf_mn10300_reloc_type (type);
1245           break;
1246
1247         case EM_MN10200:
1248         case EM_CYGNUS_MN10200:
1249           rtype = elf_mn10200_reloc_type (type);
1250           break;
1251
1252         case EM_FR30:
1253         case EM_CYGNUS_FR30:
1254           rtype = elf_fr30_reloc_type (type);
1255           break;
1256
1257         case EM_CYGNUS_FRV:
1258           rtype = elf_frv_reloc_type (type);
1259           break;
1260
1261         case EM_FT32:
1262           rtype = elf_ft32_reloc_type (type);
1263           break;
1264
1265         case EM_MCORE:
1266           rtype = elf_mcore_reloc_type (type);
1267           break;
1268
1269         case EM_MMIX:
1270           rtype = elf_mmix_reloc_type (type);
1271           break;
1272
1273         case EM_MOXIE:
1274           rtype = elf_moxie_reloc_type (type);
1275           break;
1276
1277         case EM_MSP430:
1278           if (uses_msp430x_relocs ())
1279             {
1280               rtype = elf_msp430x_reloc_type (type);
1281               break;
1282             }
1283         case EM_MSP430_OLD:
1284           rtype = elf_msp430_reloc_type (type);
1285           break;
1286
1287         case EM_NDS32:
1288           rtype = elf_nds32_reloc_type (type);
1289           break;
1290
1291         case EM_PPC:
1292           rtype = elf_ppc_reloc_type (type);
1293           break;
1294
1295         case EM_PPC64:
1296           rtype = elf_ppc64_reloc_type (type);
1297           break;
1298
1299         case EM_MIPS:
1300         case EM_MIPS_RS3_LE:
1301           rtype = elf_mips_reloc_type (type);
1302           break;
1303
1304         case EM_ALPHA:
1305           rtype = elf_alpha_reloc_type (type);
1306           break;
1307
1308         case EM_ARM:
1309           rtype = elf_arm_reloc_type (type);
1310           break;
1311
1312         case EM_ARC:
1313           rtype = elf_arc_reloc_type (type);
1314           break;
1315
1316         case EM_PARISC:
1317           rtype = elf_hppa_reloc_type (type);
1318           break;
1319
1320         case EM_H8_300:
1321         case EM_H8_300H:
1322         case EM_H8S:
1323           rtype = elf_h8_reloc_type (type);
1324           break;
1325
1326         case EM_OR1K:
1327           rtype = elf_or1k_reloc_type (type);
1328           break;
1329
1330         case EM_PJ:
1331         case EM_PJ_OLD:
1332           rtype = elf_pj_reloc_type (type);
1333           break;
1334         case EM_IA_64:
1335           rtype = elf_ia64_reloc_type (type);
1336           break;
1337
1338         case EM_CRIS:
1339           rtype = elf_cris_reloc_type (type);
1340           break;
1341
1342         case EM_860:
1343           rtype = elf_i860_reloc_type (type);
1344           break;
1345
1346         case EM_X86_64:
1347         case EM_L1OM:
1348         case EM_K1OM:
1349           rtype = elf_x86_64_reloc_type (type);
1350           break;
1351
1352         case EM_S370:
1353           rtype = i370_reloc_type (type);
1354           break;
1355
1356         case EM_S390_OLD:
1357         case EM_S390:
1358           rtype = elf_s390_reloc_type (type);
1359           break;
1360
1361         case EM_SCORE:
1362           rtype = elf_score_reloc_type (type);
1363           break;
1364
1365         case EM_XSTORMY16:
1366           rtype = elf_xstormy16_reloc_type (type);
1367           break;
1368
1369         case EM_CRX:
1370           rtype = elf_crx_reloc_type (type);
1371           break;
1372
1373         case EM_VAX:
1374           rtype = elf_vax_reloc_type (type);
1375           break;
1376
1377         case EM_VISIUM:
1378           rtype = elf_visium_reloc_type (type);
1379           break;
1380
1381         case EM_ADAPTEVA_EPIPHANY:
1382           rtype = elf_epiphany_reloc_type (type);
1383           break;
1384
1385         case EM_IP2K:
1386         case EM_IP2K_OLD:
1387           rtype = elf_ip2k_reloc_type (type);
1388           break;
1389
1390         case EM_IQ2000:
1391           rtype = elf_iq2000_reloc_type (type);
1392           break;
1393
1394         case EM_XTENSA_OLD:
1395         case EM_XTENSA:
1396           rtype = elf_xtensa_reloc_type (type);
1397           break;
1398
1399         case EM_LATTICEMICO32:
1400           rtype = elf_lm32_reloc_type (type);
1401           break;
1402
1403         case EM_M32C_OLD:
1404         case EM_M32C:
1405           rtype = elf_m32c_reloc_type (type);
1406           break;
1407
1408         case EM_MT:
1409           rtype = elf_mt_reloc_type (type);
1410           break;
1411
1412         case EM_BLACKFIN:
1413           rtype = elf_bfin_reloc_type (type);
1414           break;
1415
1416         case EM_CYGNUS_MEP:
1417           rtype = elf_mep_reloc_type (type);
1418           break;
1419
1420         case EM_CR16:
1421           rtype = elf_cr16_reloc_type (type);
1422           break;
1423
1424         case EM_MICROBLAZE:
1425         case EM_MICROBLAZE_OLD:
1426           rtype = elf_microblaze_reloc_type (type);
1427           break;
1428
1429         case EM_RL78:
1430           rtype = elf_rl78_reloc_type (type);
1431           break;
1432
1433         case EM_RX:
1434           rtype = elf_rx_reloc_type (type);
1435           break;
1436
1437         case EM_METAG:
1438           rtype = elf_metag_reloc_type (type);
1439           break;
1440
1441         case EM_XC16X:
1442         case EM_C166:
1443           rtype = elf_xc16x_reloc_type (type);
1444           break;
1445
1446         case EM_TI_C6000:
1447           rtype = elf_tic6x_reloc_type (type);
1448           break;
1449
1450         case EM_TILEGX:
1451           rtype = elf_tilegx_reloc_type (type);
1452           break;
1453
1454         case EM_TILEPRO:
1455           rtype = elf_tilepro_reloc_type (type);
1456           break;
1457
1458         case EM_XGATE:
1459           rtype = elf_xgate_reloc_type (type);
1460           break;
1461
1462         case EM_ALTERA_NIOS2:
1463           rtype = elf_nios2_reloc_type (type);
1464           break;
1465         }
1466
1467       if (rtype == NULL)
1468         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1469       else
1470         printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1471
1472       if (elf_header.e_machine == EM_ALPHA
1473           && rtype != NULL
1474           && streq (rtype, "R_ALPHA_LITUSE")
1475           && is_rela)
1476         {
1477           switch (rels[i].r_addend)
1478             {
1479             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1480             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1481             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1482             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1483             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1484             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1485             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1486             default: rtype = NULL;
1487             }
1488           if (rtype)
1489             printf (" (%s)", rtype);
1490           else
1491             {
1492               putchar (' ');
1493               printf (_("<unknown addend: %lx>"),
1494                       (unsigned long) rels[i].r_addend);
1495             }
1496         }
1497       else if (symtab_index)
1498         {
1499           if (symtab == NULL || symtab_index >= nsyms)
1500             printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1501           else
1502             {
1503               Elf_Internal_Sym * psym;
1504               const char * version_string;
1505               enum versioned_symbol_info sym_info;
1506               unsigned short vna_other;
1507
1508               psym = symtab + symtab_index;
1509
1510               version_string
1511                 = get_symbol_version_string (file, is_dynsym,
1512                                              strtab, strtablen,
1513                                              symtab_index,
1514                                              psym,
1515                                              &sym_info,
1516                                              &vna_other);
1517
1518               printf (" ");
1519
1520               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1521                 {
1522                   const char * name;
1523                   unsigned int len;
1524                   unsigned int width = is_32bit_elf ? 8 : 14;
1525
1526                   /* Relocations against GNU_IFUNC symbols do not use the value
1527                      of the symbol as the address to relocate against.  Instead
1528                      they invoke the function named by the symbol and use its
1529                      result as the address for relocation.
1530
1531                      To indicate this to the user, do not display the value of
1532                      the symbol in the "Symbols's Value" field.  Instead show
1533                      its name followed by () as a hint that the symbol is
1534                      invoked.  */
1535
1536                   if (strtab == NULL
1537                       || psym->st_name == 0
1538                       || psym->st_name >= strtablen)
1539                     name = "??";
1540                   else
1541                     name = strtab + psym->st_name;
1542
1543                   len = print_symbol (width, name);
1544                   if (version_string)
1545                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1546                             version_string);
1547                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1548                 }
1549               else
1550                 {
1551                   print_vma (psym->st_value, LONG_HEX);
1552
1553                   printf (is_32bit_elf ? "   " : " ");
1554                 }
1555
1556               if (psym->st_name == 0)
1557                 {
1558                   const char * sec_name = "<null>";
1559                   char name_buf[40];
1560
1561                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1562                     {
1563                       if (psym->st_shndx < elf_header.e_shnum)
1564                         sec_name = SECTION_NAME (section_headers + psym->st_shndx);
1565                       else if (psym->st_shndx == SHN_ABS)
1566                         sec_name = "ABS";
1567                       else if (psym->st_shndx == SHN_COMMON)
1568                         sec_name = "COMMON";
1569                       else if ((elf_header.e_machine == EM_MIPS
1570                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1571                                || (elf_header.e_machine == EM_TI_C6000
1572                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1573                         sec_name = "SCOMMON";
1574                       else if (elf_header.e_machine == EM_MIPS
1575                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1576                         sec_name = "SUNDEF";
1577                       else if ((elf_header.e_machine == EM_X86_64
1578                                 || elf_header.e_machine == EM_L1OM
1579                                 || elf_header.e_machine == EM_K1OM)
1580                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1581                         sec_name = "LARGE_COMMON";
1582                       else if (elf_header.e_machine == EM_IA_64
1583                                && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1584                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1585                         sec_name = "ANSI_COM";
1586                       else if (is_ia64_vms ()
1587                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1588                         sec_name = "VMS_SYMVEC";
1589                       else
1590                         {
1591                           sprintf (name_buf, "<section 0x%x>",
1592                                    (unsigned int) psym->st_shndx);
1593                           sec_name = name_buf;
1594                         }
1595                     }
1596                   print_symbol (22, sec_name);
1597                 }
1598               else if (strtab == NULL)
1599                 printf (_("<string table index: %3ld>"), psym->st_name);
1600               else if (psym->st_name >= strtablen)
1601                 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1602               else
1603                 {
1604                   print_symbol (22, strtab + psym->st_name);
1605                   if (version_string)
1606                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1607                             version_string);
1608                 }
1609
1610               if (is_rela)
1611                 {
1612                   bfd_signed_vma off = rels[i].r_addend;
1613
1614                   /* PR 17531: file: 2e63226f.  */
1615                   if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
1616                     printf (" + %" BFD_VMA_FMT "x", off);
1617                   else if (off < 0)
1618                     printf (" - %" BFD_VMA_FMT "x", - off);
1619                   else
1620                     printf (" + %" BFD_VMA_FMT "x", off);
1621                 }
1622             }
1623         }
1624       else if (is_rela)
1625         {
1626           bfd_signed_vma off = rels[i].r_addend;
1627
1628           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1629           /* PR 17531: file: 2e63226f.  */
1630           if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
1631             printf ("%" BFD_VMA_FMT "x", off);
1632           else if (off < 0)
1633             printf ("-%" BFD_VMA_FMT "x", - off);
1634           else
1635             printf ("%" BFD_VMA_FMT "x", off);
1636         }
1637
1638       if (elf_header.e_machine == EM_SPARCV9
1639           && rtype != NULL
1640           && streq (rtype, "R_SPARC_OLO10"))
1641         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1642
1643       putchar ('\n');
1644
1645 #ifdef BFD64
1646       if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1647         {
1648           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1649           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1650           const char * rtype2 = elf_mips_reloc_type (type2);
1651           const char * rtype3 = elf_mips_reloc_type (type3);
1652
1653           printf ("                    Type2: ");
1654
1655           if (rtype2 == NULL)
1656             printf (_("unrecognized: %-7lx"),
1657                     (unsigned long) type2 & 0xffffffff);
1658           else
1659             printf ("%-17.17s", rtype2);
1660
1661           printf ("\n                    Type3: ");
1662
1663           if (rtype3 == NULL)
1664             printf (_("unrecognized: %-7lx"),
1665                     (unsigned long) type3 & 0xffffffff);
1666           else
1667             printf ("%-17.17s", rtype3);
1668
1669           putchar ('\n');
1670         }
1671 #endif /* BFD64 */
1672     }
1673
1674   free (rels);
1675 }
1676
1677 static const char *
1678 get_mips_dynamic_type (unsigned long type)
1679 {
1680   switch (type)
1681     {
1682     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1683     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1684     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1685     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1686     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1687     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1688     case DT_MIPS_MSYM: return "MIPS_MSYM";
1689     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1690     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1691     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1692     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1693     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1694     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1695     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1696     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1697     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1698     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1699     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1700     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1701     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1702     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1703     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1704     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1705     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1706     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1707     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1708     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1709     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1710     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1711     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1712     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1713     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1714     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1715     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1716     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1717     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1718     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1719     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1720     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1721     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1722     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1723     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1724     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1725     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1726     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1727     default:
1728       return NULL;
1729     }
1730 }
1731
1732 static const char *
1733 get_sparc64_dynamic_type (unsigned long type)
1734 {
1735   switch (type)
1736     {
1737     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1738     default:
1739       return NULL;
1740     }
1741 }
1742
1743 static const char *
1744 get_ppc_dynamic_type (unsigned long type)
1745 {
1746   switch (type)
1747     {
1748     case DT_PPC_GOT:    return "PPC_GOT";
1749     case DT_PPC_OPT:    return "PPC_OPT";
1750     default:
1751       return NULL;
1752     }
1753 }
1754
1755 static const char *
1756 get_ppc64_dynamic_type (unsigned long type)
1757 {
1758   switch (type)
1759     {
1760     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1761     case DT_PPC64_OPD:    return "PPC64_OPD";
1762     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1763     case DT_PPC64_OPT:    return "PPC64_OPT";
1764     default:
1765       return NULL;
1766     }
1767 }
1768
1769 static const char *
1770 get_parisc_dynamic_type (unsigned long type)
1771 {
1772   switch (type)
1773     {
1774     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1775     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1776     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1777     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1778     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1779     case DT_HP_PREINIT:         return "HP_PREINIT";
1780     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1781     case DT_HP_NEEDED:          return "HP_NEEDED";
1782     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1783     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1784     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1785     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1786     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1787     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1788     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1789     case DT_HP_FILTERED:        return "HP_FILTERED";
1790     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1791     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1792     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1793     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1794     case DT_PLT:                return "PLT";
1795     case DT_PLT_SIZE:           return "PLT_SIZE";
1796     case DT_DLT:                return "DLT";
1797     case DT_DLT_SIZE:           return "DLT_SIZE";
1798     default:
1799       return NULL;
1800     }
1801 }
1802
1803 static const char *
1804 get_ia64_dynamic_type (unsigned long type)
1805 {
1806   switch (type)
1807     {
1808     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1809     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1810     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1811     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1812     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1813     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1814     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1815     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1816     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1817     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1818     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1819     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1820     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1821     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1822     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1823     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1824     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1825     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1826     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1827     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1828     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1829     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1830     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1831     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1832     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1833     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1834     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1835     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1836     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1837     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1838     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1839     default:
1840       return NULL;
1841     }
1842 }
1843
1844 static const char *
1845 get_alpha_dynamic_type (unsigned long type)
1846 {
1847   switch (type)
1848     {
1849     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1850     default:
1851       return NULL;
1852     }
1853 }
1854
1855 static const char *
1856 get_score_dynamic_type (unsigned long type)
1857 {
1858   switch (type)
1859     {
1860     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1861     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1862     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1863     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1864     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1865     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1866     default:
1867       return NULL;
1868     }
1869 }
1870
1871 static const char *
1872 get_tic6x_dynamic_type (unsigned long type)
1873 {
1874   switch (type)
1875     {
1876     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1877     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1878     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
1879     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
1880     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
1881     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
1882     default:
1883       return NULL;
1884     }
1885 }
1886
1887 static const char *
1888 get_nios2_dynamic_type (unsigned long type)
1889 {
1890   switch (type)
1891     {
1892     case DT_NIOS2_GP: return "NIOS2_GP";
1893     default:
1894       return NULL;
1895     }
1896 }
1897
1898 static const char *
1899 get_dynamic_type (unsigned long type)
1900 {
1901   static char buff[64];
1902
1903   switch (type)
1904     {
1905     case DT_NULL:       return "NULL";
1906     case DT_NEEDED:     return "NEEDED";
1907     case DT_PLTRELSZ:   return "PLTRELSZ";
1908     case DT_PLTGOT:     return "PLTGOT";
1909     case DT_HASH:       return "HASH";
1910     case DT_STRTAB:     return "STRTAB";
1911     case DT_SYMTAB:     return "SYMTAB";
1912     case DT_RELA:       return "RELA";
1913     case DT_RELASZ:     return "RELASZ";
1914     case DT_RELAENT:    return "RELAENT";
1915     case DT_STRSZ:      return "STRSZ";
1916     case DT_SYMENT:     return "SYMENT";
1917     case DT_INIT:       return "INIT";
1918     case DT_FINI:       return "FINI";
1919     case DT_SONAME:     return "SONAME";
1920     case DT_RPATH:      return "RPATH";
1921     case DT_SYMBOLIC:   return "SYMBOLIC";
1922     case DT_REL:        return "REL";
1923     case DT_RELSZ:      return "RELSZ";
1924     case DT_RELENT:     return "RELENT";
1925     case DT_PLTREL:     return "PLTREL";
1926     case DT_DEBUG:      return "DEBUG";
1927     case DT_TEXTREL:    return "TEXTREL";
1928     case DT_JMPREL:     return "JMPREL";
1929     case DT_BIND_NOW:   return "BIND_NOW";
1930     case DT_INIT_ARRAY: return "INIT_ARRAY";
1931     case DT_FINI_ARRAY: return "FINI_ARRAY";
1932     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1933     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1934     case DT_RUNPATH:    return "RUNPATH";
1935     case DT_FLAGS:      return "FLAGS";
1936
1937     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1938     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1939
1940     case DT_CHECKSUM:   return "CHECKSUM";
1941     case DT_PLTPADSZ:   return "PLTPADSZ";
1942     case DT_MOVEENT:    return "MOVEENT";
1943     case DT_MOVESZ:     return "MOVESZ";
1944     case DT_FEATURE:    return "FEATURE";
1945     case DT_POSFLAG_1:  return "POSFLAG_1";
1946     case DT_SYMINSZ:    return "SYMINSZ";
1947     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
1948
1949     case DT_ADDRRNGLO:  return "ADDRRNGLO";
1950     case DT_CONFIG:     return "CONFIG";
1951     case DT_DEPAUDIT:   return "DEPAUDIT";
1952     case DT_AUDIT:      return "AUDIT";
1953     case DT_PLTPAD:     return "PLTPAD";
1954     case DT_MOVETAB:    return "MOVETAB";
1955     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
1956
1957     case DT_VERSYM:     return "VERSYM";
1958
1959     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1960     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1961     case DT_RELACOUNT:  return "RELACOUNT";
1962     case DT_RELCOUNT:   return "RELCOUNT";
1963     case DT_FLAGS_1:    return "FLAGS_1";
1964     case DT_VERDEF:     return "VERDEF";
1965     case DT_VERDEFNUM:  return "VERDEFNUM";
1966     case DT_VERNEED:    return "VERNEED";
1967     case DT_VERNEEDNUM: return "VERNEEDNUM";
1968
1969     case DT_AUXILIARY:  return "AUXILIARY";
1970     case DT_USED:       return "USED";
1971     case DT_FILTER:     return "FILTER";
1972
1973     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1974     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1975     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1976     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1977     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1978     case DT_GNU_HASH:   return "GNU_HASH";
1979
1980     default:
1981       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1982         {
1983           const char * result;
1984
1985           switch (elf_header.e_machine)
1986             {
1987             case EM_MIPS:
1988             case EM_MIPS_RS3_LE:
1989               result = get_mips_dynamic_type (type);
1990               break;
1991             case EM_SPARCV9:
1992               result = get_sparc64_dynamic_type (type);
1993               break;
1994             case EM_PPC:
1995               result = get_ppc_dynamic_type (type);
1996               break;
1997             case EM_PPC64:
1998               result = get_ppc64_dynamic_type (type);
1999               break;
2000             case EM_IA_64:
2001               result = get_ia64_dynamic_type (type);
2002               break;
2003             case EM_ALPHA:
2004               result = get_alpha_dynamic_type (type);
2005               break;
2006             case EM_SCORE:
2007               result = get_score_dynamic_type (type);
2008               break;
2009             case EM_TI_C6000:
2010               result = get_tic6x_dynamic_type (type);
2011               break;
2012             case EM_ALTERA_NIOS2:
2013               result = get_nios2_dynamic_type (type);
2014               break;
2015             default:
2016               result = NULL;
2017               break;
2018             }
2019
2020           if (result != NULL)
2021             return result;
2022
2023           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2024         }
2025       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2026                || (elf_header.e_machine == EM_PARISC
2027                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2028         {
2029           const char * result;
2030
2031           switch (elf_header.e_machine)
2032             {
2033             case EM_PARISC:
2034               result = get_parisc_dynamic_type (type);
2035               break;
2036             case EM_IA_64:
2037               result = get_ia64_dynamic_type (type);
2038               break;
2039             default:
2040               result = NULL;
2041               break;
2042             }
2043
2044           if (result != NULL)
2045             return result;
2046
2047           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2048                     type);
2049         }
2050       else
2051         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2052
2053       return buff;
2054     }
2055 }
2056
2057 static char *
2058 get_file_type (unsigned e_type)
2059 {
2060   static char buff[32];
2061
2062   switch (e_type)
2063     {
2064     case ET_NONE:       return _("NONE (None)");
2065     case ET_REL:        return _("REL (Relocatable file)");
2066     case ET_EXEC:       return _("EXEC (Executable file)");
2067     case ET_DYN:        return _("DYN (Shared object file)");
2068     case ET_CORE:       return _("CORE (Core file)");
2069
2070     default:
2071       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2072         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2073       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2074         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2075       else
2076         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2077       return buff;
2078     }
2079 }
2080
2081 static char *
2082 get_machine_name (unsigned e_machine)
2083 {
2084   static char buff[64]; /* XXX */
2085
2086   switch (e_machine)
2087     {
2088     case EM_NONE:               return _("None");
2089     case EM_AARCH64:            return "AArch64";
2090     case EM_M32:                return "WE32100";
2091     case EM_SPARC:              return "Sparc";
2092     case EM_SPU:                return "SPU";
2093     case EM_386:                return "Intel 80386";
2094     case EM_68K:                return "MC68000";
2095     case EM_88K:                return "MC88000";
2096     case EM_486:                return "Intel 80486";
2097     case EM_860:                return "Intel 80860";
2098     case EM_MIPS:               return "MIPS R3000";
2099     case EM_S370:               return "IBM System/370";
2100     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2101     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2102     case EM_PARISC:             return "HPPA";
2103     case EM_PPC_OLD:            return "Power PC (old)";
2104     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2105     case EM_960:                return "Intel 90860";
2106     case EM_PPC:                return "PowerPC";
2107     case EM_PPC64:              return "PowerPC64";
2108     case EM_FR20:               return "Fujitsu FR20";
2109     case EM_FT32:               return "FTDI FT32";
2110     case EM_RH32:               return "TRW RH32";
2111     case EM_MCORE:              return "MCORE";
2112     case EM_ARM:                return "ARM";
2113     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2114     case EM_SH:                 return "Renesas / SuperH SH";
2115     case EM_SPARCV9:            return "Sparc v9";
2116     case EM_TRICORE:            return "Siemens Tricore";
2117     case EM_ARC:                return "ARC";
2118     case EM_H8_300:             return "Renesas H8/300";
2119     case EM_H8_300H:            return "Renesas H8/300H";
2120     case EM_H8S:                return "Renesas H8S";
2121     case EM_H8_500:             return "Renesas H8/500";
2122     case EM_IA_64:              return "Intel IA-64";
2123     case EM_MIPS_X:             return "Stanford MIPS-X";
2124     case EM_COLDFIRE:           return "Motorola Coldfire";
2125     case EM_ALPHA:              return "Alpha";
2126     case EM_CYGNUS_D10V:
2127     case EM_D10V:               return "d10v";
2128     case EM_CYGNUS_D30V:
2129     case EM_D30V:               return "d30v";
2130     case EM_CYGNUS_M32R:
2131     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2132     case EM_CYGNUS_V850:
2133     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2134     case EM_V850:               return "Renesas V850";
2135     case EM_CYGNUS_MN10300:
2136     case EM_MN10300:            return "mn10300";
2137     case EM_CYGNUS_MN10200:
2138     case EM_MN10200:            return "mn10200";
2139     case EM_MOXIE:              return "Moxie";
2140     case EM_CYGNUS_FR30:
2141     case EM_FR30:               return "Fujitsu FR30";
2142     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2143     case EM_PJ_OLD:
2144     case EM_PJ:                 return "picoJava";
2145     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2146     case EM_PCP:                return "Siemens PCP";
2147     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2148     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2149     case EM_STARCORE:           return "Motorola Star*Core processor";
2150     case EM_ME16:               return "Toyota ME16 processor";
2151     case EM_ST100:              return "STMicroelectronics ST100 processor";
2152     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2153     case EM_PDSP:               return "Sony DSP processor";
2154     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2155     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2156     case EM_FX66:               return "Siemens FX66 microcontroller";
2157     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2158     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2159     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2160     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2161     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2162     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2163     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2164     case EM_SVX:                return "Silicon Graphics SVx";
2165     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2166     case EM_VAX:                return "Digital VAX";
2167     case EM_VISIUM:             return "CDS VISIUMcore processor";
2168     case EM_AVR_OLD:
2169     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2170     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2171     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2172     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2173     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2174     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2175     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2176     case EM_PRISM:              return "Vitesse Prism";
2177     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2178     case EM_L1OM:               return "Intel L1OM";
2179     case EM_K1OM:               return "Intel K1OM";
2180     case EM_S390_OLD:
2181     case EM_S390:               return "IBM S/390";
2182     case EM_SCORE:              return "SUNPLUS S+Core";
2183     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2184     case EM_OR1K:               return "OpenRISC 1000";
2185     case EM_ARC_A5:             return "ARC International ARCompact processor";
2186     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2187     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2188     case EM_DLX:                return "OpenDLX";
2189     case EM_IP2K_OLD:
2190     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2191     case EM_IQ2000:             return "Vitesse IQ2000";
2192     case EM_XTENSA_OLD:
2193     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2194     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2195     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2196     case EM_NS32K:              return "National Semiconductor 32000 series";
2197     case EM_TPC:                return "Tenor Network TPC processor";
2198     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2199     case EM_MAX:                return "MAX Processor";
2200     case EM_CR:                 return "National Semiconductor CompactRISC";
2201     case EM_F2MC16:             return "Fujitsu F2MC16";
2202     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2203     case EM_LATTICEMICO32:      return "Lattice Mico32";
2204     case EM_M32C_OLD:
2205     case EM_M32C:               return "Renesas M32c";
2206     case EM_MT:                 return "Morpho Techologies MT processor";
2207     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2208     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2209     case EM_SEP:                return "Sharp embedded microprocessor";
2210     case EM_ARCA:               return "Arca RISC microprocessor";
2211     case EM_UNICORE:            return "Unicore";
2212     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2213     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2214     case EM_NIOS32:             return "Altera Nios";
2215     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2216     case EM_C166:
2217     case EM_XC16X:              return "Infineon Technologies xc16x";
2218     case EM_M16C:               return "Renesas M16C series microprocessors";
2219     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2220     case EM_CE:                 return "Freescale Communication Engine RISC core";
2221     case EM_TSK3000:            return "Altium TSK3000 core";
2222     case EM_RS08:               return "Freescale RS08 embedded processor";
2223     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2224     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2225     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2226     case EM_SE_C17:             return "Seiko Epson C17 family";
2227     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2228     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2229     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2230     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2231     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2232     case EM_R32C:               return "Renesas R32C series microprocessors";
2233     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2234     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2235     case EM_8051:               return "Intel 8051 and variants";
2236     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2237     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2238     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2239     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2240     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2241     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2242     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2243     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2244     case EM_CR16:
2245     case EM_MICROBLAZE:
2246     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2247     case EM_RL78:               return "Renesas RL78";
2248     case EM_RX:                 return "Renesas RX";
2249     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2250     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2251     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2252     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2253     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2254     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor family";
2255     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2256     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2257     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2258     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2259     case EM_CUDA:               return "NVIDIA CUDA architecture";
2260     case EM_XGATE:              return "Motorola XGATE embedded processor";
2261     default:
2262       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2263       return buff;
2264     }
2265 }
2266
2267 static void
2268 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2269 {
2270   unsigned eabi;
2271   int unknown = 0;
2272
2273   eabi = EF_ARM_EABI_VERSION (e_flags);
2274   e_flags &= ~ EF_ARM_EABIMASK;
2275
2276   /* Handle "generic" ARM flags.  */
2277   if (e_flags & EF_ARM_RELEXEC)
2278     {
2279       strcat (buf, ", relocatable executable");
2280       e_flags &= ~ EF_ARM_RELEXEC;
2281     }
2282
2283   if (e_flags & EF_ARM_HASENTRY)
2284     {
2285       strcat (buf, ", has entry point");
2286       e_flags &= ~ EF_ARM_HASENTRY;
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_ARM:
2771           decode_ARM_machine_flags (e_flags, buf);
2772           break;
2773
2774         case EM_AVR:
2775           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2776           break;
2777
2778         case EM_BLACKFIN:
2779           if (e_flags & EF_BFIN_PIC)
2780             strcat (buf, ", PIC");
2781
2782           if (e_flags & EF_BFIN_FDPIC)
2783             strcat (buf, ", FDPIC");
2784
2785           if (e_flags & EF_BFIN_CODE_IN_L1)
2786             strcat (buf, ", code in L1");
2787
2788           if (e_flags & EF_BFIN_DATA_IN_L1)
2789             strcat (buf, ", data in L1");
2790
2791           break;
2792
2793         case EM_CYGNUS_FRV:
2794           switch (e_flags & EF_FRV_CPU_MASK)
2795             {
2796             case EF_FRV_CPU_GENERIC:
2797               break;
2798
2799             default:
2800               strcat (buf, ", fr???");
2801               break;
2802
2803             case EF_FRV_CPU_FR300:
2804               strcat (buf, ", fr300");
2805               break;
2806
2807             case EF_FRV_CPU_FR400:
2808               strcat (buf, ", fr400");
2809               break;
2810             case EF_FRV_CPU_FR405:
2811               strcat (buf, ", fr405");
2812               break;
2813
2814             case EF_FRV_CPU_FR450:
2815               strcat (buf, ", fr450");
2816               break;
2817
2818             case EF_FRV_CPU_FR500:
2819               strcat (buf, ", fr500");
2820               break;
2821             case EF_FRV_CPU_FR550:
2822               strcat (buf, ", fr550");
2823               break;
2824
2825             case EF_FRV_CPU_SIMPLE:
2826               strcat (buf, ", simple");
2827               break;
2828             case EF_FRV_CPU_TOMCAT:
2829               strcat (buf, ", tomcat");
2830               break;
2831             }
2832           break;
2833
2834         case EM_68K:
2835           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2836             strcat (buf, ", m68000");
2837           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2838             strcat (buf, ", cpu32");
2839           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2840             strcat (buf, ", fido_a");
2841           else
2842             {
2843               char const * isa = _("unknown");
2844               char const * mac = _("unknown mac");
2845               char const * additional = NULL;
2846
2847               switch (e_flags & EF_M68K_CF_ISA_MASK)
2848                 {
2849                 case EF_M68K_CF_ISA_A_NODIV:
2850                   isa = "A";
2851                   additional = ", nodiv";
2852                   break;
2853                 case EF_M68K_CF_ISA_A:
2854                   isa = "A";
2855                   break;
2856                 case EF_M68K_CF_ISA_A_PLUS:
2857                   isa = "A+";
2858                   break;
2859                 case EF_M68K_CF_ISA_B_NOUSP:
2860                   isa = "B";
2861                   additional = ", nousp";
2862                   break;
2863                 case EF_M68K_CF_ISA_B:
2864                   isa = "B";
2865                   break;
2866                 case EF_M68K_CF_ISA_C:
2867                   isa = "C";
2868                   break;
2869                 case EF_M68K_CF_ISA_C_NODIV:
2870                   isa = "C";
2871                   additional = ", nodiv";
2872                   break;
2873                 }
2874               strcat (buf, ", cf, isa ");
2875               strcat (buf, isa);
2876               if (additional)
2877                 strcat (buf, additional);
2878               if (e_flags & EF_M68K_CF_FLOAT)
2879                 strcat (buf, ", float");
2880               switch (e_flags & EF_M68K_CF_MAC_MASK)
2881                 {
2882                 case 0:
2883                   mac = NULL;
2884                   break;
2885                 case EF_M68K_CF_MAC:
2886                   mac = "mac";
2887                   break;
2888                 case EF_M68K_CF_EMAC:
2889                   mac = "emac";
2890                   break;
2891                 case EF_M68K_CF_EMAC_B:
2892                   mac = "emac_b";
2893                   break;
2894                 }
2895               if (mac)
2896                 {
2897                   strcat (buf, ", ");
2898                   strcat (buf, mac);
2899                 }
2900             }
2901           break;
2902
2903         case EM_PPC:
2904           if (e_flags & EF_PPC_EMB)
2905             strcat (buf, ", emb");
2906
2907           if (e_flags & EF_PPC_RELOCATABLE)
2908             strcat (buf, _(", relocatable"));
2909
2910           if (e_flags & EF_PPC_RELOCATABLE_LIB)
2911             strcat (buf, _(", relocatable-lib"));
2912           break;
2913
2914         case EM_PPC64:
2915           if (e_flags & EF_PPC64_ABI)
2916             {
2917               char abi[] = ", abiv0";
2918
2919               abi[6] += e_flags & EF_PPC64_ABI;
2920               strcat (buf, abi);
2921             }
2922           break;
2923
2924         case EM_V800:
2925           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2926             strcat (buf, ", RH850 ABI");
2927
2928           if (e_flags & EF_V800_850E3)
2929             strcat (buf, ", V3 architecture");
2930
2931           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2932             strcat (buf, ", FPU not used");
2933
2934           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2935             strcat (buf, ", regmode: COMMON");
2936
2937           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2938             strcat (buf, ", r4 not used");
2939
2940           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2941             strcat (buf, ", r30 not used");
2942
2943           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2944             strcat (buf, ", r5 not used");
2945
2946           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2947             strcat (buf, ", r2 not used");
2948
2949           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2950             {
2951               switch (e_flags & - e_flags)
2952                 {
2953                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2954                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2955                 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2956                 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2957                 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2958                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2959                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2960                 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2961                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2962                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2963                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2964                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2965                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2966                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2967                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2968                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2969                 default: break;
2970                 }
2971             }
2972           break;
2973
2974         case EM_V850:
2975         case EM_CYGNUS_V850:
2976           switch (e_flags & EF_V850_ARCH)
2977             {
2978             case E_V850E3V5_ARCH:
2979               strcat (buf, ", v850e3v5");
2980               break;
2981             case E_V850E2V3_ARCH:
2982               strcat (buf, ", v850e2v3");
2983               break;
2984             case E_V850E2_ARCH:
2985               strcat (buf, ", v850e2");
2986               break;
2987             case E_V850E1_ARCH:
2988               strcat (buf, ", v850e1");
2989               break;
2990             case E_V850E_ARCH:
2991               strcat (buf, ", v850e");
2992               break;
2993             case E_V850_ARCH:
2994               strcat (buf, ", v850");
2995               break;
2996             default:
2997               strcat (buf, _(", unknown v850 architecture variant"));
2998               break;
2999             }
3000           break;
3001
3002         case EM_M32R:
3003         case EM_CYGNUS_M32R:
3004           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3005             strcat (buf, ", m32r");
3006           break;
3007
3008         case EM_MIPS:
3009         case EM_MIPS_RS3_LE:
3010           if (e_flags & EF_MIPS_NOREORDER)
3011             strcat (buf, ", noreorder");
3012
3013           if (e_flags & EF_MIPS_PIC)
3014             strcat (buf, ", pic");
3015
3016           if (e_flags & EF_MIPS_CPIC)
3017             strcat (buf, ", cpic");
3018
3019           if (e_flags & EF_MIPS_UCODE)
3020             strcat (buf, ", ugen_reserved");
3021
3022           if (e_flags & EF_MIPS_ABI2)
3023             strcat (buf, ", abi2");
3024
3025           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3026             strcat (buf, ", odk first");
3027
3028           if (e_flags & EF_MIPS_32BITMODE)
3029             strcat (buf, ", 32bitmode");
3030
3031           if (e_flags & EF_MIPS_NAN2008)
3032             strcat (buf, ", nan2008");
3033
3034           if (e_flags & EF_MIPS_FP64)
3035             strcat (buf, ", fp64");
3036
3037           switch ((e_flags & EF_MIPS_MACH))
3038             {
3039             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3040             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3041             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3042             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3043             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3044             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3045             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3046             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3047             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3048             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3049             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3050             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3051             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3052             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3053             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3054             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3055             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3056             case 0:
3057             /* We simply ignore the field in this case to avoid confusion:
3058                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3059                extension.  */
3060               break;
3061             default: strcat (buf, _(", unknown CPU")); break;
3062             }
3063
3064           switch ((e_flags & EF_MIPS_ABI))
3065             {
3066             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3067             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3068             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3069             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3070             case 0:
3071             /* We simply ignore the field in this case to avoid confusion:
3072                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3073                This means it is likely to be an o32 file, but not for
3074                sure.  */
3075               break;
3076             default: strcat (buf, _(", unknown ABI")); break;
3077             }
3078
3079           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3080             strcat (buf, ", mdmx");
3081
3082           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3083             strcat (buf, ", mips16");
3084
3085           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3086             strcat (buf, ", micromips");
3087
3088           switch ((e_flags & EF_MIPS_ARCH))
3089             {
3090             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3091             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3092             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3093             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3094             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3095             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3096             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3097             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3098             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3099             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3100             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3101             default: strcat (buf, _(", unknown ISA")); break;
3102             }
3103           break;
3104
3105         case EM_NDS32:
3106           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3107           break;
3108
3109         case EM_SH:
3110           switch ((e_flags & EF_SH_MACH_MASK))
3111             {
3112             case EF_SH1: strcat (buf, ", sh1"); break;
3113             case EF_SH2: strcat (buf, ", sh2"); break;
3114             case EF_SH3: strcat (buf, ", sh3"); break;
3115             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3116             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3117             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3118             case EF_SH3E: strcat (buf, ", sh3e"); break;
3119             case EF_SH4: strcat (buf, ", sh4"); break;
3120             case EF_SH5: strcat (buf, ", sh5"); break;
3121             case EF_SH2E: strcat (buf, ", sh2e"); break;
3122             case EF_SH4A: strcat (buf, ", sh4a"); break;
3123             case EF_SH2A: strcat (buf, ", sh2a"); break;
3124             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3125             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3126             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3127             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3128             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3129             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3130             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3131             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3132             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3133             default: strcat (buf, _(", unknown ISA")); break;
3134             }
3135
3136           if (e_flags & EF_SH_PIC)
3137             strcat (buf, ", pic");
3138
3139           if (e_flags & EF_SH_FDPIC)
3140             strcat (buf, ", fdpic");
3141           break;
3142
3143         case EM_OR1K:
3144           if (e_flags & EF_OR1K_NODELAY)
3145             strcat (buf, ", no delay");
3146           break;
3147
3148         case EM_SPARCV9:
3149           if (e_flags & EF_SPARC_32PLUS)
3150             strcat (buf, ", v8+");
3151
3152           if (e_flags & EF_SPARC_SUN_US1)
3153             strcat (buf, ", ultrasparcI");
3154
3155           if (e_flags & EF_SPARC_SUN_US3)
3156             strcat (buf, ", ultrasparcIII");
3157
3158           if (e_flags & EF_SPARC_HAL_R1)
3159             strcat (buf, ", halr1");
3160
3161           if (e_flags & EF_SPARC_LEDATA)
3162             strcat (buf, ", ledata");
3163
3164           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3165             strcat (buf, ", tso");
3166
3167           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3168             strcat (buf, ", pso");
3169
3170           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3171             strcat (buf, ", rmo");
3172           break;
3173
3174         case EM_PARISC:
3175           switch (e_flags & EF_PARISC_ARCH)
3176             {
3177             case EFA_PARISC_1_0:
3178               strcpy (buf, ", PA-RISC 1.0");
3179               break;
3180             case EFA_PARISC_1_1:
3181               strcpy (buf, ", PA-RISC 1.1");
3182               break;
3183             case EFA_PARISC_2_0:
3184               strcpy (buf, ", PA-RISC 2.0");
3185               break;
3186             default:
3187               break;
3188             }
3189           if (e_flags & EF_PARISC_TRAPNIL)
3190             strcat (buf, ", trapnil");
3191           if (e_flags & EF_PARISC_EXT)
3192             strcat (buf, ", ext");
3193           if (e_flags & EF_PARISC_LSB)
3194             strcat (buf, ", lsb");
3195           if (e_flags & EF_PARISC_WIDE)
3196             strcat (buf, ", wide");
3197           if (e_flags & EF_PARISC_NO_KABP)
3198             strcat (buf, ", no kabp");
3199           if (e_flags & EF_PARISC_LAZYSWAP)
3200             strcat (buf, ", lazyswap");
3201           break;
3202
3203         case EM_PJ:
3204         case EM_PJ_OLD:
3205           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3206             strcat (buf, ", new calling convention");
3207
3208           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3209             strcat (buf, ", gnu calling convention");
3210           break;
3211
3212         case EM_IA_64:
3213           if ((e_flags & EF_IA_64_ABI64))
3214             strcat (buf, ", 64-bit");
3215           else
3216             strcat (buf, ", 32-bit");
3217           if ((e_flags & EF_IA_64_REDUCEDFP))
3218             strcat (buf, ", reduced fp model");
3219           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3220             strcat (buf, ", no function descriptors, constant gp");
3221           else if ((e_flags & EF_IA_64_CONS_GP))
3222             strcat (buf, ", constant gp");
3223           if ((e_flags & EF_IA_64_ABSOLUTE))
3224             strcat (buf, ", absolute");
3225           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3226             {
3227               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3228                 strcat (buf, ", vms_linkages");
3229               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3230                 {
3231                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3232                   break;
3233                 case EF_IA_64_VMS_COMCOD_WARNING:
3234                   strcat (buf, ", warning");
3235                   break;
3236                 case EF_IA_64_VMS_COMCOD_ERROR:
3237                   strcat (buf, ", error");
3238                   break;
3239                 case EF_IA_64_VMS_COMCOD_ABORT:
3240                   strcat (buf, ", abort");
3241                   break;
3242                 default:
3243                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3244                         e_flags & EF_IA_64_VMS_COMCOD);
3245                   strcat (buf, ", <unknown>");
3246                 }
3247             }
3248           break;
3249
3250         case EM_VAX:
3251           if ((e_flags & EF_VAX_NONPIC))
3252             strcat (buf, ", non-PIC");
3253           if ((e_flags & EF_VAX_DFLOAT))
3254             strcat (buf, ", D-Float");
3255           if ((e_flags & EF_VAX_GFLOAT))
3256             strcat (buf, ", G-Float");
3257           break;
3258
3259         case EM_VISIUM:
3260           if (e_flags & EF_VISIUM_ARCH_MCM)
3261             strcat (buf, ", mcm");
3262           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3263             strcat (buf, ", mcm24");
3264           if (e_flags & EF_VISIUM_ARCH_GR6)
3265             strcat (buf, ", gr6");
3266           break;
3267
3268         case EM_RL78:
3269           if (e_flags & E_FLAG_RL78_G10)
3270             strcat (buf, ", G10");
3271           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3272             strcat (buf, ", 64-bit doubles");
3273           break;
3274
3275         case EM_RX:
3276           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3277             strcat (buf, ", 64-bit doubles");
3278           if (e_flags & E_FLAG_RX_DSP)
3279             strcat (buf, ", dsp");
3280           if (e_flags & E_FLAG_RX_PID)
3281             strcat (buf, ", pid");
3282           if (e_flags & E_FLAG_RX_ABI)
3283             strcat (buf, ", RX ABI");
3284           break;
3285
3286         case EM_S390:
3287           if (e_flags & EF_S390_HIGH_GPRS)
3288             strcat (buf, ", highgprs");
3289           break;
3290
3291         case EM_TI_C6000:
3292           if ((e_flags & EF_C6000_REL))
3293             strcat (buf, ", relocatable module");
3294           break;
3295
3296         case EM_MSP430:
3297           strcat (buf, _(": architecture variant: "));
3298           switch (e_flags & EF_MSP430_MACH)
3299             {
3300             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3301             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3302             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3303             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3304             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3305             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3306             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3307             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3308             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3309             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3310             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3311             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3312             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3313             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3314             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3315             default:
3316               strcat (buf, _(": unknown")); break;
3317             }
3318
3319           if (e_flags & ~ EF_MSP430_MACH)
3320             strcat (buf, _(": unknown extra flag bits also present"));
3321         }
3322     }
3323
3324   return buf;
3325 }
3326
3327 static const char *
3328 get_osabi_name (unsigned int osabi)
3329 {
3330   static char buff[32];
3331
3332   switch (osabi)
3333     {
3334     case ELFOSABI_NONE:         return "UNIX - System V";
3335     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3336     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3337     case ELFOSABI_GNU:          return "UNIX - GNU";
3338     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3339     case ELFOSABI_AIX:          return "UNIX - AIX";
3340     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3341     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3342     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3343     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3344     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3345     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3346     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3347     case ELFOSABI_AROS:         return "AROS";
3348     case ELFOSABI_FENIXOS:      return "FenixOS";
3349     default:
3350       if (osabi >= 64)
3351         switch (elf_header.e_machine)
3352           {
3353           case EM_ARM:
3354             switch (osabi)
3355               {
3356               case ELFOSABI_ARM:        return "ARM";
3357               default:
3358                 break;
3359               }
3360             break;
3361
3362           case EM_MSP430:
3363           case EM_MSP430_OLD:
3364           case EM_VISIUM:
3365             switch (osabi)
3366               {
3367               case ELFOSABI_STANDALONE: return _("Standalone App");
3368               default:
3369                 break;
3370               }
3371             break;
3372
3373           case EM_TI_C6000:
3374             switch (osabi)
3375               {
3376               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3377               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3378               default:
3379                 break;
3380               }
3381             break;
3382
3383           default:
3384             break;
3385           }
3386       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3387       return buff;
3388     }
3389 }
3390
3391 static const char *
3392 get_aarch64_segment_type (unsigned long type)
3393 {
3394   switch (type)
3395     {
3396     case PT_AARCH64_ARCHEXT:
3397       return "AARCH64_ARCHEXT";
3398     default:
3399       break;
3400     }
3401
3402   return NULL;
3403 }
3404
3405 static const char *
3406 get_arm_segment_type (unsigned long type)
3407 {
3408   switch (type)
3409     {
3410     case PT_ARM_EXIDX:
3411       return "EXIDX";
3412     default:
3413       break;
3414     }
3415
3416   return NULL;
3417 }
3418
3419 static const char *
3420 get_mips_segment_type (unsigned long type)
3421 {
3422   switch (type)
3423     {
3424     case PT_MIPS_REGINFO:
3425       return "REGINFO";
3426     case PT_MIPS_RTPROC:
3427       return "RTPROC";
3428     case PT_MIPS_OPTIONS:
3429       return "OPTIONS";
3430     case PT_MIPS_ABIFLAGS:
3431       return "ABIFLAGS";
3432     default:
3433       break;
3434     }
3435
3436   return NULL;
3437 }
3438
3439 static const char *
3440 get_parisc_segment_type (unsigned long type)
3441 {
3442   switch (type)
3443     {
3444     case PT_HP_TLS:             return "HP_TLS";
3445     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3446     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3447     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3448     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3449     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3450     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3451     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3452     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3453     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3454     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3455     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3456     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3457     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3458     case PT_HP_STACK:           return "HP_STACK";
3459     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3460     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3461     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3462     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3463     default:
3464       break;
3465     }
3466
3467   return NULL;
3468 }
3469
3470 static const char *
3471 get_ia64_segment_type (unsigned long type)
3472 {
3473   switch (type)
3474     {
3475     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3476     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3477     case PT_HP_TLS:             return "HP_TLS";
3478     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3479     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3480     case PT_IA_64_HP_STACK:     return "HP_STACK";
3481     default:
3482       break;
3483     }
3484
3485   return NULL;
3486 }
3487
3488 static const char *
3489 get_tic6x_segment_type (unsigned long type)
3490 {
3491   switch (type)
3492     {
3493     case PT_C6000_PHATTR:       return "C6000_PHATTR";
3494     default:
3495       break;
3496     }
3497
3498   return NULL;
3499 }
3500
3501 static const char *
3502 get_segment_type (unsigned long p_type)
3503 {
3504   static char buff[32];
3505
3506   switch (p_type)
3507     {
3508     case PT_NULL:       return "NULL";
3509     case PT_LOAD:       return "LOAD";
3510     case PT_DYNAMIC:    return "DYNAMIC";
3511     case PT_INTERP:     return "INTERP";
3512     case PT_NOTE:       return "NOTE";
3513     case PT_SHLIB:      return "SHLIB";
3514     case PT_PHDR:       return "PHDR";
3515     case PT_TLS:        return "TLS";
3516
3517     case PT_GNU_EH_FRAME:
3518                         return "GNU_EH_FRAME";
3519     case PT_GNU_STACK:  return "GNU_STACK";
3520     case PT_GNU_RELRO:  return "GNU_RELRO";
3521
3522     default:
3523       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3524         {
3525           const char * result;
3526
3527           switch (elf_header.e_machine)
3528             {
3529             case EM_AARCH64:
3530               result = get_aarch64_segment_type (p_type);
3531               break;
3532             case EM_ARM:
3533               result = get_arm_segment_type (p_type);
3534               break;
3535             case EM_MIPS:
3536             case EM_MIPS_RS3_LE:
3537               result = get_mips_segment_type (p_type);
3538               break;
3539             case EM_PARISC:
3540               result = get_parisc_segment_type (p_type);
3541               break;
3542             case EM_IA_64:
3543               result = get_ia64_segment_type (p_type);
3544               break;
3545             case EM_TI_C6000:
3546               result = get_tic6x_segment_type (p_type);
3547               break;
3548             default:
3549               result = NULL;
3550               break;
3551             }
3552
3553           if (result != NULL)
3554             return result;
3555
3556           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3557         }
3558       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3559         {
3560           const char * result;
3561
3562           switch (elf_header.e_machine)
3563             {
3564             case EM_PARISC:
3565               result = get_parisc_segment_type (p_type);
3566               break;
3567             case EM_IA_64:
3568               result = get_ia64_segment_type (p_type);
3569               break;
3570             default:
3571               result = NULL;
3572               break;
3573             }
3574
3575           if (result != NULL)
3576             return result;
3577
3578           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3579         }
3580       else
3581         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3582
3583       return buff;
3584     }
3585 }
3586
3587 static const char *
3588 get_mips_section_type_name (unsigned int sh_type)
3589 {
3590   switch (sh_type)
3591     {
3592     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3593     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3594     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3595     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3596     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3597     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3598     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3599     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3600     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3601     case SHT_MIPS_RELD:          return "MIPS_RELD";
3602     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3603     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3604     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3605     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3606     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3607     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3608     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3609     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3610     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3611     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3612     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3613     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3614     case SHT_MIPS_LINE:          return "MIPS_LINE";
3615     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3616     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3617     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3618     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3619     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3620     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3621     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3622     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3623     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3624     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3625     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3626     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3627     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3628     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3629     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3630     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3631     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
3632     default:
3633       break;
3634     }
3635   return NULL;
3636 }
3637
3638 static const char *
3639 get_parisc_section_type_name (unsigned int sh_type)
3640 {
3641   switch (sh_type)
3642     {
3643     case SHT_PARISC_EXT:        return "PARISC_EXT";
3644     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
3645     case SHT_PARISC_DOC:        return "PARISC_DOC";
3646     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
3647     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
3648     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
3649     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
3650     default:
3651       break;
3652     }
3653   return NULL;
3654 }
3655
3656 static const char *
3657 get_ia64_section_type_name (unsigned int sh_type)
3658 {
3659   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
3660   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3661     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3662
3663   switch (sh_type)
3664     {
3665     case SHT_IA_64_EXT:                return "IA_64_EXT";
3666     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
3667     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
3668     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
3669     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3670     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
3671     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
3672     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
3673     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
3674     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
3675     default:
3676       break;
3677     }
3678   return NULL;
3679 }
3680
3681 static const char *
3682 get_x86_64_section_type_name (unsigned int sh_type)
3683 {
3684   switch (sh_type)
3685     {
3686     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
3687     default:
3688       break;
3689     }
3690   return NULL;
3691 }
3692
3693 static const char *
3694 get_aarch64_section_type_name (unsigned int sh_type)
3695 {
3696   switch (sh_type)
3697     {
3698     case SHT_AARCH64_ATTRIBUTES:
3699       return "AARCH64_ATTRIBUTES";
3700     default:
3701       break;
3702     }
3703   return NULL;
3704 }
3705
3706 static const char *
3707 get_arm_section_type_name (unsigned int sh_type)
3708 {
3709   switch (sh_type)
3710     {
3711     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
3712     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
3713     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
3714     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
3715     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
3716     default:
3717       break;
3718     }
3719   return NULL;
3720 }
3721
3722 static const char *
3723 get_tic6x_section_type_name (unsigned int sh_type)
3724 {
3725   switch (sh_type)
3726     {
3727     case SHT_C6000_UNWIND:
3728       return "C6000_UNWIND";
3729     case SHT_C6000_PREEMPTMAP:
3730       return "C6000_PREEMPTMAP";
3731     case SHT_C6000_ATTRIBUTES:
3732       return "C6000_ATTRIBUTES";
3733     case SHT_TI_ICODE:
3734       return "TI_ICODE";
3735     case SHT_TI_XREF:
3736       return "TI_XREF";
3737     case SHT_TI_HANDLER:
3738       return "TI_HANDLER";
3739     case SHT_TI_INITINFO:
3740       return "TI_INITINFO";
3741     case SHT_TI_PHATTRS:
3742       return "TI_PHATTRS";
3743     default:
3744       break;
3745     }
3746   return NULL;
3747 }
3748
3749 static const char *
3750 get_msp430x_section_type_name (unsigned int sh_type)
3751 {
3752   switch (sh_type)
3753     {
3754     case SHT_MSP430_SEC_FLAGS:   return "MSP430_SEC_FLAGS";
3755     case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3756     case SHT_MSP430_ATTRIBUTES:  return "MSP430_ATTRIBUTES";
3757     default: return NULL;
3758     }
3759 }
3760
3761 static const char *
3762 get_section_type_name (unsigned int sh_type)
3763 {
3764   static char buff[32];
3765
3766   switch (sh_type)
3767     {
3768     case SHT_NULL:              return "NULL";
3769     case SHT_PROGBITS:          return "PROGBITS";
3770     case SHT_SYMTAB:            return "SYMTAB";
3771     case SHT_STRTAB:            return "STRTAB";
3772     case SHT_RELA:              return "RELA";
3773     case SHT_HASH:              return "HASH";
3774     case SHT_DYNAMIC:           return "DYNAMIC";
3775     case SHT_NOTE:              return "NOTE";
3776     case SHT_NOBITS:            return "NOBITS";
3777     case SHT_REL:               return "REL";
3778     case SHT_SHLIB:             return "SHLIB";
3779     case SHT_DYNSYM:            return "DYNSYM";
3780     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
3781     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
3782     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
3783     case SHT_GNU_HASH:          return "GNU_HASH";
3784     case SHT_GROUP:             return "GROUP";
3785     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
3786     case SHT_GNU_verdef:        return "VERDEF";
3787     case SHT_GNU_verneed:       return "VERNEED";
3788     case SHT_GNU_versym:        return "VERSYM";
3789     case 0x6ffffff0:            return "VERSYM";
3790     case 0x6ffffffc:            return "VERDEF";
3791     case 0x7ffffffd:            return "AUXILIARY";
3792     case 0x7fffffff:            return "FILTER";
3793     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
3794
3795     default:
3796       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3797         {
3798           const char * result;
3799
3800           switch (elf_header.e_machine)
3801             {
3802             case EM_MIPS:
3803             case EM_MIPS_RS3_LE:
3804               result = get_mips_section_type_name (sh_type);
3805               break;
3806             case EM_PARISC:
3807               result = get_parisc_section_type_name (sh_type);
3808               break;
3809             case EM_IA_64:
3810               result = get_ia64_section_type_name (sh_type);
3811               break;
3812             case EM_X86_64:
3813             case EM_L1OM:
3814             case EM_K1OM:
3815               result = get_x86_64_section_type_name (sh_type);
3816               break;
3817             case EM_AARCH64:
3818               result = get_aarch64_section_type_name (sh_type);
3819               break;
3820             case EM_ARM:
3821               result = get_arm_section_type_name (sh_type);
3822               break;
3823             case EM_TI_C6000:
3824               result = get_tic6x_section_type_name (sh_type);
3825               break;
3826             case EM_MSP430:
3827               result = get_msp430x_section_type_name (sh_type);
3828               break;
3829             default:
3830               result = NULL;
3831               break;
3832             }
3833
3834           if (result != NULL)
3835             return result;
3836
3837           sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3838         }
3839       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3840         {
3841           const char * result;
3842
3843           switch (elf_header.e_machine)
3844             {
3845             case EM_IA_64:
3846               result = get_ia64_section_type_name (sh_type);
3847               break;
3848             default:
3849               result = NULL;
3850               break;
3851             }
3852
3853           if (result != NULL)
3854             return result;
3855
3856           sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3857         }
3858       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3859         sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3860       else
3861         /* This message is probably going to be displayed in a 15
3862            character wide field, so put the hex value first.  */
3863         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3864
3865       return buff;
3866     }
3867 }
3868
3869 #define OPTION_DEBUG_DUMP       512
3870 #define OPTION_DYN_SYMS         513
3871 #define OPTION_DWARF_DEPTH      514
3872 #define OPTION_DWARF_START      515
3873 #define OPTION_DWARF_CHECK      516
3874
3875 static struct option options[] =
3876 {
3877   {"all",              no_argument, 0, 'a'},
3878   {"file-header",      no_argument, 0, 'h'},
3879   {"program-headers",  no_argument, 0, 'l'},
3880   {"headers",          no_argument, 0, 'e'},
3881   {"histogram",        no_argument, 0, 'I'},
3882   {"segments",         no_argument, 0, 'l'},
3883   {"sections",         no_argument, 0, 'S'},
3884   {"section-headers",  no_argument, 0, 'S'},
3885   {"section-groups",   no_argument, 0, 'g'},
3886   {"section-details",  no_argument, 0, 't'},
3887   {"full-section-name",no_argument, 0, 'N'},
3888   {"symbols",          no_argument, 0, 's'},
3889   {"syms",             no_argument, 0, 's'},
3890   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
3891   {"relocs",           no_argument, 0, 'r'},
3892   {"notes",            no_argument, 0, 'n'},
3893   {"dynamic",          no_argument, 0, 'd'},
3894   {"arch-specific",    no_argument, 0, 'A'},
3895   {"version-info",     no_argument, 0, 'V'},
3896   {"use-dynamic",      no_argument, 0, 'D'},
3897   {"unwind",           no_argument, 0, 'u'},
3898   {"archive-index",    no_argument, 0, 'c'},
3899   {"hex-dump",         required_argument, 0, 'x'},
3900   {"relocated-dump",   required_argument, 0, 'R'},
3901   {"string-dump",      required_argument, 0, 'p'},
3902 #ifdef SUPPORT_DISASSEMBLY
3903   {"instruction-dump", required_argument, 0, 'i'},
3904 #endif
3905   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
3906
3907   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
3908   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
3909   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
3910
3911   {"version",          no_argument, 0, 'v'},
3912   {"wide",             no_argument, 0, 'W'},
3913   {"help",             no_argument, 0, 'H'},
3914   {0,                  no_argument, 0, 0}
3915 };
3916
3917 static void
3918 usage (FILE * stream)
3919 {
3920   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3921   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3922   fprintf (stream, _(" Options are:\n\
3923   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3924   -h --file-header       Display the ELF file header\n\
3925   -l --program-headers   Display the program headers\n\
3926      --segments          An alias for --program-headers\n\
3927   -S --section-headers   Display the sections' header\n\
3928      --sections          An alias for --section-headers\n\
3929   -g --section-groups    Display the section groups\n\
3930   -t --section-details   Display the section details\n\
3931   -e --headers           Equivalent to: -h -l -S\n\
3932   -s --syms              Display the symbol table\n\
3933      --symbols           An alias for --syms\n\
3934   --dyn-syms             Display the dynamic symbol table\n\
3935   -n --notes             Display the core notes (if present)\n\
3936   -r --relocs            Display the relocations (if present)\n\
3937   -u --unwind            Display the unwind info (if present)\n\
3938   -d --dynamic           Display the dynamic section (if present)\n\
3939   -V --version-info      Display the version sections (if present)\n\
3940   -A --arch-specific     Display architecture specific information (if any)\n\
3941   -c --archive-index     Display the symbol/file index in an archive\n\
3942   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
3943   -x --hex-dump=<number|name>\n\
3944                          Dump the contents of section <number|name> as bytes\n\
3945   -p --string-dump=<number|name>\n\
3946                          Dump the contents of section <number|name> as strings\n\
3947   -R --relocated-dump=<number|name>\n\
3948                          Dump the contents of section <number|name> as relocated bytes\n\
3949   -w[lLiaprmfFsoRt] or\n\
3950   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3951                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3952                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3953                =addr,=cu_index]\n\
3954                          Display the contents of DWARF2 debug sections\n"));
3955   fprintf (stream, _("\
3956   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
3957   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
3958                          or deeper\n"));
3959 #ifdef SUPPORT_DISASSEMBLY
3960   fprintf (stream, _("\
3961   -i --instruction-dump=<number|name>\n\
3962                          Disassemble the contents of section <number|name>\n"));
3963 #endif
3964   fprintf (stream, _("\
3965   -I --histogram         Display histogram of bucket list lengths\n\
3966   -W --wide              Allow output width to exceed 80 characters\n\
3967   @<file>                Read options from <file>\n\
3968   -H --help              Display this information\n\
3969   -v --version           Display the version number of readelf\n"));
3970
3971   if (REPORT_BUGS_TO[0] && stream == stdout)
3972     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3973
3974   exit (stream == stdout ? 0 : 1);
3975 }
3976
3977 /* Record the fact that the user wants the contents of section number
3978    SECTION to be displayed using the method(s) encoded as flags bits
3979    in TYPE.  Note, TYPE can be zero if we are creating the array for
3980    the first time.  */
3981
3982 static void
3983 request_dump_bynumber (unsigned int section, dump_type type)
3984 {
3985   if (section >= num_dump_sects)
3986     {
3987       dump_type * new_dump_sects;
3988
3989       new_dump_sects = (dump_type *) calloc (section + 1,
3990                                              sizeof (* dump_sects));
3991
3992       if (new_dump_sects == NULL)
3993         error (_("Out of memory allocating dump request table.\n"));
3994       else
3995         {
3996           /* Copy current flag settings.  */
3997           memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3998
3999           free (dump_sects);
4000
4001           dump_sects = new_dump_sects;
4002           num_dump_sects = section + 1;
4003         }
4004     }
4005
4006   if (dump_sects)
4007     dump_sects[section] |= type;
4008
4009   return;
4010 }
4011
4012 /* Request a dump by section name.  */
4013
4014 static void
4015 request_dump_byname (const char * section, dump_type type)
4016 {
4017   struct dump_list_entry * new_request;
4018
4019   new_request = (struct dump_list_entry *)
4020       malloc (sizeof (struct dump_list_entry));
4021   if (!new_request)
4022     error (_("Out of memory allocating dump request table.\n"));
4023
4024   new_request->name = strdup (section);
4025   if (!new_request->name)
4026     error (_("Out of memory allocating dump request table.\n"));
4027
4028   new_request->type = type;
4029
4030   new_request->next = dump_sects_byname;
4031   dump_sects_byname = new_request;
4032 }
4033
4034 static inline void
4035 request_dump (dump_type type)
4036 {
4037   int section;
4038   char * cp;
4039
4040   do_dump++;
4041   section = strtoul (optarg, & cp, 0);
4042
4043   if (! *cp && section >= 0)
4044     request_dump_bynumber (section, type);
4045   else
4046     request_dump_byname (optarg, type);
4047 }
4048
4049
4050 static void
4051 parse_args (int argc, char ** argv)
4052 {
4053   int c;
4054
4055   if (argc < 2)
4056     usage (stderr);
4057
4058   while ((c = getopt_long
4059           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
4060     {
4061       switch (c)
4062         {
4063         case 0:
4064           /* Long options.  */
4065           break;
4066         case 'H':
4067           usage (stdout);
4068           break;
4069
4070         case 'a':
4071           do_syms++;
4072           do_reloc++;
4073           do_unwind++;
4074           do_dynamic++;
4075           do_header++;
4076           do_sections++;
4077           do_section_groups++;
4078           do_segments++;
4079           do_version++;
4080           do_histogram++;
4081           do_arch++;
4082           do_notes++;
4083           break;
4084         case 'g':
4085           do_section_groups++;
4086           break;
4087         case 't':
4088         case 'N':
4089           do_sections++;
4090           do_section_details++;
4091           break;
4092         case 'e':
4093           do_header++;
4094           do_sections++;
4095           do_segments++;
4096           break;
4097         case 'A':
4098           do_arch++;
4099           break;
4100         case 'D':
4101           do_using_dynamic++;
4102           break;
4103         case 'r':
4104           do_reloc++;
4105           break;
4106         case 'u':
4107           do_unwind++;
4108           break;
4109         case 'h':
4110           do_header++;
4111           break;
4112         case 'l':
4113           do_segments++;
4114           break;
4115         case 's':
4116           do_syms++;
4117           break;
4118         case 'S':
4119           do_sections++;
4120           break;
4121         case 'd':
4122           do_dynamic++;
4123           break;
4124         case 'I':
4125           do_histogram++;
4126           break;
4127         case 'n':
4128           do_notes++;
4129           break;
4130         case 'c':
4131           do_archive_index++;
4132           break;
4133         case 'x':
4134           request_dump (HEX_DUMP);
4135           break;
4136         case 'p':
4137           request_dump (STRING_DUMP);
4138           break;
4139         case 'R':
4140           request_dump (RELOC_DUMP);
4141           break;
4142         case 'w':
4143           do_dump++;
4144           if (optarg == 0)
4145             {
4146               do_debugging = 1;
4147               dwarf_select_sections_all ();
4148             }
4149           else
4150             {
4151               do_debugging = 0;
4152               dwarf_select_sections_by_letters (optarg);
4153             }
4154           break;
4155         case OPTION_DEBUG_DUMP:
4156           do_dump++;
4157           if (optarg == 0)
4158             do_debugging = 1;
4159           else
4160             {
4161               do_debugging = 0;
4162               dwarf_select_sections_by_names (optarg);
4163             }
4164           break;
4165         case OPTION_DWARF_DEPTH:
4166           {
4167             char *cp;
4168
4169             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4170           }
4171           break;
4172         case OPTION_DWARF_START:
4173           {
4174             char *cp;
4175
4176             dwarf_start_die = strtoul (optarg, & cp, 0);
4177           }
4178           break;
4179         case OPTION_DWARF_CHECK:
4180           dwarf_check = 1;
4181           break;
4182         case OPTION_DYN_SYMS:
4183           do_dyn_syms++;
4184           break;
4185 #ifdef SUPPORT_DISASSEMBLY
4186         case 'i':
4187           request_dump (DISASS_DUMP);
4188           break;
4189 #endif
4190         case 'v':
4191           print_version (program_name);
4192           break;
4193         case 'V':
4194           do_version++;
4195           break;
4196         case 'W':
4197           do_wide++;
4198           break;
4199         default:
4200           /* xgettext:c-format */
4201           error (_("Invalid option '-%c'\n"), c);
4202           /* Drop through.  */
4203         case '?':
4204           usage (stderr);
4205         }
4206     }
4207
4208   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4209       && !do_segments && !do_header && !do_dump && !do_version
4210       && !do_histogram && !do_debugging && !do_arch && !do_notes
4211       && !do_section_groups && !do_archive_index
4212       && !do_dyn_syms)
4213     usage (stderr);
4214   else if (argc < 3)
4215     {
4216       warn (_("Nothing to do.\n"));
4217       usage (stderr);
4218     }
4219 }
4220
4221 static const char *
4222 get_elf_class (unsigned int elf_class)
4223 {
4224   static char buff[32];
4225
4226   switch (elf_class)
4227     {
4228     case ELFCLASSNONE: return _("none");
4229     case ELFCLASS32:   return "ELF32";
4230     case ELFCLASS64:   return "ELF64";
4231     default:
4232       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4233       return buff;
4234     }
4235 }
4236
4237 static const char *
4238 get_data_encoding (unsigned int encoding)
4239 {
4240   static char buff[32];
4241
4242   switch (encoding)
4243     {
4244     case ELFDATANONE: return _("none");
4245     case ELFDATA2LSB: return _("2's complement, little endian");
4246     case ELFDATA2MSB: return _("2's complement, big endian");
4247     default:
4248       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4249       return buff;
4250     }
4251 }
4252
4253 /* Decode the data held in 'elf_header'.  */
4254
4255 static int
4256 process_file_header (void)
4257 {
4258   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
4259       || elf_header.e_ident[EI_MAG1] != ELFMAG1
4260       || elf_header.e_ident[EI_MAG2] != ELFMAG2
4261       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4262     {
4263       error
4264         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4265       return 0;
4266     }
4267
4268   init_dwarf_regnames (elf_header.e_machine);
4269
4270   if (do_header)
4271     {
4272       int i;
4273
4274       printf (_("ELF Header:\n"));
4275       printf (_("  Magic:   "));
4276       for (i = 0; i < EI_NIDENT; i++)
4277         printf ("%2.2x ", elf_header.e_ident[i]);
4278       printf ("\n");
4279       printf (_("  Class:                             %s\n"),
4280               get_elf_class (elf_header.e_ident[EI_CLASS]));
4281       printf (_("  Data:                              %s\n"),
4282               get_data_encoding (elf_header.e_ident[EI_DATA]));
4283       printf (_("  Version:                           %d %s\n"),
4284               elf_header.e_ident[EI_VERSION],
4285               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4286                ? "(current)"
4287                : (elf_header.e_ident[EI_VERSION] != EV_NONE
4288                   ? _("<unknown: %lx>")
4289                   : "")));
4290       printf (_("  OS/ABI:                            %s\n"),
4291               get_osabi_name (elf_header.e_ident[EI_OSABI]));
4292       printf (_("  ABI Version:                       %d\n"),
4293               elf_header.e_ident[EI_ABIVERSION]);
4294       printf (_("  Type:                              %s\n"),
4295               get_file_type (elf_header.e_type));
4296       printf (_("  Machine:                           %s\n"),
4297               get_machine_name (elf_header.e_machine));
4298       printf (_("  Version:                           0x%lx\n"),
4299               (unsigned long) elf_header.e_version);
4300
4301       printf (_("  Entry point address:               "));
4302       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4303       printf (_("\n  Start of program headers:          "));
4304       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4305       printf (_(" (bytes into file)\n  Start of section headers:          "));
4306       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4307       printf (_(" (bytes into file)\n"));
4308
4309       printf (_("  Flags:                             0x%lx%s\n"),
4310               (unsigned long) elf_header.e_flags,
4311               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4312       printf (_("  Size of this header:               %ld (bytes)\n"),
4313               (long) elf_header.e_ehsize);
4314       printf (_("  Size of program headers:           %ld (bytes)\n"),
4315               (long) elf_header.e_phentsize);
4316       printf (_("  Number of program headers:         %ld"),
4317               (long) elf_header.e_phnum);
4318       if (section_headers != NULL
4319           && elf_header.e_phnum == PN_XNUM
4320           && section_headers[0].sh_info != 0)
4321         printf (" (%ld)", (long) section_headers[0].sh_info);
4322       putc ('\n', stdout);
4323       printf (_("  Size of section headers:           %ld (bytes)\n"),
4324               (long) elf_header.e_shentsize);
4325       printf (_("  Number of section headers:         %ld"),
4326               (long) elf_header.e_shnum);
4327       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4328         printf (" (%ld)", (long) section_headers[0].sh_size);
4329       putc ('\n', stdout);
4330       printf (_("  Section header string table index: %ld"),
4331               (long) elf_header.e_shstrndx);
4332       if (section_headers != NULL
4333           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4334         printf (" (%u)", section_headers[0].sh_link);
4335       else if (elf_header.e_shstrndx != SHN_UNDEF
4336                && elf_header.e_shstrndx >= elf_header.e_shnum)
4337         printf (_(" <corrupt: out of range>"));
4338       putc ('\n', stdout);
4339     }
4340
4341   if (section_headers != NULL)
4342     {
4343       if (elf_header.e_phnum == PN_XNUM
4344           && section_headers[0].sh_info != 0)
4345         elf_header.e_phnum = section_headers[0].sh_info;
4346       if (elf_header.e_shnum == SHN_UNDEF)
4347         elf_header.e_shnum = section_headers[0].sh_size;
4348       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4349         elf_header.e_shstrndx = section_headers[0].sh_link;
4350       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4351         elf_header.e_shstrndx = SHN_UNDEF;
4352       free (section_headers);
4353       section_headers = NULL;
4354     }
4355
4356   return 1;
4357 }
4358
4359 static bfd_boolean
4360 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4361 {
4362   Elf32_External_Phdr * phdrs;
4363   Elf32_External_Phdr * external;
4364   Elf_Internal_Phdr *   internal;
4365   unsigned int i;
4366   unsigned int size = elf_header.e_phentsize;
4367   unsigned int num  = elf_header.e_phnum;
4368
4369   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4370   if (size == 0 || num == 0)
4371     return FALSE;
4372   if (size < sizeof * phdrs)
4373     {
4374       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4375       return FALSE;
4376     }
4377   if (size > sizeof * phdrs)
4378     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4379
4380   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4381                                             size, num, _("program headers"));
4382   if (phdrs == NULL)
4383     return FALSE;
4384
4385   for (i = 0, internal = pheaders, external = phdrs;
4386        i < elf_header.e_phnum;
4387        i++, internal++, external++)
4388     {
4389       internal->p_type   = BYTE_GET (external->p_type);
4390       internal->p_offset = BYTE_GET (external->p_offset);
4391       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4392       internal->p_paddr  = BYTE_GET (external->p_paddr);
4393       internal->p_filesz = BYTE_GET (external->p_filesz);
4394       internal->p_memsz  = BYTE_GET (external->p_memsz);
4395       internal->p_flags  = BYTE_GET (external->p_flags);
4396       internal->p_align  = BYTE_GET (external->p_align);
4397     }
4398
4399   free (phdrs);
4400   return TRUE;
4401 }
4402
4403 static bfd_boolean
4404 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4405 {
4406   Elf64_External_Phdr * phdrs;
4407   Elf64_External_Phdr * external;
4408   Elf_Internal_Phdr *   internal;
4409   unsigned int i;
4410   unsigned int size = elf_header.e_phentsize;
4411   unsigned int num  = elf_header.e_phnum;
4412
4413   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4414   if (size == 0 || num == 0)
4415     return FALSE;
4416   if (size < sizeof * phdrs)
4417     {
4418       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4419       return FALSE;
4420     }
4421   if (size > sizeof * phdrs)
4422     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4423
4424   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4425                                             size, num, _("program headers"));
4426   if (!phdrs)
4427     return FALSE;
4428
4429   for (i = 0, internal = pheaders, external = phdrs;
4430        i < elf_header.e_phnum;
4431        i++, internal++, external++)
4432     {
4433       internal->p_type   = BYTE_GET (external->p_type);
4434       internal->p_flags  = BYTE_GET (external->p_flags);
4435       internal->p_offset = BYTE_GET (external->p_offset);
4436       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4437       internal->p_paddr  = BYTE_GET (external->p_paddr);
4438       internal->p_filesz = BYTE_GET (external->p_filesz);
4439       internal->p_memsz  = BYTE_GET (external->p_memsz);
4440       internal->p_align  = BYTE_GET (external->p_align);
4441     }
4442
4443   free (phdrs);
4444   return TRUE;
4445 }
4446
4447 /* Returns 1 if the program headers were read into `program_headers'.  */
4448
4449 static int
4450 get_program_headers (FILE * file)
4451 {
4452   Elf_Internal_Phdr * phdrs;
4453
4454   /* Check cache of prior read.  */
4455   if (program_headers != NULL)
4456     return 1;
4457
4458   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4459                                          sizeof (Elf_Internal_Phdr));
4460
4461   if (phdrs == NULL)
4462     {
4463       error (_("Out of memory reading %u program headers\n"),
4464              elf_header.e_phnum);
4465       return 0;
4466     }
4467
4468   if (is_32bit_elf
4469       ? get_32bit_program_headers (file, phdrs)
4470       : get_64bit_program_headers (file, phdrs))
4471     {
4472       program_headers = phdrs;
4473       return 1;
4474     }
4475
4476   free (phdrs);
4477   return 0;
4478 }
4479
4480 /* Returns 1 if the program headers were loaded.  */
4481
4482 static int
4483 process_program_headers (FILE * file)
4484 {
4485   Elf_Internal_Phdr * segment;
4486   unsigned int i;
4487
4488   if (elf_header.e_phnum == 0)
4489     {
4490       /* PR binutils/12467.  */
4491       if (elf_header.e_phoff != 0)
4492         warn (_("possibly corrupt ELF header - it has a non-zero program"
4493                 " header offset, but no program headers"));
4494       else if (do_segments)
4495         printf (_("\nThere are no program headers in this file.\n"));
4496       return 0;
4497     }
4498
4499   if (do_segments && !do_header)
4500     {
4501       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4502       printf (_("Entry point "));
4503       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4504       printf (_("\nThere are %d program headers, starting at offset "),
4505               elf_header.e_phnum);
4506       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4507       printf ("\n");
4508     }
4509
4510   if (! get_program_headers (file))
4511       return 0;
4512
4513   if (do_segments)
4514     {
4515       if (elf_header.e_phnum > 1)
4516         printf (_("\nProgram Headers:\n"));
4517       else
4518         printf (_("\nProgram Headers:\n"));
4519
4520       if (is_32bit_elf)
4521         printf
4522           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4523       else if (do_wide)
4524         printf
4525           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4526       else
4527         {
4528           printf
4529             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4530           printf
4531             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4532         }
4533     }
4534
4535   dynamic_addr = 0;
4536   dynamic_size = 0;
4537
4538   for (i = 0, segment = program_headers;
4539        i < elf_header.e_phnum;
4540        i++, segment++)
4541     {
4542       if (do_segments)
4543         {
4544           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4545
4546           if (is_32bit_elf)
4547             {
4548               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4549               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4550               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4551               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4552               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4553               printf ("%c%c%c ",
4554                       (segment->p_flags & PF_R ? 'R' : ' '),
4555                       (segment->p_flags & PF_W ? 'W' : ' '),
4556                       (segment->p_flags & PF_X ? 'E' : ' '));
4557               printf ("%#lx", (unsigned long) segment->p_align);
4558             }
4559           else if (do_wide)
4560             {
4561               if ((unsigned long) segment->p_offset == segment->p_offset)
4562                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4563               else
4564                 {
4565                   print_vma (segment->p_offset, FULL_HEX);
4566                   putchar (' ');
4567                 }
4568
4569               print_vma (segment->p_vaddr, FULL_HEX);
4570               putchar (' ');
4571               print_vma (segment->p_paddr, FULL_HEX);
4572               putchar (' ');
4573
4574               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4575                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4576               else
4577                 {
4578                   print_vma (segment->p_filesz, FULL_HEX);
4579                   putchar (' ');
4580                 }
4581
4582               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4583                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4584               else
4585                 {
4586                   print_vma (segment->p_memsz, FULL_HEX);
4587                 }
4588
4589               printf (" %c%c%c ",
4590                       (segment->p_flags & PF_R ? 'R' : ' '),
4591                       (segment->p_flags & PF_W ? 'W' : ' '),
4592                       (segment->p_flags & PF_X ? 'E' : ' '));
4593
4594               if ((unsigned long) segment->p_align == segment->p_align)
4595                 printf ("%#lx", (unsigned long) segment->p_align);
4596               else
4597                 {
4598                   print_vma (segment->p_align, PREFIX_HEX);
4599                 }
4600             }
4601           else
4602             {
4603               print_vma (segment->p_offset, FULL_HEX);
4604               putchar (' ');
4605               print_vma (segment->p_vaddr, FULL_HEX);
4606               putchar (' ');
4607               print_vma (segment->p_paddr, FULL_HEX);
4608               printf ("\n                 ");
4609               print_vma (segment->p_filesz, FULL_HEX);
4610               putchar (' ');
4611               print_vma (segment->p_memsz, FULL_HEX);
4612               printf ("  %c%c%c    ",
4613                       (segment->p_flags & PF_R ? 'R' : ' '),
4614                       (segment->p_flags & PF_W ? 'W' : ' '),
4615                       (segment->p_flags & PF_X ? 'E' : ' '));
4616               print_vma (segment->p_align, HEX);
4617             }
4618         }
4619
4620       if (do_segments)
4621         putc ('\n', stdout);
4622
4623       switch (segment->p_type)
4624         {
4625         case PT_DYNAMIC:
4626           if (dynamic_addr)
4627             error (_("more than one dynamic segment\n"));
4628
4629           /* By default, assume that the .dynamic section is the first
4630              section in the DYNAMIC segment.  */
4631           dynamic_addr = segment->p_offset;
4632           dynamic_size = segment->p_filesz;
4633           /* PR binutils/17512: Avoid corrupt dynamic section info in the segment.  */
4634           if (dynamic_addr + dynamic_size >= current_file_size)
4635             {
4636               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4637               dynamic_addr = dynamic_size = 0;
4638             }
4639
4640           /* Try to locate the .dynamic section. If there is
4641              a section header table, we can easily locate it.  */
4642           if (section_headers != NULL)
4643             {
4644               Elf_Internal_Shdr * sec;
4645
4646               sec = find_section (".dynamic");
4647               if (sec == NULL || sec->sh_size == 0)
4648                 {
4649                   /* A corresponding .dynamic section is expected, but on
4650                      IA-64/OpenVMS it is OK for it to be missing.  */
4651                   if (!is_ia64_vms ())
4652                     error (_("no .dynamic section in the dynamic segment\n"));
4653                   break;
4654                 }
4655
4656               if (sec->sh_type == SHT_NOBITS)
4657                 {
4658                   dynamic_size = 0;
4659                   break;
4660                 }
4661
4662               dynamic_addr = sec->sh_offset;
4663               dynamic_size = sec->sh_size;
4664
4665               if (dynamic_addr < segment->p_offset
4666                   || dynamic_addr > segment->p_offset + segment->p_filesz)
4667                 warn (_("the .dynamic section is not contained"
4668                         " within the dynamic segment\n"));
4669               else if (dynamic_addr > segment->p_offset)
4670                 warn (_("the .dynamic section is not the first section"
4671                         " in the dynamic segment.\n"));
4672             }
4673           break;
4674
4675         case PT_INTERP:
4676           if (fseek (file, archive_file_offset + (long) segment->p_offset,
4677                      SEEK_SET))
4678             error (_("Unable to find program interpreter name\n"));
4679           else
4680             {
4681               char fmt [32];
4682               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
4683
4684               if (ret >= (int) sizeof (fmt) || ret < 0)
4685                 error (_("Internal error: failed to create format string to display program interpreter\n"));
4686
4687               program_interpreter[0] = 0;
4688               if (fscanf (file, fmt, program_interpreter) <= 0)
4689                 error (_("Unable to read program interpreter name\n"));
4690
4691               if (do_segments)
4692                 printf (_("      [Requesting program interpreter: %s]\n"),
4693                     program_interpreter);
4694             }
4695           break;
4696         }
4697     }
4698
4699   if (do_segments && section_headers != NULL && string_table != NULL)
4700     {
4701       printf (_("\n Section to Segment mapping:\n"));
4702       printf (_("  Segment Sections...\n"));
4703
4704       for (i = 0; i < elf_header.e_phnum; i++)
4705         {
4706           unsigned int j;
4707           Elf_Internal_Shdr * section;
4708
4709           segment = program_headers + i;
4710           section = section_headers + 1;
4711
4712           printf ("   %2.2d     ", i);
4713
4714           for (j = 1; j < elf_header.e_shnum; j++, section++)
4715             {
4716               if (!ELF_TBSS_SPECIAL (section, segment)
4717                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4718                 printf ("%s ", printable_section_name (section));
4719             }
4720
4721           putc ('\n',stdout);
4722         }
4723     }
4724
4725   return 1;
4726 }
4727
4728
4729 /* Find the file offset corresponding to VMA by using the program headers.  */
4730
4731 static long
4732 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4733 {
4734   Elf_Internal_Phdr * seg;
4735
4736   if (! get_program_headers (file))
4737     {
4738       warn (_("Cannot interpret virtual addresses without program headers.\n"));
4739       return (long) vma;
4740     }
4741
4742   for (seg = program_headers;
4743        seg < program_headers + elf_header.e_phnum;
4744        ++seg)
4745     {
4746       if (seg->p_type != PT_LOAD)
4747         continue;
4748
4749       if (vma >= (seg->p_vaddr & -seg->p_align)
4750           && vma + size <= seg->p_vaddr + seg->p_filesz)
4751         return vma - seg->p_vaddr + seg->p_offset;
4752     }
4753
4754   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4755         (unsigned long) vma);
4756   return (long) vma;
4757 }
4758
4759
4760 /* Allocate memory and load the sections headers into the global pointer
4761    SECTION_HEADERS.  If PROBE is true, this is just a probe and we do not
4762    generate any error messages if the load fails.  */
4763
4764 static bfd_boolean
4765 get_32bit_section_headers (FILE * file, bfd_boolean probe)
4766 {
4767   Elf32_External_Shdr * shdrs;
4768   Elf_Internal_Shdr *   internal;
4769   unsigned int i;
4770   unsigned int size = elf_header.e_shentsize;
4771   unsigned int num = probe ? 1 : elf_header.e_shnum;
4772
4773   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4774   if (size == 0 || num == 0)
4775     return FALSE;
4776   if (size < sizeof * shdrs)
4777     {
4778       if (! probe)
4779         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4780       return FALSE;
4781     }
4782   if (!probe && size > sizeof * shdrs)
4783     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4784
4785   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4786                                             size, num,
4787                                             probe ? NULL : _("section headers"));
4788   if (shdrs == NULL)
4789     return FALSE;
4790
4791   if (section_headers != NULL)
4792     free (section_headers);
4793   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4794                                                    sizeof (Elf_Internal_Shdr));
4795   if (section_headers == NULL)
4796     {
4797       if (!probe)
4798         error (_("Out of memory reading %u section headers\n"), num);
4799       return FALSE;
4800     }
4801
4802   for (i = 0, internal = section_headers;
4803        i < num;
4804        i++, internal++)
4805     {
4806       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4807       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4808       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4809       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4810       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4811       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4812       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4813       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4814       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4815       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4816     }
4817
4818   free (shdrs);
4819   return TRUE;
4820 }
4821
4822 static bfd_boolean
4823 get_64bit_section_headers (FILE * file, bfd_boolean probe)
4824 {
4825   Elf64_External_Shdr * shdrs;
4826   Elf_Internal_Shdr *   internal;
4827   unsigned int i;
4828   unsigned int size = elf_header.e_shentsize;
4829   unsigned int num = probe ? 1 : elf_header.e_shnum;
4830
4831   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4832   if (size == 0 || num == 0)
4833     return FALSE;
4834   if (size < sizeof * shdrs)
4835     {
4836       if (! probe)
4837         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4838       return FALSE;
4839     }
4840   if (! probe && size > sizeof * shdrs)
4841     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4842
4843   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4844                                             size, num,
4845                                             probe ? NULL : _("section headers"));
4846   if (shdrs == NULL)
4847     return FALSE;
4848
4849   if (section_headers != NULL)
4850     free (section_headers);
4851   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4852                                                    sizeof (Elf_Internal_Shdr));
4853   if (section_headers == NULL)
4854     {
4855       if (! probe)
4856         error (_("Out of memory reading %u section headers\n"), num);
4857       return FALSE;
4858     }
4859
4860   for (i = 0, internal = section_headers;
4861        i < num;
4862        i++, internal++)
4863     {
4864       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4865       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4866       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4867       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4868       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4869       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4870       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4871       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4872       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4873       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4874     }
4875
4876   free (shdrs);
4877   return TRUE;
4878 }
4879
4880 static Elf_Internal_Sym *
4881 get_32bit_elf_symbols (FILE * file,
4882                        Elf_Internal_Shdr * section,
4883                        unsigned long * num_syms_return)
4884 {
4885   unsigned long number = 0;
4886   Elf32_External_Sym * esyms = NULL;
4887   Elf_External_Sym_Shndx * shndx = NULL;
4888   Elf_Internal_Sym * isyms = NULL;
4889   Elf_Internal_Sym * psym;
4890   unsigned int j;
4891
4892   if (section->sh_size == 0)
4893     {
4894       if (num_syms_return != NULL)
4895         * num_syms_return = 0;
4896       return NULL;
4897     }
4898
4899   /* Run some sanity checks first.  */
4900   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
4901     {
4902       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4903              printable_section_name (section), (unsigned long) section->sh_entsize);
4904       goto exit_point;
4905     }
4906
4907   if (section->sh_size > current_file_size)
4908     {
4909       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4910              printable_section_name (section), (unsigned long) section->sh_size);
4911       goto exit_point;
4912     }
4913
4914   number = section->sh_size / section->sh_entsize;
4915
4916   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4917     {
4918       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4919              (unsigned long) section->sh_size,
4920              printable_section_name (section),
4921              (unsigned long) section->sh_entsize);
4922       goto exit_point;
4923     }
4924
4925   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4926                                            section->sh_size, _("symbols"));
4927   if (esyms == NULL)
4928     goto exit_point;
4929
4930   shndx = NULL;
4931   if (symtab_shndx_hdr != NULL
4932       && (symtab_shndx_hdr->sh_link
4933           == (unsigned long) (section - section_headers)))
4934     {
4935       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4936                                                    symtab_shndx_hdr->sh_offset,
4937                                                    1, symtab_shndx_hdr->sh_size,
4938                                                    _("symbol table section indicies"));
4939       if (shndx == NULL)
4940         goto exit_point;
4941       /* PR17531: file: heap-buffer-overflow */
4942       else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
4943         {
4944           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4945                  printable_section_name (symtab_shndx_hdr),
4946                  (unsigned long) symtab_shndx_hdr->sh_size,
4947                  (unsigned long) section->sh_size);
4948           goto exit_point;
4949         }
4950     }
4951
4952   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4953
4954   if (isyms == NULL)
4955     {
4956       error (_("Out of memory reading %lu symbols\n"),
4957              (unsigned long) number);
4958       goto exit_point;
4959     }
4960
4961   for (j = 0, psym = isyms; j < number; j++, psym++)
4962     {
4963       psym->st_name  = BYTE_GET (esyms[j].st_name);
4964       psym->st_value = BYTE_GET (esyms[j].st_value);
4965       psym->st_size  = BYTE_GET (esyms[j].st_size);
4966       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4967       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4968         psym->st_shndx
4969           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4970       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4971         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4972       psym->st_info  = BYTE_GET (esyms[j].st_info);
4973       psym->st_other = BYTE_GET (esyms[j].st_other);
4974     }
4975
4976  exit_point:
4977   if (shndx != NULL)
4978     free (shndx);
4979   if (esyms != NULL)
4980     free (esyms);
4981
4982   if (num_syms_return != NULL)
4983     * num_syms_return = isyms == NULL ? 0 : number;
4984
4985   return isyms;
4986 }
4987
4988 static Elf_Internal_Sym *
4989 get_64bit_elf_symbols (FILE * file,
4990                        Elf_Internal_Shdr * section,
4991                        unsigned long * num_syms_return)
4992 {
4993   unsigned long number = 0;
4994   Elf64_External_Sym * esyms = NULL;
4995   Elf_External_Sym_Shndx * shndx = NULL;
4996   Elf_Internal_Sym * isyms = NULL;
4997   Elf_Internal_Sym * psym;
4998   unsigned int j;
4999
5000   if (section->sh_size == 0)
5001     {
5002       if (num_syms_return != NULL)
5003         * num_syms_return = 0;
5004       return NULL;
5005     }
5006
5007   /* Run some sanity checks first.  */
5008   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5009     {
5010       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5011              printable_section_name (section),
5012              (unsigned long) section->sh_entsize);
5013       goto exit_point;
5014     }
5015
5016   if (section->sh_size > current_file_size)
5017     {
5018       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5019              printable_section_name (section),
5020              (unsigned long) section->sh_size);
5021       goto exit_point;
5022     }
5023
5024   number = section->sh_size / section->sh_entsize;
5025
5026   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5027     {
5028       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5029              (unsigned long) section->sh_size,
5030              printable_section_name (section),
5031              (unsigned long) section->sh_entsize);
5032       goto exit_point;
5033     }
5034
5035   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5036                                            section->sh_size, _("symbols"));
5037   if (!esyms)
5038     goto exit_point;
5039
5040   if (symtab_shndx_hdr != NULL
5041       && (symtab_shndx_hdr->sh_link
5042           == (unsigned long) (section - section_headers)))
5043     {
5044       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5045                                                    symtab_shndx_hdr->sh_offset,
5046                                                    1, symtab_shndx_hdr->sh_size,
5047                                                    _("symbol table section indicies"));
5048       if (shndx == NULL)
5049         goto exit_point;
5050       else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5051         {
5052           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5053                  printable_section_name (symtab_shndx_hdr),
5054                  (unsigned long) symtab_shndx_hdr->sh_size,
5055                  (unsigned long) section->sh_size);
5056           goto exit_point;
5057         }
5058     }
5059
5060   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5061
5062   if (isyms == NULL)
5063     {
5064       error (_("Out of memory reading %lu symbols\n"),
5065              (unsigned long) number);
5066       goto exit_point;
5067     }
5068
5069   for (j = 0, psym = isyms; j < number; j++, psym++)
5070     {
5071       psym->st_name  = BYTE_GET (esyms[j].st_name);
5072       psym->st_info  = BYTE_GET (esyms[j].st_info);
5073       psym->st_other = BYTE_GET (esyms[j].st_other);
5074       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5075
5076       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5077         psym->st_shndx
5078           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5079       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5080         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5081
5082       psym->st_value = BYTE_GET (esyms[j].st_value);
5083       psym->st_size  = BYTE_GET (esyms[j].st_size);
5084     }
5085
5086  exit_point:
5087   if (shndx != NULL)
5088     free (shndx);
5089   if (esyms != NULL)
5090     free (esyms);
5091
5092   if (num_syms_return != NULL)
5093     * num_syms_return = isyms == NULL ? 0 : number;
5094
5095   return isyms;
5096 }
5097
5098 static const char *
5099 get_elf_section_flags (bfd_vma sh_flags)
5100 {
5101   static char buff[1024];
5102   char * p = buff;
5103   int field_size = is_32bit_elf ? 8 : 16;
5104   int sindex;
5105   int size = sizeof (buff) - (field_size + 4 + 1);
5106   bfd_vma os_flags = 0;
5107   bfd_vma proc_flags = 0;
5108   bfd_vma unknown_flags = 0;
5109   static const struct
5110     {
5111       const char * str;
5112       int len;
5113     }
5114   flags [] =
5115     {
5116       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5117       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5118       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5119       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5120       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5121       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5122       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5123       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5124       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5125       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5126       /* IA-64 specific.  */
5127       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5128       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5129       /* IA-64 OpenVMS specific.  */
5130       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5131       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5132       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5133       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5134       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5135       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5136       /* Generic.  */
5137       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5138       /* SPARC specific.  */
5139       /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5140     };
5141
5142   if (do_section_details)
5143     {
5144       sprintf (buff, "[%*.*lx]: ",
5145                field_size, field_size, (unsigned long) sh_flags);
5146       p += field_size + 4;
5147     }
5148
5149   while (sh_flags)
5150     {
5151       bfd_vma flag;
5152
5153       flag = sh_flags & - sh_flags;
5154       sh_flags &= ~ flag;
5155
5156       if (do_section_details)
5157         {
5158           switch (flag)
5159             {
5160             case SHF_WRITE:             sindex = 0; break;
5161             case SHF_ALLOC:             sindex = 1; break;
5162             case SHF_EXECINSTR:         sindex = 2; break;
5163             case SHF_MERGE:             sindex = 3; break;
5164             case SHF_STRINGS:           sindex = 4; break;
5165             case SHF_INFO_LINK:         sindex = 5; break;
5166             case SHF_LINK_ORDER:        sindex = 6; break;
5167             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5168             case SHF_GROUP:             sindex = 8; break;
5169             case SHF_TLS:               sindex = 9; break;
5170             case SHF_EXCLUDE:           sindex = 18; break;
5171
5172             default:
5173               sindex = -1;
5174               switch (elf_header.e_machine)
5175                 {
5176                 case EM_IA_64:
5177                   if (flag == SHF_IA_64_SHORT)
5178                     sindex = 10;
5179                   else if (flag == SHF_IA_64_NORECOV)
5180                     sindex = 11;
5181 #ifdef BFD64
5182                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5183                     switch (flag)
5184                       {
5185                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5186                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5187                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5188                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5189                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5190                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5191                       default:                        break;
5192                       }
5193 #endif
5194                   break;
5195
5196                 case EM_386:
5197                 case EM_486:
5198                 case EM_X86_64:
5199                 case EM_L1OM:
5200                 case EM_K1OM:
5201                 case EM_OLD_SPARCV9:
5202                 case EM_SPARC32PLUS:
5203                 case EM_SPARCV9:
5204                 case EM_SPARC:
5205                   if (flag == SHF_ORDERED)
5206                     sindex = 19;
5207                   break;
5208                 default:
5209                   break;
5210                 }
5211             }
5212
5213           if (sindex != -1)
5214             {
5215               if (p != buff + field_size + 4)
5216                 {
5217                   if (size < (10 + 2))
5218                     {
5219                       warn (_("Internal error: not enough buffer room for section flag info"));
5220                       return _("<unknown>");
5221                     }
5222                   size -= 2;
5223                   *p++ = ',';
5224                   *p++ = ' ';
5225                 }
5226
5227               size -= flags [sindex].len;
5228               p = stpcpy (p, flags [sindex].str);
5229             }
5230           else if (flag & SHF_MASKOS)
5231             os_flags |= flag;
5232           else if (flag & SHF_MASKPROC)
5233             proc_flags |= flag;
5234           else
5235             unknown_flags |= flag;
5236         }
5237       else
5238         {
5239           switch (flag)
5240             {
5241             case SHF_WRITE:             *p = 'W'; break;
5242             case SHF_ALLOC:             *p = 'A'; break;
5243             case SHF_EXECINSTR:         *p = 'X'; break;
5244             case SHF_MERGE:             *p = 'M'; break;
5245             case SHF_STRINGS:           *p = 'S'; break;
5246             case SHF_INFO_LINK:         *p = 'I'; break;
5247             case SHF_LINK_ORDER:        *p = 'L'; break;
5248             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5249             case SHF_GROUP:             *p = 'G'; break;
5250             case SHF_TLS:               *p = 'T'; break;
5251             case SHF_EXCLUDE:           *p = 'E'; break;
5252
5253             default:
5254               if ((elf_header.e_machine == EM_X86_64
5255                    || elf_header.e_machine == EM_L1OM
5256                    || elf_header.e_machine == EM_K1OM)
5257                   && flag == SHF_X86_64_LARGE)
5258                 *p = 'l';
5259               else if (flag & SHF_MASKOS)
5260                 {
5261                   *p = 'o';
5262                   sh_flags &= ~ SHF_MASKOS;
5263                 }
5264               else if (flag & SHF_MASKPROC)
5265                 {
5266                   *p = 'p';
5267                   sh_flags &= ~ SHF_MASKPROC;
5268                 }
5269               else
5270                 *p = 'x';
5271               break;
5272             }
5273           p++;
5274         }
5275     }
5276
5277   if (do_section_details)
5278     {
5279       if (os_flags)
5280         {
5281           size -= 5 + field_size;
5282           if (p != buff + field_size + 4)
5283             {
5284               if (size < (2 + 1))
5285                 {
5286                   warn (_("Internal error: not enough buffer room for section flag info"));
5287                   return _("<unknown>");
5288                 }
5289               size -= 2;
5290               *p++ = ',';
5291               *p++ = ' ';
5292             }
5293           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5294                    (unsigned long) os_flags);
5295           p += 5 + field_size;
5296         }
5297       if (proc_flags)
5298         {
5299           size -= 7 + field_size;
5300           if (p != buff + field_size + 4)
5301             {
5302               if (size < (2 + 1))
5303                 {
5304                   warn (_("Internal error: not enough buffer room for section flag info"));
5305                   return _("<unknown>");
5306                 }
5307               size -= 2;
5308               *p++ = ',';
5309               *p++ = ' ';
5310             }
5311           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5312                    (unsigned long) proc_flags);
5313           p += 7 + field_size;
5314         }
5315       if (unknown_flags)
5316         {
5317           size -= 10 + field_size;
5318           if (p != buff + field_size + 4)
5319             {
5320               if (size < (2 + 1))
5321                 {
5322                   warn (_("Internal error: not enough buffer room for section flag info"));
5323                   return _("<unknown>");
5324                 }
5325               size -= 2;
5326               *p++ = ',';
5327               *p++ = ' ';
5328             }
5329           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5330                    (unsigned long) unknown_flags);
5331           p += 10 + field_size;
5332         }
5333     }
5334
5335   *p = '\0';
5336   return buff;
5337 }
5338
5339 static int
5340 process_section_headers (FILE * file)
5341 {
5342   Elf_Internal_Shdr * section;
5343   unsigned int i;
5344
5345   section_headers = NULL;
5346
5347   if (elf_header.e_shnum == 0)
5348     {
5349       /* PR binutils/12467.  */
5350       if (elf_header.e_shoff != 0)
5351         warn (_("possibly corrupt ELF file header - it has a non-zero"
5352                 " section header offset, but no section headers\n"));
5353       else if (do_sections)
5354         printf (_("\nThere are no sections in this file.\n"));
5355
5356       return 1;
5357     }
5358
5359   if (do_sections && !do_header)
5360     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5361             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5362
5363   if (is_32bit_elf)
5364     {
5365       if (! get_32bit_section_headers (file, FALSE))
5366         return 0;
5367     }
5368   else if (! get_64bit_section_headers (file, FALSE))
5369     return 0;
5370
5371   /* Read in the string table, so that we have names to display.  */
5372   if (elf_header.e_shstrndx != SHN_UNDEF
5373        && elf_header.e_shstrndx < elf_header.e_shnum)
5374     {
5375       section = section_headers + elf_header.e_shstrndx;
5376
5377       if (section->sh_size != 0)
5378         {
5379           string_table = (char *) get_data (NULL, file, section->sh_offset,
5380                                             1, section->sh_size,
5381                                             _("string table"));
5382
5383           string_table_length = string_table != NULL ? section->sh_size : 0;
5384         }
5385     }
5386
5387   /* Scan the sections for the dynamic symbol table
5388      and dynamic string table and debug sections.  */
5389   dynamic_symbols = NULL;
5390   dynamic_strings = NULL;
5391   dynamic_syminfo = NULL;
5392   symtab_shndx_hdr = NULL;
5393
5394   eh_addr_size = is_32bit_elf ? 4 : 8;
5395   switch (elf_header.e_machine)
5396     {
5397     case EM_MIPS:
5398     case EM_MIPS_RS3_LE:
5399       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5400          FDE addresses.  However, the ABI also has a semi-official ILP32
5401          variant for which the normal FDE address size rules apply.
5402
5403          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5404          section, where XX is the size of longs in bits.  Unfortunately,
5405          earlier compilers provided no way of distinguishing ILP32 objects
5406          from LP64 objects, so if there's any doubt, we should assume that
5407          the official LP64 form is being used.  */
5408       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5409           && find_section (".gcc_compiled_long32") == NULL)
5410         eh_addr_size = 8;
5411       break;
5412
5413     case EM_H8_300:
5414     case EM_H8_300H:
5415       switch (elf_header.e_flags & EF_H8_MACH)
5416         {
5417         case E_H8_MACH_H8300:
5418         case E_H8_MACH_H8300HN:
5419         case E_H8_MACH_H8300SN:
5420         case E_H8_MACH_H8300SXN:
5421           eh_addr_size = 2;
5422           break;
5423         case E_H8_MACH_H8300H:
5424         case E_H8_MACH_H8300S:
5425         case E_H8_MACH_H8300SX:
5426           eh_addr_size = 4;
5427           break;
5428         }
5429       break;
5430
5431     case EM_M32C_OLD:
5432     case EM_M32C:
5433       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5434         {
5435         case EF_M32C_CPU_M16C:
5436           eh_addr_size = 2;
5437           break;
5438         }
5439       break;
5440     }
5441
5442 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
5443   do                                                                    \
5444     {                                                                   \
5445       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
5446       if (section->sh_entsize != expected_entsize)                      \
5447         {                                                               \
5448           char buf[40];                                                 \
5449           sprintf_vma (buf, section->sh_entsize);                       \
5450           /* Note: coded this way so that there is a single string for  \
5451              translation.  */ \
5452           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5453           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5454                    (unsigned) expected_entsize);                        \
5455           section->sh_entsize = expected_entsize;                       \
5456         }                                                               \
5457     }                                                                   \
5458   while (0)
5459
5460 #define CHECK_ENTSIZE(section, i, type)                                 \
5461   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
5462                         sizeof (Elf64_External_##type))
5463
5464   for (i = 0, section = section_headers;
5465        i < elf_header.e_shnum;
5466        i++, section++)
5467     {
5468       char * name = SECTION_NAME (section);
5469
5470       if (section->sh_type == SHT_DYNSYM)
5471         {
5472           if (dynamic_symbols != NULL)
5473             {
5474               error (_("File contains multiple dynamic symbol tables\n"));
5475               continue;
5476             }
5477
5478           CHECK_ENTSIZE (section, i, Sym);
5479           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5480         }
5481       else if (section->sh_type == SHT_STRTAB
5482                && streq (name, ".dynstr"))
5483         {
5484           if (dynamic_strings != NULL)
5485             {
5486               error (_("File contains multiple dynamic string tables\n"));
5487               continue;
5488             }
5489
5490           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5491                                                1, section->sh_size,
5492                                                _("dynamic strings"));
5493           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5494         }
5495       else if (section->sh_type == SHT_SYMTAB_SHNDX)
5496         {
5497           if (symtab_shndx_hdr != NULL)
5498             {
5499               error (_("File contains multiple symtab shndx tables\n"));
5500               continue;
5501             }
5502           symtab_shndx_hdr = section;
5503         }
5504       else if (section->sh_type == SHT_SYMTAB)
5505         CHECK_ENTSIZE (section, i, Sym);
5506       else if (section->sh_type == SHT_GROUP)
5507         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5508       else if (section->sh_type == SHT_REL)
5509         CHECK_ENTSIZE (section, i, Rel);
5510       else if (section->sh_type == SHT_RELA)
5511         CHECK_ENTSIZE (section, i, Rela);
5512       else if ((do_debugging || do_debug_info || do_debug_abbrevs
5513                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5514                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5515                 || do_debug_str || do_debug_loc || do_debug_ranges
5516                 || do_debug_addr || do_debug_cu_index)
5517                && (const_strneq (name, ".debug_")
5518                    || const_strneq (name, ".zdebug_")))
5519         {
5520           if (name[1] == 'z')
5521             name += sizeof (".zdebug_") - 1;
5522           else
5523             name += sizeof (".debug_") - 1;
5524
5525           if (do_debugging
5526               || (do_debug_info     && const_strneq (name, "info"))
5527               || (do_debug_info     && const_strneq (name, "types"))
5528               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
5529               || (do_debug_lines    && strcmp (name, "line") == 0)
5530               || (do_debug_lines    && const_strneq (name, "line."))
5531               || (do_debug_pubnames && const_strneq (name, "pubnames"))
5532               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5533               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5534               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5535               || (do_debug_aranges  && const_strneq (name, "aranges"))
5536               || (do_debug_ranges   && const_strneq (name, "ranges"))
5537               || (do_debug_frames   && const_strneq (name, "frame"))
5538               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
5539               || (do_debug_macinfo  && const_strneq (name, "macro"))
5540               || (do_debug_str      && const_strneq (name, "str"))
5541               || (do_debug_loc      && const_strneq (name, "loc"))
5542               || (do_debug_addr     && const_strneq (name, "addr"))
5543               || (do_debug_cu_index && const_strneq (name, "cu_index"))
5544               || (do_debug_cu_index && const_strneq (name, "tu_index"))
5545               )
5546             request_dump_bynumber (i, DEBUG_DUMP);
5547         }
5548       /* Linkonce section to be combined with .debug_info at link time.  */
5549       else if ((do_debugging || do_debug_info)
5550                && const_strneq (name, ".gnu.linkonce.wi."))
5551         request_dump_bynumber (i, DEBUG_DUMP);
5552       else if (do_debug_frames && streq (name, ".eh_frame"))
5553         request_dump_bynumber (i, DEBUG_DUMP);
5554       else if (do_gdb_index && streq (name, ".gdb_index"))
5555         request_dump_bynumber (i, DEBUG_DUMP);
5556       /* Trace sections for Itanium VMS.  */
5557       else if ((do_debugging || do_trace_info || do_trace_abbrevs
5558                 || do_trace_aranges)
5559                && const_strneq (name, ".trace_"))
5560         {
5561           name += sizeof (".trace_") - 1;
5562
5563           if (do_debugging
5564               || (do_trace_info     && streq (name, "info"))
5565               || (do_trace_abbrevs  && streq (name, "abbrev"))
5566               || (do_trace_aranges  && streq (name, "aranges"))
5567               )
5568             request_dump_bynumber (i, DEBUG_DUMP);
5569         }
5570     }
5571
5572   if (! do_sections)
5573     return 1;
5574
5575   if (elf_header.e_shnum > 1)
5576     printf (_("\nSection Headers:\n"));
5577   else
5578     printf (_("\nSection Header:\n"));
5579
5580   if (is_32bit_elf)
5581     {
5582       if (do_section_details)
5583         {
5584           printf (_("  [Nr] Name\n"));
5585           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
5586         }
5587       else
5588         printf
5589           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
5590     }
5591   else if (do_wide)
5592     {
5593       if (do_section_details)
5594         {
5595           printf (_("  [Nr] Name\n"));
5596           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
5597         }
5598       else
5599         printf
5600           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
5601     }
5602   else
5603     {
5604       if (do_section_details)
5605         {
5606           printf (_("  [Nr] Name\n"));
5607           printf (_("       Type              Address          Offset            Link\n"));
5608           printf (_("       Size              EntSize          Info              Align\n"));
5609         }
5610       else
5611         {
5612           printf (_("  [Nr] Name              Type             Address           Offset\n"));
5613           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
5614         }
5615     }
5616
5617   if (do_section_details)
5618     printf (_("       Flags\n"));
5619
5620   for (i = 0, section = section_headers;
5621        i < elf_header.e_shnum;
5622        i++, section++)
5623     {
5624       printf ("  [%2u] ", i);
5625       if (do_section_details)
5626         printf ("%s\n      ", printable_section_name (section));
5627       else
5628         print_symbol (-17, SECTION_NAME (section));
5629
5630       printf (do_wide ? " %-15s " : " %-15.15s ",
5631               get_section_type_name (section->sh_type));
5632
5633       if (is_32bit_elf)
5634         {
5635           const char * link_too_big = NULL;
5636
5637           print_vma (section->sh_addr, LONG_HEX);
5638
5639           printf ( " %6.6lx %6.6lx %2.2lx",
5640                    (unsigned long) section->sh_offset,
5641                    (unsigned long) section->sh_size,
5642                    (unsigned long) section->sh_entsize);
5643
5644           if (do_section_details)
5645             fputs ("  ", stdout);
5646           else
5647             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5648
5649           if (section->sh_link >= elf_header.e_shnum)
5650             {
5651               link_too_big = "";
5652               /* The sh_link value is out of range.  Normally this indicates
5653                  an error but it can have special values in Solaris binaries.  */
5654               switch (elf_header.e_machine)
5655                 {
5656                 case EM_386:
5657                 case EM_486:
5658                 case EM_X86_64:
5659                 case EM_L1OM:
5660                 case EM_K1OM:
5661                 case EM_OLD_SPARCV9:
5662                 case EM_SPARC32PLUS:
5663                 case EM_SPARCV9:
5664                 case EM_SPARC:
5665                   if (section->sh_link == (SHN_BEFORE & 0xffff))
5666                     link_too_big = "BEFORE";
5667                   else if (section->sh_link == (SHN_AFTER & 0xffff))
5668                     link_too_big = "AFTER";
5669                   break;
5670                 default:
5671                   break;
5672                 }
5673             }
5674
5675           if (do_section_details)
5676             {
5677               if (link_too_big != NULL && * link_too_big)
5678                 printf ("<%s> ", link_too_big);
5679               else
5680                 printf ("%2u ", section->sh_link);
5681               printf ("%3u %2lu\n", section->sh_info,
5682                       (unsigned long) section->sh_addralign);
5683             }
5684           else
5685             printf ("%2u %3u %2lu\n",
5686                     section->sh_link,
5687                     section->sh_info,
5688                     (unsigned long) section->sh_addralign);
5689
5690           if (link_too_big && ! * link_too_big)
5691             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5692                   i, section->sh_link);
5693         }
5694       else if (do_wide)
5695         {
5696           print_vma (section->sh_addr, LONG_HEX);
5697
5698           if ((long) section->sh_offset == section->sh_offset)
5699             printf (" %6.6lx", (unsigned long) section->sh_offset);
5700           else
5701             {
5702               putchar (' ');
5703               print_vma (section->sh_offset, LONG_HEX);
5704             }
5705
5706           if ((unsigned long) section->sh_size == section->sh_size)
5707             printf (" %6.6lx", (unsigned long) section->sh_size);
5708           else
5709             {
5710               putchar (' ');
5711               print_vma (section->sh_size, LONG_HEX);
5712             }
5713
5714           if ((unsigned long) section->sh_entsize == section->sh_entsize)
5715             printf (" %2.2lx", (unsigned long) section->sh_entsize);
5716           else
5717             {
5718               putchar (' ');
5719               print_vma (section->sh_entsize, LONG_HEX);
5720             }
5721
5722           if (do_section_details)
5723             fputs ("  ", stdout);
5724           else
5725             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5726
5727           printf ("%2u %3u ", section->sh_link, section->sh_info);
5728
5729           if ((unsigned long) section->sh_addralign == section->sh_addralign)
5730             printf ("%2lu\n", (unsigned long) section->sh_addralign);
5731           else
5732             {
5733               print_vma (section->sh_addralign, DEC);
5734               putchar ('\n');
5735             }
5736         }
5737       else if (do_section_details)
5738         {
5739           printf ("       %-15.15s  ",
5740                   get_section_type_name (section->sh_type));
5741           print_vma (section->sh_addr, LONG_HEX);
5742           if ((long) section->sh_offset == section->sh_offset)
5743             printf ("  %16.16lx", (unsigned long) section->sh_offset);
5744           else
5745             {
5746               printf ("  ");
5747               print_vma (section->sh_offset, LONG_HEX);
5748             }
5749           printf ("  %u\n       ", section->sh_link);
5750           print_vma (section->sh_size, LONG_HEX);
5751           putchar (' ');
5752           print_vma (section->sh_entsize, LONG_HEX);
5753
5754           printf ("  %-16u  %lu\n",
5755                   section->sh_info,
5756                   (unsigned long) section->sh_addralign);
5757         }
5758       else
5759         {
5760           putchar (' ');
5761           print_vma (section->sh_addr, LONG_HEX);
5762           if ((long) section->sh_offset == section->sh_offset)
5763             printf ("  %8.8lx", (unsigned long) section->sh_offset);
5764           else
5765             {
5766               printf ("  ");
5767               print_vma (section->sh_offset, LONG_HEX);
5768             }
5769           printf ("\n       ");
5770           print_vma (section->sh_size, LONG_HEX);
5771           printf ("  ");
5772           print_vma (section->sh_entsize, LONG_HEX);
5773
5774           printf (" %3s ", get_elf_section_flags (section->sh_flags));
5775
5776           printf ("     %2u   %3u     %lu\n",
5777                   section->sh_link,
5778                   section->sh_info,
5779                   (unsigned long) section->sh_addralign);
5780         }
5781
5782       if (do_section_details)
5783         printf ("       %s\n", get_elf_section_flags (section->sh_flags));
5784     }
5785
5786   if (!do_section_details)
5787     {
5788       if (elf_header.e_machine == EM_X86_64
5789           || elf_header.e_machine == EM_L1OM
5790           || elf_header.e_machine == EM_K1OM)
5791         printf (_("Key to Flags:\n\
5792   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5793   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5794   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5795       else
5796         printf (_("Key to Flags:\n\
5797   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5798   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5799   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5800     }
5801
5802   return 1;
5803 }
5804
5805 static const char *
5806 get_group_flags (unsigned int flags)
5807 {
5808   static char buff[32];
5809   switch (flags)
5810     {
5811     case 0:
5812       return "";
5813
5814     case GRP_COMDAT:
5815       return "COMDAT ";
5816
5817    default:
5818       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5819       break;
5820     }
5821   return buff;
5822 }
5823
5824 static int
5825 process_section_groups (FILE * file)
5826 {
5827   Elf_Internal_Shdr * section;
5828   unsigned int i;
5829   struct group * group;
5830   Elf_Internal_Shdr * symtab_sec;
5831   Elf_Internal_Shdr * strtab_sec;
5832   Elf_Internal_Sym * symtab;
5833   unsigned long num_syms;
5834   char * strtab;
5835   size_t strtab_size;
5836
5837   /* Don't process section groups unless needed.  */
5838   if (!do_unwind && !do_section_groups)
5839     return 1;
5840
5841   if (elf_header.e_shnum == 0)
5842     {
5843       if (do_section_groups)
5844         printf (_("\nThere are no sections to group in this file.\n"));
5845
5846       return 1;
5847     }
5848
5849   if (section_headers == NULL)
5850     {
5851       error (_("Section headers are not available!\n"));
5852       /* PR 13622: This can happen with a corrupt ELF header.  */
5853       return 0;
5854     }
5855
5856   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5857                                                      sizeof (struct group *));
5858
5859   if (section_headers_groups == NULL)
5860     {
5861       error (_("Out of memory reading %u section group headers\n"),
5862              elf_header.e_shnum);
5863       return 0;
5864     }
5865
5866   /* Scan the sections for the group section.  */
5867   group_count = 0;
5868   for (i = 0, section = section_headers;
5869        i < elf_header.e_shnum;
5870        i++, section++)
5871     if (section->sh_type == SHT_GROUP)
5872       group_count++;
5873
5874   if (group_count == 0)
5875     {
5876       if (do_section_groups)
5877         printf (_("\nThere are no section groups in this file.\n"));
5878
5879       return 1;
5880     }
5881
5882   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5883
5884   if (section_groups == NULL)
5885     {
5886       error (_("Out of memory reading %lu groups\n"),
5887              (unsigned long) group_count);
5888       return 0;
5889     }
5890
5891   symtab_sec = NULL;
5892   strtab_sec = NULL;
5893   symtab = NULL;
5894   num_syms = 0;
5895   strtab = NULL;
5896   strtab_size = 0;
5897   for (i = 0, section = section_headers, group = section_groups;
5898        i < elf_header.e_shnum;
5899        i++, section++)
5900     {
5901       if (section->sh_type == SHT_GROUP)
5902         {
5903           const char * name = printable_section_name (section);
5904           const char * group_name;
5905           unsigned char * start;
5906           unsigned char * indices;
5907           unsigned int entry, j, size;
5908           Elf_Internal_Shdr * sec;
5909           Elf_Internal_Sym * sym;
5910
5911           /* Get the symbol table.  */
5912           if (section->sh_link >= elf_header.e_shnum
5913               || ((sec = section_headers + section->sh_link)->sh_type
5914                   != SHT_SYMTAB))
5915             {
5916               error (_("Bad sh_link in group section `%s'\n"), name);
5917               continue;
5918             }
5919
5920           if (symtab_sec != sec)
5921             {
5922               symtab_sec = sec;
5923               if (symtab)
5924                 free (symtab);
5925               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5926             }
5927
5928           if (symtab == NULL)
5929             {
5930               error (_("Corrupt header in group section `%s'\n"), name);
5931               continue;
5932             }
5933
5934           if (section->sh_info >= num_syms)
5935             {
5936               error (_("Bad sh_info in group section `%s'\n"), name);
5937               continue;
5938             }
5939
5940           sym = symtab + section->sh_info;
5941
5942           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5943             {
5944               if (sym->st_shndx == 0
5945                   || sym->st_shndx >= elf_header.e_shnum)
5946                 {
5947                   error (_("Bad sh_info in group section `%s'\n"), name);
5948                   continue;
5949                 }
5950
5951               group_name = SECTION_NAME (section_headers + sym->st_shndx);
5952               strtab_sec = NULL;
5953               if (strtab)
5954                 free (strtab);
5955               strtab = NULL;
5956               strtab_size = 0;
5957             }
5958           else
5959             {
5960               /* Get the string table.  */
5961               if (symtab_sec->sh_link >= elf_header.e_shnum)
5962                 {
5963                   strtab_sec = NULL;
5964                   if (strtab)
5965                     free (strtab);
5966                   strtab = NULL;
5967                   strtab_size = 0;
5968                 }
5969               else if (strtab_sec
5970                        != (sec = section_headers + symtab_sec->sh_link))
5971                 {
5972                   strtab_sec = sec;
5973                   if (strtab)
5974                     free (strtab);
5975
5976                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5977                                               1, strtab_sec->sh_size,
5978                                               _("string table"));
5979                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5980                 }
5981               group_name = sym->st_name < strtab_size
5982                 ? strtab + sym->st_name : _("<corrupt>");
5983             }
5984
5985           /* PR 17531: file: loop.  */
5986           if (section->sh_entsize > section->sh_size)
5987             {
5988               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
5989                      printable_section_name (section),
5990                      (unsigned long) section->sh_entsize,
5991                      (unsigned long) section->sh_size);
5992               break;
5993             }
5994
5995           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5996                                               1, section->sh_size,
5997                                               _("section data"));
5998           if (start == NULL)
5999             continue;
6000
6001           indices = start;
6002           size = (section->sh_size / section->sh_entsize) - 1;
6003           entry = byte_get (indices, 4);
6004           indices += 4;
6005
6006           if (do_section_groups)
6007             {
6008               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6009                       get_group_flags (entry), i, name, group_name, size);
6010
6011               printf (_("   [Index]    Name\n"));
6012             }
6013
6014           group->group_index = i;
6015
6016           for (j = 0; j < size; j++)
6017             {
6018               struct group_list * g;
6019
6020               entry = byte_get (indices, 4);
6021               indices += 4;
6022
6023               if (entry >= elf_header.e_shnum)
6024                 {
6025                   static unsigned num_group_errors = 0;
6026
6027                   if (num_group_errors ++ < 10)
6028                     {
6029                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6030                              entry, i, elf_header.e_shnum - 1);
6031                       if (num_group_errors == 10)
6032                         warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6033                     }
6034                   continue;
6035                 }
6036
6037               if (section_headers_groups [entry] != NULL)
6038                 {
6039                   if (entry)
6040                     {
6041                       static unsigned num_errs = 0;
6042
6043                       if (num_errs ++ < 10)
6044                         {
6045                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6046                                  entry, i,
6047                                  section_headers_groups [entry]->group_index);
6048                           if (num_errs == 10)
6049                             warn (_("Further error messages about already contained group sections suppressed\n"));
6050                         }
6051                       continue;
6052                     }
6053                   else
6054                     {
6055                       /* Intel C/C++ compiler may put section 0 in a
6056                          section group. We just warn it the first time
6057                          and ignore it afterwards.  */
6058                       static int warned = 0;
6059                       if (!warned)
6060                         {
6061                           error (_("section 0 in group section [%5u]\n"),
6062                                  section_headers_groups [entry]->group_index);
6063                           warned++;
6064                         }
6065                     }
6066                 }
6067
6068               section_headers_groups [entry] = group;
6069
6070               if (do_section_groups)
6071                 {
6072                   sec = section_headers + entry;
6073                   printf ("   [%5u]   %s\n", entry, printable_section_name (sec));
6074                 }
6075
6076               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6077               g->section_index = entry;
6078               g->next = group->root;
6079               group->root = g;
6080             }
6081
6082           if (start)
6083             free (start);
6084
6085           group++;
6086         }
6087     }
6088
6089   if (symtab)
6090     free (symtab);
6091   if (strtab)
6092     free (strtab);
6093   return 1;
6094 }
6095
6096 /* Data used to display dynamic fixups.  */
6097
6098 struct ia64_vms_dynfixup
6099 {
6100   bfd_vma needed_ident;         /* Library ident number.  */
6101   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6102   bfd_vma fixup_needed;         /* Index of the library.  */
6103   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6104   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6105 };
6106
6107 /* Data used to display dynamic relocations.  */
6108
6109 struct ia64_vms_dynimgrela
6110 {
6111   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6112   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6113 };
6114
6115 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6116    library).  */
6117
6118 static void
6119 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6120                               const char *strtab, unsigned int strtab_sz)
6121 {
6122   Elf64_External_VMS_IMAGE_FIXUP *imfs;
6123   long i;
6124   const char *lib_name;
6125
6126   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6127                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6128                    _("dynamic section image fixups"));
6129   if (!imfs)
6130     return;
6131
6132   if (fixup->needed < strtab_sz)
6133     lib_name = strtab + fixup->needed;
6134   else
6135     {
6136       warn ("corrupt library name index of 0x%lx found in dynamic entry",
6137             (unsigned long) fixup->needed);
6138       lib_name = "???";
6139     }
6140   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6141           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6142   printf
6143     (_("Seg Offset           Type                             SymVec DataType\n"));
6144
6145   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6146     {
6147       unsigned int type;
6148       const char *rtype;
6149
6150       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6151       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6152       type = BYTE_GET (imfs [i].type);
6153       rtype = elf_ia64_reloc_type (type);
6154       if (rtype == NULL)
6155         printf (" 0x%08x                       ", type);
6156       else
6157         printf (" %-32s ", rtype);
6158       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6159       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6160     }
6161
6162   free (imfs);
6163 }
6164
6165 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6166
6167 static void
6168 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6169 {
6170   Elf64_External_VMS_IMAGE_RELA *imrs;
6171   long i;
6172
6173   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6174                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6175                    _("dynamic section image relocations"));
6176   if (!imrs)
6177     return;
6178
6179   printf (_("\nImage relocs\n"));
6180   printf
6181     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6182
6183   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6184     {
6185       unsigned int type;
6186       const char *rtype;
6187
6188       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6189       printf ("%08" BFD_VMA_FMT "x ",
6190               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6191       type = BYTE_GET (imrs [i].type);
6192       rtype = elf_ia64_reloc_type (type);
6193       if (rtype == NULL)
6194         printf ("0x%08x                      ", type);
6195       else
6196         printf ("%-31s ", rtype);
6197       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6198       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6199       printf ("%08" BFD_VMA_FMT "x\n",
6200               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6201     }
6202
6203   free (imrs);
6204 }
6205
6206 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
6207
6208 static int
6209 process_ia64_vms_dynamic_relocs (FILE *file)
6210 {
6211   struct ia64_vms_dynfixup fixup;
6212   struct ia64_vms_dynimgrela imgrela;
6213   Elf_Internal_Dyn *entry;
6214   int res = 0;
6215   bfd_vma strtab_off = 0;
6216   bfd_vma strtab_sz = 0;
6217   char *strtab = NULL;
6218
6219   memset (&fixup, 0, sizeof (fixup));
6220   memset (&imgrela, 0, sizeof (imgrela));
6221
6222   /* Note: the order of the entries is specified by the OpenVMS specs.  */
6223   for (entry = dynamic_section;
6224        entry < dynamic_section + dynamic_nent;
6225        entry++)
6226     {
6227       switch (entry->d_tag)
6228         {
6229         case DT_IA_64_VMS_STRTAB_OFFSET:
6230           strtab_off = entry->d_un.d_val;
6231           break;
6232         case DT_STRSZ:
6233           strtab_sz = entry->d_un.d_val;
6234           if (strtab == NULL)
6235             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6236                                1, strtab_sz, _("dynamic string section"));
6237           break;
6238
6239         case DT_IA_64_VMS_NEEDED_IDENT:
6240           fixup.needed_ident = entry->d_un.d_val;
6241           break;
6242         case DT_NEEDED:
6243           fixup.needed = entry->d_un.d_val;
6244           break;
6245         case DT_IA_64_VMS_FIXUP_NEEDED:
6246           fixup.fixup_needed = entry->d_un.d_val;
6247           break;
6248         case DT_IA_64_VMS_FIXUP_RELA_CNT:
6249           fixup.fixup_rela_cnt = entry->d_un.d_val;
6250           break;
6251         case DT_IA_64_VMS_FIXUP_RELA_OFF:
6252           fixup.fixup_rela_off = entry->d_un.d_val;
6253           res++;
6254           dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6255           break;
6256
6257         case DT_IA_64_VMS_IMG_RELA_CNT:
6258           imgrela.img_rela_cnt = entry->d_un.d_val;
6259           break;
6260         case DT_IA_64_VMS_IMG_RELA_OFF:
6261           imgrela.img_rela_off = entry->d_un.d_val;
6262           res++;
6263           dump_ia64_vms_dynamic_relocs (file, &imgrela);
6264           break;
6265
6266         default:
6267           break;
6268         }
6269     }
6270
6271   if (strtab != NULL)
6272     free (strtab);
6273
6274   return res;
6275 }
6276
6277 static struct
6278 {
6279   const char * name;
6280   int reloc;
6281   int size;
6282   int rela;
6283 } dynamic_relocations [] =
6284 {
6285     { "REL", DT_REL, DT_RELSZ, FALSE },
6286     { "RELA", DT_RELA, DT_RELASZ, TRUE },
6287     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6288 };
6289
6290 /* Process the reloc section.  */
6291
6292 static int
6293 process_relocs (FILE * file)
6294 {
6295   unsigned long rel_size;
6296   unsigned long rel_offset;
6297
6298
6299   if (!do_reloc)
6300     return 1;
6301
6302   if (do_using_dynamic)
6303     {
6304       int is_rela;
6305       const char * name;
6306       int has_dynamic_reloc;
6307       unsigned int i;
6308
6309       has_dynamic_reloc = 0;
6310
6311       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6312         {
6313           is_rela = dynamic_relocations [i].rela;
6314           name = dynamic_relocations [i].name;
6315           rel_size = dynamic_info [dynamic_relocations [i].size];
6316           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6317
6318           has_dynamic_reloc |= rel_size;
6319
6320           if (is_rela == UNKNOWN)
6321             {
6322               if (dynamic_relocations [i].reloc == DT_JMPREL)
6323                 switch (dynamic_info[DT_PLTREL])
6324                   {
6325                   case DT_REL:
6326                     is_rela = FALSE;
6327                     break;
6328                   case DT_RELA:
6329                     is_rela = TRUE;
6330                     break;
6331                   }
6332             }
6333
6334           if (rel_size)
6335             {
6336               printf
6337                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6338                  name, rel_offset, rel_size);
6339
6340               dump_relocations (file,
6341                                 offset_from_vma (file, rel_offset, rel_size),
6342                                 rel_size,
6343                                 dynamic_symbols, num_dynamic_syms,
6344                                 dynamic_strings, dynamic_strings_length,
6345                                 is_rela, 1);
6346             }
6347         }
6348
6349       if (is_ia64_vms ())
6350         has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6351
6352       if (! has_dynamic_reloc)
6353         printf (_("\nThere are no dynamic relocations in this file.\n"));
6354     }
6355   else
6356     {
6357       Elf_Internal_Shdr * section;
6358       unsigned long i;
6359       int found = 0;
6360
6361       for (i = 0, section = section_headers;
6362            i < elf_header.e_shnum;
6363            i++, section++)
6364         {
6365           if (   section->sh_type != SHT_RELA
6366               && section->sh_type != SHT_REL)
6367             continue;
6368
6369           rel_offset = section->sh_offset;
6370           rel_size   = section->sh_size;
6371
6372           if (rel_size)
6373             {
6374               Elf_Internal_Shdr * strsec;
6375               int is_rela;
6376
6377               printf (_("\nRelocation section "));
6378
6379               if (string_table == NULL)
6380                 printf ("%d", section->sh_name);
6381               else
6382                 printf ("'%s'", printable_section_name (section));
6383
6384               printf (_(" at offset 0x%lx contains %lu entries:\n"),
6385                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6386
6387               is_rela = section->sh_type == SHT_RELA;
6388
6389               if (section->sh_link != 0
6390                   && section->sh_link < elf_header.e_shnum)
6391                 {
6392                   Elf_Internal_Shdr * symsec;
6393                   Elf_Internal_Sym *  symtab;
6394                   unsigned long nsyms;
6395                   unsigned long strtablen = 0;
6396                   char * strtab = NULL;
6397
6398                   symsec = section_headers + section->sh_link;
6399                   if (symsec->sh_type != SHT_SYMTAB
6400                       && symsec->sh_type != SHT_DYNSYM)
6401                     continue;
6402
6403                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
6404
6405                   if (symtab == NULL)
6406                     continue;
6407
6408                   if (symsec->sh_link != 0
6409                       && symsec->sh_link < elf_header.e_shnum)
6410                     {
6411                       strsec = section_headers + symsec->sh_link;
6412
6413                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6414                                                   1, strsec->sh_size,
6415                                                   _("string table"));
6416                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
6417                     }
6418
6419                   dump_relocations (file, rel_offset, rel_size,
6420                                     symtab, nsyms, strtab, strtablen,
6421                                     is_rela,
6422                                     symsec->sh_type == SHT_DYNSYM);
6423                   if (strtab)
6424                     free (strtab);
6425                   free (symtab);
6426                 }
6427               else
6428                 dump_relocations (file, rel_offset, rel_size,
6429                                   NULL, 0, NULL, 0, is_rela, 0);
6430
6431               found = 1;
6432             }
6433         }
6434
6435       if (! found)
6436         printf (_("\nThere are no relocations in this file.\n"));
6437     }
6438
6439   return 1;
6440 }
6441
6442 /* Process the unwind section.  */
6443
6444 #include "unwind-ia64.h"
6445
6446 /* An absolute address consists of a section and an offset.  If the
6447    section is NULL, the offset itself is the address, otherwise, the
6448    address equals to LOAD_ADDRESS(section) + offset.  */
6449
6450 struct absaddr
6451   {
6452     unsigned short section;
6453     bfd_vma offset;
6454   };
6455
6456 #define ABSADDR(a) \
6457   ((a).section \
6458    ? section_headers [(a).section].sh_addr + (a).offset \
6459    : (a).offset)
6460
6461 struct ia64_unw_table_entry
6462   {
6463     struct absaddr start;
6464     struct absaddr end;
6465     struct absaddr info;
6466   };
6467
6468 struct ia64_unw_aux_info
6469   {
6470
6471     struct ia64_unw_table_entry *table; /* Unwind table.  */
6472     unsigned long table_len;    /* Length of unwind table.  */
6473     unsigned char * info;       /* Unwind info.  */
6474     unsigned long info_size;    /* Size of unwind info.  */
6475     bfd_vma info_addr;          /* starting address of unwind info.  */
6476     bfd_vma seg_base;           /* Starting address of segment.  */
6477     Elf_Internal_Sym * symtab;  /* The symbol table.  */
6478     unsigned long nsyms;        /* Number of symbols.  */
6479     char * strtab;              /* The string table.  */
6480     unsigned long strtab_size;  /* Size of string table.  */
6481   };
6482
6483 static void
6484 find_symbol_for_address (Elf_Internal_Sym * symtab,
6485                          unsigned long nsyms,
6486                          const char * strtab,
6487                          unsigned long strtab_size,
6488                          struct absaddr addr,
6489                          const char ** symname,
6490                          bfd_vma * offset)
6491 {
6492   bfd_vma dist = 0x100000;
6493   Elf_Internal_Sym * sym;
6494   Elf_Internal_Sym * best = NULL;
6495   unsigned long i;
6496
6497   REMOVE_ARCH_BITS (addr.offset);
6498
6499   for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
6500     {
6501       bfd_vma value = sym->st_value;
6502
6503       REMOVE_ARCH_BITS (value);
6504
6505       if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
6506           && sym->st_name != 0
6507           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6508           && addr.offset >= value
6509           && addr.offset - value < dist)
6510         {
6511           best = sym;
6512           dist = addr.offset - value;
6513           if (!dist)
6514             break;
6515         }
6516     }
6517
6518   if (best)
6519     {
6520       *symname = (best->st_name >= strtab_size
6521                   ? _("<corrupt>") : strtab + best->st_name);
6522       *offset = dist;
6523       return;
6524     }
6525
6526   *symname = NULL;
6527   *offset = addr.offset;
6528 }
6529
6530 static void
6531 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6532 {
6533   struct ia64_unw_table_entry * tp;
6534   int in_body;
6535
6536   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6537     {
6538       bfd_vma stamp;
6539       bfd_vma offset;
6540       const unsigned char * dp;
6541       const unsigned char * head;
6542       const unsigned char * end;
6543       const char * procname;
6544
6545       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6546                                aux->strtab_size, tp->start, &procname, &offset);
6547
6548       fputs ("\n<", stdout);
6549
6550       if (procname)
6551         {
6552           fputs (procname, stdout);
6553
6554           if (offset)
6555             printf ("+%lx", (unsigned long) offset);
6556         }
6557
6558       fputs (">: [", stdout);
6559       print_vma (tp->start.offset, PREFIX_HEX);
6560       fputc ('-', stdout);
6561       print_vma (tp->end.offset, PREFIX_HEX);
6562       printf ("], info at +0x%lx\n",
6563               (unsigned long) (tp->info.offset - aux->seg_base));
6564
6565       /* PR 17531: file: 86232b32.  */
6566       if (aux->info == NULL)
6567         continue;
6568
6569       /* PR 17531: file: 0997b4d1.  */
6570       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6571         {
6572           warn (_("Invalid offset %lx in table entry %ld\n"),
6573                 (long) tp->info.offset, (long) (tp - aux->table));
6574           continue;
6575         }
6576
6577       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6578       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6579
6580       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6581               (unsigned) UNW_VER (stamp),
6582               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6583               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6584               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6585               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6586
6587       if (UNW_VER (stamp) != 1)
6588         {
6589           printf (_("\tUnknown version.\n"));
6590           continue;
6591         }
6592
6593       in_body = 0;
6594       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6595       /* PR 17531: file: 16ceda89.  */
6596       if (end > aux->info + aux->info_size)
6597         end = aux->info + aux->info_size;
6598       for (dp = head + 8; dp < end;)
6599         dp = unw_decode (dp, in_body, & in_body);
6600     }
6601 }
6602
6603 static bfd_boolean
6604 slurp_ia64_unwind_table (FILE * file,
6605                          struct ia64_unw_aux_info * aux,
6606                          Elf_Internal_Shdr * sec)
6607 {
6608   unsigned long size, nrelas, i;
6609   Elf_Internal_Phdr * seg;
6610   struct ia64_unw_table_entry * tep;
6611   Elf_Internal_Shdr * relsec;
6612   Elf_Internal_Rela * rela;
6613   Elf_Internal_Rela * rp;
6614   unsigned char * table;
6615   unsigned char * tp;
6616   Elf_Internal_Sym * sym;
6617   const char * relname;
6618
6619   aux->table_len = 0;
6620
6621   /* First, find the starting address of the segment that includes
6622      this section: */
6623
6624   if (elf_header.e_phnum)
6625     {
6626       if (! get_program_headers (file))
6627           return FALSE;
6628
6629       for (seg = program_headers;
6630            seg < program_headers + elf_header.e_phnum;
6631            ++seg)
6632         {
6633           if (seg->p_type != PT_LOAD)
6634             continue;
6635
6636           if (sec->sh_addr >= seg->p_vaddr
6637               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6638             {
6639               aux->seg_base = seg->p_vaddr;
6640               break;
6641             }
6642         }
6643     }
6644
6645   /* Second, build the unwind table from the contents of the unwind section:  */
6646   size = sec->sh_size;
6647   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6648                                       _("unwind table"));
6649   if (!table)
6650     return FALSE;
6651
6652   aux->table_len = size / (3 * eh_addr_size);
6653   aux->table = (struct ia64_unw_table_entry *)
6654     xcmalloc (aux->table_len, sizeof (aux->table[0]));
6655   tep = aux->table;
6656
6657   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
6658     {
6659       tep->start.section = SHN_UNDEF;
6660       tep->end.section   = SHN_UNDEF;
6661       tep->info.section  = SHN_UNDEF;
6662       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6663       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6664       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6665       tep->start.offset += aux->seg_base;
6666       tep->end.offset   += aux->seg_base;
6667       tep->info.offset  += aux->seg_base;
6668     }
6669   free (table);
6670
6671   /* Third, apply any relocations to the unwind table:  */
6672   for (relsec = section_headers;
6673        relsec < section_headers + elf_header.e_shnum;
6674        ++relsec)
6675     {
6676       if (relsec->sh_type != SHT_RELA
6677           || relsec->sh_info >= elf_header.e_shnum
6678           || section_headers + relsec->sh_info != sec)
6679         continue;
6680
6681       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6682                               & rela, & nrelas))
6683         {
6684           free (aux->table);
6685           aux->table = NULL;
6686           aux->table_len = 0;
6687           return FALSE;
6688         }
6689
6690       for (rp = rela; rp < rela + nrelas; ++rp)
6691         {
6692           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6693           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6694
6695           /* PR 17531: file: 9fa67536.  */
6696           if (relname == NULL)
6697             {
6698               warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6699               continue;
6700             }
6701
6702           if (! const_strneq (relname, "R_IA64_SEGREL"))
6703             {
6704               warn (_("Skipping unexpected relocation type: %s\n"), relname);
6705               continue;
6706             }
6707
6708           i = rp->r_offset / (3 * eh_addr_size);
6709
6710           /* PR 17531: file: 5bc8d9bf.  */
6711           if (i >= aux->table_len)
6712             {
6713               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6714               continue;
6715             }
6716
6717           switch (rp->r_offset / eh_addr_size % 3)
6718             {
6719             case 0:
6720               aux->table[i].start.section = sym->st_shndx;
6721               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
6722               break;
6723             case 1:
6724               aux->table[i].end.section   = sym->st_shndx;
6725               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
6726               break;
6727             case 2:
6728               aux->table[i].info.section  = sym->st_shndx;
6729               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
6730               break;
6731             default:
6732               break;
6733             }
6734         }
6735
6736       free (rela);
6737     }
6738
6739   return TRUE;
6740 }
6741
6742 static void
6743 ia64_process_unwind (FILE * file)
6744 {
6745   Elf_Internal_Shdr * sec;
6746   Elf_Internal_Shdr * unwsec = NULL;
6747   Elf_Internal_Shdr * strsec;
6748   unsigned long i, unwcount = 0, unwstart = 0;
6749   struct ia64_unw_aux_info aux;
6750
6751   memset (& aux, 0, sizeof (aux));
6752
6753   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6754     {
6755       if (sec->sh_type == SHT_SYMTAB
6756           && sec->sh_link < elf_header.e_shnum)
6757         {
6758           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6759
6760           strsec = section_headers + sec->sh_link;
6761           if (aux.strtab != NULL)
6762             {
6763               error (_("Multiple auxillary string tables encountered\n"));
6764               free (aux.strtab);
6765             }
6766           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6767                                           1, strsec->sh_size,
6768                                           _("string table"));
6769           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6770         }
6771       else if (sec->sh_type == SHT_IA_64_UNWIND)
6772         unwcount++;
6773     }
6774
6775   if (!unwcount)
6776     printf (_("\nThere are no unwind sections in this file.\n"));
6777
6778   while (unwcount-- > 0)
6779     {
6780       char * suffix;
6781       size_t len, len2;
6782
6783       for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
6784            i < elf_header.e_shnum; ++i, ++sec)
6785         if (sec->sh_type == SHT_IA_64_UNWIND)
6786           {
6787             unwsec = sec;
6788             break;
6789           }
6790       /* We have already counted the number of SHT_IA64_UNWIND
6791          sections so the loop above should never fail.  */
6792       assert (unwsec != NULL);
6793
6794       unwstart = i + 1;
6795       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6796
6797       if ((unwsec->sh_flags & SHF_GROUP) != 0)
6798         {
6799           /* We need to find which section group it is in.  */
6800           struct group_list * g;
6801
6802           if (section_headers_groups == NULL
6803               || section_headers_groups [i] == NULL)
6804             i = elf_header.e_shnum;
6805           else
6806             {
6807               g = section_headers_groups [i]->root;
6808
6809               for (; g != NULL; g = g->next)
6810                 {
6811                   sec = section_headers + g->section_index;
6812
6813                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6814                     break;
6815                 }
6816
6817               if (g == NULL)
6818                 i = elf_header.e_shnum;
6819             }
6820         }
6821       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6822         {
6823           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
6824           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6825           suffix = SECTION_NAME (unwsec) + len;
6826           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6827                ++i, ++sec)
6828             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6829                 && streq (SECTION_NAME (sec) + len2, suffix))
6830               break;
6831         }
6832       else
6833         {
6834           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6835              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
6836           len = sizeof (ELF_STRING_ia64_unwind) - 1;
6837           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6838           suffix = "";
6839           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6840             suffix = SECTION_NAME (unwsec) + len;
6841           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6842                ++i, ++sec)
6843             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6844                 && streq (SECTION_NAME (sec) + len2, suffix))
6845               break;
6846         }
6847
6848       if (i == elf_header.e_shnum)
6849         {
6850           printf (_("\nCould not find unwind info section for "));
6851
6852           if (string_table == NULL)
6853             printf ("%d", unwsec->sh_name);
6854           else
6855             printf ("'%s'", printable_section_name (unwsec));
6856         }
6857       else
6858         {
6859           aux.info_addr = sec->sh_addr;
6860           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6861                                                  sec->sh_size,
6862                                                  _("unwind info"));
6863           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6864
6865           printf (_("\nUnwind section "));
6866
6867           if (string_table == NULL)
6868             printf ("%d", unwsec->sh_name);
6869           else
6870             printf ("'%s'", printable_section_name (unwsec));
6871
6872           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6873                   (unsigned long) unwsec->sh_offset,
6874                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6875
6876           if (slurp_ia64_unwind_table (file, & aux, unwsec)
6877               && aux.table_len > 0)
6878             dump_ia64_unwind (& aux);
6879
6880           if (aux.table)
6881             free ((char *) aux.table);
6882           if (aux.info)
6883             free ((char *) aux.info);
6884           aux.table = NULL;
6885           aux.info = NULL;
6886         }
6887     }
6888
6889   if (aux.symtab)
6890     free (aux.symtab);
6891   if (aux.strtab)
6892     free ((char *) aux.strtab);
6893 }
6894
6895 struct hppa_unw_table_entry
6896   {
6897     struct absaddr start;
6898     struct absaddr end;
6899     unsigned int Cannot_unwind:1;                       /* 0 */
6900     unsigned int Millicode:1;                   /* 1 */
6901     unsigned int Millicode_save_sr0:1;          /* 2 */
6902     unsigned int Region_description:2;          /* 3..4 */
6903     unsigned int reserved1:1;                   /* 5 */
6904     unsigned int Entry_SR:1;                    /* 6 */
6905     unsigned int Entry_FR:4;     /* number saved */     /* 7..10 */
6906     unsigned int Entry_GR:5;     /* number saved */     /* 11..15 */
6907     unsigned int Args_stored:1;                 /* 16 */
6908     unsigned int Variable_Frame:1;                      /* 17 */
6909     unsigned int Separate_Package_Body:1;               /* 18 */
6910     unsigned int Frame_Extension_Millicode:1;   /* 19 */
6911     unsigned int Stack_Overflow_Check:1;                /* 20 */
6912     unsigned int Two_Instruction_SP_Increment:1;        /* 21 */
6913     unsigned int Ada_Region:1;                  /* 22 */
6914     unsigned int cxx_info:1;                    /* 23 */
6915     unsigned int cxx_try_catch:1;                       /* 24 */
6916     unsigned int sched_entry_seq:1;                     /* 25 */
6917     unsigned int reserved2:1;                   /* 26 */
6918     unsigned int Save_SP:1;                             /* 27 */
6919     unsigned int Save_RP:1;                             /* 28 */
6920     unsigned int Save_MRP_in_frame:1;           /* 29 */
6921     unsigned int extn_ptr_defined:1;            /* 30 */
6922     unsigned int Cleanup_defined:1;                     /* 31 */
6923
6924     unsigned int MPE_XL_interrupt_marker:1;             /* 0 */
6925     unsigned int HP_UX_interrupt_marker:1;              /* 1 */
6926     unsigned int Large_frame:1;                 /* 2 */
6927     unsigned int Pseudo_SP_Set:1;                       /* 3 */
6928     unsigned int reserved4:1;                   /* 4 */
6929     unsigned int Total_frame_size:27;           /* 5..31 */
6930   };
6931
6932 struct hppa_unw_aux_info
6933   {
6934     struct hppa_unw_table_entry *table; /* Unwind table.  */
6935     unsigned long table_len;    /* Length of unwind table.  */
6936     bfd_vma seg_base;           /* Starting address of segment.  */
6937     Elf_Internal_Sym * symtab;  /* The symbol table.  */
6938     unsigned long nsyms;        /* Number of symbols.  */
6939     char * strtab;              /* The string table.  */
6940     unsigned long strtab_size;  /* Size of string table.  */
6941   };
6942
6943 static void
6944 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
6945 {
6946   struct hppa_unw_table_entry * tp;
6947
6948   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6949     {
6950       bfd_vma offset;
6951       const char * procname;
6952
6953       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6954                                aux->strtab_size, tp->start, &procname,
6955                                &offset);
6956
6957       fputs ("\n<", stdout);
6958
6959       if (procname)
6960         {
6961           fputs (procname, stdout);
6962
6963           if (offset)
6964             printf ("+%lx", (unsigned long) offset);
6965         }
6966
6967       fputs (">: [", stdout);
6968       print_vma (tp->start.offset, PREFIX_HEX);
6969       fputc ('-', stdout);
6970       print_vma (tp->end.offset, PREFIX_HEX);
6971       printf ("]\n\t");
6972
6973 #define PF(_m) if (tp->_m) printf (#_m " ");
6974 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6975       PF(Cannot_unwind);
6976       PF(Millicode);
6977       PF(Millicode_save_sr0);
6978       /* PV(Region_description);  */
6979       PF(Entry_SR);
6980       PV(Entry_FR);
6981       PV(Entry_GR);
6982       PF(Args_stored);
6983       PF(Variable_Frame);
6984       PF(Separate_Package_Body);
6985       PF(Frame_Extension_Millicode);
6986       PF(Stack_Overflow_Check);
6987       PF(Two_Instruction_SP_Increment);
6988       PF(Ada_Region);
6989       PF(cxx_info);
6990       PF(cxx_try_catch);
6991       PF(sched_entry_seq);
6992       PF(Save_SP);
6993       PF(Save_RP);
6994       PF(Save_MRP_in_frame);
6995       PF(extn_ptr_defined);
6996       PF(Cleanup_defined);
6997       PF(MPE_XL_interrupt_marker);
6998       PF(HP_UX_interrupt_marker);
6999       PF(Large_frame);
7000       PF(Pseudo_SP_Set);
7001       PV(Total_frame_size);
7002 #undef PF
7003 #undef PV
7004     }
7005
7006   printf ("\n");
7007 }
7008
7009 static int
7010 slurp_hppa_unwind_table (FILE * file,
7011                          struct hppa_unw_aux_info * aux,
7012                          Elf_Internal_Shdr * sec)
7013 {
7014   unsigned long size, unw_ent_size, nentries, nrelas, i;
7015   Elf_Internal_Phdr * seg;
7016   struct hppa_unw_table_entry * tep;
7017   Elf_Internal_Shdr * relsec;
7018   Elf_Internal_Rela * rela;
7019   Elf_Internal_Rela * rp;
7020   unsigned char * table;
7021   unsigned char * tp;
7022   Elf_Internal_Sym * sym;
7023   const char * relname;
7024
7025   /* First, find the starting address of the segment that includes
7026      this section.  */
7027
7028   if (elf_header.e_phnum)
7029     {
7030       if (! get_program_headers (file))
7031         return 0;
7032
7033       for (seg = program_headers;
7034            seg < program_headers + elf_header.e_phnum;
7035            ++seg)
7036         {
7037           if (seg->p_type != PT_LOAD)
7038             continue;
7039
7040           if (sec->sh_addr >= seg->p_vaddr
7041               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7042             {
7043               aux->seg_base = seg->p_vaddr;
7044               break;
7045             }
7046         }
7047     }
7048
7049   /* Second, build the unwind table from the contents of the unwind
7050      section.  */
7051   size = sec->sh_size;
7052   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7053                                       _("unwind table"));
7054   if (!table)
7055     return 0;
7056
7057   unw_ent_size = 16;
7058   nentries = size / unw_ent_size;
7059   size = unw_ent_size * nentries;
7060
7061   tep = aux->table = (struct hppa_unw_table_entry *)
7062       xcmalloc (nentries, sizeof (aux->table[0]));
7063
7064   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7065     {
7066       unsigned int tmp1, tmp2;
7067
7068       tep->start.section = SHN_UNDEF;
7069       tep->end.section   = SHN_UNDEF;
7070
7071       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7072       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7073       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7074       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7075
7076       tep->start.offset += aux->seg_base;
7077       tep->end.offset   += aux->seg_base;
7078
7079       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7080       tep->Millicode = (tmp1 >> 30) & 0x1;
7081       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7082       tep->Region_description = (tmp1 >> 27) & 0x3;
7083       tep->reserved1 = (tmp1 >> 26) & 0x1;
7084       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7085       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7086       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7087       tep->Args_stored = (tmp1 >> 15) & 0x1;
7088       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7089       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7090       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7091       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7092       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7093       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7094       tep->cxx_info = (tmp1 >> 8) & 0x1;
7095       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7096       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7097       tep->reserved2 = (tmp1 >> 5) & 0x1;
7098       tep->Save_SP = (tmp1 >> 4) & 0x1;
7099       tep->Save_RP = (tmp1 >> 3) & 0x1;
7100       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7101       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7102       tep->Cleanup_defined = tmp1 & 0x1;
7103
7104       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7105       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7106       tep->Large_frame = (tmp2 >> 29) & 0x1;
7107       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7108       tep->reserved4 = (tmp2 >> 27) & 0x1;
7109       tep->Total_frame_size = tmp2 & 0x7ffffff;
7110     }
7111   free (table);
7112
7113   /* Third, apply any relocations to the unwind table.  */
7114   for (relsec = section_headers;
7115        relsec < section_headers + elf_header.e_shnum;
7116        ++relsec)
7117     {
7118       if (relsec->sh_type != SHT_RELA
7119           || relsec->sh_info >= elf_header.e_shnum
7120           || section_headers + relsec->sh_info != sec)
7121         continue;
7122
7123       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7124                               & rela, & nrelas))
7125         return 0;
7126
7127       for (rp = rela; rp < rela + nrelas; ++rp)
7128         {
7129           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7130           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7131
7132           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
7133           if (! const_strneq (relname, "R_PARISC_SEGREL"))
7134             {
7135               warn (_("Skipping unexpected relocation type %s\n"), relname);
7136               continue;
7137             }
7138
7139           i = rp->r_offset / unw_ent_size;
7140
7141           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7142             {
7143             case 0:
7144               aux->table[i].start.section = sym->st_shndx;
7145               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
7146               break;
7147             case 1:
7148               aux->table[i].end.section   = sym->st_shndx;
7149               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
7150               break;
7151             default:
7152               break;
7153             }
7154         }
7155
7156       free (rela);
7157     }
7158
7159   aux->table_len = nentries;
7160
7161   return 1;
7162 }
7163
7164 static void
7165 hppa_process_unwind (FILE * file)
7166 {
7167   struct hppa_unw_aux_info aux;
7168   Elf_Internal_Shdr * unwsec = NULL;
7169   Elf_Internal_Shdr * strsec;
7170   Elf_Internal_Shdr * sec;
7171   unsigned long i;
7172
7173   if (string_table == NULL)
7174     return;
7175
7176   memset (& aux, 0, sizeof (aux));
7177
7178   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7179     {
7180       if (sec->sh_type == SHT_SYMTAB
7181           && sec->sh_link < elf_header.e_shnum)
7182         {
7183           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7184
7185           strsec = section_headers + sec->sh_link;
7186           if (aux.strtab != NULL)
7187             {
7188               error (_("Multiple auxillary string tables encountered\n"));
7189               free (aux.strtab);
7190             }
7191           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7192                                           1, strsec->sh_size,
7193                                           _("string table"));
7194           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7195         }
7196       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7197         unwsec = sec;
7198     }
7199
7200   if (!unwsec)
7201     printf (_("\nThere are no unwind sections in this file.\n"));
7202
7203   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7204     {
7205       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7206         {
7207           printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7208                   printable_section_name (sec),
7209                   (unsigned long) sec->sh_offset,
7210                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7211
7212           slurp_hppa_unwind_table (file, &aux, sec);
7213           if (aux.table_len > 0)
7214             dump_hppa_unwind (&aux);
7215
7216           if (aux.table)
7217             free ((char *) aux.table);
7218           aux.table = NULL;
7219         }
7220     }
7221
7222   if (aux.symtab)
7223     free (aux.symtab);
7224   if (aux.strtab)
7225     free ((char *) aux.strtab);
7226 }
7227
7228 struct arm_section
7229 {
7230   unsigned char *      data;            /* The unwind data.  */
7231   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
7232   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
7233   unsigned long        nrelas;          /* The number of relocations.  */
7234   unsigned int         rel_type;        /* REL or RELA ?  */
7235   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
7236 };
7237
7238 struct arm_unw_aux_info
7239 {
7240   FILE *              file;             /* The file containing the unwind sections.  */
7241   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
7242   unsigned long       nsyms;            /* Number of symbols.  */
7243   char *              strtab;           /* The file's string table.  */
7244   unsigned long       strtab_size;      /* Size of string table.  */
7245 };
7246
7247 static const char *
7248 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7249                         bfd_vma fn, struct absaddr addr)
7250 {
7251   const char *procname;
7252   bfd_vma sym_offset;
7253
7254   if (addr.section == SHN_UNDEF)
7255     addr.offset = fn;
7256
7257   find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
7258                            aux->strtab_size, addr, &procname,
7259                            &sym_offset);
7260
7261   print_vma (fn, PREFIX_HEX);
7262
7263   if (procname)
7264     {
7265       fputs (" <", stdout);
7266       fputs (procname, stdout);
7267
7268       if (sym_offset)
7269         printf ("+0x%lx", (unsigned long) sym_offset);
7270       fputc ('>', stdout);
7271     }
7272
7273   return procname;
7274 }
7275
7276 static void
7277 arm_free_section (struct arm_section *arm_sec)
7278 {
7279   if (arm_sec->data != NULL)
7280     free (arm_sec->data);
7281
7282   if (arm_sec->rela != NULL)
7283     free (arm_sec->rela);
7284 }
7285
7286 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7287       cached section and install SEC instead.
7288    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7289       and return its valued in * WORDP, relocating if necessary.
7290    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7291       relocation's offset in ADDR.
7292    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7293       into the string table of the symbol associated with the reloc.  If no
7294       reloc was applied store -1 there.
7295    5) Return TRUE upon success, FALSE otherwise.  */
7296
7297 static bfd_boolean
7298 get_unwind_section_word (struct arm_unw_aux_info *  aux,
7299                          struct arm_section *       arm_sec,
7300                          Elf_Internal_Shdr *        sec,
7301                          bfd_vma                    word_offset,
7302                          unsigned int *             wordp,
7303                          struct absaddr *           addr,
7304                          bfd_vma *                  sym_name)
7305 {
7306   Elf_Internal_Rela *rp;
7307   Elf_Internal_Sym *sym;
7308   const char * relname;
7309   unsigned int word;
7310   bfd_boolean wrapped;
7311
7312   if (sec == NULL || arm_sec == NULL)
7313     return FALSE;
7314
7315   addr->section = SHN_UNDEF;
7316   addr->offset = 0;
7317
7318   if (sym_name != NULL)
7319     *sym_name = (bfd_vma) -1;
7320
7321   /* If necessary, update the section cache.  */
7322   if (sec != arm_sec->sec)
7323     {
7324       Elf_Internal_Shdr *relsec;
7325
7326       arm_free_section (arm_sec);
7327
7328       arm_sec->sec = sec;
7329       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7330                                 sec->sh_size, _("unwind data"));
7331       arm_sec->rela = NULL;
7332       arm_sec->nrelas = 0;
7333
7334       for (relsec = section_headers;
7335            relsec < section_headers + elf_header.e_shnum;
7336            ++relsec)
7337         {
7338           if (relsec->sh_info >= elf_header.e_shnum
7339               || section_headers + relsec->sh_info != sec
7340               /* PR 15745: Check the section type as well.  */
7341               || (relsec->sh_type != SHT_REL
7342                   && relsec->sh_type != SHT_RELA))
7343             continue;
7344
7345           arm_sec->rel_type = relsec->sh_type;
7346           if (relsec->sh_type == SHT_REL)
7347             {
7348               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7349                                      relsec->sh_size,
7350                                      & arm_sec->rela, & arm_sec->nrelas))
7351                 return FALSE;
7352             }
7353           else /* relsec->sh_type == SHT_RELA */
7354             {
7355               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7356                                       relsec->sh_size,
7357                                       & arm_sec->rela, & arm_sec->nrelas))
7358                 return FALSE;
7359             }
7360           break;
7361         }
7362
7363       arm_sec->next_rela = arm_sec->rela;
7364     }
7365
7366   /* If there is no unwind data we can do nothing.  */
7367   if (arm_sec->data == NULL)
7368     return FALSE;
7369
7370   /* If the offset is invalid then fail.  */
7371   if (word_offset > sec->sh_size - 4)
7372     return FALSE;
7373
7374   /* Get the word at the required offset.  */
7375   word = byte_get (arm_sec->data + word_offset, 4);
7376
7377   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
7378   if (arm_sec->rela == NULL)
7379     {
7380       * wordp = word;
7381       return TRUE;
7382     }
7383
7384   /* Look through the relocs to find the one that applies to the provided offset.  */
7385   wrapped = FALSE;
7386   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7387     {
7388       bfd_vma prelval, offset;
7389
7390       if (rp->r_offset > word_offset && !wrapped)
7391         {
7392           rp = arm_sec->rela;
7393           wrapped = TRUE;
7394         }
7395       if (rp->r_offset > word_offset)
7396         break;
7397
7398       if (rp->r_offset & 3)
7399         {
7400           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7401                 (unsigned long) rp->r_offset);
7402           continue;
7403         }
7404
7405       if (rp->r_offset < word_offset)
7406         continue;
7407
7408       /* PR 17531: file: 027-161405-0.004  */
7409       if (aux->symtab == NULL)
7410         continue;
7411
7412       if (arm_sec->rel_type == SHT_REL)
7413         {
7414           offset = word & 0x7fffffff;
7415           if (offset & 0x40000000)
7416             offset |= ~ (bfd_vma) 0x7fffffff;
7417         }
7418       else if (arm_sec->rel_type == SHT_RELA)
7419         offset = rp->r_addend;
7420       else
7421         {
7422           error (_("Unknown section relocation type %d encountered\n"),
7423                  arm_sec->rel_type);
7424           break;
7425         }
7426
7427       /* PR 17531 file: 027-1241568-0.004.  */
7428       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7429         {
7430           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7431                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7432           break;
7433         }
7434
7435       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
7436       offset += sym->st_value;
7437       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7438
7439       /* Check that we are processing the expected reloc type.  */
7440       if (elf_header.e_machine == EM_ARM)
7441         {
7442           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
7443           if (relname == NULL)
7444             {
7445               warn (_("Skipping unknown ARM relocation type: %d\n"),
7446                     (int) ELF32_R_TYPE (rp->r_info));
7447               continue;
7448             }
7449
7450           if (streq (relname, "R_ARM_NONE"))
7451               continue;
7452
7453           if (! streq (relname, "R_ARM_PREL31"))
7454             {
7455               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
7456               continue;
7457             }
7458         }
7459       else if (elf_header.e_machine == EM_TI_C6000)
7460         {
7461           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
7462           if (relname == NULL)
7463             {
7464               warn (_("Skipping unknown C6000 relocation type: %d\n"),
7465                     (int) ELF32_R_TYPE (rp->r_info));
7466               continue;
7467             }
7468
7469           if (streq (relname, "R_C6000_NONE"))
7470             continue;
7471
7472           if (! streq (relname, "R_C6000_PREL31"))
7473             {
7474               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
7475               continue;
7476             }
7477
7478           prelval >>= 1;
7479         }
7480       else
7481         {
7482           /* This function currently only supports ARM and TI unwinders.  */
7483           warn (_("Only TI and ARM unwinders are currently supported\n"));
7484           break;
7485         }
7486
7487       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7488       addr->section = sym->st_shndx;
7489       addr->offset = offset;
7490
7491       if (sym_name)
7492         * sym_name = sym->st_name;
7493       break;
7494     }
7495
7496   *wordp = word;
7497   arm_sec->next_rela = rp;
7498
7499   return TRUE;
7500 }
7501
7502 static const char *tic6x_unwind_regnames[16] =
7503 {
7504   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7505   "A14", "A13", "A12", "A11", "A10",
7506   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7507 };
7508
7509 static void
7510 decode_tic6x_unwind_regmask (unsigned int mask)
7511 {
7512   int i;
7513
7514   for (i = 12; mask; mask >>= 1, i--)
7515     {
7516       if (mask & 1)
7517         {
7518           fputs (tic6x_unwind_regnames[i], stdout);
7519           if (mask > 1)
7520             fputs (", ", stdout);
7521         }
7522     }
7523 }
7524
7525 #define ADVANCE                                                 \
7526   if (remaining == 0 && more_words)                             \
7527     {                                                           \
7528       data_offset += 4;                                         \
7529       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
7530                                      data_offset, & word, & addr, NULL))        \
7531         return;                                                 \
7532       remaining = 4;                                            \
7533       more_words--;                                             \
7534     }                                                           \
7535
7536 #define GET_OP(OP)                      \
7537   ADVANCE;                              \
7538   if (remaining)                        \
7539     {                                   \
7540       remaining--;                      \
7541       (OP) = word >> 24;                \
7542       word <<= 8;                       \
7543     }                                   \
7544   else                                  \
7545     {                                   \
7546       printf (_("[Truncated opcode]\n"));       \
7547       return;                           \
7548     }                                   \
7549   printf ("0x%02x ", OP)
7550
7551 static void
7552 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
7553                             unsigned int word, unsigned int remaining,
7554                             unsigned int more_words,
7555                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7556                             struct arm_section *data_arm_sec)
7557 {
7558   struct absaddr addr;
7559
7560   /* Decode the unwinding instructions.  */
7561   while (1)
7562     {
7563       unsigned int op, op2;
7564
7565       ADVANCE;
7566       if (remaining == 0)
7567         break;
7568       remaining--;
7569       op = word >> 24;
7570       word <<= 8;
7571
7572       printf ("  0x%02x ", op);
7573
7574       if ((op & 0xc0) == 0x00)
7575         {
7576           int offset = ((op & 0x3f) << 2) + 4;
7577
7578           printf ("     vsp = vsp + %d", offset);
7579         }
7580       else if ((op & 0xc0) == 0x40)
7581         {
7582           int offset = ((op & 0x3f) << 2) + 4;
7583
7584           printf ("     vsp = vsp - %d", offset);
7585         }
7586       else if ((op & 0xf0) == 0x80)
7587         {
7588           GET_OP (op2);
7589           if (op == 0x80 && op2 == 0)
7590             printf (_("Refuse to unwind"));
7591           else
7592             {
7593               unsigned int mask = ((op & 0x0f) << 8) | op2;
7594               int first = 1;
7595               int i;
7596
7597               printf ("pop {");
7598               for (i = 0; i < 12; i++)
7599                 if (mask & (1 << i))
7600                   {
7601                     if (first)
7602                       first = 0;
7603                     else
7604                       printf (", ");
7605                     printf ("r%d", 4 + i);
7606                   }
7607               printf ("}");
7608             }
7609         }
7610       else if ((op & 0xf0) == 0x90)
7611         {
7612           if (op == 0x9d || op == 0x9f)
7613             printf (_("     [Reserved]"));
7614           else
7615             printf ("     vsp = r%d", op & 0x0f);
7616         }
7617       else if ((op & 0xf0) == 0xa0)
7618         {
7619           int end = 4 + (op & 0x07);
7620           int first = 1;
7621           int i;
7622
7623           printf ("     pop {");
7624           for (i = 4; i <= end; i++)
7625             {
7626               if (first)
7627                 first = 0;
7628               else
7629                 printf (", ");
7630               printf ("r%d", i);
7631             }
7632           if (op & 0x08)
7633             {
7634               if (!first)
7635                 printf (", ");
7636               printf ("r14");
7637             }
7638           printf ("}");
7639         }
7640       else if (op == 0xb0)
7641         printf (_("     finish"));
7642       else if (op == 0xb1)
7643         {
7644           GET_OP (op2);
7645           if (op2 == 0 || (op2 & 0xf0) != 0)
7646             printf (_("[Spare]"));
7647           else
7648             {
7649               unsigned int mask = op2 & 0x0f;
7650               int first = 1;
7651               int i;
7652
7653               printf ("pop {");
7654               for (i = 0; i < 12; i++)
7655                 if (mask & (1 << i))
7656                   {
7657                     if (first)
7658                       first = 0;
7659                     else
7660                       printf (", ");
7661                     printf ("r%d", i);
7662                   }
7663               printf ("}");
7664             }
7665         }
7666       else if (op == 0xb2)
7667         {
7668           unsigned char buf[9];
7669           unsigned int i, len;
7670           unsigned long offset;
7671
7672           for (i = 0; i < sizeof (buf); i++)
7673             {
7674               GET_OP (buf[i]);
7675               if ((buf[i] & 0x80) == 0)
7676                 break;
7677             }
7678           if (i == sizeof (buf))
7679             printf (_("corrupt change to vsp"));
7680           else
7681             {
7682               offset = read_uleb128 (buf, &len, buf + i + 1);
7683               assert (len == i + 1);
7684               offset = offset * 4 + 0x204;
7685               printf ("vsp = vsp + %ld", offset);
7686             }
7687         }
7688       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
7689         {
7690           unsigned int first, last;
7691
7692           GET_OP (op2);
7693           first = op2 >> 4;
7694           last = op2 & 0x0f;
7695           if (op == 0xc8)
7696             first = first + 16;
7697           printf ("pop {D%d", first);
7698           if (last)
7699             printf ("-D%d", first + last);
7700           printf ("}");
7701         }
7702       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7703         {
7704           unsigned int count = op & 0x07;
7705
7706           printf ("pop {D8");
7707           if (count)
7708             printf ("-D%d", 8 + count);
7709           printf ("}");
7710         }
7711       else if (op >= 0xc0 && op <= 0xc5)
7712         {
7713           unsigned int count = op & 0x07;
7714
7715           printf ("     pop {wR10");
7716           if (count)
7717             printf ("-wR%d", 10 + count);
7718           printf ("}");
7719         }
7720       else if (op == 0xc6)
7721         {
7722           unsigned int first, last;
7723
7724           GET_OP (op2);
7725           first = op2 >> 4;
7726           last = op2 & 0x0f;
7727           printf ("pop {wR%d", first);
7728           if (last)
7729             printf ("-wR%d", first + last);
7730           printf ("}");
7731         }
7732       else if (op == 0xc7)
7733         {
7734           GET_OP (op2);
7735           if (op2 == 0 || (op2 & 0xf0) != 0)
7736             printf (_("[Spare]"));
7737           else
7738             {
7739               unsigned int mask = op2 & 0x0f;
7740               int first = 1;
7741               int i;
7742
7743               printf ("pop {");
7744               for (i = 0; i < 4; i++)
7745                 if (mask & (1 << i))
7746                   {
7747                     if (first)
7748                       first = 0;
7749                     else
7750                       printf (", ");
7751                     printf ("wCGR%d", i);
7752                   }
7753               printf ("}");
7754             }
7755         }
7756       else
7757         printf (_("     [unsupported opcode]"));
7758       printf ("\n");
7759     }
7760 }
7761
7762 static void
7763 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7764                             unsigned int word, unsigned int remaining,
7765                             unsigned int more_words,
7766                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7767                             struct arm_section *data_arm_sec)
7768 {
7769   struct absaddr addr;
7770
7771   /* Decode the unwinding instructions.  */
7772   while (1)
7773     {
7774       unsigned int op, op2;
7775
7776       ADVANCE;
7777       if (remaining == 0)
7778         break;
7779       remaining--;
7780       op = word >> 24;
7781       word <<= 8;
7782
7783       printf ("  0x%02x ", op);
7784
7785       if ((op & 0xc0) == 0x00)
7786         {
7787           int offset = ((op & 0x3f) << 3) + 8;
7788           printf ("     sp = sp + %d", offset);
7789         }
7790       else if ((op & 0xc0) == 0x80)
7791         {
7792           GET_OP (op2);
7793           if (op == 0x80 && op2 == 0)
7794             printf (_("Refuse to unwind"));
7795           else
7796             {
7797               unsigned int mask = ((op & 0x1f) << 8) | op2;
7798               if (op & 0x20)
7799                 printf ("pop compact {");
7800               else
7801                 printf ("pop {");
7802
7803               decode_tic6x_unwind_regmask (mask);
7804               printf("}");
7805             }
7806         }
7807       else if ((op & 0xf0) == 0xc0)
7808         {
7809           unsigned int reg;
7810           unsigned int nregs;
7811           unsigned int i;
7812           const char *name;
7813           struct
7814           {
7815               unsigned int offset;
7816               unsigned int reg;
7817           } regpos[16];
7818
7819           /* Scan entire instruction first so that GET_OP output is not
7820              interleaved with disassembly.  */
7821           nregs = 0;
7822           for (i = 0; nregs < (op & 0xf); i++)
7823             {
7824               GET_OP (op2);
7825               reg = op2 >> 4;
7826               if (reg != 0xf)
7827                 {
7828                   regpos[nregs].offset = i * 2;
7829                   regpos[nregs].reg = reg;
7830                   nregs++;
7831                 }
7832
7833               reg = op2 & 0xf;
7834               if (reg != 0xf)
7835                 {
7836                   regpos[nregs].offset = i * 2 + 1;
7837                   regpos[nregs].reg = reg;
7838                   nregs++;
7839                 }
7840             }
7841
7842           printf (_("pop frame {"));
7843           reg = nregs - 1;
7844           for (i = i * 2; i > 0; i--)
7845             {
7846               if (regpos[reg].offset == i - 1)
7847                 {
7848                   name = tic6x_unwind_regnames[regpos[reg].reg];
7849                   if (reg > 0)
7850                     reg--;
7851                 }
7852               else
7853                 name = _("[pad]");
7854
7855               fputs (name, stdout);
7856               if (i > 1)
7857                 printf (", ");
7858             }
7859
7860           printf ("}");
7861         }
7862       else if (op == 0xd0)
7863         printf ("     MOV FP, SP");
7864       else if (op == 0xd1)
7865         printf ("     __c6xabi_pop_rts");
7866       else if (op == 0xd2)
7867         {
7868           unsigned char buf[9];
7869           unsigned int i, len;
7870           unsigned long offset;
7871
7872           for (i = 0; i < sizeof (buf); i++)
7873             {
7874               GET_OP (buf[i]);
7875               if ((buf[i] & 0x80) == 0)
7876                 break;
7877             }
7878           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
7879           if (i == sizeof (buf))
7880             {
7881               printf ("<corrupt sp adjust>\n");
7882               warn (_("Corrupt stack pointer adjustment detected\n"));
7883               return;
7884             }
7885
7886           offset = read_uleb128 (buf, &len, buf + i + 1);
7887           assert (len == i + 1);
7888           offset = offset * 8 + 0x408;
7889           printf (_("sp = sp + %ld"), offset);
7890         }
7891       else if ((op & 0xf0) == 0xe0)
7892         {
7893           if ((op & 0x0f) == 7)
7894             printf ("     RETURN");
7895           else
7896             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7897         }
7898       else
7899         {
7900           printf (_("     [unsupported opcode]"));
7901         }
7902       putchar ('\n');
7903     }
7904 }
7905
7906 static bfd_vma
7907 arm_expand_prel31 (bfd_vma word, bfd_vma where)
7908 {
7909   bfd_vma offset;
7910
7911   offset = word & 0x7fffffff;
7912   if (offset & 0x40000000)
7913     offset |= ~ (bfd_vma) 0x7fffffff;
7914
7915   if (elf_header.e_machine == EM_TI_C6000)
7916     offset <<= 1;
7917
7918   return offset + where;
7919 }
7920
7921 static void
7922 decode_arm_unwind (struct arm_unw_aux_info *  aux,
7923                    unsigned int               word,
7924                    unsigned int               remaining,
7925                    bfd_vma                    data_offset,
7926                    Elf_Internal_Shdr *        data_sec,
7927                    struct arm_section *       data_arm_sec)
7928 {
7929   int per_index;
7930   unsigned int more_words = 0;
7931   struct absaddr addr;
7932   bfd_vma sym_name = (bfd_vma) -1;
7933
7934   if (remaining == 0)
7935     {
7936       /* Fetch the first word.
7937          Note - when decoding an object file the address extracted
7938          here will always be 0.  So we also pass in the sym_name
7939          parameter so that we can find the symbol associated with
7940          the personality routine.  */
7941       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7942                                      & word, & addr, & sym_name))
7943         return;
7944
7945       remaining = 4;
7946     }
7947
7948   if ((word & 0x80000000) == 0)
7949     {
7950       /* Expand prel31 for personality routine.  */
7951       bfd_vma fn;
7952       const char *procname;
7953
7954       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
7955       printf (_("  Personality routine: "));
7956       if (fn == 0
7957           && addr.section == SHN_UNDEF && addr.offset == 0
7958           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7959         {
7960           procname = aux->strtab + sym_name;
7961           print_vma (fn, PREFIX_HEX);
7962           if (procname)
7963             {
7964               fputs (" <", stdout);
7965               fputs (procname, stdout);
7966               fputc ('>', stdout);
7967             }
7968         }
7969       else
7970         procname = arm_print_vma_and_name (aux, fn, addr);
7971       fputc ('\n', stdout);
7972
7973       /* The GCC personality routines use the standard compact
7974          encoding, starting with one byte giving the number of
7975          words.  */
7976       if (procname != NULL
7977           && (const_strneq (procname, "__gcc_personality_v0")
7978               || const_strneq (procname, "__gxx_personality_v0")
7979               || const_strneq (procname, "__gcj_personality_v0")
7980               || const_strneq (procname, "__gnu_objc_personality_v0")))
7981         {
7982           remaining = 0;
7983           more_words = 1;
7984           ADVANCE;
7985           if (!remaining)
7986             {
7987               printf (_("  [Truncated data]\n"));
7988               return;
7989             }
7990           more_words = word >> 24;
7991           word <<= 8;
7992           remaining--;
7993           per_index = -1;
7994         }
7995       else
7996         return;
7997     }
7998   else
7999     {
8000       /* ARM EHABI Section 6.3:
8001
8002          An exception-handling table entry for the compact model looks like:
8003
8004            31 30-28 27-24 23-0
8005            -- ----- ----- ----
8006             1   0   index Data for personalityRoutine[index]    */
8007
8008       if (elf_header.e_machine == EM_ARM
8009           && (word & 0x70000000))
8010         warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8011
8012       per_index = (word >> 24) & 0x7f;
8013       printf (_("  Compact model index: %d\n"), per_index);
8014       if (per_index == 0)
8015         {
8016           more_words = 0;
8017           word <<= 8;
8018           remaining--;
8019         }
8020       else if (per_index < 3)
8021         {
8022           more_words = (word >> 16) & 0xff;
8023           word <<= 16;
8024           remaining -= 2;
8025         }
8026     }
8027
8028   switch (elf_header.e_machine)
8029     {
8030     case EM_ARM:
8031       if (per_index < 3)
8032         {
8033           decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8034                                       data_offset, data_sec, data_arm_sec);
8035         }
8036       else
8037         {
8038           warn (_("Unknown ARM compact model index encountered\n"));
8039           printf (_("  [reserved]\n"));
8040         }
8041       break;
8042
8043     case EM_TI_C6000:
8044       if (per_index < 3)
8045         {
8046           decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8047                                         data_offset, data_sec, data_arm_sec);
8048         }
8049       else if (per_index < 5)
8050         {
8051           if (((word >> 17) & 0x7f) == 0x7f)
8052             printf (_("  Restore stack from frame pointer\n"));
8053           else
8054             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8055           printf (_("  Registers restored: "));
8056           if (per_index == 4)
8057             printf (" (compact) ");
8058           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8059           putchar ('\n');
8060           printf (_("  Return register: %s\n"),
8061                   tic6x_unwind_regnames[word & 0xf]);
8062         }
8063       else
8064         printf (_("  [reserved (%d)]\n"), per_index);
8065       break;
8066
8067     default:
8068       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8069              elf_header.e_machine);
8070     }
8071
8072   /* Decode the descriptors.  Not implemented.  */
8073 }
8074
8075 static void
8076 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8077 {
8078   struct arm_section exidx_arm_sec, extab_arm_sec;
8079   unsigned int i, exidx_len;
8080
8081   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8082   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8083   exidx_len = exidx_sec->sh_size / 8;
8084
8085   for (i = 0; i < exidx_len; i++)
8086     {
8087       unsigned int exidx_fn, exidx_entry;
8088       struct absaddr fn_addr, entry_addr;
8089       bfd_vma fn;
8090
8091       fputc ('\n', stdout);
8092
8093       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8094                                      8 * i, & exidx_fn, & fn_addr, NULL)
8095           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8096                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
8097         {
8098           arm_free_section (& exidx_arm_sec);
8099           arm_free_section (& extab_arm_sec);
8100           return;
8101         }
8102
8103       /* ARM EHABI, Section 5:
8104          An index table entry consists of 2 words.
8105          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
8106       if (exidx_fn & 0x80000000)
8107         warn (_("corrupt index table entry: %x\n"), exidx_fn);
8108
8109       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8110
8111       arm_print_vma_and_name (aux, fn, fn_addr);
8112       fputs (": ", stdout);
8113
8114       if (exidx_entry == 1)
8115         {
8116           print_vma (exidx_entry, PREFIX_HEX);
8117           fputs (" [cantunwind]\n", stdout);
8118         }
8119       else if (exidx_entry & 0x80000000)
8120         {
8121           print_vma (exidx_entry, PREFIX_HEX);
8122           fputc ('\n', stdout);
8123           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8124         }
8125       else
8126         {
8127           bfd_vma table, table_offset = 0;
8128           Elf_Internal_Shdr *table_sec;
8129
8130           fputs ("@", stdout);
8131           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8132           print_vma (table, PREFIX_HEX);
8133           printf ("\n");
8134
8135           /* Locate the matching .ARM.extab.  */
8136           if (entry_addr.section != SHN_UNDEF
8137               && entry_addr.section < elf_header.e_shnum)
8138             {
8139               table_sec = section_headers + entry_addr.section;
8140               table_offset = entry_addr.offset;
8141             }
8142           else
8143             {
8144               table_sec = find_section_by_address (table);
8145               if (table_sec != NULL)
8146                 table_offset = table - table_sec->sh_addr;
8147             }
8148           if (table_sec == NULL)
8149             {
8150               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8151                     (unsigned long) table);
8152               continue;
8153             }
8154           decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8155                              &extab_arm_sec);
8156         }
8157     }
8158
8159   printf ("\n");
8160
8161   arm_free_section (&exidx_arm_sec);
8162   arm_free_section (&extab_arm_sec);
8163 }
8164
8165 /* Used for both ARM and C6X unwinding tables.  */
8166
8167 static void
8168 arm_process_unwind (FILE *file)
8169 {
8170   struct arm_unw_aux_info aux;
8171   Elf_Internal_Shdr *unwsec = NULL;
8172   Elf_Internal_Shdr *strsec;
8173   Elf_Internal_Shdr *sec;
8174   unsigned long i;
8175   unsigned int sec_type;
8176
8177   switch (elf_header.e_machine)
8178     {
8179     case EM_ARM:
8180       sec_type = SHT_ARM_EXIDX;
8181       break;
8182
8183     case EM_TI_C6000:
8184       sec_type = SHT_C6000_UNWIND;
8185       break;
8186
8187     default:
8188       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8189              elf_header.e_machine);
8190       return;
8191     }
8192
8193   if (string_table == NULL)
8194     return;
8195
8196   memset (& aux, 0, sizeof (aux));
8197   aux.file = file;
8198
8199   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8200     {
8201       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8202         {
8203           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
8204
8205           strsec = section_headers + sec->sh_link;
8206
8207           /* PR binutils/17531 file: 011-12666-0.004.  */
8208           if (aux.strtab != NULL)
8209             {
8210               error (_("Multiple string tables found in file.\n"));
8211               free (aux.strtab);
8212             }
8213           aux.strtab = get_data (NULL, file, strsec->sh_offset,
8214                                  1, strsec->sh_size, _("string table"));
8215           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8216         }
8217       else if (sec->sh_type == sec_type)
8218         unwsec = sec;
8219     }
8220
8221   if (unwsec == NULL)
8222     printf (_("\nThere are no unwind sections in this file.\n"));
8223   else
8224     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8225       {
8226         if (sec->sh_type == sec_type)
8227           {
8228             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8229                     printable_section_name (sec),
8230                     (unsigned long) sec->sh_offset,
8231                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
8232
8233             dump_arm_unwind (&aux, sec);
8234           }
8235       }
8236
8237   if (aux.symtab)
8238     free (aux.symtab);
8239   if (aux.strtab)
8240     free ((char *) aux.strtab);
8241 }
8242
8243 static void
8244 process_unwind (FILE * file)
8245 {
8246   struct unwind_handler
8247   {
8248     int machtype;
8249     void (* handler)(FILE *);
8250   } handlers[] =
8251   {
8252     { EM_ARM, arm_process_unwind },
8253     { EM_IA_64, ia64_process_unwind },
8254     { EM_PARISC, hppa_process_unwind },
8255     { EM_TI_C6000, arm_process_unwind },
8256     { 0, 0 }
8257   };
8258   int i;
8259
8260   if (!do_unwind)
8261     return;
8262
8263   for (i = 0; handlers[i].handler != NULL; i++)
8264     if (elf_header.e_machine == handlers[i].machtype)
8265       {
8266         handlers[i].handler (file);
8267         return;
8268       }
8269
8270   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8271           get_machine_name (elf_header.e_machine));
8272 }
8273
8274 static void
8275 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
8276 {
8277   switch (entry->d_tag)
8278     {
8279     case DT_MIPS_FLAGS:
8280       if (entry->d_un.d_val == 0)
8281         printf (_("NONE"));
8282       else
8283         {
8284           static const char * opts[] =
8285           {
8286             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8287             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8288             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8289             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8290             "RLD_ORDER_SAFE"
8291           };
8292           unsigned int cnt;
8293           int first = 1;
8294
8295           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
8296             if (entry->d_un.d_val & (1 << cnt))
8297               {
8298                 printf ("%s%s", first ? "" : " ", opts[cnt]);
8299                 first = 0;
8300               }
8301         }
8302       break;
8303
8304     case DT_MIPS_IVERSION:
8305       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8306         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
8307       else
8308         {
8309           char buf[40];
8310           sprintf_vma (buf, entry->d_un.d_ptr);
8311           /* Note: coded this way so that there is a single string for translation.  */
8312           printf (_("<corrupt: %s>"), buf);
8313         }
8314       break;
8315
8316     case DT_MIPS_TIME_STAMP:
8317       {
8318         char timebuf[20];
8319         struct tm * tmp;
8320         time_t atime = entry->d_un.d_val;
8321
8322         tmp = gmtime (&atime);
8323         /* PR 17531: file: 6accc532.  */
8324         if (tmp == NULL)
8325           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8326         else
8327           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8328                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8329                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8330         printf (_("Time Stamp: %s"), timebuf);
8331       }
8332       break;
8333
8334     case DT_MIPS_RLD_VERSION:
8335     case DT_MIPS_LOCAL_GOTNO:
8336     case DT_MIPS_CONFLICTNO:
8337     case DT_MIPS_LIBLISTNO:
8338     case DT_MIPS_SYMTABNO:
8339     case DT_MIPS_UNREFEXTNO:
8340     case DT_MIPS_HIPAGENO:
8341     case DT_MIPS_DELTA_CLASS_NO:
8342     case DT_MIPS_DELTA_INSTANCE_NO:
8343     case DT_MIPS_DELTA_RELOC_NO:
8344     case DT_MIPS_DELTA_SYM_NO:
8345     case DT_MIPS_DELTA_CLASSSYM_NO:
8346     case DT_MIPS_COMPACT_SIZE:
8347       print_vma (entry->d_un.d_ptr, DEC);
8348       break;
8349
8350     default:
8351       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8352     }
8353     putchar ('\n');
8354 }
8355
8356 static void
8357 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
8358 {
8359   switch (entry->d_tag)
8360     {
8361     case DT_HP_DLD_FLAGS:
8362       {
8363         static struct
8364         {
8365           long int bit;
8366           const char * str;
8367         }
8368         flags[] =
8369         {
8370           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8371           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8372           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8373           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8374           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8375           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8376           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8377           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8378           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8379           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
8380           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8381           { DT_HP_GST, "HP_GST" },
8382           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8383           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8384           { DT_HP_NODELETE, "HP_NODELETE" },
8385           { DT_HP_GROUP, "HP_GROUP" },
8386           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
8387         };
8388         int first = 1;
8389         size_t cnt;
8390         bfd_vma val = entry->d_un.d_val;
8391
8392         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
8393           if (val & flags[cnt].bit)
8394             {
8395               if (! first)
8396                 putchar (' ');
8397               fputs (flags[cnt].str, stdout);
8398               first = 0;
8399               val ^= flags[cnt].bit;
8400             }
8401
8402         if (val != 0 || first)
8403           {
8404             if (! first)
8405               putchar (' ');
8406             print_vma (val, HEX);
8407           }
8408       }
8409       break;
8410
8411     default:
8412       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8413       break;
8414     }
8415   putchar ('\n');
8416 }
8417
8418 #ifdef BFD64
8419
8420 /* VMS vs Unix time offset and factor.  */
8421
8422 #define VMS_EPOCH_OFFSET 35067168000000000LL
8423 #define VMS_GRANULARITY_FACTOR 10000000
8424
8425 /* Display a VMS time in a human readable format.  */
8426
8427 static void
8428 print_vms_time (bfd_int64_t vmstime)
8429 {
8430   struct tm *tm;
8431   time_t unxtime;
8432
8433   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8434   tm = gmtime (&unxtime);
8435   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8436           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8437           tm->tm_hour, tm->tm_min, tm->tm_sec);
8438 }
8439 #endif /* BFD64 */
8440
8441 static void
8442 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
8443 {
8444   switch (entry->d_tag)
8445     {
8446     case DT_IA_64_PLT_RESERVE:
8447       /* First 3 slots reserved.  */
8448       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8449       printf (" -- ");
8450       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
8451       break;
8452
8453     case DT_IA_64_VMS_LINKTIME:
8454 #ifdef BFD64
8455       print_vms_time (entry->d_un.d_val);
8456 #endif
8457       break;
8458
8459     case DT_IA_64_VMS_LNKFLAGS:
8460       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8461       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8462         printf (" CALL_DEBUG");
8463       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8464         printf (" NOP0BUFS");
8465       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8466         printf (" P0IMAGE");
8467       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8468         printf (" MKTHREADS");
8469       if (entry->d_un.d_val & VMS_LF_UPCALLS)
8470         printf (" UPCALLS");
8471       if (entry->d_un.d_val & VMS_LF_IMGSTA)
8472         printf (" IMGSTA");
8473       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8474         printf (" INITIALIZE");
8475       if (entry->d_un.d_val & VMS_LF_MAIN)
8476         printf (" MAIN");
8477       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8478         printf (" EXE_INIT");
8479       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8480         printf (" TBK_IN_IMG");
8481       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8482         printf (" DBG_IN_IMG");
8483       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8484         printf (" TBK_IN_DSF");
8485       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8486         printf (" DBG_IN_DSF");
8487       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8488         printf (" SIGNATURES");
8489       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8490         printf (" REL_SEG_OFF");
8491       break;
8492
8493     default:
8494       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8495       break;
8496     }
8497   putchar ('\n');
8498 }
8499
8500 static int
8501 get_32bit_dynamic_section (FILE * file)
8502 {
8503   Elf32_External_Dyn * edyn;
8504   Elf32_External_Dyn * ext;
8505   Elf_Internal_Dyn * entry;
8506
8507   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8508                                           dynamic_size, _("dynamic section"));
8509   if (!edyn)
8510     return 0;
8511
8512   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8513      might not have the luxury of section headers.  Look for the DT_NULL
8514      terminator to determine the number of entries.  */
8515   for (ext = edyn, dynamic_nent = 0;
8516        (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
8517        ext++)
8518     {
8519       dynamic_nent++;
8520       if (BYTE_GET (ext->d_tag) == DT_NULL)
8521         break;
8522     }
8523
8524   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8525                                                   sizeof (* entry));
8526   if (dynamic_section == NULL)
8527     {
8528       error (_("Out of memory allocating space for %lu dynamic entries\n"),
8529              (unsigned long) dynamic_nent);
8530       free (edyn);
8531       return 0;
8532     }
8533
8534   for (ext = edyn, entry = dynamic_section;
8535        entry < dynamic_section + dynamic_nent;
8536        ext++, entry++)
8537     {
8538       entry->d_tag      = BYTE_GET (ext->d_tag);
8539       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8540     }
8541
8542   free (edyn);
8543
8544   return 1;
8545 }
8546
8547 static int
8548 get_64bit_dynamic_section (FILE * file)
8549 {
8550   Elf64_External_Dyn * edyn;
8551   Elf64_External_Dyn * ext;
8552   Elf_Internal_Dyn * entry;
8553
8554   /* Read in the data.  */
8555   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8556                                           dynamic_size, _("dynamic section"));
8557   if (!edyn)
8558     return 0;
8559
8560   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8561      might not have the luxury of section headers.  Look for the DT_NULL
8562      terminator to determine the number of entries.  */
8563   for (ext = edyn, dynamic_nent = 0;
8564        /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer.  */
8565        (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
8566        ext++)
8567     {
8568       dynamic_nent++;
8569       if (BYTE_GET (ext->d_tag) == DT_NULL)
8570         break;
8571     }
8572
8573   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8574                                                   sizeof (* entry));
8575   if (dynamic_section == NULL)
8576     {
8577       error (_("Out of memory allocating space for %lu dynamic entries\n"),
8578              (unsigned long) dynamic_nent);
8579       free (edyn);
8580       return 0;
8581     }
8582
8583   /* Convert from external to internal formats.  */
8584   for (ext = edyn, entry = dynamic_section;
8585        entry < dynamic_section + dynamic_nent;
8586        ext++, entry++)
8587     {
8588       entry->d_tag      = BYTE_GET (ext->d_tag);
8589       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8590     }
8591
8592   free (edyn);
8593
8594   return 1;
8595 }
8596
8597 static void
8598 print_dynamic_flags (bfd_vma flags)
8599 {
8600   int first = 1;
8601
8602   while (flags)
8603     {
8604       bfd_vma flag;
8605
8606       flag = flags & - flags;
8607       flags &= ~ flag;
8608
8609       if (first)
8610         first = 0;
8611       else
8612         putc (' ', stdout);
8613
8614       switch (flag)
8615         {
8616         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
8617         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
8618         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
8619         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
8620         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
8621         default:                fputs (_("unknown"), stdout); break;
8622         }
8623     }
8624   puts ("");
8625 }
8626
8627 /* Parse and display the contents of the dynamic section.  */
8628
8629 static int
8630 process_dynamic_section (FILE * file)
8631 {
8632   Elf_Internal_Dyn * entry;
8633
8634   if (dynamic_size == 0)
8635     {
8636       if (do_dynamic)
8637         printf (_("\nThere is no dynamic section in this file.\n"));
8638
8639       return 1;
8640     }
8641
8642   if (is_32bit_elf)
8643     {
8644       if (! get_32bit_dynamic_section (file))
8645         return 0;
8646     }
8647   else if (! get_64bit_dynamic_section (file))
8648     return 0;
8649
8650   /* Find the appropriate symbol table.  */
8651   if (dynamic_symbols == NULL)
8652     {
8653       for (entry = dynamic_section;
8654            entry < dynamic_section + dynamic_nent;
8655            ++entry)
8656         {
8657           Elf_Internal_Shdr section;
8658
8659           if (entry->d_tag != DT_SYMTAB)
8660             continue;
8661
8662           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8663
8664           /* Since we do not know how big the symbol table is,
8665              we default to reading in the entire file (!) and
8666              processing that.  This is overkill, I know, but it
8667              should work.  */
8668           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8669
8670           if (archive_file_offset != 0)
8671             section.sh_size = archive_file_size - section.sh_offset;
8672           else
8673             {
8674               if (fseek (file, 0, SEEK_END))
8675                 error (_("Unable to seek to end of file!\n"));
8676
8677               section.sh_size = ftell (file) - section.sh_offset;
8678             }
8679
8680           if (is_32bit_elf)
8681             section.sh_entsize = sizeof (Elf32_External_Sym);
8682           else
8683             section.sh_entsize = sizeof (Elf64_External_Sym);
8684           section.sh_name = string_table_length;
8685
8686           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
8687           if (num_dynamic_syms < 1)
8688             {
8689               error (_("Unable to determine the number of symbols to load\n"));
8690               continue;
8691             }
8692         }
8693     }
8694
8695   /* Similarly find a string table.  */
8696   if (dynamic_strings == NULL)
8697     {
8698       for (entry = dynamic_section;
8699            entry < dynamic_section + dynamic_nent;
8700            ++entry)
8701         {
8702           unsigned long offset;
8703           long str_tab_len;
8704
8705           if (entry->d_tag != DT_STRTAB)
8706             continue;
8707
8708           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8709
8710           /* Since we do not know how big the string table is,
8711              we default to reading in the entire file (!) and
8712              processing that.  This is overkill, I know, but it
8713              should work.  */
8714
8715           offset = offset_from_vma (file, entry->d_un.d_val, 0);
8716
8717           if (archive_file_offset != 0)
8718             str_tab_len = archive_file_size - offset;
8719           else
8720             {
8721               if (fseek (file, 0, SEEK_END))
8722                 error (_("Unable to seek to end of file\n"));
8723               str_tab_len = ftell (file) - offset;
8724             }
8725
8726           if (str_tab_len < 1)
8727             {
8728               error
8729                 (_("Unable to determine the length of the dynamic string table\n"));
8730               continue;
8731             }
8732
8733           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8734                                                str_tab_len,
8735                                                _("dynamic string table"));
8736           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
8737           break;
8738         }
8739     }
8740
8741   /* And find the syminfo section if available.  */
8742   if (dynamic_syminfo == NULL)
8743     {
8744       unsigned long syminsz = 0;
8745
8746       for (entry = dynamic_section;
8747            entry < dynamic_section + dynamic_nent;
8748            ++entry)
8749         {
8750           if (entry->d_tag == DT_SYMINENT)
8751             {
8752               /* Note: these braces are necessary to avoid a syntax
8753                  error from the SunOS4 C compiler.  */
8754               /* PR binutils/17531: A corrupt file can trigger this test.
8755                  So do not use an assert, instead generate an error message.  */
8756               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
8757                 error (_("Bad value (%d) for SYMINENT entry\n"),
8758                        (int) entry->d_un.d_val);
8759             }
8760           else if (entry->d_tag == DT_SYMINSZ)
8761             syminsz = entry->d_un.d_val;
8762           else if (entry->d_tag == DT_SYMINFO)
8763             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8764                                                       syminsz);
8765         }
8766
8767       if (dynamic_syminfo_offset != 0 && syminsz != 0)
8768         {
8769           Elf_External_Syminfo * extsyminfo;
8770           Elf_External_Syminfo * extsym;
8771           Elf_Internal_Syminfo * syminfo;
8772
8773           /* There is a syminfo section.  Read the data.  */
8774           extsyminfo = (Elf_External_Syminfo *)
8775               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8776                         _("symbol information"));
8777           if (!extsyminfo)
8778             return 0;
8779
8780           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
8781           if (dynamic_syminfo == NULL)
8782             {
8783               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8784                      (unsigned long) syminsz);
8785               return 0;
8786             }
8787
8788           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
8789           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8790                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8791                ++syminfo, ++extsym)
8792             {
8793               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8794               syminfo->si_flags = BYTE_GET (extsym->si_flags);
8795             }
8796
8797           free (extsyminfo);
8798         }
8799     }
8800
8801   if (do_dynamic && dynamic_addr)
8802     printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8803             dynamic_addr, (unsigned long) dynamic_nent);
8804   if (do_dynamic)
8805     printf (_("  Tag        Type                         Name/Value\n"));
8806
8807   for (entry = dynamic_section;
8808        entry < dynamic_section + dynamic_nent;
8809        entry++)
8810     {
8811       if (do_dynamic)
8812         {
8813           const char * dtype;
8814
8815           putchar (' ');
8816           print_vma (entry->d_tag, FULL_HEX);
8817           dtype = get_dynamic_type (entry->d_tag);
8818           printf (" (%s)%*s", dtype,
8819                   ((is_32bit_elf ? 27 : 19)
8820                    - (int) strlen (dtype)),
8821                   " ");
8822         }
8823
8824       switch (entry->d_tag)
8825         {
8826         case DT_FLAGS:
8827           if (do_dynamic)
8828             print_dynamic_flags (entry->d_un.d_val);
8829           break;
8830
8831         case DT_AUXILIARY:
8832         case DT_FILTER:
8833         case DT_CONFIG:
8834         case DT_DEPAUDIT:
8835         case DT_AUDIT:
8836           if (do_dynamic)
8837             {
8838               switch (entry->d_tag)
8839                 {
8840                 case DT_AUXILIARY:
8841                   printf (_("Auxiliary library"));
8842                   break;
8843
8844                 case DT_FILTER:
8845                   printf (_("Filter library"));
8846                   break;
8847
8848                 case DT_CONFIG:
8849                   printf (_("Configuration file"));
8850                   break;
8851
8852                 case DT_DEPAUDIT:
8853                   printf (_("Dependency audit library"));
8854                   break;
8855
8856                 case DT_AUDIT:
8857                   printf (_("Audit library"));
8858                   break;
8859                 }
8860
8861               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8862                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
8863               else
8864                 {
8865                   printf (": ");
8866                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8867                   putchar ('\n');
8868                 }
8869             }
8870           break;
8871
8872         case DT_FEATURE:
8873           if (do_dynamic)
8874             {
8875               printf (_("Flags:"));
8876
8877               if (entry->d_un.d_val == 0)
8878                 printf (_(" None\n"));
8879               else
8880                 {
8881                   unsigned long int val = entry->d_un.d_val;
8882
8883                   if (val & DTF_1_PARINIT)
8884                     {
8885                       printf (" PARINIT");
8886                       val ^= DTF_1_PARINIT;
8887                     }
8888                   if (val & DTF_1_CONFEXP)
8889                     {
8890                       printf (" CONFEXP");
8891                       val ^= DTF_1_CONFEXP;
8892                     }
8893                   if (val != 0)
8894                     printf (" %lx", val);
8895                   puts ("");
8896                 }
8897             }
8898           break;
8899
8900         case DT_POSFLAG_1:
8901           if (do_dynamic)
8902             {
8903               printf (_("Flags:"));
8904
8905               if (entry->d_un.d_val == 0)
8906                 printf (_(" None\n"));
8907               else
8908                 {
8909                   unsigned long int val = entry->d_un.d_val;
8910
8911                   if (val & DF_P1_LAZYLOAD)
8912                     {
8913                       printf (" LAZYLOAD");
8914                       val ^= DF_P1_LAZYLOAD;
8915                     }
8916                   if (val & DF_P1_GROUPPERM)
8917                     {
8918                       printf (" GROUPPERM");
8919                       val ^= DF_P1_GROUPPERM;
8920                     }
8921                   if (val != 0)
8922                     printf (" %lx", val);
8923                   puts ("");
8924                 }
8925             }
8926           break;
8927
8928         case DT_FLAGS_1:
8929           if (do_dynamic)
8930             {
8931               printf (_("Flags:"));
8932               if (entry->d_un.d_val == 0)
8933                 printf (_(" None\n"));
8934               else
8935                 {
8936                   unsigned long int val = entry->d_un.d_val;
8937
8938                   if (val & DF_1_NOW)
8939                     {
8940                       printf (" NOW");
8941                       val ^= DF_1_NOW;
8942                     }
8943                   if (val & DF_1_GLOBAL)
8944                     {
8945                       printf (" GLOBAL");
8946                       val ^= DF_1_GLOBAL;
8947                     }
8948                   if (val & DF_1_GROUP)
8949                     {
8950                       printf (" GROUP");
8951                       val ^= DF_1_GROUP;
8952                     }
8953                   if (val & DF_1_NODELETE)
8954                     {
8955                       printf (" NODELETE");
8956                       val ^= DF_1_NODELETE;
8957                     }
8958                   if (val & DF_1_LOADFLTR)
8959                     {
8960                       printf (" LOADFLTR");
8961                       val ^= DF_1_LOADFLTR;
8962                     }
8963                   if (val & DF_1_INITFIRST)
8964                     {
8965                       printf (" INITFIRST");
8966                       val ^= DF_1_INITFIRST;
8967                     }
8968                   if (val & DF_1_NOOPEN)
8969                     {
8970                       printf (" NOOPEN");
8971                       val ^= DF_1_NOOPEN;
8972                     }
8973                   if (val & DF_1_ORIGIN)
8974                     {
8975                       printf (" ORIGIN");
8976                       val ^= DF_1_ORIGIN;
8977                     }
8978                   if (val & DF_1_DIRECT)
8979                     {
8980                       printf (" DIRECT");
8981                       val ^= DF_1_DIRECT;
8982                     }
8983                   if (val & DF_1_TRANS)
8984                     {
8985                       printf (" TRANS");
8986                       val ^= DF_1_TRANS;
8987                     }
8988                   if (val & DF_1_INTERPOSE)
8989                     {
8990                       printf (" INTERPOSE");
8991                       val ^= DF_1_INTERPOSE;
8992                     }
8993                   if (val & DF_1_NODEFLIB)
8994                     {
8995                       printf (" NODEFLIB");
8996                       val ^= DF_1_NODEFLIB;
8997                     }
8998                   if (val & DF_1_NODUMP)
8999                     {
9000                       printf (" NODUMP");
9001                       val ^= DF_1_NODUMP;
9002                     }
9003                   if (val & DF_1_CONFALT)
9004                     {
9005                       printf (" CONFALT");
9006                       val ^= DF_1_CONFALT;
9007                     }
9008                   if (val & DF_1_ENDFILTEE)
9009                     {
9010                       printf (" ENDFILTEE");
9011                       val ^= DF_1_ENDFILTEE;
9012                     }
9013                   if (val & DF_1_DISPRELDNE)
9014                     {
9015                       printf (" DISPRELDNE");
9016                       val ^= DF_1_DISPRELDNE;
9017                     }
9018                   if (val & DF_1_DISPRELPND)
9019                     {
9020                       printf (" DISPRELPND");
9021                       val ^= DF_1_DISPRELPND;
9022                     }
9023                   if (val & DF_1_NODIRECT)
9024                     {
9025                       printf (" NODIRECT");
9026                       val ^= DF_1_NODIRECT;
9027                     }
9028                   if (val & DF_1_IGNMULDEF)
9029                     {
9030                       printf (" IGNMULDEF");
9031                       val ^= DF_1_IGNMULDEF;
9032                     }
9033                   if (val & DF_1_NOKSYMS)
9034                     {
9035                       printf (" NOKSYMS");
9036                       val ^= DF_1_NOKSYMS;
9037                     }
9038                   if (val & DF_1_NOHDR)
9039                     {
9040                       printf (" NOHDR");
9041                       val ^= DF_1_NOHDR;
9042                     }
9043                   if (val & DF_1_EDITED)
9044                     {
9045                       printf (" EDITED");
9046                       val ^= DF_1_EDITED;
9047                     }
9048                   if (val & DF_1_NORELOC)
9049                     {
9050                       printf (" NORELOC");
9051                       val ^= DF_1_NORELOC;
9052                     }
9053                   if (val & DF_1_SYMINTPOSE)
9054                     {
9055                       printf (" SYMINTPOSE");
9056                       val ^= DF_1_SYMINTPOSE;
9057                     }
9058                   if (val & DF_1_GLOBAUDIT)
9059                     {
9060                       printf (" GLOBAUDIT");
9061                       val ^= DF_1_GLOBAUDIT;
9062                     }
9063                   if (val & DF_1_SINGLETON)
9064                     {
9065                       printf (" SINGLETON");
9066                       val ^= DF_1_SINGLETON;
9067                     }
9068                   if (val != 0)
9069                     printf (" %lx", val);
9070                   puts ("");
9071                 }
9072             }
9073           break;
9074
9075         case DT_PLTREL:
9076           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9077           if (do_dynamic)
9078             puts (get_dynamic_type (entry->d_un.d_val));
9079           break;
9080
9081         case DT_NULL    :
9082         case DT_NEEDED  :
9083         case DT_PLTGOT  :
9084         case DT_HASH    :
9085         case DT_STRTAB  :
9086         case DT_SYMTAB  :
9087         case DT_RELA    :
9088         case DT_INIT    :
9089         case DT_FINI    :
9090         case DT_SONAME  :
9091         case DT_RPATH   :
9092         case DT_SYMBOLIC:
9093         case DT_REL     :
9094         case DT_DEBUG   :
9095         case DT_TEXTREL :
9096         case DT_JMPREL  :
9097         case DT_RUNPATH :
9098           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9099
9100           if (do_dynamic)
9101             {
9102               char * name;
9103
9104               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9105                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9106               else
9107                 name = NULL;
9108
9109               if (name)
9110                 {
9111                   switch (entry->d_tag)
9112                     {
9113                     case DT_NEEDED:
9114                       printf (_("Shared library: [%s]"), name);
9115
9116                       if (streq (name, program_interpreter))
9117                         printf (_(" program interpreter"));
9118                       break;
9119
9120                     case DT_SONAME:
9121                       printf (_("Library soname: [%s]"), name);
9122                       break;
9123
9124                     case DT_RPATH:
9125                       printf (_("Library rpath: [%s]"), name);
9126                       break;
9127
9128                     case DT_RUNPATH:
9129                       printf (_("Library runpath: [%s]"), name);
9130                       break;
9131
9132                     default:
9133                       print_vma (entry->d_un.d_val, PREFIX_HEX);
9134                       break;
9135                     }
9136                 }
9137               else
9138                 print_vma (entry->d_un.d_val, PREFIX_HEX);
9139
9140               putchar ('\n');
9141             }
9142           break;
9143
9144         case DT_PLTRELSZ:
9145         case DT_RELASZ  :
9146         case DT_STRSZ   :
9147         case DT_RELSZ   :
9148         case DT_RELAENT :
9149         case DT_SYMENT  :
9150         case DT_RELENT  :
9151           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9152         case DT_PLTPADSZ:
9153         case DT_MOVEENT :
9154         case DT_MOVESZ  :
9155         case DT_INIT_ARRAYSZ:
9156         case DT_FINI_ARRAYSZ:
9157         case DT_GNU_CONFLICTSZ:
9158         case DT_GNU_LIBLISTSZ:
9159           if (do_dynamic)
9160             {
9161               print_vma (entry->d_un.d_val, UNSIGNED);
9162               printf (_(" (bytes)\n"));
9163             }
9164           break;
9165
9166         case DT_VERDEFNUM:
9167         case DT_VERNEEDNUM:
9168         case DT_RELACOUNT:
9169         case DT_RELCOUNT:
9170           if (do_dynamic)
9171             {
9172               print_vma (entry->d_un.d_val, UNSIGNED);
9173               putchar ('\n');
9174             }
9175           break;
9176
9177         case DT_SYMINSZ:
9178         case DT_SYMINENT:
9179         case DT_SYMINFO:
9180         case DT_USED:
9181         case DT_INIT_ARRAY:
9182         case DT_FINI_ARRAY:
9183           if (do_dynamic)
9184             {
9185               if (entry->d_tag == DT_USED
9186                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
9187                 {
9188                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9189
9190                   if (*name)
9191                     {
9192                       printf (_("Not needed object: [%s]\n"), name);
9193                       break;
9194                     }
9195                 }
9196
9197               print_vma (entry->d_un.d_val, PREFIX_HEX);
9198               putchar ('\n');
9199             }
9200           break;
9201
9202         case DT_BIND_NOW:
9203           /* The value of this entry is ignored.  */
9204           if (do_dynamic)
9205             putchar ('\n');
9206           break;
9207
9208         case DT_GNU_PRELINKED:
9209           if (do_dynamic)
9210             {
9211               struct tm * tmp;
9212               time_t atime = entry->d_un.d_val;
9213
9214               tmp = gmtime (&atime);
9215               /* PR 17533 file: 041-1244816-0.004.  */
9216               if (tmp == NULL)
9217                 printf (_("<corrupt time val: %lx"),
9218                         (unsigned long) atime);
9219               else
9220                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9221                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9222                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9223
9224             }
9225           break;
9226
9227         case DT_GNU_HASH:
9228           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9229           if (do_dynamic)
9230             {
9231               print_vma (entry->d_un.d_val, PREFIX_HEX);
9232               putchar ('\n');
9233             }
9234           break;
9235
9236         default:
9237           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
9238             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
9239               entry->d_un.d_val;
9240
9241           if (do_dynamic)
9242             {
9243               switch (elf_header.e_machine)
9244                 {
9245                 case EM_MIPS:
9246                 case EM_MIPS_RS3_LE:
9247                   dynamic_section_mips_val (entry);
9248                   break;
9249                 case EM_PARISC:
9250                   dynamic_section_parisc_val (entry);
9251                   break;
9252                 case EM_IA_64:
9253                   dynamic_section_ia64_val (entry);
9254                   break;
9255                 default:
9256                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9257                   putchar ('\n');
9258                 }
9259             }
9260           break;
9261         }
9262     }
9263
9264   return 1;
9265 }
9266
9267 static char *
9268 get_ver_flags (unsigned int flags)
9269 {
9270   static char buff[32];
9271
9272   buff[0] = 0;
9273
9274   if (flags == 0)
9275     return _("none");
9276
9277   if (flags & VER_FLG_BASE)
9278     strcat (buff, "BASE ");
9279
9280   if (flags & VER_FLG_WEAK)
9281     {
9282       if (flags & VER_FLG_BASE)
9283         strcat (buff, "| ");
9284
9285       strcat (buff, "WEAK ");
9286     }
9287
9288   if (flags & VER_FLG_INFO)
9289     {
9290       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9291         strcat (buff, "| ");
9292
9293       strcat (buff, "INFO ");
9294     }
9295
9296   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
9297     strcat (buff, _("| <unknown>"));
9298
9299   return buff;
9300 }
9301
9302 /* Display the contents of the version sections.  */
9303
9304 static int
9305 process_version_sections (FILE * file)
9306 {
9307   Elf_Internal_Shdr * section;
9308   unsigned i;
9309   int found = 0;
9310
9311   if (! do_version)
9312     return 1;
9313
9314   for (i = 0, section = section_headers;
9315        i < elf_header.e_shnum;
9316        i++, section++)
9317     {
9318       switch (section->sh_type)
9319         {
9320         case SHT_GNU_verdef:
9321           {
9322             Elf_External_Verdef * edefs;
9323             unsigned int idx;
9324             unsigned int cnt;
9325             char * endbuf;
9326
9327             found = 1;
9328
9329             printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9330                     printable_section_name (section),
9331                     section->sh_info);
9332
9333             printf (_("  Addr: 0x"));
9334             printf_vma (section->sh_addr);
9335             printf (_("  Offset: %#08lx  Link: %u (%s)"),
9336                     (unsigned long) section->sh_offset, section->sh_link,
9337                     printable_section_name_from_index (section->sh_link));
9338
9339             edefs = (Elf_External_Verdef *)
9340                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9341                           _("version definition section"));
9342             if (!edefs)
9343               break;
9344             endbuf = (char *) edefs + section->sh_size;
9345
9346             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9347               {
9348                 char * vstart;
9349                 Elf_External_Verdef * edef;
9350                 Elf_Internal_Verdef ent;
9351                 Elf_External_Verdaux * eaux;
9352                 Elf_Internal_Verdaux aux;
9353                 int j;
9354                 int isum;
9355
9356                 /* Check for very large indicies.  */
9357                 if (idx > (size_t) (endbuf - (char *) edefs))
9358                   break;
9359
9360                 vstart = ((char *) edefs) + idx;
9361                 if (vstart + sizeof (*edef) > endbuf)
9362                   break;
9363
9364                 edef = (Elf_External_Verdef *) vstart;
9365
9366                 ent.vd_version = BYTE_GET (edef->vd_version);
9367                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
9368                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
9369                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
9370                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
9371                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
9372                 ent.vd_next    = BYTE_GET (edef->vd_next);
9373
9374                 printf (_("  %#06x: Rev: %d  Flags: %s"),
9375                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9376
9377                 printf (_("  Index: %d  Cnt: %d  "),
9378                         ent.vd_ndx, ent.vd_cnt);
9379
9380                 /* Check for overflow.  */
9381                 if (ent.vd_aux > (size_t) (endbuf - vstart))
9382                   break;
9383
9384                 vstart += ent.vd_aux;
9385
9386                 eaux = (Elf_External_Verdaux *) vstart;
9387
9388                 aux.vda_name = BYTE_GET (eaux->vda_name);
9389                 aux.vda_next = BYTE_GET (eaux->vda_next);
9390
9391                 if (VALID_DYNAMIC_NAME (aux.vda_name))
9392                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
9393                 else
9394                   printf (_("Name index: %ld\n"), aux.vda_name);
9395
9396                 isum = idx + ent.vd_aux;
9397
9398                 for (j = 1; j < ent.vd_cnt; j++)
9399                   {
9400                     /* Check for overflow.  */
9401                     if (aux.vda_next > (size_t) (endbuf - vstart))
9402                       break;
9403
9404                     isum   += aux.vda_next;
9405                     vstart += aux.vda_next;
9406
9407                     eaux = (Elf_External_Verdaux *) vstart;
9408                     if (vstart + sizeof (*eaux) > endbuf)
9409                       break;
9410
9411                     aux.vda_name = BYTE_GET (eaux->vda_name);
9412                     aux.vda_next = BYTE_GET (eaux->vda_next);
9413
9414                     if (VALID_DYNAMIC_NAME (aux.vda_name))
9415                       printf (_("  %#06x: Parent %d: %s\n"),
9416                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
9417                     else
9418                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
9419                               isum, j, aux.vda_name);
9420                   }
9421
9422                 if (j < ent.vd_cnt)
9423                   printf (_("  Version def aux past end of section\n"));
9424
9425                 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2.  */
9426                 if (idx + ent.vd_next <= idx)
9427                   break;
9428
9429                 idx += ent.vd_next;
9430               }
9431
9432             if (cnt < section->sh_info)
9433               printf (_("  Version definition past end of section\n"));
9434
9435             free (edefs);
9436           }
9437           break;
9438
9439         case SHT_GNU_verneed:
9440           {
9441             Elf_External_Verneed * eneed;
9442             unsigned int idx;
9443             unsigned int cnt;
9444             char * endbuf;
9445
9446             found = 1;
9447
9448             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9449                     printable_section_name (section), section->sh_info);
9450
9451             printf (_(" Addr: 0x"));
9452             printf_vma (section->sh_addr);
9453             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9454                     (unsigned long) section->sh_offset, section->sh_link,
9455                     printable_section_name_from_index (section->sh_link));
9456
9457             eneed = (Elf_External_Verneed *) get_data (NULL, file,
9458                                                        section->sh_offset, 1,
9459                                                        section->sh_size,
9460                                                        _("Version Needs section"));
9461             if (!eneed)
9462               break;
9463             endbuf = (char *) eneed + section->sh_size;
9464
9465             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9466               {
9467                 Elf_External_Verneed * entry;
9468                 Elf_Internal_Verneed ent;
9469                 int j;
9470                 int isum;
9471                 char * vstart;
9472
9473                 if (idx > (size_t) (endbuf - (char *) eneed))
9474                   break;
9475
9476                 vstart = ((char *) eneed) + idx;
9477                 if (vstart + sizeof (*entry) > endbuf)
9478                   break;
9479
9480                 entry = (Elf_External_Verneed *) vstart;
9481
9482                 ent.vn_version = BYTE_GET (entry->vn_version);
9483                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
9484                 ent.vn_file    = BYTE_GET (entry->vn_file);
9485                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
9486                 ent.vn_next    = BYTE_GET (entry->vn_next);
9487
9488                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
9489
9490                 if (VALID_DYNAMIC_NAME (ent.vn_file))
9491                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
9492                 else
9493                   printf (_("  File: %lx"), ent.vn_file);
9494
9495                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
9496
9497                 /* Check for overflow.  */
9498                 if (ent.vn_aux > (size_t) (endbuf - vstart))
9499                   break;
9500                 vstart += ent.vn_aux;
9501
9502                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9503                   {
9504                     Elf_External_Vernaux * eaux;
9505                     Elf_Internal_Vernaux aux;
9506
9507                     if (vstart + sizeof (*eaux) > endbuf)
9508                       break;
9509                     eaux = (Elf_External_Vernaux *) vstart;
9510
9511                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
9512                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
9513                     aux.vna_other = BYTE_GET (eaux->vna_other);
9514                     aux.vna_name  = BYTE_GET (eaux->vna_name);
9515                     aux.vna_next  = BYTE_GET (eaux->vna_next);
9516
9517                     if (VALID_DYNAMIC_NAME (aux.vna_name))
9518                       printf (_("  %#06x:   Name: %s"),
9519                               isum, GET_DYNAMIC_NAME (aux.vna_name));
9520                     else
9521                       printf (_("  %#06x:   Name index: %lx"),
9522                               isum, aux.vna_name);
9523
9524                     printf (_("  Flags: %s  Version: %d\n"),
9525                             get_ver_flags (aux.vna_flags), aux.vna_other);
9526
9527                     /* Check for overflow.  */
9528                     if (aux.vna_next > (size_t) (endbuf - vstart)
9529                         || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9530                       {
9531                         warn (_("Invalid vna_next field of %lx\n"),
9532                               aux.vna_next);
9533                         j = ent.vn_cnt;
9534                         break;
9535                       }
9536                     isum   += aux.vna_next;
9537                     vstart += aux.vna_next;
9538                   }
9539
9540                 if (j < ent.vn_cnt)
9541                   warn (_("Missing Version Needs auxillary information\n"));
9542
9543                 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
9544                   {
9545                     warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9546                     cnt = section->sh_info;
9547                     break;
9548                   }
9549                 idx += ent.vn_next;
9550               }
9551
9552             if (cnt < section->sh_info)
9553               warn (_("Missing Version Needs information\n"));
9554
9555             free (eneed);
9556           }
9557           break;
9558
9559         case SHT_GNU_versym:
9560           {
9561             Elf_Internal_Shdr * link_section;
9562             size_t total;
9563             unsigned int cnt;
9564             unsigned char * edata;
9565             unsigned short * data;
9566             char * strtab;
9567             Elf_Internal_Sym * symbols;
9568             Elf_Internal_Shdr * string_sec;
9569             unsigned long num_syms;
9570             long off;
9571
9572             if (section->sh_link >= elf_header.e_shnum)
9573               break;
9574
9575             link_section = section_headers + section->sh_link;
9576             total = section->sh_size / sizeof (Elf_External_Versym);
9577
9578             if (link_section->sh_link >= elf_header.e_shnum)
9579               break;
9580
9581             found = 1;
9582
9583             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9584             if (symbols == NULL)
9585               break;
9586
9587             string_sec = section_headers + link_section->sh_link;
9588
9589             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9590                                         string_sec->sh_size,
9591                                         _("version string table"));
9592             if (!strtab)
9593               {
9594                 free (symbols);
9595                 break;
9596               }
9597
9598             printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9599                     printable_section_name (section), (unsigned long) total);
9600
9601             printf (_(" Addr: "));
9602             printf_vma (section->sh_addr);
9603             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9604                     (unsigned long) section->sh_offset, section->sh_link,
9605                     printable_section_name (link_section));
9606
9607             off = offset_from_vma (file,
9608                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9609                                    total * sizeof (short));
9610             edata = (unsigned char *) get_data (NULL, file, off, total,
9611                                                 sizeof (short),
9612                                                 _("version symbol data"));
9613             if (!edata)
9614               {
9615                 free (strtab);
9616                 free (symbols);
9617                 break;
9618               }
9619
9620             data = (short unsigned int *) cmalloc (total, sizeof (short));
9621
9622             for (cnt = total; cnt --;)
9623               data[cnt] = byte_get (edata + cnt * sizeof (short),
9624                                     sizeof (short));
9625
9626             free (edata);
9627
9628             for (cnt = 0; cnt < total; cnt += 4)
9629               {
9630                 int j, nn;
9631                 int check_def, check_need;
9632                 char * name;
9633
9634                 printf ("  %03x:", cnt);
9635
9636                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
9637                   switch (data[cnt + j])
9638                     {
9639                     case 0:
9640                       fputs (_("   0 (*local*)    "), stdout);
9641                       break;
9642
9643                     case 1:
9644                       fputs (_("   1 (*global*)   "), stdout);
9645                       break;
9646
9647                     default:
9648                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9649                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
9650
9651                       /* If this index value is greater than the size of the symbols
9652                          array, break to avoid an out-of-bounds read.  */
9653                       if ((unsigned long)(cnt + j) >= num_syms)
9654                         {
9655                           warn (_("invalid index into symbol array\n"));
9656                           break;
9657                         }
9658
9659                       check_def = 1;
9660                       check_need = 1;
9661                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9662                           || section_headers[symbols[cnt + j].st_shndx].sh_type
9663                              != SHT_NOBITS)
9664                         {
9665                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
9666                             check_def = 0;
9667                           else
9668                             check_need = 0;
9669                         }
9670
9671                       if (check_need
9672                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
9673                         {
9674                           Elf_Internal_Verneed ivn;
9675                           unsigned long offset;
9676
9677                           offset = offset_from_vma
9678                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9679                              sizeof (Elf_External_Verneed));
9680
9681                           do
9682                             {
9683                               Elf_Internal_Vernaux ivna;
9684                               Elf_External_Verneed evn;
9685                               Elf_External_Vernaux evna;
9686                               unsigned long a_off;
9687
9688                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9689                                             _("version need")) == NULL)
9690                                 break;
9691
9692                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9693                               ivn.vn_next = BYTE_GET (evn.vn_next);
9694
9695                               a_off = offset + ivn.vn_aux;
9696
9697                               do
9698                                 {
9699                                   if (get_data (&evna, file, a_off, sizeof (evna),
9700                                                 1, _("version need aux (2)")) == NULL)
9701                                     {
9702                                       ivna.vna_next  = 0;
9703                                       ivna.vna_other = 0;
9704                                     }
9705                                   else
9706                                     {
9707                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
9708                                       ivna.vna_other = BYTE_GET (evna.vna_other);
9709                                     }
9710
9711                                   a_off += ivna.vna_next;
9712                                 }
9713                               while (ivna.vna_other != data[cnt + j]
9714                                      && ivna.vna_next != 0);
9715
9716                               if (ivna.vna_other == data[cnt + j])
9717                                 {
9718                                   ivna.vna_name = BYTE_GET (evna.vna_name);
9719
9720                                   if (ivna.vna_name >= string_sec->sh_size)
9721                                     name = _("*invalid*");
9722                                   else
9723                                     name = strtab + ivna.vna_name;
9724                                   nn += printf ("(%s%-*s",
9725                                                 name,
9726                                                 12 - (int) strlen (name),
9727                                                 ")");
9728                                   check_def = 0;
9729                                   break;
9730                                 }
9731
9732                               offset += ivn.vn_next;
9733                             }
9734                           while (ivn.vn_next);
9735                         }
9736
9737                       if (check_def && data[cnt + j] != 0x8001
9738                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9739                         {
9740                           Elf_Internal_Verdef ivd;
9741                           Elf_External_Verdef evd;
9742                           unsigned long offset;
9743
9744                           offset = offset_from_vma
9745                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9746                              sizeof evd);
9747
9748                           do
9749                             {
9750                               if (get_data (&evd, file, offset, sizeof (evd), 1,
9751                                             _("version def")) == NULL)
9752                                 {
9753                                   ivd.vd_next = 0;
9754                                   /* PR 17531: file: 046-1082287-0.004.  */
9755                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
9756                                   break;
9757                                 }
9758                               else
9759                                 {
9760                                   ivd.vd_next = BYTE_GET (evd.vd_next);
9761                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
9762                                 }
9763
9764                               offset += ivd.vd_next;
9765                             }
9766                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
9767                                  && ivd.vd_next != 0);
9768
9769                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
9770                             {
9771                               Elf_External_Verdaux evda;
9772                               Elf_Internal_Verdaux ivda;
9773
9774                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
9775
9776                               if (get_data (&evda, file,
9777                                             offset - ivd.vd_next + ivd.vd_aux,
9778                                             sizeof (evda), 1,
9779                                             _("version def aux")) == NULL)
9780                                 break;
9781
9782                               ivda.vda_name = BYTE_GET (evda.vda_name);
9783
9784                               if (ivda.vda_name >= string_sec->sh_size)
9785                                 name = _("*invalid*");
9786                               else
9787                                 name = strtab + ivda.vda_name;
9788                               nn += printf ("(%s%-*s",
9789                                             name,
9790                                             12 - (int) strlen (name),
9791                                             ")");
9792                             }
9793                         }
9794
9795                       if (nn < 18)
9796                         printf ("%*c", 18 - nn, ' ');
9797                     }
9798
9799                 putchar ('\n');
9800               }
9801
9802             free (data);
9803             free (strtab);
9804             free (symbols);
9805           }
9806           break;
9807
9808         default:
9809           break;
9810         }
9811     }
9812
9813   if (! found)
9814     printf (_("\nNo version information found in this file.\n"));
9815
9816   return 1;
9817 }
9818
9819 static const char *
9820 get_symbol_binding (unsigned int binding)
9821 {
9822   static char buff[32];
9823
9824   switch (binding)
9825     {
9826     case STB_LOCAL:     return "LOCAL";
9827     case STB_GLOBAL:    return "GLOBAL";
9828     case STB_WEAK:      return "WEAK";
9829     default:
9830       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
9831         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9832                   binding);
9833       else if (binding >= STB_LOOS && binding <= STB_HIOS)
9834         {
9835           if (binding == STB_GNU_UNIQUE
9836               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9837                   /* GNU is still using the default value 0.  */
9838                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9839             return "UNIQUE";
9840           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9841         }
9842       else
9843         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
9844       return buff;
9845     }
9846 }
9847
9848 static const char *
9849 get_symbol_type (unsigned int type)
9850 {
9851   static char buff[32];
9852
9853   switch (type)
9854     {
9855     case STT_NOTYPE:    return "NOTYPE";
9856     case STT_OBJECT:    return "OBJECT";
9857     case STT_FUNC:      return "FUNC";
9858     case STT_SECTION:   return "SECTION";
9859     case STT_FILE:      return "FILE";
9860     case STT_COMMON:    return "COMMON";
9861     case STT_TLS:       return "TLS";
9862     case STT_RELC:      return "RELC";
9863     case STT_SRELC:     return "SRELC";
9864     default:
9865       if (type >= STT_LOPROC && type <= STT_HIPROC)
9866         {
9867           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
9868             return "THUMB_FUNC";
9869
9870           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
9871             return "REGISTER";
9872
9873           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9874             return "PARISC_MILLI";
9875
9876           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
9877         }
9878       else if (type >= STT_LOOS && type <= STT_HIOS)
9879         {
9880           if (elf_header.e_machine == EM_PARISC)
9881             {
9882               if (type == STT_HP_OPAQUE)
9883                 return "HP_OPAQUE";
9884               if (type == STT_HP_STUB)
9885                 return "HP_STUB";
9886             }
9887
9888           if (type == STT_GNU_IFUNC
9889               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9890                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9891                   /* GNU is still using the default value 0.  */
9892                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9893             return "IFUNC";
9894
9895           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
9896         }
9897       else
9898         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
9899       return buff;
9900     }
9901 }
9902
9903 static const char *
9904 get_symbol_visibility (unsigned int visibility)
9905 {
9906   switch (visibility)
9907     {
9908     case STV_DEFAULT:   return "DEFAULT";
9909     case STV_INTERNAL:  return "INTERNAL";
9910     case STV_HIDDEN:    return "HIDDEN";
9911     case STV_PROTECTED: return "PROTECTED";
9912     default:
9913       error (_("Unrecognized visibility value: %u"), visibility);
9914       return _("<unknown>");
9915     }
9916 }
9917
9918 static const char *
9919 get_mips_symbol_other (unsigned int other)
9920 {
9921   switch (other)
9922     {
9923     case STO_OPTIONAL:
9924       return "OPTIONAL";
9925     case STO_MIPS_PLT:
9926       return "MIPS PLT";
9927     case STO_MIPS_PIC:
9928       return "MIPS PIC";
9929     case STO_MICROMIPS:
9930       return "MICROMIPS";
9931     case STO_MICROMIPS | STO_MIPS_PIC:
9932       return "MICROMIPS, MIPS PIC";
9933     case STO_MIPS16:
9934       return "MIPS16";
9935     default:
9936       return NULL;
9937     }
9938 }
9939
9940 static const char *
9941 get_ia64_symbol_other (unsigned int other)
9942 {
9943   if (is_ia64_vms ())
9944     {
9945       static char res[32];
9946
9947       res[0] = 0;
9948
9949       /* Function types is for images and .STB files only.  */
9950       switch (elf_header.e_type)
9951         {
9952         case ET_DYN:
9953         case ET_EXEC:
9954           switch (VMS_ST_FUNC_TYPE (other))
9955             {
9956             case VMS_SFT_CODE_ADDR:
9957               strcat (res, " CA");
9958               break;
9959             case VMS_SFT_SYMV_IDX:
9960               strcat (res, " VEC");
9961               break;
9962             case VMS_SFT_FD:
9963               strcat (res, " FD");
9964               break;
9965             case VMS_SFT_RESERVE:
9966               strcat (res, " RSV");
9967               break;
9968             default:
9969               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
9970                     VMS_ST_FUNC_TYPE (other));
9971               strcat (res, " <unknown>");
9972               break;
9973             }
9974           break;
9975         default:
9976           break;
9977         }
9978       switch (VMS_ST_LINKAGE (other))
9979         {
9980         case VMS_STL_IGNORE:
9981           strcat (res, " IGN");
9982           break;
9983         case VMS_STL_RESERVE:
9984           strcat (res, " RSV");
9985           break;
9986         case VMS_STL_STD:
9987           strcat (res, " STD");
9988           break;
9989         case VMS_STL_LNK:
9990           strcat (res, " LNK");
9991           break;
9992         default:
9993           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
9994                 VMS_ST_LINKAGE (other));
9995           strcat (res, " <unknown>");
9996           break;
9997         }
9998
9999       if (res[0] != 0)
10000         return res + 1;
10001       else
10002         return res;
10003     }
10004   return NULL;
10005 }
10006
10007 static const char *
10008 get_ppc64_symbol_other (unsigned int other)
10009 {
10010   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10011     {
10012       static char buf[32];
10013       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10014                 PPC64_LOCAL_ENTRY_OFFSET (other));
10015       return buf;
10016     }
10017   return NULL;
10018 }
10019
10020 static const char *
10021 get_symbol_other (unsigned int other)
10022 {
10023   const char * result = NULL;
10024   static char buff [32];
10025
10026   if (other == 0)
10027     return "";
10028
10029   switch (elf_header.e_machine)
10030     {
10031     case EM_MIPS:
10032       result = get_mips_symbol_other (other);
10033       break;
10034     case EM_IA_64:
10035       result = get_ia64_symbol_other (other);
10036       break;
10037     case EM_PPC64:
10038       result = get_ppc64_symbol_other (other);
10039       break;
10040     default:
10041       break;
10042     }
10043
10044   if (result)
10045     return result;
10046
10047   snprintf (buff, sizeof buff, _("<other>: %x"), other);
10048   return buff;
10049 }
10050
10051 static const char *
10052 get_symbol_index_type (unsigned int type)
10053 {
10054   static char buff[32];
10055
10056   switch (type)
10057     {
10058     case SHN_UNDEF:     return "UND";
10059     case SHN_ABS:       return "ABS";
10060     case SHN_COMMON:    return "COM";
10061     default:
10062       if (type == SHN_IA_64_ANSI_COMMON
10063           && elf_header.e_machine == EM_IA_64
10064           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10065         return "ANSI_COM";
10066       else if ((elf_header.e_machine == EM_X86_64
10067                 || elf_header.e_machine == EM_L1OM
10068                 || elf_header.e_machine == EM_K1OM)
10069                && type == SHN_X86_64_LCOMMON)
10070         return "LARGE_COM";
10071       else if ((type == SHN_MIPS_SCOMMON
10072                 && elf_header.e_machine == EM_MIPS)
10073                || (type == SHN_TIC6X_SCOMMON
10074                    && elf_header.e_machine == EM_TI_C6000))
10075         return "SCOM";
10076       else if (type == SHN_MIPS_SUNDEFINED
10077                && elf_header.e_machine == EM_MIPS)
10078         return "SUND";
10079       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10080         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10081       else if (type >= SHN_LOOS && type <= SHN_HIOS)
10082         sprintf (buff, "OS [0x%04x]", type & 0xffff);
10083       else if (type >= SHN_LORESERVE)
10084         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10085       else if (type >= elf_header.e_shnum)
10086         sprintf (buff, _("bad section index[%3d]"), type);
10087       else
10088         sprintf (buff, "%3d", type);
10089       break;
10090     }
10091
10092   return buff;
10093 }
10094
10095 static bfd_vma *
10096 get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10097 {
10098   unsigned char * e_data;
10099   bfd_vma * i_data;
10100
10101   /* If the size_t type is smaller than the bfd_size_type, eg because
10102      you are building a 32-bit tool on a 64-bit host, then make sure
10103      that when (number) is cast to (size_t) no information is lost.  */
10104   if (sizeof (size_t) < sizeof (bfd_size_type)
10105       && (bfd_size_type) ((size_t) number) != number)
10106     {
10107       error (_("Size truncation prevents reading %llu elements of size %u\n"),
10108              (unsigned long long) number, ent_size);
10109       return NULL;
10110     }
10111
10112   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10113      attempting to allocate memory when the read is bound to fail.  */
10114   if (ent_size * number > current_file_size)
10115     {
10116       error (_("Invalid number of dynamic entries: %llu\n"),
10117              (unsigned long long) number);
10118       return NULL;
10119     }
10120
10121   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
10122   if (e_data == NULL)
10123     {
10124       error (_("Out of memory reading %llu dynamic entries\n"),
10125              (unsigned long long) number);
10126       return NULL;
10127     }
10128
10129   if (fread (e_data, ent_size, (size_t) number, file) != number)
10130     {
10131       error (_("Unable to read in %llu bytes of dynamic data\n"),
10132              (unsigned long long) (number * ent_size));
10133       free (e_data);
10134       return NULL;
10135     }
10136
10137   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
10138   if (i_data == NULL)
10139     {
10140       error (_("Out of memory allocating space for %llu dynamic entries\n"),
10141              (unsigned long long) number);
10142       free (e_data);
10143       return NULL;
10144     }
10145
10146   while (number--)
10147     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
10148
10149   free (e_data);
10150
10151   return i_data;
10152 }
10153
10154 static void
10155 print_dynamic_symbol (bfd_vma si, unsigned long hn)
10156 {
10157   Elf_Internal_Sym * psym;
10158   int n;
10159
10160   n = print_vma (si, DEC_5);
10161   if (n < 5)
10162     fputs (&"     "[n], stdout);
10163   printf (" %3lu: ", hn);
10164
10165   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10166     {
10167       printf (_("<No info available for dynamic symbol number %lu>\n"),
10168               (unsigned long) si);
10169       return;
10170     }
10171
10172   psym = dynamic_symbols + si;
10173   print_vma (psym->st_value, LONG_HEX);
10174   putchar (' ');
10175   print_vma (psym->st_size, DEC_5);
10176
10177   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10178   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10179   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10180   /* Check to see if any other bits in the st_other field are set.
10181      Note - displaying this information disrupts the layout of the
10182      table being generated, but for the moment this case is very
10183      rare.  */
10184   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10185     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10186   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10187   if (VALID_DYNAMIC_NAME (psym->st_name))
10188     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10189   else
10190     printf (_(" <corrupt: %14ld>"), psym->st_name);
10191   putchar ('\n');
10192 }
10193
10194 static const char *
10195 get_symbol_version_string (FILE *file, int is_dynsym,
10196                            const char *strtab,
10197                            unsigned long int strtab_size,
10198                            unsigned int si, Elf_Internal_Sym *psym,
10199                            enum versioned_symbol_info *sym_info,
10200                            unsigned short *vna_other)
10201 {
10202   const char *version_string = NULL;
10203
10204   if (is_dynsym
10205       && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10206     {
10207       unsigned char data[2];
10208       unsigned short vers_data;
10209       unsigned long offset;
10210       int is_nobits;
10211       int check_def;
10212
10213       offset = offset_from_vma
10214         (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10215          sizeof data + si * sizeof (vers_data));
10216
10217       if (get_data (&data, file, offset + si * sizeof (vers_data),
10218                     sizeof (data), 1, _("version data")) == NULL)
10219         return NULL;
10220
10221       vers_data = byte_get (data, 2);
10222
10223       is_nobits = (section_headers != NULL
10224                    && psym->st_shndx < elf_header.e_shnum
10225                    && section_headers[psym->st_shndx].sh_type
10226                    == SHT_NOBITS);
10227
10228       check_def = (psym->st_shndx != SHN_UNDEF);
10229
10230       if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10231         {
10232           if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10233               && (is_nobits || ! check_def))
10234             {
10235               Elf_External_Verneed evn;
10236               Elf_Internal_Verneed ivn;
10237               Elf_Internal_Vernaux ivna;
10238
10239               /* We must test both.  */
10240               offset = offset_from_vma
10241                 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10242                  sizeof evn);
10243
10244               do
10245                 {
10246                   unsigned long vna_off;
10247
10248                   if (get_data (&evn, file, offset, sizeof (evn), 1,
10249                                 _("version need")) == NULL)
10250                     {
10251                       ivna.vna_next = 0;
10252                       ivna.vna_other = 0;
10253                       ivna.vna_name = 0;
10254                       break;
10255                     }
10256
10257                   ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10258                   ivn.vn_next = BYTE_GET (evn.vn_next);
10259
10260                   vna_off = offset + ivn.vn_aux;
10261
10262                   do
10263                     {
10264                       Elf_External_Vernaux evna;
10265
10266                       if (get_data (&evna, file, vna_off,
10267                                     sizeof (evna), 1,
10268                                     _("version need aux (3)")) == NULL)
10269                         {
10270                           ivna.vna_next = 0;
10271                           ivna.vna_other = 0;
10272                           ivna.vna_name = 0;
10273                         }
10274                       else
10275                         {
10276                           ivna.vna_other = BYTE_GET (evna.vna_other);
10277                           ivna.vna_next  = BYTE_GET (evna.vna_next);
10278                           ivna.vna_name  = BYTE_GET (evna.vna_name);
10279                         }
10280
10281                       vna_off += ivna.vna_next;
10282                     }
10283                   while (ivna.vna_other != vers_data
10284                          && ivna.vna_next != 0);
10285
10286                   if (ivna.vna_other == vers_data)
10287                     break;
10288
10289                   offset += ivn.vn_next;
10290                 }
10291               while (ivn.vn_next != 0);
10292
10293               if (ivna.vna_other == vers_data)
10294                 {
10295                   *sym_info = symbol_undefined;
10296                   *vna_other = ivna.vna_other;
10297                   version_string = (ivna.vna_name < strtab_size
10298                                     ? strtab + ivna.vna_name
10299                                     : _("<corrupt>"));
10300                   check_def = 0;
10301                 }
10302               else if (! is_nobits)
10303                 error (_("bad dynamic symbol\n"));
10304               else
10305                 check_def = 1;
10306             }
10307
10308           if (check_def)
10309             {
10310               if (vers_data != 0x8001
10311                   && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10312                 {
10313                   Elf_Internal_Verdef ivd;
10314                   Elf_Internal_Verdaux ivda;
10315                   Elf_External_Verdaux evda;
10316                   unsigned long off;
10317
10318                   off = offset_from_vma
10319                     (file,
10320                      version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10321                      sizeof (Elf_External_Verdef));
10322
10323                   do
10324                     {
10325                       Elf_External_Verdef evd;
10326
10327                       if (get_data (&evd, file, off, sizeof (evd),
10328                                     1, _("version def")) == NULL)
10329                         {
10330                           ivd.vd_ndx = 0;
10331                           ivd.vd_aux = 0;
10332                           ivd.vd_next = 0;
10333                         }
10334                       else
10335                         {
10336                           ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10337                           ivd.vd_aux = BYTE_GET (evd.vd_aux);
10338                           ivd.vd_next = BYTE_GET (evd.vd_next);
10339                         }
10340
10341                       off += ivd.vd_next;
10342                     }
10343                   while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10344                          && ivd.vd_next != 0);
10345
10346                   off -= ivd.vd_next;
10347                   off += ivd.vd_aux;
10348
10349                   if (get_data (&evda, file, off, sizeof (evda),
10350                                 1, _("version def aux")) == NULL)
10351                     return version_string;
10352
10353                   ivda.vda_name = BYTE_GET (evda.vda_name);
10354
10355                   if (psym->st_name != ivda.vda_name)
10356                     {
10357                       *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10358                                    ? symbol_hidden : symbol_public);
10359                       version_string = (ivda.vda_name < strtab_size
10360                                         ? strtab + ivda.vda_name
10361                                         : _("<corrupt>"));
10362                     }
10363                 }
10364             }
10365         }
10366     }
10367   return version_string;
10368 }
10369
10370 /* Dump the symbol table.  */
10371 static int
10372 process_symbol_table (FILE * file)
10373 {
10374   Elf_Internal_Shdr * section;
10375   bfd_size_type nbuckets = 0;
10376   bfd_size_type nchains = 0;
10377   bfd_vma * buckets = NULL;
10378   bfd_vma * chains = NULL;
10379   bfd_vma ngnubuckets = 0;
10380   bfd_vma * gnubuckets = NULL;
10381   bfd_vma * gnuchains = NULL;
10382   bfd_vma gnusymidx = 0;
10383   bfd_size_type ngnuchains = 0;
10384
10385   if (!do_syms && !do_dyn_syms && !do_histogram)
10386     return 1;
10387
10388   if (dynamic_info[DT_HASH]
10389       && (do_histogram
10390           || (do_using_dynamic
10391               && !do_dyn_syms
10392               && dynamic_strings != NULL)))
10393     {
10394       unsigned char nb[8];
10395       unsigned char nc[8];
10396       unsigned int hash_ent_size = 4;
10397
10398       if ((elf_header.e_machine == EM_ALPHA
10399            || elf_header.e_machine == EM_S390
10400            || elf_header.e_machine == EM_S390_OLD)
10401           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10402         hash_ent_size = 8;
10403
10404       if (fseek (file,
10405                  (archive_file_offset
10406                   + offset_from_vma (file, dynamic_info[DT_HASH],
10407                                      sizeof nb + sizeof nc)),
10408                  SEEK_SET))
10409         {
10410           error (_("Unable to seek to start of dynamic information\n"));
10411           goto no_hash;
10412         }
10413
10414       if (fread (nb, hash_ent_size, 1, file) != 1)
10415         {
10416           error (_("Failed to read in number of buckets\n"));
10417           goto no_hash;
10418         }
10419
10420       if (fread (nc, hash_ent_size, 1, file) != 1)
10421         {
10422           error (_("Failed to read in number of chains\n"));
10423           goto no_hash;
10424         }
10425
10426       nbuckets = byte_get (nb, hash_ent_size);
10427       nchains  = byte_get (nc, hash_ent_size);
10428
10429       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10430       chains  = get_dynamic_data (file, nchains, hash_ent_size);
10431
10432     no_hash:
10433       if (buckets == NULL || chains == NULL)
10434         {
10435           if (do_using_dynamic)
10436             return 0;
10437           free (buckets);
10438           free (chains);
10439           buckets = NULL;
10440           chains = NULL;
10441           nbuckets = 0;
10442           nchains = 0;
10443         }
10444     }
10445
10446   if (dynamic_info_DT_GNU_HASH
10447       && (do_histogram
10448           || (do_using_dynamic
10449               && !do_dyn_syms
10450               && dynamic_strings != NULL)))
10451     {
10452       unsigned char nb[16];
10453       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10454       bfd_vma buckets_vma;
10455
10456       if (fseek (file,
10457                  (archive_file_offset
10458                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10459                                      sizeof nb)),
10460                  SEEK_SET))
10461         {
10462           error (_("Unable to seek to start of dynamic information\n"));
10463           goto no_gnu_hash;
10464         }
10465
10466       if (fread (nb, 16, 1, file) != 1)
10467         {
10468           error (_("Failed to read in number of buckets\n"));
10469           goto no_gnu_hash;
10470         }
10471
10472       ngnubuckets = byte_get (nb, 4);
10473       gnusymidx = byte_get (nb + 4, 4);
10474       bitmaskwords = byte_get (nb + 8, 4);
10475       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
10476       if (is_32bit_elf)
10477         buckets_vma += bitmaskwords * 4;
10478       else
10479         buckets_vma += bitmaskwords * 8;
10480
10481       if (fseek (file,
10482                  (archive_file_offset
10483                   + offset_from_vma (file, buckets_vma, 4)),
10484                  SEEK_SET))
10485         {
10486           error (_("Unable to seek to start of dynamic information\n"));
10487           goto no_gnu_hash;
10488         }
10489
10490       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
10491
10492       if (gnubuckets == NULL)
10493         goto no_gnu_hash;
10494
10495       for (i = 0; i < ngnubuckets; i++)
10496         if (gnubuckets[i] != 0)
10497           {
10498             if (gnubuckets[i] < gnusymidx)
10499               return 0;
10500
10501             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10502               maxchain = gnubuckets[i];
10503           }
10504
10505       if (maxchain == 0xffffffff)
10506         goto no_gnu_hash;
10507
10508       maxchain -= gnusymidx;
10509
10510       if (fseek (file,
10511                  (archive_file_offset
10512                   + offset_from_vma (file, buckets_vma
10513                                            + 4 * (ngnubuckets + maxchain), 4)),
10514                  SEEK_SET))
10515         {
10516           error (_("Unable to seek to start of dynamic information\n"));
10517           goto no_gnu_hash;
10518         }
10519
10520       do
10521         {
10522           if (fread (nb, 4, 1, file) != 1)
10523             {
10524               error (_("Failed to determine last chain length\n"));
10525               goto no_gnu_hash;
10526             }
10527
10528           if (maxchain + 1 == 0)
10529             goto no_gnu_hash;
10530
10531           ++maxchain;
10532         }
10533       while ((byte_get (nb, 4) & 1) == 0);
10534
10535       if (fseek (file,
10536                  (archive_file_offset
10537                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10538                  SEEK_SET))
10539         {
10540           error (_("Unable to seek to start of dynamic information\n"));
10541           goto no_gnu_hash;
10542         }
10543
10544       gnuchains = get_dynamic_data (file, maxchain, 4);
10545       ngnuchains = maxchain;
10546
10547     no_gnu_hash:
10548       if (gnuchains == NULL)
10549         {
10550           free (gnubuckets);
10551           gnubuckets = NULL;
10552           ngnubuckets = 0;
10553           if (do_using_dynamic)
10554             return 0;
10555         }
10556     }
10557
10558   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10559       && do_syms
10560       && do_using_dynamic
10561       && dynamic_strings != NULL
10562       && dynamic_symbols != NULL)
10563     {
10564       unsigned long hn;
10565
10566       if (dynamic_info[DT_HASH])
10567         {
10568           bfd_vma si;
10569
10570           printf (_("\nSymbol table for image:\n"));
10571           if (is_32bit_elf)
10572             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
10573           else
10574             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
10575
10576           for (hn = 0; hn < nbuckets; hn++)
10577             {
10578               if (! buckets[hn])
10579                 continue;
10580
10581               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10582                 print_dynamic_symbol (si, hn);
10583             }
10584         }
10585
10586       if (dynamic_info_DT_GNU_HASH)
10587         {
10588           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10589           if (is_32bit_elf)
10590             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
10591           else
10592             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
10593
10594           for (hn = 0; hn < ngnubuckets; ++hn)
10595             if (gnubuckets[hn] != 0)
10596               {
10597                 bfd_vma si = gnubuckets[hn];
10598                 bfd_vma off = si - gnusymidx;
10599
10600                 do
10601                   {
10602                     print_dynamic_symbol (si, hn);
10603                     si++;
10604                   }
10605                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
10606               }
10607         }
10608     }
10609   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10610            && section_headers != NULL)
10611     {
10612       unsigned int i;
10613
10614       for (i = 0, section = section_headers;
10615            i < elf_header.e_shnum;
10616            i++, section++)
10617         {
10618           unsigned int si;
10619           char * strtab = NULL;
10620           unsigned long int strtab_size = 0;
10621           Elf_Internal_Sym * symtab;
10622           Elf_Internal_Sym * psym;
10623           unsigned long num_syms;
10624
10625           if ((section->sh_type != SHT_SYMTAB
10626                && section->sh_type != SHT_DYNSYM)
10627               || (!do_syms
10628                   && section->sh_type == SHT_SYMTAB))
10629             continue;
10630
10631           if (section->sh_entsize == 0)
10632             {
10633               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10634                       printable_section_name (section));
10635               continue;
10636             }
10637
10638           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10639                   printable_section_name (section),
10640                   (unsigned long) (section->sh_size / section->sh_entsize));
10641
10642           if (is_32bit_elf)
10643             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
10644           else
10645             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
10646
10647           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
10648           if (symtab == NULL)
10649             continue;
10650
10651           if (section->sh_link == elf_header.e_shstrndx)
10652             {
10653               strtab = string_table;
10654               strtab_size = string_table_length;
10655             }
10656           else if (section->sh_link < elf_header.e_shnum)
10657             {
10658               Elf_Internal_Shdr * string_sec;
10659
10660               string_sec = section_headers + section->sh_link;
10661
10662               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10663                                           1, string_sec->sh_size,
10664                                           _("string table"));
10665               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
10666             }
10667
10668           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
10669             {
10670               const char *version_string;
10671               enum versioned_symbol_info sym_info;
10672               unsigned short vna_other;
10673
10674               printf ("%6d: ", si);
10675               print_vma (psym->st_value, LONG_HEX);
10676               putchar (' ');
10677               print_vma (psym->st_size, DEC_5);
10678               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10679               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10680               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10681               /* Check to see if any other bits in the st_other field are set.
10682                  Note - displaying this information disrupts the layout of the
10683                  table being generated, but for the moment this case is very rare.  */
10684               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10685                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10686               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
10687               print_symbol (25, psym->st_name < strtab_size
10688                             ? strtab + psym->st_name : _("<corrupt>"));
10689
10690               version_string
10691                 = get_symbol_version_string (file,
10692                                              section->sh_type == SHT_DYNSYM,
10693                                              strtab, strtab_size, si,
10694                                              psym, &sym_info, &vna_other);
10695               if (version_string)
10696                 {
10697                   if (sym_info == symbol_undefined)
10698                     printf ("@%s (%d)", version_string, vna_other);
10699                   else
10700                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10701                             version_string);
10702                 }
10703
10704               putchar ('\n');
10705             }
10706
10707           free (symtab);
10708           if (strtab != string_table)
10709             free (strtab);
10710         }
10711     }
10712   else if (do_syms)
10713     printf
10714       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10715
10716   if (do_histogram && buckets != NULL)
10717     {
10718       unsigned long * lengths;
10719       unsigned long * counts;
10720       unsigned long hn;
10721       bfd_vma si;
10722       unsigned long maxlength = 0;
10723       unsigned long nzero_counts = 0;
10724       unsigned long nsyms = 0;
10725
10726       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10727               (unsigned long) nbuckets);
10728
10729       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
10730       if (lengths == NULL)
10731         {
10732           error (_("Out of memory allocating space for histogram buckets\n"));
10733           return 0;
10734         }
10735
10736       printf (_(" Length  Number     %% of total  Coverage\n"));
10737       for (hn = 0; hn < nbuckets; ++hn)
10738         {
10739           for (si = buckets[hn]; si > 0 && si < nchains && si < nbuckets; si = chains[si])
10740             {
10741               ++nsyms;
10742               if (maxlength < ++lengths[hn])
10743                 ++maxlength;
10744
10745               /* PR binutils/17531: A corrupt binary could contain broken
10746                  histogram data.  Do not go into an infinite loop trying
10747                  to process it.  */
10748               if (chains[si] == si)
10749                 {
10750                   error (_("histogram chain links to itself\n"));
10751                   break;
10752                 }
10753             }
10754         }
10755
10756       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10757       if (counts == NULL)
10758         {
10759           free (lengths);
10760           error (_("Out of memory allocating space for histogram counts\n"));
10761           return 0;
10762         }
10763
10764       for (hn = 0; hn < nbuckets; ++hn)
10765         ++counts[lengths[hn]];
10766
10767       if (nbuckets > 0)
10768         {
10769           unsigned long i;
10770           printf ("      0  %-10lu (%5.1f%%)\n",
10771                   counts[0], (counts[0] * 100.0) / nbuckets);
10772           for (i = 1; i <= maxlength; ++i)
10773             {
10774               nzero_counts += counts[i] * i;
10775               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
10776                       i, counts[i], (counts[i] * 100.0) / nbuckets,
10777                       (nzero_counts * 100.0) / nsyms);
10778             }
10779         }
10780
10781       free (counts);
10782       free (lengths);
10783     }
10784
10785   if (buckets != NULL)
10786     {
10787       free (buckets);
10788       free (chains);
10789     }
10790
10791   if (do_histogram && gnubuckets != NULL)
10792     {
10793       unsigned long * lengths;
10794       unsigned long * counts;
10795       unsigned long hn;
10796       unsigned long maxlength = 0;
10797       unsigned long nzero_counts = 0;
10798       unsigned long nsyms = 0;
10799
10800       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10801               (unsigned long) ngnubuckets);
10802
10803       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
10804       if (lengths == NULL)
10805         {
10806           error (_("Out of memory allocating space for gnu histogram buckets\n"));
10807           return 0;
10808         }
10809
10810       printf (_(" Length  Number     %% of total  Coverage\n"));
10811
10812       for (hn = 0; hn < ngnubuckets; ++hn)
10813         if (gnubuckets[hn] != 0)
10814           {
10815             bfd_vma off, length = 1;
10816
10817             for (off = gnubuckets[hn] - gnusymidx;
10818                  /* PR 17531 file: 010-77222-0.004.  */
10819                  off < ngnuchains && (gnuchains[off] & 1) == 0;
10820                  ++off)
10821               ++length;
10822             lengths[hn] = length;
10823             if (length > maxlength)
10824               maxlength = length;
10825             nsyms += length;
10826           }
10827
10828       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10829       if (counts == NULL)
10830         {
10831           free (lengths);
10832           error (_("Out of memory allocating space for gnu histogram counts\n"));
10833           return 0;
10834         }
10835
10836       for (hn = 0; hn < ngnubuckets; ++hn)
10837         ++counts[lengths[hn]];
10838
10839       if (ngnubuckets > 0)
10840         {
10841           unsigned long j;
10842           printf ("      0  %-10lu (%5.1f%%)\n",
10843                   counts[0], (counts[0] * 100.0) / ngnubuckets);
10844           for (j = 1; j <= maxlength; ++j)
10845             {
10846               nzero_counts += counts[j] * j;
10847               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
10848                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10849                       (nzero_counts * 100.0) / nsyms);
10850             }
10851         }
10852
10853       free (counts);
10854       free (lengths);
10855       free (gnubuckets);
10856       free (gnuchains);
10857     }
10858
10859   return 1;
10860 }
10861
10862 static int
10863 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
10864 {
10865   unsigned int i;
10866
10867   if (dynamic_syminfo == NULL
10868       || !do_dynamic)
10869     /* No syminfo, this is ok.  */
10870     return 1;
10871
10872   /* There better should be a dynamic symbol section.  */
10873   if (dynamic_symbols == NULL || dynamic_strings == NULL)
10874     return 0;
10875
10876   if (dynamic_addr)
10877     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10878             dynamic_syminfo_offset, dynamic_syminfo_nent);
10879
10880   printf (_(" Num: Name                           BoundTo     Flags\n"));
10881   for (i = 0; i < dynamic_syminfo_nent; ++i)
10882     {
10883       unsigned short int flags = dynamic_syminfo[i].si_flags;
10884
10885       printf ("%4d: ", i);
10886       if (i >= num_dynamic_syms)
10887         printf (_("<corrupt index>"));
10888       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
10889         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10890       else
10891         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
10892       putchar (' ');
10893
10894       switch (dynamic_syminfo[i].si_boundto)
10895         {
10896         case SYMINFO_BT_SELF:
10897           fputs ("SELF       ", stdout);
10898           break;
10899         case SYMINFO_BT_PARENT:
10900           fputs ("PARENT     ", stdout);
10901           break;
10902         default:
10903           if (dynamic_syminfo[i].si_boundto > 0
10904               && dynamic_syminfo[i].si_boundto < dynamic_nent
10905               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
10906             {
10907               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
10908               putchar (' ' );
10909             }
10910           else
10911             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10912           break;
10913         }
10914
10915       if (flags & SYMINFO_FLG_DIRECT)
10916         printf (" DIRECT");
10917       if (flags & SYMINFO_FLG_PASSTHRU)
10918         printf (" PASSTHRU");
10919       if (flags & SYMINFO_FLG_COPY)
10920         printf (" COPY");
10921       if (flags & SYMINFO_FLG_LAZYLOAD)
10922         printf (" LAZYLOAD");
10923
10924       puts ("");
10925     }
10926
10927   return 1;
10928 }
10929
10930 /* Check to see if the given reloc needs to be handled in a target specific
10931    manner.  If so then process the reloc and return TRUE otherwise return
10932    FALSE.  */
10933
10934 static bfd_boolean
10935 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10936                                 unsigned char *     start,
10937                                 Elf_Internal_Sym *  symtab)
10938 {
10939   unsigned int reloc_type = get_reloc_type (reloc->r_info);
10940
10941   switch (elf_header.e_machine)
10942     {
10943     case EM_MSP430:
10944     case EM_MSP430_OLD:
10945       {
10946         static Elf_Internal_Sym * saved_sym = NULL;
10947
10948         switch (reloc_type)
10949           {
10950           case 10: /* R_MSP430_SYM_DIFF */
10951             if (uses_msp430x_relocs ())
10952               break;
10953           case 21: /* R_MSP430X_SYM_DIFF */
10954             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10955             return TRUE;
10956
10957           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10958           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10959             goto handle_sym_diff;
10960
10961           case 5: /* R_MSP430_16_BYTE */
10962           case 9: /* R_MSP430_8 */
10963             if (uses_msp430x_relocs ())
10964               break;
10965             goto handle_sym_diff;
10966
10967           case 2: /* R_MSP430_ABS16 */
10968           case 15: /* R_MSP430X_ABS16 */
10969             if (! uses_msp430x_relocs ())
10970               break;
10971             goto handle_sym_diff;
10972
10973           handle_sym_diff:
10974             if (saved_sym != NULL)
10975               {
10976                 bfd_vma value;
10977
10978                 value = reloc->r_addend
10979                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10980                      - saved_sym->st_value);
10981
10982                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10983
10984                 saved_sym = NULL;
10985                 return TRUE;
10986               }
10987             break;
10988
10989           default:
10990             if (saved_sym != NULL)
10991               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
10992             break;
10993           }
10994         break;
10995       }
10996
10997     case EM_MN10300:
10998     case EM_CYGNUS_MN10300:
10999       {
11000         static Elf_Internal_Sym * saved_sym = NULL;
11001
11002         switch (reloc_type)
11003           {
11004           case 34: /* R_MN10300_ALIGN */
11005             return TRUE;
11006           case 33: /* R_MN10300_SYM_DIFF */
11007             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11008             return TRUE;
11009           case 1: /* R_MN10300_32 */
11010           case 2: /* R_MN10300_16 */
11011             if (saved_sym != NULL)
11012               {
11013                 bfd_vma value;
11014
11015                 value = reloc->r_addend
11016                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11017                      - saved_sym->st_value);
11018
11019                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11020
11021                 saved_sym = NULL;
11022                 return TRUE;
11023               }
11024             break;
11025           default:
11026             if (saved_sym != NULL)
11027               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11028             break;
11029           }
11030         break;
11031       }
11032     }
11033
11034   return FALSE;
11035 }
11036
11037 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11038    DWARF debug sections.  This is a target specific test.  Note - we do not
11039    go through the whole including-target-headers-multiple-times route, (as
11040    we have already done with <elf/h8.h>) because this would become very
11041    messy and even then this function would have to contain target specific
11042    information (the names of the relocs instead of their numeric values).
11043    FIXME: This is not the correct way to solve this problem.  The proper way
11044    is to have target specific reloc sizing and typing functions created by
11045    the reloc-macros.h header, in the same way that it already creates the
11046    reloc naming functions.  */
11047
11048 static bfd_boolean
11049 is_32bit_abs_reloc (unsigned int reloc_type)
11050 {
11051   switch (elf_header.e_machine)
11052     {
11053     case EM_386:
11054     case EM_486:
11055       return reloc_type == 1; /* R_386_32.  */
11056     case EM_68K:
11057       return reloc_type == 1; /* R_68K_32.  */
11058     case EM_860:
11059       return reloc_type == 1; /* R_860_32.  */
11060     case EM_960:
11061       return reloc_type == 2; /* R_960_32.  */
11062     case EM_AARCH64:
11063       return reloc_type == 258; /* R_AARCH64_ABS32 */
11064     case EM_ALPHA:
11065       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
11066     case EM_ARC:
11067       return reloc_type == 1; /* R_ARC_32.  */
11068     case EM_ARM:
11069       return reloc_type == 2; /* R_ARM_ABS32 */
11070     case EM_AVR_OLD:
11071     case EM_AVR:
11072       return reloc_type == 1;
11073     case EM_ADAPTEVA_EPIPHANY:
11074       return reloc_type == 3;
11075     case EM_BLACKFIN:
11076       return reloc_type == 0x12; /* R_byte4_data.  */
11077     case EM_CRIS:
11078       return reloc_type == 3; /* R_CRIS_32.  */
11079     case EM_CR16:
11080       return reloc_type == 3; /* R_CR16_NUM32.  */
11081     case EM_CRX:
11082       return reloc_type == 15; /* R_CRX_NUM32.  */
11083     case EM_CYGNUS_FRV:
11084       return reloc_type == 1;
11085     case EM_CYGNUS_D10V:
11086     case EM_D10V:
11087       return reloc_type == 6; /* R_D10V_32.  */
11088     case EM_CYGNUS_D30V:
11089     case EM_D30V:
11090       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
11091     case EM_DLX:
11092       return reloc_type == 3; /* R_DLX_RELOC_32.  */
11093     case EM_CYGNUS_FR30:
11094     case EM_FR30:
11095       return reloc_type == 3; /* R_FR30_32.  */
11096     case EM_FT32:
11097       return reloc_type == 1; /* R_FT32_32.  */
11098     case EM_H8S:
11099     case EM_H8_300:
11100     case EM_H8_300H:
11101       return reloc_type == 1; /* R_H8_DIR32.  */
11102     case EM_IA_64:
11103       return reloc_type == 0x65; /* R_IA64_SECREL32LSB.  */
11104     case EM_IP2K_OLD:
11105     case EM_IP2K:
11106       return reloc_type == 2; /* R_IP2K_32.  */
11107     case EM_IQ2000:
11108       return reloc_type == 2; /* R_IQ2000_32.  */
11109     case EM_LATTICEMICO32:
11110       return reloc_type == 3; /* R_LM32_32.  */
11111     case EM_M32C_OLD:
11112     case EM_M32C:
11113       return reloc_type == 3; /* R_M32C_32.  */
11114     case EM_M32R:
11115       return reloc_type == 34; /* R_M32R_32_RELA.  */
11116     case EM_MCORE:
11117       return reloc_type == 1; /* R_MCORE_ADDR32.  */
11118     case EM_CYGNUS_MEP:
11119       return reloc_type == 4; /* R_MEP_32.  */
11120     case EM_METAG:
11121       return reloc_type == 2; /* R_METAG_ADDR32.  */
11122     case EM_MICROBLAZE:
11123       return reloc_type == 1; /* R_MICROBLAZE_32.  */
11124     case EM_MIPS:
11125       return reloc_type == 2; /* R_MIPS_32.  */
11126     case EM_MMIX:
11127       return reloc_type == 4; /* R_MMIX_32.  */
11128     case EM_CYGNUS_MN10200:
11129     case EM_MN10200:
11130       return reloc_type == 1; /* R_MN10200_32.  */
11131     case EM_CYGNUS_MN10300:
11132     case EM_MN10300:
11133       return reloc_type == 1; /* R_MN10300_32.  */
11134     case EM_MOXIE:
11135       return reloc_type == 1; /* R_MOXIE_32.  */
11136     case EM_MSP430_OLD:
11137     case EM_MSP430:
11138       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
11139     case EM_MT:
11140       return reloc_type == 2; /* R_MT_32.  */
11141     case EM_NDS32:
11142       return reloc_type == 20; /* R_NDS32_RELA.  */
11143     case EM_ALTERA_NIOS2:
11144       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
11145     case EM_NIOS32:
11146       return reloc_type == 1; /* R_NIOS_32.  */
11147     case EM_OR1K:
11148       return reloc_type == 1; /* R_OR1K_32.  */
11149     case EM_PARISC:
11150       return (reloc_type == 1 /* R_PARISC_DIR32.  */
11151               || reloc_type == 41); /* R_PARISC_SECREL32.  */
11152     case EM_PJ:
11153     case EM_PJ_OLD:
11154       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
11155     case EM_PPC64:
11156       return reloc_type == 1; /* R_PPC64_ADDR32.  */
11157     case EM_PPC:
11158       return reloc_type == 1; /* R_PPC_ADDR32.  */
11159     case EM_RL78:
11160       return reloc_type == 1; /* R_RL78_DIR32.  */
11161     case EM_RX:
11162       return reloc_type == 1; /* R_RX_DIR32.  */
11163     case EM_S370:
11164       return reloc_type == 1; /* R_I370_ADDR31.  */
11165     case EM_S390_OLD:
11166     case EM_S390:
11167       return reloc_type == 4; /* R_S390_32.  */
11168     case EM_SCORE:
11169       return reloc_type == 8; /* R_SCORE_ABS32.  */
11170     case EM_SH:
11171       return reloc_type == 1; /* R_SH_DIR32.  */
11172     case EM_SPARC32PLUS:
11173     case EM_SPARCV9:
11174     case EM_SPARC:
11175       return reloc_type == 3 /* R_SPARC_32.  */
11176         || reloc_type == 23; /* R_SPARC_UA32.  */
11177     case EM_SPU:
11178       return reloc_type == 6; /* R_SPU_ADDR32 */
11179     case EM_TI_C6000:
11180       return reloc_type == 1; /* R_C6000_ABS32.  */
11181     case EM_TILEGX:
11182       return reloc_type == 2; /* R_TILEGX_32.  */
11183     case EM_TILEPRO:
11184       return reloc_type == 1; /* R_TILEPRO_32.  */
11185     case EM_CYGNUS_V850:
11186     case EM_V850:
11187       return reloc_type == 6; /* R_V850_ABS32.  */
11188     case EM_V800:
11189       return reloc_type == 0x33; /* R_V810_WORD.  */
11190     case EM_VAX:
11191       return reloc_type == 1; /* R_VAX_32.  */
11192     case EM_VISIUM:
11193       return reloc_type == 3;  /* R_VISIUM_32. */
11194     case EM_X86_64:
11195     case EM_L1OM:
11196     case EM_K1OM:
11197       return reloc_type == 10; /* R_X86_64_32.  */
11198     case EM_XC16X:
11199     case EM_C166:
11200       return reloc_type == 3; /* R_XC16C_ABS_32.  */
11201     case EM_XGATE:
11202       return reloc_type == 4; /* R_XGATE_32.  */
11203     case EM_XSTORMY16:
11204       return reloc_type == 1; /* R_XSTROMY16_32.  */
11205     case EM_XTENSA_OLD:
11206     case EM_XTENSA:
11207       return reloc_type == 1; /* R_XTENSA_32.  */
11208     default:
11209       {
11210         static unsigned int prev_warn = 0;
11211
11212         /* Avoid repeating the same warning multiple times.  */
11213         if (prev_warn != elf_header.e_machine)
11214           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11215                  elf_header.e_machine);
11216         prev_warn = elf_header.e_machine;
11217         return FALSE;
11218       }
11219     }
11220 }
11221
11222 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11223    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
11224
11225 static bfd_boolean
11226 is_32bit_pcrel_reloc (unsigned int reloc_type)
11227 {
11228   switch (elf_header.e_machine)
11229     {
11230     case EM_386:
11231     case EM_486:
11232       return reloc_type == 2;  /* R_386_PC32.  */
11233     case EM_68K:
11234       return reloc_type == 4;  /* R_68K_PC32.  */
11235     case EM_AARCH64:
11236       return reloc_type == 261; /* R_AARCH64_PREL32 */
11237     case EM_ADAPTEVA_EPIPHANY:
11238       return reloc_type == 6;
11239     case EM_ALPHA:
11240       return reloc_type == 10; /* R_ALPHA_SREL32.  */
11241     case EM_ARM:
11242       return reloc_type == 3;  /* R_ARM_REL32 */
11243     case EM_MICROBLAZE:
11244       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
11245     case EM_OR1K:
11246       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
11247     case EM_PARISC:
11248       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
11249     case EM_PPC:
11250       return reloc_type == 26; /* R_PPC_REL32.  */
11251     case EM_PPC64:
11252       return reloc_type == 26; /* R_PPC64_REL32.  */
11253     case EM_S390_OLD:
11254     case EM_S390:
11255       return reloc_type == 5;  /* R_390_PC32.  */
11256     case EM_SH:
11257       return reloc_type == 2;  /* R_SH_REL32.  */
11258     case EM_SPARC32PLUS:
11259     case EM_SPARCV9:
11260     case EM_SPARC:
11261       return reloc_type == 6;  /* R_SPARC_DISP32.  */
11262     case EM_SPU:
11263       return reloc_type == 13; /* R_SPU_REL32.  */
11264     case EM_TILEGX:
11265       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
11266     case EM_TILEPRO:
11267       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
11268     case EM_VISIUM:
11269       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
11270     case EM_X86_64:
11271     case EM_L1OM:
11272     case EM_K1OM:
11273       return reloc_type == 2;  /* R_X86_64_PC32.  */
11274     case EM_XTENSA_OLD:
11275     case EM_XTENSA:
11276       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
11277     default:
11278       /* Do not abort or issue an error message here.  Not all targets use
11279          pc-relative 32-bit relocs in their DWARF debug information and we
11280          have already tested for target coverage in is_32bit_abs_reloc.  A
11281          more helpful warning message will be generated by apply_relocations
11282          anyway, so just return.  */
11283       return FALSE;
11284     }
11285 }
11286
11287 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11288    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
11289
11290 static bfd_boolean
11291 is_64bit_abs_reloc (unsigned int reloc_type)
11292 {
11293   switch (elf_header.e_machine)
11294     {
11295     case EM_AARCH64:
11296       return reloc_type == 257; /* R_AARCH64_ABS64.  */
11297     case EM_ALPHA:
11298       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
11299     case EM_IA_64:
11300       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
11301     case EM_PARISC:
11302       return reloc_type == 80; /* R_PARISC_DIR64.  */
11303     case EM_PPC64:
11304       return reloc_type == 38; /* R_PPC64_ADDR64.  */
11305     case EM_SPARC32PLUS:
11306     case EM_SPARCV9:
11307     case EM_SPARC:
11308       return reloc_type == 54; /* R_SPARC_UA64.  */
11309     case EM_X86_64:
11310     case EM_L1OM:
11311     case EM_K1OM:
11312       return reloc_type == 1; /* R_X86_64_64.  */
11313     case EM_S390_OLD:
11314     case EM_S390:
11315       return reloc_type == 22;  /* R_S390_64.  */
11316     case EM_TILEGX:
11317       return reloc_type == 1; /* R_TILEGX_64.  */
11318     case EM_MIPS:
11319       return reloc_type == 18;  /* R_MIPS_64.  */
11320     default:
11321       return FALSE;
11322     }
11323 }
11324
11325 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11326    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
11327
11328 static bfd_boolean
11329 is_64bit_pcrel_reloc (unsigned int reloc_type)
11330 {
11331   switch (elf_header.e_machine)
11332     {
11333     case EM_AARCH64:
11334       return reloc_type == 260; /* R_AARCH64_PREL64.  */
11335     case EM_ALPHA:
11336       return reloc_type == 11; /* R_ALPHA_SREL64.  */
11337     case EM_IA_64:
11338       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
11339     case EM_PARISC:
11340       return reloc_type == 72; /* R_PARISC_PCREL64.  */
11341     case EM_PPC64:
11342       return reloc_type == 44; /* R_PPC64_REL64.  */
11343     case EM_SPARC32PLUS:
11344     case EM_SPARCV9:
11345     case EM_SPARC:
11346       return reloc_type == 46; /* R_SPARC_DISP64.  */
11347     case EM_X86_64:
11348     case EM_L1OM:
11349     case EM_K1OM:
11350       return reloc_type == 24; /* R_X86_64_PC64.  */
11351     case EM_S390_OLD:
11352     case EM_S390:
11353       return reloc_type == 23;  /* R_S390_PC64.  */
11354     case EM_TILEGX:
11355       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
11356     default:
11357       return FALSE;
11358     }
11359 }
11360
11361 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11362    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
11363
11364 static bfd_boolean
11365 is_24bit_abs_reloc (unsigned int reloc_type)
11366 {
11367   switch (elf_header.e_machine)
11368     {
11369     case EM_CYGNUS_MN10200:
11370     case EM_MN10200:
11371       return reloc_type == 4; /* R_MN10200_24.  */
11372     default:
11373       return FALSE;
11374     }
11375 }
11376
11377 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11378    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
11379
11380 static bfd_boolean
11381 is_16bit_abs_reloc (unsigned int reloc_type)
11382 {
11383   switch (elf_header.e_machine)
11384     {
11385     case EM_AVR_OLD:
11386     case EM_AVR:
11387       return reloc_type == 4; /* R_AVR_16.  */
11388     case EM_ADAPTEVA_EPIPHANY:
11389       return reloc_type == 5;
11390     case EM_CYGNUS_D10V:
11391     case EM_D10V:
11392       return reloc_type == 3; /* R_D10V_16.  */
11393     case EM_H8S:
11394     case EM_H8_300:
11395     case EM_H8_300H:
11396       return reloc_type == R_H8_DIR16;
11397     case EM_IP2K_OLD:
11398     case EM_IP2K:
11399       return reloc_type == 1; /* R_IP2K_16.  */
11400     case EM_M32C_OLD:
11401     case EM_M32C:
11402       return reloc_type == 1; /* R_M32C_16 */
11403     case EM_MSP430:
11404       if (uses_msp430x_relocs ())
11405         return reloc_type == 2; /* R_MSP430_ABS16.  */
11406     case EM_MSP430_OLD:
11407       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
11408     case EM_NDS32:
11409       return reloc_type == 19; /* R_NDS32_RELA.  */
11410     case EM_ALTERA_NIOS2:
11411       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
11412     case EM_NIOS32:
11413       return reloc_type == 9; /* R_NIOS_16.  */
11414     case EM_OR1K:
11415       return reloc_type == 2; /* R_OR1K_16.  */
11416     case EM_TI_C6000:
11417       return reloc_type == 2; /* R_C6000_ABS16.  */
11418     case EM_XC16X:
11419     case EM_C166:
11420       return reloc_type == 2; /* R_XC16C_ABS_16.  */
11421     case EM_CYGNUS_MN10200:
11422     case EM_MN10200:
11423       return reloc_type == 2; /* R_MN10200_16.  */
11424     case EM_CYGNUS_MN10300:
11425     case EM_MN10300:
11426       return reloc_type == 2; /* R_MN10300_16.  */
11427     case EM_VISIUM:
11428       return reloc_type == 2; /* R_VISIUM_16. */
11429     case EM_XGATE:
11430       return reloc_type == 3; /* R_XGATE_16.  */
11431     default:
11432       return FALSE;
11433     }
11434 }
11435
11436 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11437    relocation entries (possibly formerly used for SHT_GROUP sections).  */
11438
11439 static bfd_boolean
11440 is_none_reloc (unsigned int reloc_type)
11441 {
11442   switch (elf_header.e_machine)
11443     {
11444     case EM_68K:     /* R_68K_NONE.  */
11445     case EM_386:     /* R_386_NONE.  */
11446     case EM_SPARC32PLUS:
11447     case EM_SPARCV9:
11448     case EM_SPARC:   /* R_SPARC_NONE.  */
11449     case EM_MIPS:    /* R_MIPS_NONE.  */
11450     case EM_PARISC:  /* R_PARISC_NONE.  */
11451     case EM_ALPHA:   /* R_ALPHA_NONE.  */
11452     case EM_ADAPTEVA_EPIPHANY:
11453     case EM_PPC:     /* R_PPC_NONE.  */
11454     case EM_PPC64:   /* R_PPC64_NONE.  */
11455     case EM_ARM:     /* R_ARM_NONE.  */
11456     case EM_IA_64:   /* R_IA64_NONE.  */
11457     case EM_SH:      /* R_SH_NONE.  */
11458     case EM_S390_OLD:
11459     case EM_S390:    /* R_390_NONE.  */
11460     case EM_CRIS:    /* R_CRIS_NONE.  */
11461     case EM_X86_64:  /* R_X86_64_NONE.  */
11462     case EM_L1OM:    /* R_X86_64_NONE.  */
11463     case EM_K1OM:    /* R_X86_64_NONE.  */
11464     case EM_MN10300: /* R_MN10300_NONE.  */
11465     case EM_FT32:    /* R_FT32_NONE.  */
11466     case EM_MOXIE:   /* R_MOXIE_NONE.  */
11467     case EM_M32R:    /* R_M32R_NONE.  */
11468     case EM_TI_C6000:/* R_C6000_NONE.  */
11469     case EM_TILEGX:  /* R_TILEGX_NONE.  */
11470     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
11471     case EM_XC16X:
11472     case EM_C166:    /* R_XC16X_NONE.  */
11473     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
11474     case EM_NIOS32:  /* R_NIOS_NONE.  */
11475     case EM_OR1K:    /* R_OR1K_NONE. */
11476       return reloc_type == 0;
11477     case EM_AARCH64:
11478       return reloc_type == 0 || reloc_type == 256;
11479     case EM_NDS32:
11480       return (reloc_type == 0       /* R_XTENSA_NONE.  */
11481               || reloc_type == 204  /* R_NDS32_DIFF8.  */
11482               || reloc_type == 205  /* R_NDS32_DIFF16.  */
11483               || reloc_type == 206  /* R_NDS32_DIFF32.  */
11484               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
11485     case EM_XTENSA_OLD:
11486     case EM_XTENSA:
11487       return (reloc_type == 0      /* R_XTENSA_NONE.  */
11488               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
11489               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
11490               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
11491     case EM_METAG:
11492       return reloc_type == 3; /* R_METAG_NONE.  */
11493     }
11494   return FALSE;
11495 }
11496
11497 /* Apply relocations to a section.
11498    Note: So far support has been added only for those relocations
11499    which can be found in debug sections.
11500    FIXME: Add support for more relocations ?  */
11501
11502 static void
11503 apply_relocations (void * file,
11504                    Elf_Internal_Shdr * section,
11505                    unsigned char * start)
11506 {
11507   Elf_Internal_Shdr * relsec;
11508   unsigned char * end = start + section->sh_size;
11509
11510   if (elf_header.e_type != ET_REL)
11511     return;
11512
11513   /* Find the reloc section associated with the section.  */
11514   for (relsec = section_headers;
11515        relsec < section_headers + elf_header.e_shnum;
11516        ++relsec)
11517     {
11518       bfd_boolean is_rela;
11519       unsigned long num_relocs;
11520       Elf_Internal_Rela * relocs;
11521       Elf_Internal_Rela * rp;
11522       Elf_Internal_Shdr * symsec;
11523       Elf_Internal_Sym * symtab;
11524       unsigned long num_syms;
11525       Elf_Internal_Sym * sym;
11526
11527       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11528           || relsec->sh_info >= elf_header.e_shnum
11529           || section_headers + relsec->sh_info != section
11530           || relsec->sh_size == 0
11531           || relsec->sh_link >= elf_header.e_shnum)
11532         continue;
11533
11534       is_rela = relsec->sh_type == SHT_RELA;
11535
11536       if (is_rela)
11537         {
11538           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11539                                   relsec->sh_size, & relocs, & num_relocs))
11540             return;
11541         }
11542       else
11543         {
11544           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11545                                  relsec->sh_size, & relocs, & num_relocs))
11546             return;
11547         }
11548
11549       /* SH uses RELA but uses in place value instead of the addend field.  */
11550       if (elf_header.e_machine == EM_SH)
11551         is_rela = FALSE;
11552
11553       symsec = section_headers + relsec->sh_link;
11554       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
11555
11556       for (rp = relocs; rp < relocs + num_relocs; ++rp)
11557         {
11558           bfd_vma         addend;
11559           unsigned int    reloc_type;
11560           unsigned int    reloc_size;
11561           unsigned char * rloc;
11562           unsigned long   sym_index;
11563
11564           reloc_type = get_reloc_type (rp->r_info);
11565
11566           if (target_specific_reloc_handling (rp, start, symtab))
11567             continue;
11568           else if (is_none_reloc (reloc_type))
11569             continue;
11570           else if (is_32bit_abs_reloc (reloc_type)
11571                    || is_32bit_pcrel_reloc (reloc_type))
11572             reloc_size = 4;
11573           else if (is_64bit_abs_reloc (reloc_type)
11574                    || is_64bit_pcrel_reloc (reloc_type))
11575             reloc_size = 8;
11576           else if (is_24bit_abs_reloc (reloc_type))
11577             reloc_size = 3;
11578           else if (is_16bit_abs_reloc (reloc_type))
11579             reloc_size = 2;
11580           else
11581             {
11582               static unsigned int prev_reloc = 0;
11583               if (reloc_type != prev_reloc)
11584                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11585                       reloc_type, printable_section_name (section));
11586               prev_reloc = reloc_type;
11587               continue;
11588             }
11589
11590           rloc = start + rp->r_offset;
11591           if ((rloc + reloc_size) > end || (rloc < start))
11592             {
11593               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11594                     (unsigned long) rp->r_offset,
11595                     printable_section_name (section));
11596               continue;
11597             }
11598
11599           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11600           if (sym_index >= num_syms)
11601             {
11602               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11603                     sym_index, printable_section_name (section));
11604               continue;
11605             }
11606           sym = symtab + sym_index;
11607
11608           /* If the reloc has a symbol associated with it,
11609              make sure that it is of an appropriate type.
11610
11611              Relocations against symbols without type can happen.
11612              Gcc -feliminate-dwarf2-dups may generate symbols
11613              without type for debug info.
11614
11615              Icc generates relocations against function symbols
11616              instead of local labels.
11617
11618              Relocations against object symbols can happen, eg when
11619              referencing a global array.  For an example of this see
11620              the _clz.o binary in libgcc.a.  */
11621           if (sym != symtab
11622               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
11623             {
11624               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11625                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
11626                     (long int)(rp - relocs),
11627                     printable_section_name (relsec));
11628               continue;
11629             }
11630
11631           addend = 0;
11632           if (is_rela)
11633             addend += rp->r_addend;
11634           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11635              partial_inplace.  */
11636           if (!is_rela
11637               || (elf_header.e_machine == EM_XTENSA
11638                   && reloc_type == 1)
11639               || ((elf_header.e_machine == EM_PJ
11640                    || elf_header.e_machine == EM_PJ_OLD)
11641                   && reloc_type == 1)
11642               || ((elf_header.e_machine == EM_D30V
11643                    || elf_header.e_machine == EM_CYGNUS_D30V)
11644                   && reloc_type == 12))
11645             addend += byte_get (rloc, reloc_size);
11646
11647           if (is_32bit_pcrel_reloc (reloc_type)
11648               || is_64bit_pcrel_reloc (reloc_type))
11649             {
11650               /* On HPPA, all pc-relative relocations are biased by 8.  */
11651               if (elf_header.e_machine == EM_PARISC)
11652                 addend -= 8;
11653               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
11654                         reloc_size);
11655             }
11656           else
11657             byte_put (rloc, addend + sym->st_value, reloc_size);
11658         }
11659
11660       free (symtab);
11661       free (relocs);
11662       break;
11663     }
11664 }
11665
11666 #ifdef SUPPORT_DISASSEMBLY
11667 static int
11668 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11669 {
11670   printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
11671
11672   /* FIXME: XXX -- to be done --- XXX */
11673
11674   return 1;
11675 }
11676 #endif
11677
11678 /* Reads in the contents of SECTION from FILE, returning a pointer
11679    to a malloc'ed buffer or NULL if something went wrong.  */
11680
11681 static char *
11682 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11683 {
11684   bfd_size_type num_bytes;
11685
11686   num_bytes = section->sh_size;
11687
11688   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11689     {
11690       printf (_("\nSection '%s' has no data to dump.\n"),
11691               printable_section_name (section));
11692       return NULL;
11693     }
11694
11695   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11696                              _("section contents"));
11697 }
11698
11699
11700 static void
11701 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11702 {
11703   Elf_Internal_Shdr * relsec;
11704   bfd_size_type num_bytes;
11705   char * data;
11706   char * end;
11707   char * start;
11708   bfd_boolean some_strings_shown;
11709
11710   start = get_section_contents (section, file);
11711   if (start == NULL)
11712     return;
11713
11714   printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
11715
11716   /* If the section being dumped has relocations against it the user might
11717      be expecting these relocations to have been applied.  Check for this
11718      case and issue a warning message in order to avoid confusion.
11719      FIXME: Maybe we ought to have an option that dumps a section with
11720      relocs applied ?  */
11721   for (relsec = section_headers;
11722        relsec < section_headers + elf_header.e_shnum;
11723        ++relsec)
11724     {
11725       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11726           || relsec->sh_info >= elf_header.e_shnum
11727           || section_headers + relsec->sh_info != section
11728           || relsec->sh_size == 0
11729           || relsec->sh_link >= elf_header.e_shnum)
11730         continue;
11731
11732       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11733       break;
11734     }
11735
11736   num_bytes = section->sh_size;
11737   data = start;
11738   end  = start + num_bytes;
11739   some_strings_shown = FALSE;
11740
11741   while (data < end)
11742     {
11743       while (!ISPRINT (* data))
11744         if (++ data >= end)
11745           break;
11746
11747       if (data < end)
11748         {
11749           size_t maxlen = end - data;
11750
11751 #ifndef __MSVCRT__
11752           /* PR 11128: Use two separate invocations in order to work
11753              around bugs in the Solaris 8 implementation of printf.  */
11754           printf ("  [%6tx]  ", data - start);
11755 #else
11756           printf ("  [%6Ix]  ", (size_t) (data - start));
11757 #endif
11758           if (maxlen > 0)
11759             {
11760               print_symbol ((int) maxlen, data);
11761               putchar ('\n');
11762               data += strnlen (data, maxlen);
11763             }
11764           else
11765             {
11766               printf (_("<corrupt>\n"));
11767               data = end;
11768             }
11769           some_strings_shown = TRUE;
11770         }
11771     }
11772
11773   if (! some_strings_shown)
11774     printf (_("  No strings found in this section."));
11775
11776   free (start);
11777
11778   putchar ('\n');
11779 }
11780
11781 static void
11782 dump_section_as_bytes (Elf_Internal_Shdr * section,
11783                        FILE * file,
11784                        bfd_boolean relocate)
11785 {
11786   Elf_Internal_Shdr * relsec;
11787   bfd_size_type bytes;
11788   bfd_vma addr;
11789   unsigned char * data;
11790   unsigned char * start;
11791
11792   start = (unsigned char *) get_section_contents (section, file);
11793   if (start == NULL)
11794     return;
11795
11796   printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
11797
11798   if (relocate)
11799     {
11800       apply_relocations (file, section, start);
11801     }
11802   else
11803     {
11804       /* If the section being dumped has relocations against it the user might
11805          be expecting these relocations to have been applied.  Check for this
11806          case and issue a warning message in order to avoid confusion.
11807          FIXME: Maybe we ought to have an option that dumps a section with
11808          relocs applied ?  */
11809       for (relsec = section_headers;
11810            relsec < section_headers + elf_header.e_shnum;
11811            ++relsec)
11812         {
11813           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11814               || relsec->sh_info >= elf_header.e_shnum
11815               || section_headers + relsec->sh_info != section
11816               || relsec->sh_size == 0
11817               || relsec->sh_link >= elf_header.e_shnum)
11818             continue;
11819
11820           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11821           break;
11822         }
11823     }
11824
11825   addr = section->sh_addr;
11826   bytes = section->sh_size;
11827   data = start;
11828
11829   while (bytes)
11830     {
11831       int j;
11832       int k;
11833       int lbytes;
11834
11835       lbytes = (bytes > 16 ? 16 : bytes);
11836
11837       printf ("  0x%8.8lx ", (unsigned long) addr);
11838
11839       for (j = 0; j < 16; j++)
11840         {
11841           if (j < lbytes)
11842             printf ("%2.2x", data[j]);
11843           else
11844             printf ("  ");
11845
11846           if ((j & 3) == 3)
11847             printf (" ");
11848         }
11849
11850       for (j = 0; j < lbytes; j++)
11851         {
11852           k = data[j];
11853           if (k >= ' ' && k < 0x7f)
11854             printf ("%c", k);
11855           else
11856             printf (".");
11857         }
11858
11859       putchar ('\n');
11860
11861       data  += lbytes;
11862       addr  += lbytes;
11863       bytes -= lbytes;
11864     }
11865
11866   free (start);
11867
11868   putchar ('\n');
11869 }
11870
11871 /* Uncompresses a section that was compressed using zlib, in place.  */
11872
11873 static int
11874 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11875                              dwarf_size_type *size ATTRIBUTE_UNUSED)
11876 {
11877 #ifndef HAVE_ZLIB_H
11878   return FALSE;
11879 #else
11880   dwarf_size_type compressed_size = *size;
11881   unsigned char * compressed_buffer = *buffer;
11882   dwarf_size_type uncompressed_size;
11883   unsigned char * uncompressed_buffer;
11884   z_stream strm;
11885   int rc;
11886   dwarf_size_type header_size = 12;
11887
11888   /* Read the zlib header.  In this case, it should be "ZLIB" followed
11889      by the uncompressed section size, 8 bytes in big-endian order.  */
11890   if (compressed_size < header_size
11891       || ! streq ((char *) compressed_buffer, "ZLIB"))
11892     return 0;
11893
11894   uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11895   uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11896   uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11897   uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11898   uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11899   uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11900   uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11901   uncompressed_size += compressed_buffer[11];
11902
11903   /* It is possible the section consists of several compressed
11904      buffers concatenated together, so we uncompress in a loop.  */
11905   strm.zalloc = NULL;
11906   strm.zfree = NULL;
11907   strm.opaque = NULL;
11908   strm.avail_in = compressed_size - header_size;
11909   strm.next_in = (Bytef *) compressed_buffer + header_size;
11910   strm.avail_out = uncompressed_size;
11911   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
11912
11913   rc = inflateInit (& strm);
11914   while (strm.avail_in > 0)
11915     {
11916       if (rc != Z_OK)
11917         goto fail;
11918       strm.next_out = ((Bytef *) uncompressed_buffer
11919                        + (uncompressed_size - strm.avail_out));
11920       rc = inflate (&strm, Z_FINISH);
11921       if (rc != Z_STREAM_END)
11922         goto fail;
11923       rc = inflateReset (& strm);
11924     }
11925   rc = inflateEnd (& strm);
11926   if (rc != Z_OK
11927       || strm.avail_out != 0)
11928     goto fail;
11929
11930   free (compressed_buffer);
11931   *buffer = uncompressed_buffer;
11932   *size = uncompressed_size;
11933   return 1;
11934
11935  fail:
11936   free (uncompressed_buffer);
11937   /* Indicate decompression failure.  */
11938   *buffer = NULL;
11939   return 0;
11940 #endif  /* HAVE_ZLIB_H */
11941 }
11942
11943 static int
11944 load_specific_debug_section (enum dwarf_section_display_enum debug,
11945                              Elf_Internal_Shdr * sec, void * file)
11946 {
11947   struct dwarf_section * section = &debug_displays [debug].section;
11948   char buf [64];
11949
11950   /* If it is already loaded, do nothing.  */
11951   if (section->start != NULL)
11952     return 1;
11953
11954   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11955   section->address = sec->sh_addr;
11956   section->user_data = NULL;
11957   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11958                                                sec->sh_offset, 1,
11959                                                sec->sh_size, buf);
11960   if (section->start == NULL)
11961     section->size = 0;
11962   else
11963     {
11964       section->size = sec->sh_size;
11965       if (uncompress_section_contents (&section->start, &section->size))
11966         sec->sh_size = section->size;
11967     }
11968
11969   if (section->start == NULL)
11970     return 0;
11971
11972   if (debug_displays [debug].relocate)
11973     apply_relocations ((FILE *) file, sec, section->start);
11974
11975   return 1;
11976 }
11977
11978 /* If this is not NULL, load_debug_section will only look for sections
11979    within the list of sections given here.  */
11980 unsigned int *section_subset = NULL;
11981
11982 int
11983 load_debug_section (enum dwarf_section_display_enum debug, void * file)
11984 {
11985   struct dwarf_section * section = &debug_displays [debug].section;
11986   Elf_Internal_Shdr * sec;
11987
11988   /* Locate the debug section.  */
11989   sec = find_section_in_set (section->uncompressed_name, section_subset);
11990   if (sec != NULL)
11991     section->name = section->uncompressed_name;
11992   else
11993     {
11994       sec = find_section_in_set (section->compressed_name, section_subset);
11995       if (sec != NULL)
11996         section->name = section->compressed_name;
11997     }
11998   if (sec == NULL)
11999     return 0;
12000
12001   /* If we're loading from a subset of sections, and we've loaded
12002      a section matching this name before, it's likely that it's a
12003      different one.  */
12004   if (section_subset != NULL)
12005     free_debug_section (debug);
12006
12007   return load_specific_debug_section (debug, sec, (FILE *) file);
12008 }
12009
12010 void
12011 free_debug_section (enum dwarf_section_display_enum debug)
12012 {
12013   struct dwarf_section * section = &debug_displays [debug].section;
12014
12015   if (section->start == NULL)
12016     return;
12017
12018   free ((char *) section->start);
12019   section->start = NULL;
12020   section->address = 0;
12021   section->size = 0;
12022 }
12023
12024 static int
12025 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
12026 {
12027   char * name = SECTION_NAME (section);
12028   const char * print_name = printable_section_name (section);
12029   bfd_size_type length;
12030   int result = 1;
12031   int i;
12032
12033   length = section->sh_size;
12034   if (length == 0)
12035     {
12036       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
12037       return 0;
12038     }
12039   if (section->sh_type == SHT_NOBITS)
12040     {
12041       /* There is no point in dumping the contents of a debugging section
12042          which has the NOBITS type - the bits in the file will be random.
12043          This can happen when a file containing a .eh_frame section is
12044          stripped with the --only-keep-debug command line option.  */
12045       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12046               print_name);
12047       return 0;
12048     }
12049
12050   if (const_strneq (name, ".gnu.linkonce.wi."))
12051     name = ".debug_info";
12052
12053   /* See if we know how to display the contents of this section.  */
12054   for (i = 0; i < max; i++)
12055     if (streq (debug_displays[i].section.uncompressed_name, name)
12056         || (i == line && const_strneq (name, ".debug_line."))
12057         || streq (debug_displays[i].section.compressed_name, name))
12058       {
12059         struct dwarf_section * sec = &debug_displays [i].section;
12060         int secondary = (section != find_section (name));
12061
12062         if (secondary)
12063           free_debug_section ((enum dwarf_section_display_enum) i);
12064
12065         if (i == line && const_strneq (name, ".debug_line."))
12066           sec->name = name;
12067         else if (streq (sec->uncompressed_name, name))
12068           sec->name = sec->uncompressed_name;
12069         else
12070           sec->name = sec->compressed_name;
12071         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12072                                          section, file))
12073           {
12074             /* If this debug section is part of a CU/TU set in a .dwp file,
12075                restrict load_debug_section to the sections in that set.  */
12076             section_subset = find_cu_tu_set (file, shndx);
12077
12078             result &= debug_displays[i].display (sec, file);
12079
12080             section_subset = NULL;
12081
12082             if (secondary || (i != info && i != abbrev))
12083               free_debug_section ((enum dwarf_section_display_enum) i);
12084           }
12085
12086         break;
12087       }
12088
12089   if (i == max)
12090     {
12091       printf (_("Unrecognized debug section: %s\n"), print_name);
12092       result = 0;
12093     }
12094
12095   return result;
12096 }
12097
12098 /* Set DUMP_SECTS for all sections where dumps were requested
12099    based on section name.  */
12100
12101 static void
12102 initialise_dumps_byname (void)
12103 {
12104   struct dump_list_entry * cur;
12105
12106   for (cur = dump_sects_byname; cur; cur = cur->next)
12107     {
12108       unsigned int i;
12109       int any;
12110
12111       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12112         if (streq (SECTION_NAME (section_headers + i), cur->name))
12113           {
12114             request_dump_bynumber (i, cur->type);
12115             any = 1;
12116           }
12117
12118       if (!any)
12119         warn (_("Section '%s' was not dumped because it does not exist!\n"),
12120               cur->name);
12121     }
12122 }
12123
12124 static void
12125 process_section_contents (FILE * file)
12126 {
12127   Elf_Internal_Shdr * section;
12128   unsigned int i;
12129
12130   if (! do_dump)
12131     return;
12132
12133   initialise_dumps_byname ();
12134
12135   for (i = 0, section = section_headers;
12136        i < elf_header.e_shnum && i < num_dump_sects;
12137        i++, section++)
12138     {
12139 #ifdef SUPPORT_DISASSEMBLY
12140       if (dump_sects[i] & DISASS_DUMP)
12141         disassemble_section (section, file);
12142 #endif
12143       if (dump_sects[i] & HEX_DUMP)
12144         dump_section_as_bytes (section, file, FALSE);
12145
12146       if (dump_sects[i] & RELOC_DUMP)
12147         dump_section_as_bytes (section, file, TRUE);
12148
12149       if (dump_sects[i] & STRING_DUMP)
12150         dump_section_as_strings (section, file);
12151
12152       if (dump_sects[i] & DEBUG_DUMP)
12153         display_debug_section (i, section, file);
12154     }
12155
12156   /* Check to see if the user requested a
12157      dump of a section that does not exist.  */
12158   while (i++ < num_dump_sects)
12159     if (dump_sects[i])
12160       warn (_("Section %d was not dumped because it does not exist!\n"), i);
12161 }
12162
12163 static void
12164 process_mips_fpe_exception (int mask)
12165 {
12166   if (mask)
12167     {
12168       int first = 1;
12169       if (mask & OEX_FPU_INEX)
12170         fputs ("INEX", stdout), first = 0;
12171       if (mask & OEX_FPU_UFLO)
12172         printf ("%sUFLO", first ? "" : "|"), first = 0;
12173       if (mask & OEX_FPU_OFLO)
12174         printf ("%sOFLO", first ? "" : "|"), first = 0;
12175       if (mask & OEX_FPU_DIV0)
12176         printf ("%sDIV0", first ? "" : "|"), first = 0;
12177       if (mask & OEX_FPU_INVAL)
12178         printf ("%sINVAL", first ? "" : "|");
12179     }
12180   else
12181     fputs ("0", stdout);
12182 }
12183
12184 /* Display's the value of TAG at location P.  If TAG is
12185    greater than 0 it is assumed to be an unknown tag, and
12186    a message is printed to this effect.  Otherwise it is
12187    assumed that a message has already been printed.
12188
12189    If the bottom bit of TAG is set it assumed to have a
12190    string value, otherwise it is assumed to have an integer
12191    value.
12192
12193    Returns an updated P pointing to the first unread byte
12194    beyond the end of TAG's value.
12195
12196    Reads at or beyond END will not be made.  */
12197
12198 static unsigned char *
12199 display_tag_value (int tag,
12200                    unsigned char * p,
12201                    const unsigned char * const end)
12202 {
12203   unsigned long val;
12204
12205   if (tag > 0)
12206     printf ("  Tag_unknown_%d: ", tag);
12207
12208   if (p >= end)
12209     {
12210       warn (_("<corrupt tag>\n"));
12211     }
12212   else if (tag & 1)
12213     {
12214       /* PR 17531 file: 027-19978-0.004.  */
12215       size_t maxlen = (end - p) - 1;
12216
12217       putchar ('"');
12218       if (maxlen > 0)
12219         {
12220           print_symbol ((int) maxlen, (const char *) p);
12221           p += strnlen ((char *) p, maxlen) + 1;
12222         }
12223       else
12224         {
12225           printf (_("<corrupt string tag>"));
12226           p = (unsigned char *) end;
12227         }
12228       printf ("\"\n");
12229     }
12230   else
12231     {
12232       unsigned int len;
12233
12234       val = read_uleb128 (p, &len, end);
12235       p += len;
12236       printf ("%ld (0x%lx)\n", val, val);
12237     }
12238
12239   assert (p <= end);
12240   return p;
12241 }
12242
12243 /* ARM EABI attributes section.  */
12244 typedef struct
12245 {
12246   unsigned int tag;
12247   const char * name;
12248   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
12249   unsigned int type;
12250   const char ** table;
12251 } arm_attr_public_tag;
12252
12253 static const char * arm_attr_tag_CPU_arch[] =
12254   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12255    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12256 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12257 static const char * arm_attr_tag_THUMB_ISA_use[] =
12258   {"No", "Thumb-1", "Thumb-2"};
12259 static const char * arm_attr_tag_FP_arch[] =
12260   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12261    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12262 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
12263 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
12264   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12265 static const char * arm_attr_tag_PCS_config[] =
12266   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12267    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12268 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
12269   {"V6", "SB", "TLS", "Unused"};
12270 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
12271   {"Absolute", "PC-relative", "SB-relative", "None"};
12272 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
12273   {"Absolute", "PC-relative", "None"};
12274 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
12275   {"None", "direct", "GOT-indirect"};
12276 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
12277   {"None", "??? 1", "2", "??? 3", "4"};
12278 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12279 static const char * arm_attr_tag_ABI_FP_denormal[] =
12280   {"Unused", "Needed", "Sign only"};
12281 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12282 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12283 static const char * arm_attr_tag_ABI_FP_number_model[] =
12284   {"Unused", "Finite", "RTABI", "IEEE 754"};
12285 static const char * arm_attr_tag_ABI_enum_size[] =
12286   {"Unused", "small", "int", "forced to int"};
12287 static const char * arm_attr_tag_ABI_HardFP_use[] =
12288   {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
12289 static const char * arm_attr_tag_ABI_VFP_args[] =
12290   {"AAPCS", "VFP registers", "custom", "compatible"};
12291 static const char * arm_attr_tag_ABI_WMMX_args[] =
12292   {"AAPCS", "WMMX registers", "custom"};
12293 static const char * arm_attr_tag_ABI_optimization_goals[] =
12294   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12295     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12296 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
12297   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12298     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12299 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
12300 static const char * arm_attr_tag_FP_HP_extension[] =
12301   {"Not Allowed", "Allowed"};
12302 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
12303   {"None", "IEEE 754", "Alternative Format"};
12304 static const char * arm_attr_tag_MPextension_use[] =
12305   {"Not Allowed", "Allowed"};
12306 static const char * arm_attr_tag_DIV_use[] =
12307   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12308     "Allowed in v7-A with integer division extension"};
12309 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12310 static const char * arm_attr_tag_Virtualization_use[] =
12311   {"Not Allowed", "TrustZone", "Virtualization Extensions",
12312     "TrustZone and Virtualization Extensions"};
12313 static const char * arm_attr_tag_MPextension_use_legacy[] =
12314   {"Not Allowed", "Allowed"};
12315
12316 #define LOOKUP(id, name) \
12317   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12318 static arm_attr_public_tag arm_attr_public_tags[] =
12319 {
12320   {4, "CPU_raw_name", 1, NULL},
12321   {5, "CPU_name", 1, NULL},
12322   LOOKUP(6, CPU_arch),
12323   {7, "CPU_arch_profile", 0, NULL},
12324   LOOKUP(8, ARM_ISA_use),
12325   LOOKUP(9, THUMB_ISA_use),
12326   LOOKUP(10, FP_arch),
12327   LOOKUP(11, WMMX_arch),
12328   LOOKUP(12, Advanced_SIMD_arch),
12329   LOOKUP(13, PCS_config),
12330   LOOKUP(14, ABI_PCS_R9_use),
12331   LOOKUP(15, ABI_PCS_RW_data),
12332   LOOKUP(16, ABI_PCS_RO_data),
12333   LOOKUP(17, ABI_PCS_GOT_use),
12334   LOOKUP(18, ABI_PCS_wchar_t),
12335   LOOKUP(19, ABI_FP_rounding),
12336   LOOKUP(20, ABI_FP_denormal),
12337   LOOKUP(21, ABI_FP_exceptions),
12338   LOOKUP(22, ABI_FP_user_exceptions),
12339   LOOKUP(23, ABI_FP_number_model),
12340   {24, "ABI_align_needed", 0, NULL},
12341   {25, "ABI_align_preserved", 0, NULL},
12342   LOOKUP(26, ABI_enum_size),
12343   LOOKUP(27, ABI_HardFP_use),
12344   LOOKUP(28, ABI_VFP_args),
12345   LOOKUP(29, ABI_WMMX_args),
12346   LOOKUP(30, ABI_optimization_goals),
12347   LOOKUP(31, ABI_FP_optimization_goals),
12348   {32, "compatibility", 0, NULL},
12349   LOOKUP(34, CPU_unaligned_access),
12350   LOOKUP(36, FP_HP_extension),
12351   LOOKUP(38, ABI_FP_16bit_format),
12352   LOOKUP(42, MPextension_use),
12353   LOOKUP(44, DIV_use),
12354   {64, "nodefaults", 0, NULL},
12355   {65, "also_compatible_with", 0, NULL},
12356   LOOKUP(66, T2EE_use),
12357   {67, "conformance", 1, NULL},
12358   LOOKUP(68, Virtualization_use),
12359   LOOKUP(70, MPextension_use_legacy)
12360 };
12361 #undef LOOKUP
12362
12363 static unsigned char *
12364 display_arm_attribute (unsigned char * p,
12365                        const unsigned char * const end)
12366 {
12367   unsigned int tag;
12368   unsigned int len;
12369   unsigned int val;
12370   arm_attr_public_tag * attr;
12371   unsigned i;
12372   unsigned int type;
12373
12374   tag = read_uleb128 (p, &len, end);
12375   p += len;
12376   attr = NULL;
12377   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
12378     {
12379       if (arm_attr_public_tags[i].tag == tag)
12380         {
12381           attr = &arm_attr_public_tags[i];
12382           break;
12383         }
12384     }
12385
12386   if (attr)
12387     {
12388       printf ("  Tag_%s: ", attr->name);
12389       switch (attr->type)
12390         {
12391         case 0:
12392           switch (tag)
12393             {
12394             case 7: /* Tag_CPU_arch_profile.  */
12395               val = read_uleb128 (p, &len, end);
12396               p += len;
12397               switch (val)
12398                 {
12399                 case 0: printf (_("None\n")); break;
12400                 case 'A': printf (_("Application\n")); break;
12401                 case 'R': printf (_("Realtime\n")); break;
12402                 case 'M': printf (_("Microcontroller\n")); break;
12403                 case 'S': printf (_("Application or Realtime\n")); break;
12404                 default: printf ("??? (%d)\n", val); break;
12405                 }
12406               break;
12407
12408             case 24: /* Tag_align_needed.  */
12409               val = read_uleb128 (p, &len, end);
12410               p += len;
12411               switch (val)
12412                 {
12413                 case 0: printf (_("None\n")); break;
12414                 case 1: printf (_("8-byte\n")); break;
12415                 case 2: printf (_("4-byte\n")); break;
12416                 case 3: printf ("??? 3\n"); break;
12417                 default:
12418                   if (val <= 12)
12419                     printf (_("8-byte and up to %d-byte extended\n"),
12420                             1 << val);
12421                   else
12422                     printf ("??? (%d)\n", val);
12423                   break;
12424                 }
12425               break;
12426
12427             case 25: /* Tag_align_preserved.  */
12428               val = read_uleb128 (p, &len, end);
12429               p += len;
12430               switch (val)
12431                 {
12432                 case 0: printf (_("None\n")); break;
12433                 case 1: printf (_("8-byte, except leaf SP\n")); break;
12434                 case 2: printf (_("8-byte\n")); break;
12435                 case 3: printf ("??? 3\n"); break;
12436                 default:
12437                   if (val <= 12)
12438                     printf (_("8-byte and up to %d-byte extended\n"),
12439                             1 << val);
12440                   else
12441                     printf ("??? (%d)\n", val);
12442                   break;
12443                 }
12444               break;
12445
12446             case 32: /* Tag_compatibility.  */
12447               {
12448                 val = read_uleb128 (p, &len, end);
12449                 p += len;
12450                 printf (_("flag = %d, vendor = "), val);
12451                 if (p < end - 1)
12452                   {
12453                     size_t maxlen = (end - p) - 1;
12454
12455                     print_symbol ((int) maxlen, (const char *) p);
12456                     p += strnlen ((char *) p, maxlen) + 1;
12457                   }
12458                 else
12459                   {
12460                     printf (_("<corrupt>"));
12461                     p = (unsigned char *) end;
12462                   }
12463                 putchar ('\n');
12464               }
12465               break;
12466
12467             case 64: /* Tag_nodefaults.  */
12468               /* PR 17531: file: 001-505008-0.01.  */
12469               if (p < end)
12470                 p++;
12471               printf (_("True\n"));
12472               break;
12473
12474             case 65: /* Tag_also_compatible_with.  */
12475               val = read_uleb128 (p, &len, end);
12476               p += len;
12477               if (val == 6 /* Tag_CPU_arch.  */)
12478                 {
12479                   val = read_uleb128 (p, &len, end);
12480                   p += len;
12481                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
12482                     printf ("??? (%d)\n", val);
12483                   else
12484                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12485                 }
12486               else
12487                 printf ("???\n");
12488               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
12489                 ;
12490               break;
12491
12492             default:
12493               printf (_("<unknown: %d>\n"), tag);
12494               break;
12495             }
12496           return p;
12497
12498         case 1:
12499           return display_tag_value (-1, p, end);
12500         case 2:
12501           return display_tag_value (0, p, end);
12502
12503         default:
12504           assert (attr->type & 0x80);
12505           val = read_uleb128 (p, &len, end);
12506           p += len;
12507           type = attr->type & 0x7f;
12508           if (val >= type)
12509             printf ("??? (%d)\n", val);
12510           else
12511             printf ("%s\n", attr->table[val]);
12512           return p;
12513         }
12514     }
12515
12516   return display_tag_value (tag, p, end);
12517 }
12518
12519 static unsigned char *
12520 display_gnu_attribute (unsigned char * p,
12521                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12522                        const unsigned char * const end)
12523 {
12524   int tag;
12525   unsigned int len;
12526   int val;
12527
12528   tag = read_uleb128 (p, &len, end);
12529   p += len;
12530
12531   /* Tag_compatibility is the only generic GNU attribute defined at
12532      present.  */
12533   if (tag == 32)
12534     {
12535       val = read_uleb128 (p, &len, end);
12536       p += len;
12537
12538       printf (_("flag = %d, vendor = "), val);
12539       if (p == end)
12540         {
12541           printf (_("<corrupt>\n"));
12542           warn (_("corrupt vendor attribute\n"));
12543         }
12544       else
12545         {
12546           if (p < end - 1)
12547             {
12548               size_t maxlen = (end - p) - 1;
12549
12550               print_symbol ((int) maxlen, (const char *) p);
12551               p += strnlen ((char *) p, maxlen) + 1;
12552             }
12553           else
12554             {
12555               printf (_("<corrupt>"));
12556               p = (unsigned char *) end;
12557             }
12558           putchar ('\n');
12559         }
12560       return p;
12561     }
12562
12563   if ((tag & 2) == 0 && display_proc_gnu_attribute)
12564     return display_proc_gnu_attribute (p, tag, end);
12565
12566   return display_tag_value (tag, p, end);
12567 }
12568
12569 static unsigned char *
12570 display_power_gnu_attribute (unsigned char * p,
12571                              int tag,
12572                              const unsigned char * const end)
12573 {
12574   unsigned int len;
12575   int val;
12576
12577   if (tag == Tag_GNU_Power_ABI_FP)
12578     {
12579       val = read_uleb128 (p, &len, end);
12580       p += len;
12581       printf ("  Tag_GNU_Power_ABI_FP: ");
12582
12583       switch (val)
12584         {
12585         case 0:
12586           printf (_("Hard or soft float\n"));
12587           break;
12588         case 1:
12589           printf (_("Hard float\n"));
12590           break;
12591         case 2:
12592           printf (_("Soft float\n"));
12593           break;
12594         case 3:
12595           printf (_("Single-precision hard float\n"));
12596           break;
12597         default:
12598           printf ("??? (%d)\n", val);
12599           break;
12600         }
12601       return p;
12602    }
12603
12604   if (tag == Tag_GNU_Power_ABI_Vector)
12605     {
12606       val = read_uleb128 (p, &len, end);
12607       p += len;
12608       printf ("  Tag_GNU_Power_ABI_Vector: ");
12609       switch (val)
12610         {
12611         case 0:
12612           printf (_("Any\n"));
12613           break;
12614         case 1:
12615           printf (_("Generic\n"));
12616           break;
12617         case 2:
12618           printf ("AltiVec\n");
12619           break;
12620         case 3:
12621           printf ("SPE\n");
12622           break;
12623         default:
12624           printf ("??? (%d)\n", val);
12625           break;
12626         }
12627       return p;
12628    }
12629
12630   if (tag == Tag_GNU_Power_ABI_Struct_Return)
12631     {
12632       if (p == end)
12633         {
12634           warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
12635           return p;
12636         }
12637
12638       val = read_uleb128 (p, &len, end);
12639       p += len;
12640       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
12641       switch (val)
12642        {
12643        case 0:
12644          printf (_("Any\n"));
12645          break;
12646        case 1:
12647          printf ("r3/r4\n");
12648          break;
12649        case 2:
12650          printf (_("Memory\n"));
12651          break;
12652        default:
12653          printf ("??? (%d)\n", val);
12654          break;
12655        }
12656       return p;
12657     }
12658
12659   return display_tag_value (tag & 1, p, end);
12660 }
12661
12662 static void
12663 display_sparc_hwcaps (int mask)
12664 {
12665   if (mask)
12666     {
12667       int first = 1;
12668
12669       if (mask & ELF_SPARC_HWCAP_MUL32)
12670         fputs ("mul32", stdout), first = 0;
12671       if (mask & ELF_SPARC_HWCAP_DIV32)
12672         printf ("%sdiv32", first ? "" : "|"), first = 0;
12673       if (mask & ELF_SPARC_HWCAP_FSMULD)
12674         printf ("%sfsmuld", first ? "" : "|"), first = 0;
12675       if (mask & ELF_SPARC_HWCAP_V8PLUS)
12676         printf ("%sv8plus", first ? "" : "|"), first = 0;
12677       if (mask & ELF_SPARC_HWCAP_POPC)
12678         printf ("%spopc", first ? "" : "|"), first = 0;
12679       if (mask & ELF_SPARC_HWCAP_VIS)
12680         printf ("%svis", first ? "" : "|"), first = 0;
12681       if (mask & ELF_SPARC_HWCAP_VIS2)
12682         printf ("%svis2", first ? "" : "|"), first = 0;
12683       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12684         printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12685       if (mask & ELF_SPARC_HWCAP_FMAF)
12686         printf ("%sfmaf", first ? "" : "|"), first = 0;
12687       if (mask & ELF_SPARC_HWCAP_VIS3)
12688         printf ("%svis3", first ? "" : "|"), first = 0;
12689       if (mask & ELF_SPARC_HWCAP_HPC)
12690         printf ("%shpc", first ? "" : "|"), first = 0;
12691       if (mask & ELF_SPARC_HWCAP_RANDOM)
12692         printf ("%srandom", first ? "" : "|"), first = 0;
12693       if (mask & ELF_SPARC_HWCAP_TRANS)
12694         printf ("%strans", first ? "" : "|"), first = 0;
12695       if (mask & ELF_SPARC_HWCAP_FJFMAU)
12696         printf ("%sfjfmau", first ? "" : "|"), first = 0;
12697       if (mask & ELF_SPARC_HWCAP_IMA)
12698         printf ("%sima", first ? "" : "|"), first = 0;
12699       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12700         printf ("%scspare", first ? "" : "|"), first = 0;
12701     }
12702   else
12703     fputc ('0', stdout);
12704   fputc ('\n', stdout);
12705 }
12706
12707 static void
12708 display_sparc_hwcaps2 (int mask)
12709 {
12710   if (mask)
12711     {
12712       int first = 1;
12713
12714       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12715         fputs ("fjathplus", stdout), first = 0;
12716       if (mask & ELF_SPARC_HWCAP2_VIS3B)
12717         printf ("%svis3b", first ? "" : "|"), first = 0;
12718       if (mask & ELF_SPARC_HWCAP2_ADP)
12719         printf ("%sadp", first ? "" : "|"), first = 0;
12720       if (mask & ELF_SPARC_HWCAP2_SPARC5)
12721         printf ("%ssparc5", first ? "" : "|"), first = 0;
12722       if (mask & ELF_SPARC_HWCAP2_MWAIT)
12723         printf ("%smwait", first ? "" : "|"), first = 0;
12724       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12725         printf ("%sxmpmul", first ? "" : "|"), first = 0;
12726       if (mask & ELF_SPARC_HWCAP2_XMONT)
12727         printf ("%sxmont2", first ? "" : "|"), first = 0;
12728       if (mask & ELF_SPARC_HWCAP2_NSEC)
12729         printf ("%snsec", first ? "" : "|"), first = 0;
12730       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12731         printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12732       if (mask & ELF_SPARC_HWCAP2_FJDES)
12733         printf ("%sfjdes", first ? "" : "|"), first = 0;
12734       if (mask & ELF_SPARC_HWCAP2_FJAES)
12735         printf ("%sfjaes", first ? "" : "|"), first = 0;
12736     }
12737   else
12738     fputc ('0', stdout);
12739   fputc ('\n', stdout);
12740 }
12741
12742 static unsigned char *
12743 display_sparc_gnu_attribute (unsigned char * p,
12744                              int tag,
12745                              const unsigned char * const end)
12746 {
12747   unsigned int len;
12748   int val;
12749
12750   if (tag == Tag_GNU_Sparc_HWCAPS)
12751     {
12752       val = read_uleb128 (p, &len, end);
12753       p += len;
12754       printf ("  Tag_GNU_Sparc_HWCAPS: ");
12755       display_sparc_hwcaps (val);
12756       return p;
12757     }
12758   if (tag == Tag_GNU_Sparc_HWCAPS2)
12759     {
12760       val = read_uleb128 (p, &len, end);
12761       p += len;
12762       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
12763       display_sparc_hwcaps2 (val);
12764       return p;
12765     }
12766
12767   return display_tag_value (tag, p, end);
12768 }
12769
12770 static void
12771 print_mips_fp_abi_value (int val)
12772 {
12773   switch (val)
12774     {
12775     case Val_GNU_MIPS_ABI_FP_ANY:
12776       printf (_("Hard or soft float\n"));
12777       break;
12778     case Val_GNU_MIPS_ABI_FP_DOUBLE:
12779       printf (_("Hard float (double precision)\n"));
12780       break;
12781     case Val_GNU_MIPS_ABI_FP_SINGLE:
12782       printf (_("Hard float (single precision)\n"));
12783       break;
12784     case Val_GNU_MIPS_ABI_FP_SOFT:
12785       printf (_("Soft float\n"));
12786       break;
12787     case Val_GNU_MIPS_ABI_FP_OLD_64:
12788       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12789       break;
12790     case Val_GNU_MIPS_ABI_FP_XX:
12791       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12792       break;
12793     case Val_GNU_MIPS_ABI_FP_64:
12794       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12795       break;
12796     case Val_GNU_MIPS_ABI_FP_64A:
12797       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12798       break;
12799     default:
12800       printf ("??? (%d)\n", val);
12801       break;
12802     }
12803 }
12804
12805 static unsigned char *
12806 display_mips_gnu_attribute (unsigned char * p,
12807                             int tag,
12808                             const unsigned char * const end)
12809 {
12810   if (tag == Tag_GNU_MIPS_ABI_FP)
12811     {
12812       unsigned int len;
12813       int val;
12814
12815       val = read_uleb128 (p, &len, end);
12816       p += len;
12817       printf ("  Tag_GNU_MIPS_ABI_FP: ");
12818
12819       print_mips_fp_abi_value (val);
12820
12821       return p;
12822    }
12823
12824   if (tag == Tag_GNU_MIPS_ABI_MSA)
12825     {
12826       unsigned int len;
12827       int val;
12828
12829       val = read_uleb128 (p, &len, end);
12830       p += len;
12831       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
12832
12833       switch (val)
12834         {
12835         case Val_GNU_MIPS_ABI_MSA_ANY:
12836           printf (_("Any MSA or not\n"));
12837           break;
12838         case Val_GNU_MIPS_ABI_MSA_128:
12839           printf (_("128-bit MSA\n"));
12840           break;
12841         default:
12842           printf ("??? (%d)\n", val);
12843           break;
12844         }
12845       return p;
12846     }
12847
12848   return display_tag_value (tag & 1, p, end);
12849 }
12850
12851 static unsigned char *
12852 display_tic6x_attribute (unsigned char * p,
12853                          const unsigned char * const end)
12854 {
12855   int tag;
12856   unsigned int len;
12857   int val;
12858
12859   tag = read_uleb128 (p, &len, end);
12860   p += len;
12861
12862   switch (tag)
12863     {
12864     case Tag_ISA:
12865       val = read_uleb128 (p, &len, end);
12866       p += len;
12867       printf ("  Tag_ISA: ");
12868
12869       switch (val)
12870         {
12871         case C6XABI_Tag_ISA_none:
12872           printf (_("None\n"));
12873           break;
12874         case C6XABI_Tag_ISA_C62X:
12875           printf ("C62x\n");
12876           break;
12877         case C6XABI_Tag_ISA_C67X:
12878           printf ("C67x\n");
12879           break;
12880         case C6XABI_Tag_ISA_C67XP:
12881           printf ("C67x+\n");
12882           break;
12883         case C6XABI_Tag_ISA_C64X:
12884           printf ("C64x\n");
12885           break;
12886         case C6XABI_Tag_ISA_C64XP:
12887           printf ("C64x+\n");
12888           break;
12889         case C6XABI_Tag_ISA_C674X:
12890           printf ("C674x\n");
12891           break;
12892         default:
12893           printf ("??? (%d)\n", val);
12894           break;
12895         }
12896       return p;
12897
12898     case Tag_ABI_wchar_t:
12899       val = read_uleb128 (p, &len, end);
12900       p += len;
12901       printf ("  Tag_ABI_wchar_t: ");
12902       switch (val)
12903         {
12904         case 0:
12905           printf (_("Not used\n"));
12906           break;
12907         case 1:
12908           printf (_("2 bytes\n"));
12909           break;
12910         case 2:
12911           printf (_("4 bytes\n"));
12912           break;
12913         default:
12914           printf ("??? (%d)\n", val);
12915           break;
12916         }
12917       return p;
12918
12919     case Tag_ABI_stack_align_needed:
12920       val = read_uleb128 (p, &len, end);
12921       p += len;
12922       printf ("  Tag_ABI_stack_align_needed: ");
12923       switch (val)
12924         {
12925         case 0:
12926           printf (_("8-byte\n"));
12927           break;
12928         case 1:
12929           printf (_("16-byte\n"));
12930           break;
12931         default:
12932           printf ("??? (%d)\n", val);
12933           break;
12934         }
12935       return p;
12936
12937     case Tag_ABI_stack_align_preserved:
12938       val = read_uleb128 (p, &len, end);
12939       p += len;
12940       printf ("  Tag_ABI_stack_align_preserved: ");
12941       switch (val)
12942         {
12943         case 0:
12944           printf (_("8-byte\n"));
12945           break;
12946         case 1:
12947           printf (_("16-byte\n"));
12948           break;
12949         default:
12950           printf ("??? (%d)\n", val);
12951           break;
12952         }
12953       return p;
12954
12955     case Tag_ABI_DSBT:
12956       val = read_uleb128 (p, &len, end);
12957       p += len;
12958       printf ("  Tag_ABI_DSBT: ");
12959       switch (val)
12960         {
12961         case 0:
12962           printf (_("DSBT addressing not used\n"));
12963           break;
12964         case 1:
12965           printf (_("DSBT addressing used\n"));
12966           break;
12967         default:
12968           printf ("??? (%d)\n", val);
12969           break;
12970         }
12971       return p;
12972
12973     case Tag_ABI_PID:
12974       val = read_uleb128 (p, &len, end);
12975       p += len;
12976       printf ("  Tag_ABI_PID: ");
12977       switch (val)
12978         {
12979         case 0:
12980           printf (_("Data addressing position-dependent\n"));
12981           break;
12982         case 1:
12983           printf (_("Data addressing position-independent, GOT near DP\n"));
12984           break;
12985         case 2:
12986           printf (_("Data addressing position-independent, GOT far from DP\n"));
12987           break;
12988         default:
12989           printf ("??? (%d)\n", val);
12990           break;
12991         }
12992       return p;
12993
12994     case Tag_ABI_PIC:
12995       val = read_uleb128 (p, &len, end);
12996       p += len;
12997       printf ("  Tag_ABI_PIC: ");
12998       switch (val)
12999         {
13000         case 0:
13001           printf (_("Code addressing position-dependent\n"));
13002           break;
13003         case 1:
13004           printf (_("Code addressing position-independent\n"));
13005           break;
13006         default:
13007           printf ("??? (%d)\n", val);
13008           break;
13009         }
13010       return p;
13011
13012     case Tag_ABI_array_object_alignment:
13013       val = read_uleb128 (p, &len, end);
13014       p += len;
13015       printf ("  Tag_ABI_array_object_alignment: ");
13016       switch (val)
13017         {
13018         case 0:
13019           printf (_("8-byte\n"));
13020           break;
13021         case 1:
13022           printf (_("4-byte\n"));
13023           break;
13024         case 2:
13025           printf (_("16-byte\n"));
13026           break;
13027         default:
13028           printf ("??? (%d)\n", val);
13029           break;
13030         }
13031       return p;
13032
13033     case Tag_ABI_array_object_align_expected:
13034       val = read_uleb128 (p, &len, end);
13035       p += len;
13036       printf ("  Tag_ABI_array_object_align_expected: ");
13037       switch (val)
13038         {
13039         case 0:
13040           printf (_("8-byte\n"));
13041           break;
13042         case 1:
13043           printf (_("4-byte\n"));
13044           break;
13045         case 2:
13046           printf (_("16-byte\n"));
13047           break;
13048         default:
13049           printf ("??? (%d)\n", val);
13050           break;
13051         }
13052       return p;
13053
13054     case Tag_ABI_compatibility:
13055       {
13056         val = read_uleb128 (p, &len, end);
13057         p += len;
13058         printf ("  Tag_ABI_compatibility: ");
13059         printf (_("flag = %d, vendor = "), val);
13060         if (p < end - 1)
13061           {
13062             size_t maxlen = (end - p) - 1;
13063
13064             print_symbol ((int) maxlen, (const char *) p);
13065             p += strnlen ((char *) p, maxlen) + 1;
13066           }
13067         else
13068           {
13069             printf (_("<corrupt>"));
13070             p = (unsigned char *) end;
13071           }
13072         putchar ('\n');
13073         return p;
13074       }
13075
13076     case Tag_ABI_conformance:
13077       {
13078         printf ("  Tag_ABI_conformance: \"");
13079         if (p < end - 1)
13080           {
13081             size_t maxlen = (end - p) - 1;
13082
13083             print_symbol ((int) maxlen, (const char *) p);
13084             p += strnlen ((char *) p, maxlen) + 1;
13085           }
13086         else
13087           {
13088             printf (_("<corrupt>"));
13089             p = (unsigned char *) end;
13090           }
13091         printf ("\"\n");
13092         return p;
13093       }
13094     }
13095
13096   return display_tag_value (tag, p, end);
13097 }
13098
13099 static void
13100 display_raw_attribute (unsigned char * p, unsigned char * end)
13101 {
13102   unsigned long addr = 0;
13103   size_t bytes = end - p;
13104
13105   assert (end > p);
13106   while (bytes)
13107     {
13108       int j;
13109       int k;
13110       int lbytes = (bytes > 16 ? 16 : bytes);
13111
13112       printf ("  0x%8.8lx ", addr);
13113
13114       for (j = 0; j < 16; j++)
13115         {
13116           if (j < lbytes)
13117             printf ("%2.2x", p[j]);
13118           else
13119             printf ("  ");
13120
13121           if ((j & 3) == 3)
13122             printf (" ");
13123         }
13124
13125       for (j = 0; j < lbytes; j++)
13126         {
13127           k = p[j];
13128           if (k >= ' ' && k < 0x7f)
13129             printf ("%c", k);
13130           else
13131             printf (".");
13132         }
13133
13134       putchar ('\n');
13135
13136       p  += lbytes;
13137       bytes -= lbytes;
13138       addr += lbytes;
13139     }
13140
13141   putchar ('\n');
13142 }
13143
13144 static unsigned char *
13145 display_msp430x_attribute (unsigned char * p,
13146                            const unsigned char * const end)
13147 {
13148   unsigned int len;
13149   int val;
13150   int tag;
13151
13152   tag = read_uleb128 (p, & len, end);
13153   p += len;
13154
13155   switch (tag)
13156     {
13157     case OFBA_MSPABI_Tag_ISA:
13158       val = read_uleb128 (p, &len, end);
13159       p += len;
13160       printf ("  Tag_ISA: ");
13161       switch (val)
13162         {
13163         case 0: printf (_("None\n")); break;
13164         case 1: printf (_("MSP430\n")); break;
13165         case 2: printf (_("MSP430X\n")); break;
13166         default: printf ("??? (%d)\n", val); break;
13167         }
13168       break;
13169
13170     case OFBA_MSPABI_Tag_Code_Model:
13171       val = read_uleb128 (p, &len, end);
13172       p += len;
13173       printf ("  Tag_Code_Model: ");
13174       switch (val)
13175         {
13176         case 0: printf (_("None\n")); break;
13177         case 1: printf (_("Small\n")); break;
13178         case 2: printf (_("Large\n")); break;
13179         default: printf ("??? (%d)\n", val); break;
13180         }
13181       break;
13182
13183     case OFBA_MSPABI_Tag_Data_Model:
13184       val = read_uleb128 (p, &len, end);
13185       p += len;
13186       printf ("  Tag_Data_Model: ");
13187       switch (val)
13188         {
13189         case 0: printf (_("None\n")); break;
13190         case 1: printf (_("Small\n")); break;
13191         case 2: printf (_("Large\n")); break;
13192         case 3: printf (_("Restricted Large\n")); break;
13193         default: printf ("??? (%d)\n", val); break;
13194         }
13195       break;
13196
13197     default:
13198       printf (_("  <unknown tag %d>: "), tag);
13199
13200       if (tag & 1)
13201         {
13202           putchar ('"');
13203           if (p < end - 1)
13204             {
13205               size_t maxlen = (end - p) - 1;
13206
13207               print_symbol ((int) maxlen, (const char *) p);
13208               p += strnlen ((char *) p, maxlen) + 1;
13209             }
13210           else
13211             {
13212               printf (_("<corrupt>"));
13213               p = (unsigned char *) end;
13214             }
13215           printf ("\"\n");
13216         }
13217       else
13218         {
13219           val = read_uleb128 (p, &len, end);
13220           p += len;
13221           printf ("%d (0x%x)\n", val, val);
13222         }
13223       break;
13224    }
13225
13226   assert (p <= end);
13227   return p;
13228 }
13229
13230 static int
13231 process_attributes (FILE * file,
13232                     const char * public_name,
13233                     unsigned int proc_type,
13234                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13235                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
13236 {
13237   Elf_Internal_Shdr * sect;
13238   unsigned i;
13239
13240   /* Find the section header so that we get the size.  */
13241   for (i = 0, sect = section_headers;
13242        i < elf_header.e_shnum;
13243        i++, sect++)
13244     {
13245       unsigned char * contents;
13246       unsigned char * p;
13247
13248       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
13249         continue;
13250
13251       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13252                                              sect->sh_size, _("attributes"));
13253       if (contents == NULL)
13254         continue;
13255
13256       p = contents;
13257       if (*p == 'A')
13258         {
13259           bfd_vma section_len;
13260
13261           section_len = sect->sh_size - 1;
13262           p++;
13263
13264           while (section_len > 0)
13265             {
13266               bfd_vma attr_len;
13267               unsigned int namelen;
13268               bfd_boolean public_section;
13269               bfd_boolean gnu_section;
13270
13271               if (section_len <= 4)
13272                 {
13273                   error (_("Tag section ends prematurely\n"));
13274                   break;
13275                 }
13276               attr_len = byte_get (p, 4);
13277               p += 4;
13278
13279               if (attr_len > section_len)
13280                 {
13281                   error (_("Bad attribute length (%u > %u)\n"),
13282                           (unsigned) attr_len, (unsigned) section_len);
13283                   attr_len = section_len;
13284                 }
13285               /* PR 17531: file: 001-101425-0.004  */
13286               else if (attr_len < 5)
13287                 {
13288                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
13289                   break;
13290                 }
13291
13292               section_len -= attr_len;
13293               attr_len -= 4;
13294
13295               namelen = strnlen ((char *) p, attr_len) + 1;
13296               if (namelen == 0 || namelen >= attr_len)
13297                 {
13298                   error (_("Corrupt attribute section name\n"));
13299                   break;
13300                 }
13301
13302               printf (_("Attribute Section: "));
13303               print_symbol (INT_MAX, (const char *) p);
13304               putchar ('\n');
13305
13306               if (public_name && streq ((char *) p, public_name))
13307                 public_section = TRUE;
13308               else
13309                 public_section = FALSE;
13310
13311               if (streq ((char *) p, "gnu"))
13312                 gnu_section = TRUE;
13313               else
13314                 gnu_section = FALSE;
13315
13316               p += namelen;
13317               attr_len -= namelen;
13318
13319               while (attr_len > 0 && p < contents + sect->sh_size)
13320                 {
13321                   int tag;
13322                   int val;
13323                   bfd_vma size;
13324                   unsigned char * end;
13325
13326                   /* PR binutils/17531: Safe handling of corrupt files.  */
13327                   if (attr_len < 6)
13328                     {
13329                       error (_("Unused bytes at end of section\n"));
13330                       section_len = 0;
13331                       break;
13332                     }
13333
13334                   tag = *(p++);
13335                   size = byte_get (p, 4);
13336                   if (size > attr_len)
13337                     {
13338                       error (_("Bad subsection length (%u > %u)\n"),
13339                               (unsigned) size, (unsigned) attr_len);
13340                       size = attr_len;
13341                     }
13342                   /* PR binutils/17531: Safe handling of corrupt files.  */
13343                   if (size < 6)
13344                     {
13345                       error (_("Bad subsection length (%u < 6)\n"),
13346                               (unsigned) size);
13347                       section_len = 0;
13348                       break;
13349                     }
13350
13351                   attr_len -= size;
13352                   end = p + size - 1;
13353                   assert (end <= contents + sect->sh_size);
13354                   p += 4;
13355
13356                   switch (tag)
13357                     {
13358                     case 1:
13359                       printf (_("File Attributes\n"));
13360                       break;
13361                     case 2:
13362                       printf (_("Section Attributes:"));
13363                       goto do_numlist;
13364                     case 3:
13365                       printf (_("Symbol Attributes:"));
13366                     do_numlist:
13367                       for (;;)
13368                         {
13369                           unsigned int j;
13370
13371                           val = read_uleb128 (p, &j, end);
13372                           p += j;
13373                           if (val == 0)
13374                             break;
13375                           printf (" %d", val);
13376                         }
13377                       printf ("\n");
13378                       break;
13379                     default:
13380                       printf (_("Unknown tag: %d\n"), tag);
13381                       public_section = FALSE;
13382                       break;
13383                     }
13384
13385                   if (public_section && display_pub_attribute != NULL)
13386                     {
13387                       while (p < end)
13388                         p = display_pub_attribute (p, end);
13389                       assert (p <= end);
13390                     }
13391                   else if (gnu_section && display_proc_gnu_attribute != NULL)
13392                     {
13393                       while (p < end)
13394                         p = display_gnu_attribute (p,
13395                                                    display_proc_gnu_attribute,
13396                                                    end);
13397                       assert (p <= end);
13398                     }
13399                   else if (p < end)
13400                     {
13401                       printf (_("  Unknown attribute:\n"));
13402                       display_raw_attribute (p, end);
13403                       p = end;
13404                     }
13405                   else
13406                     attr_len = 0;
13407                 }
13408             }
13409         }
13410       else
13411         printf (_("Unknown format '%c' (%d)\n"), *p, *p);
13412
13413       free (contents);
13414     }
13415   return 1;
13416 }
13417
13418 static int
13419 process_arm_specific (FILE * file)
13420 {
13421   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13422                              display_arm_attribute, NULL);
13423 }
13424
13425 static int
13426 process_power_specific (FILE * file)
13427 {
13428   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13429                              display_power_gnu_attribute);
13430 }
13431
13432 static int
13433 process_sparc_specific (FILE * file)
13434 {
13435   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13436                              display_sparc_gnu_attribute);
13437 }
13438
13439 static int
13440 process_tic6x_specific (FILE * file)
13441 {
13442   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13443                              display_tic6x_attribute, NULL);
13444 }
13445
13446 static int
13447 process_msp430x_specific (FILE * file)
13448 {
13449   return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13450                              display_msp430x_attribute, NULL);
13451 }
13452
13453 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13454    Print the Address, Access and Initial fields of an entry at VMA ADDR
13455    and return the VMA of the next entry, or -1 if there was a problem.
13456    Does not read from DATA_END or beyond.  */
13457
13458 static bfd_vma
13459 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13460                       unsigned char * data_end)
13461 {
13462   printf ("  ");
13463   print_vma (addr, LONG_HEX);
13464   printf (" ");
13465   if (addr < pltgot + 0xfff0)
13466     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13467   else
13468     printf ("%10s", "");
13469   printf (" ");
13470   if (data == NULL)
13471     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13472   else
13473     {
13474       bfd_vma entry;
13475       unsigned char * from = data + addr - pltgot;
13476
13477       if (from + (is_32bit_elf ? 4 : 8) > data_end)
13478         {
13479           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13480           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13481           return (bfd_vma) -1;
13482         }
13483       else
13484         {
13485           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13486           print_vma (entry, LONG_HEX);
13487         }
13488     }
13489   return addr + (is_32bit_elf ? 4 : 8);
13490 }
13491
13492 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13493    PLTGOT.  Print the Address and Initial fields of an entry at VMA
13494    ADDR and return the VMA of the next entry.  */
13495
13496 static bfd_vma
13497 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
13498 {
13499   printf ("  ");
13500   print_vma (addr, LONG_HEX);
13501   printf (" ");
13502   if (data == NULL)
13503     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13504   else
13505     {
13506       bfd_vma entry;
13507
13508       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13509       print_vma (entry, LONG_HEX);
13510     }
13511   return addr + (is_32bit_elf ? 4 : 8);
13512 }
13513
13514 static void
13515 print_mips_ases (unsigned int mask)
13516 {
13517   if (mask & AFL_ASE_DSP)
13518     fputs ("\n\tDSP ASE", stdout);
13519   if (mask & AFL_ASE_DSPR2)
13520     fputs ("\n\tDSP R2 ASE", stdout);
13521   if (mask & AFL_ASE_EVA)
13522     fputs ("\n\tEnhanced VA Scheme", stdout);
13523   if (mask & AFL_ASE_MCU)
13524     fputs ("\n\tMCU (MicroController) ASE", stdout);
13525   if (mask & AFL_ASE_MDMX)
13526     fputs ("\n\tMDMX ASE", stdout);
13527   if (mask & AFL_ASE_MIPS3D)
13528     fputs ("\n\tMIPS-3D ASE", stdout);
13529   if (mask & AFL_ASE_MT)
13530     fputs ("\n\tMT ASE", stdout);
13531   if (mask & AFL_ASE_SMARTMIPS)
13532     fputs ("\n\tSmartMIPS ASE", stdout);
13533   if (mask & AFL_ASE_VIRT)
13534     fputs ("\n\tVZ ASE", stdout);
13535   if (mask & AFL_ASE_MSA)
13536     fputs ("\n\tMSA ASE", stdout);
13537   if (mask & AFL_ASE_MIPS16)
13538     fputs ("\n\tMIPS16 ASE", stdout);
13539   if (mask & AFL_ASE_MICROMIPS)
13540     fputs ("\n\tMICROMIPS ASE", stdout);
13541   if (mask & AFL_ASE_XPA)
13542     fputs ("\n\tXPA ASE", stdout);
13543   if (mask == 0)
13544     fprintf (stdout, "\n\t%s", _("None"));
13545   else if ((mask & ~AFL_ASE_MASK) != 0)
13546     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
13547 }
13548
13549 static void
13550 print_mips_isa_ext (unsigned int isa_ext)
13551 {
13552   switch (isa_ext)
13553     {
13554     case 0:
13555       fputs (_("None"), stdout);
13556       break;
13557     case AFL_EXT_XLR:
13558       fputs ("RMI XLR", stdout);
13559       break;
13560     case AFL_EXT_OCTEON3:
13561       fputs ("Cavium Networks Octeon3", stdout);
13562       break;
13563     case AFL_EXT_OCTEON2:
13564       fputs ("Cavium Networks Octeon2", stdout);
13565       break;
13566     case AFL_EXT_OCTEONP:
13567       fputs ("Cavium Networks OcteonP", stdout);
13568       break;
13569     case AFL_EXT_LOONGSON_3A:
13570       fputs ("Loongson 3A", stdout);
13571       break;
13572     case AFL_EXT_OCTEON:
13573       fputs ("Cavium Networks Octeon", stdout);
13574       break;
13575     case AFL_EXT_5900:
13576       fputs ("Toshiba R5900", stdout);
13577       break;
13578     case AFL_EXT_4650:
13579       fputs ("MIPS R4650", stdout);
13580       break;
13581     case AFL_EXT_4010:
13582       fputs ("LSI R4010", stdout);
13583       break;
13584     case AFL_EXT_4100:
13585       fputs ("NEC VR4100", stdout);
13586       break;
13587     case AFL_EXT_3900:
13588       fputs ("Toshiba R3900", stdout);
13589       break;
13590     case AFL_EXT_10000:
13591       fputs ("MIPS R10000", stdout);
13592       break;
13593     case AFL_EXT_SB1:
13594       fputs ("Broadcom SB-1", stdout);
13595       break;
13596     case AFL_EXT_4111:
13597       fputs ("NEC VR4111/VR4181", stdout);
13598       break;
13599     case AFL_EXT_4120:
13600       fputs ("NEC VR4120", stdout);
13601       break;
13602     case AFL_EXT_5400:
13603       fputs ("NEC VR5400", stdout);
13604       break;
13605     case AFL_EXT_5500:
13606       fputs ("NEC VR5500", stdout);
13607       break;
13608     case AFL_EXT_LOONGSON_2E:
13609       fputs ("ST Microelectronics Loongson 2E", stdout);
13610       break;
13611     case AFL_EXT_LOONGSON_2F:
13612       fputs ("ST Microelectronics Loongson 2F", stdout);
13613       break;
13614     default:
13615       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
13616     }
13617 }
13618
13619 static int
13620 get_mips_reg_size (int reg_size)
13621 {
13622   return (reg_size == AFL_REG_NONE) ? 0
13623          : (reg_size == AFL_REG_32) ? 32
13624          : (reg_size == AFL_REG_64) ? 64
13625          : (reg_size == AFL_REG_128) ? 128
13626          : -1;
13627 }
13628
13629 static int
13630 process_mips_specific (FILE * file)
13631 {
13632   Elf_Internal_Dyn * entry;
13633   Elf_Internal_Shdr *sect = NULL;
13634   size_t liblist_offset = 0;
13635   size_t liblistno = 0;
13636   size_t conflictsno = 0;
13637   size_t options_offset = 0;
13638   size_t conflicts_offset = 0;
13639   size_t pltrelsz = 0;
13640   size_t pltrel = 0;
13641   bfd_vma pltgot = 0;
13642   bfd_vma mips_pltgot = 0;
13643   bfd_vma jmprel = 0;
13644   bfd_vma local_gotno = 0;
13645   bfd_vma gotsym = 0;
13646   bfd_vma symtabno = 0;
13647
13648   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13649                       display_mips_gnu_attribute);
13650
13651   sect = find_section (".MIPS.abiflags");
13652
13653   if (sect != NULL)
13654     {
13655       Elf_External_ABIFlags_v0 *abiflags_ext;
13656       Elf_Internal_ABIFlags_v0 abiflags_in;
13657
13658       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
13659         fputs ("\nCorrupt ABI Flags section.\n", stdout);
13660       else
13661         {
13662           abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
13663                                    sect->sh_size, _("MIPS ABI Flags section"));
13664           if (abiflags_ext)
13665             {
13666               abiflags_in.version = BYTE_GET (abiflags_ext->version);
13667               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
13668               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
13669               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
13670               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
13671               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
13672               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
13673               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
13674               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
13675               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
13676               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
13677
13678               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
13679               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
13680               if (abiflags_in.isa_rev > 1)
13681                 printf ("r%d", abiflags_in.isa_rev);
13682               printf ("\nGPR size: %d",
13683                       get_mips_reg_size (abiflags_in.gpr_size));
13684               printf ("\nCPR1 size: %d",
13685                       get_mips_reg_size (abiflags_in.cpr1_size));
13686               printf ("\nCPR2 size: %d",
13687                       get_mips_reg_size (abiflags_in.cpr2_size));
13688               fputs ("\nFP ABI: ", stdout);
13689               print_mips_fp_abi_value (abiflags_in.fp_abi);
13690               fputs ("ISA Extension: ", stdout);
13691               print_mips_isa_ext (abiflags_in.isa_ext);
13692               fputs ("\nASEs:", stdout);
13693               print_mips_ases (abiflags_in.ases);
13694               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13695               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13696               fputc ('\n', stdout);
13697               free (abiflags_ext);
13698             }
13699         }
13700     }
13701
13702   /* We have a lot of special sections.  Thanks SGI!  */
13703   if (dynamic_section == NULL)
13704     /* No information available.  */
13705     return 0;
13706
13707   for (entry = dynamic_section;
13708        /* PR 17531 file: 012-50589-0.004.  */
13709        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
13710        ++entry)
13711     switch (entry->d_tag)
13712       {
13713       case DT_MIPS_LIBLIST:
13714         liblist_offset
13715           = offset_from_vma (file, entry->d_un.d_val,
13716                              liblistno * sizeof (Elf32_External_Lib));
13717         break;
13718       case DT_MIPS_LIBLISTNO:
13719         liblistno = entry->d_un.d_val;
13720         break;
13721       case DT_MIPS_OPTIONS:
13722         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
13723         break;
13724       case DT_MIPS_CONFLICT:
13725         conflicts_offset
13726           = offset_from_vma (file, entry->d_un.d_val,
13727                              conflictsno * sizeof (Elf32_External_Conflict));
13728         break;
13729       case DT_MIPS_CONFLICTNO:
13730         conflictsno = entry->d_un.d_val;
13731         break;
13732       case DT_PLTGOT:
13733         pltgot = entry->d_un.d_ptr;
13734         break;
13735       case DT_MIPS_LOCAL_GOTNO:
13736         local_gotno = entry->d_un.d_val;
13737         break;
13738       case DT_MIPS_GOTSYM:
13739         gotsym = entry->d_un.d_val;
13740         break;
13741       case DT_MIPS_SYMTABNO:
13742         symtabno = entry->d_un.d_val;
13743         break;
13744       case DT_MIPS_PLTGOT:
13745         mips_pltgot = entry->d_un.d_ptr;
13746         break;
13747       case DT_PLTREL:
13748         pltrel = entry->d_un.d_val;
13749         break;
13750       case DT_PLTRELSZ:
13751         pltrelsz = entry->d_un.d_val;
13752         break;
13753       case DT_JMPREL:
13754         jmprel = entry->d_un.d_ptr;
13755         break;
13756       default:
13757         break;
13758       }
13759
13760   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
13761     {
13762       Elf32_External_Lib * elib;
13763       size_t cnt;
13764
13765       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
13766                                               liblistno,
13767                                               sizeof (Elf32_External_Lib),
13768                                               _("liblist section data"));
13769       if (elib)
13770         {
13771           printf (_("\nSection '.liblist' contains %lu entries:\n"),
13772                   (unsigned long) liblistno);
13773           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
13774                  stdout);
13775
13776           for (cnt = 0; cnt < liblistno; ++cnt)
13777             {
13778               Elf32_Lib liblist;
13779               time_t atime;
13780               char timebuf[20];
13781               struct tm * tmp;
13782
13783               liblist.l_name = BYTE_GET (elib[cnt].l_name);
13784               atime = BYTE_GET (elib[cnt].l_time_stamp);
13785               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13786               liblist.l_version = BYTE_GET (elib[cnt].l_version);
13787               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13788
13789               tmp = gmtime (&atime);
13790               snprintf (timebuf, sizeof (timebuf),
13791                         "%04u-%02u-%02uT%02u:%02u:%02u",
13792                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13793                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
13794
13795               printf ("%3lu: ", (unsigned long) cnt);
13796               if (VALID_DYNAMIC_NAME (liblist.l_name))
13797                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
13798               else
13799                 printf (_("<corrupt: %9ld>"), liblist.l_name);
13800               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
13801                       liblist.l_version);
13802
13803               if (liblist.l_flags == 0)
13804                 puts (_(" NONE"));
13805               else
13806                 {
13807                   static const struct
13808                   {
13809                     const char * name;
13810                     int bit;
13811                   }
13812                   l_flags_vals[] =
13813                   {
13814                     { " EXACT_MATCH", LL_EXACT_MATCH },
13815                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
13816                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
13817                     { " EXPORTS", LL_EXPORTS },
13818                     { " DELAY_LOAD", LL_DELAY_LOAD },
13819                     { " DELTA", LL_DELTA }
13820                   };
13821                   int flags = liblist.l_flags;
13822                   size_t fcnt;
13823
13824                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
13825                     if ((flags & l_flags_vals[fcnt].bit) != 0)
13826                       {
13827                         fputs (l_flags_vals[fcnt].name, stdout);
13828                         flags ^= l_flags_vals[fcnt].bit;
13829                       }
13830                   if (flags != 0)
13831                     printf (" %#x", (unsigned int) flags);
13832
13833                   puts ("");
13834                 }
13835             }
13836
13837           free (elib);
13838         }
13839     }
13840
13841   if (options_offset != 0)
13842     {
13843       Elf_External_Options * eopt;
13844       Elf_Internal_Options * iopt;
13845       Elf_Internal_Options * option;
13846       size_t offset;
13847       int cnt;
13848       sect = section_headers;
13849
13850       /* Find the section header so that we get the size.  */
13851       sect = find_section_by_type (SHT_MIPS_OPTIONS);
13852       /* PR 17533 file: 012-277276-0.004.  */
13853       if (sect == NULL)
13854         {
13855           error (_("No MIPS_OPTIONS header found\n"));
13856           return 0;
13857         }
13858
13859       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
13860                                                 sect->sh_size, _("options"));
13861       if (eopt)
13862         {
13863           iopt = (Elf_Internal_Options *)
13864               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
13865           if (iopt == NULL)
13866             {
13867               error (_("Out of memory allocatinf space for MIPS options\n"));
13868               return 0;
13869             }
13870
13871           offset = cnt = 0;
13872           option = iopt;
13873
13874           while (offset <= sect->sh_size - sizeof (* eopt))
13875             {
13876               Elf_External_Options * eoption;
13877
13878               eoption = (Elf_External_Options *) ((char *) eopt + offset);
13879
13880               option->kind = BYTE_GET (eoption->kind);
13881               option->size = BYTE_GET (eoption->size);
13882               option->section = BYTE_GET (eoption->section);
13883               option->info = BYTE_GET (eoption->info);
13884
13885               /* PR 17531: file: ffa0fa3b.  */
13886               if (option->size < sizeof (* eopt)
13887                   || offset + option->size > sect->sh_size)
13888                 {
13889                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
13890                   return 0;
13891                 }
13892               offset += option->size;
13893
13894               ++option;
13895               ++cnt;
13896             }
13897
13898           printf (_("\nSection '%s' contains %d entries:\n"),
13899                   printable_section_name (sect), cnt);
13900
13901           option = iopt;
13902           offset = 0;
13903
13904           while (cnt-- > 0)
13905             {
13906               size_t len;
13907
13908               switch (option->kind)
13909                 {
13910                 case ODK_NULL:
13911                   /* This shouldn't happen.  */
13912                   printf (" NULL       %d %lx", option->section, option->info);
13913                   break;
13914                 case ODK_REGINFO:
13915                   printf (" REGINFO    ");
13916                   if (elf_header.e_machine == EM_MIPS)
13917                     {
13918                       /* 32bit form.  */
13919                       Elf32_External_RegInfo * ereg;
13920                       Elf32_RegInfo reginfo;
13921
13922                       ereg = (Elf32_External_RegInfo *) (option + 1);
13923                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13924                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13925                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13926                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13927                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13928                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
13929
13930                       printf ("GPR %08lx  GP 0x%lx\n",
13931                               reginfo.ri_gprmask,
13932                               (unsigned long) reginfo.ri_gp_value);
13933                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
13934                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13935                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13936                     }
13937                   else
13938                     {
13939                       /* 64 bit form.  */
13940                       Elf64_External_RegInfo * ereg;
13941                       Elf64_Internal_RegInfo reginfo;
13942
13943                       ereg = (Elf64_External_RegInfo *) (option + 1);
13944                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
13945                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13946                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13947                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13948                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13949                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
13950
13951                       printf ("GPR %08lx  GP 0x",
13952                               reginfo.ri_gprmask);
13953                       printf_vma (reginfo.ri_gp_value);
13954                       printf ("\n");
13955
13956                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
13957                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13958                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13959                     }
13960                   ++option;
13961                   continue;
13962                 case ODK_EXCEPTIONS:
13963                   fputs (" EXCEPTIONS fpe_min(", stdout);
13964                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
13965                   fputs (") fpe_max(", stdout);
13966                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
13967                   fputs (")", stdout);
13968
13969                   if (option->info & OEX_PAGE0)
13970                     fputs (" PAGE0", stdout);
13971                   if (option->info & OEX_SMM)
13972                     fputs (" SMM", stdout);
13973                   if (option->info & OEX_FPDBUG)
13974                     fputs (" FPDBUG", stdout);
13975                   if (option->info & OEX_DISMISS)
13976                     fputs (" DISMISS", stdout);
13977                   break;
13978                 case ODK_PAD:
13979                   fputs (" PAD       ", stdout);
13980                   if (option->info & OPAD_PREFIX)
13981                     fputs (" PREFIX", stdout);
13982                   if (option->info & OPAD_POSTFIX)
13983                     fputs (" POSTFIX", stdout);
13984                   if (option->info & OPAD_SYMBOL)
13985                     fputs (" SYMBOL", stdout);
13986                   break;
13987                 case ODK_HWPATCH:
13988                   fputs (" HWPATCH   ", stdout);
13989                   if (option->info & OHW_R4KEOP)
13990                     fputs (" R4KEOP", stdout);
13991                   if (option->info & OHW_R8KPFETCH)
13992                     fputs (" R8KPFETCH", stdout);
13993                   if (option->info & OHW_R5KEOP)
13994                     fputs (" R5KEOP", stdout);
13995                   if (option->info & OHW_R5KCVTL)
13996                     fputs (" R5KCVTL", stdout);
13997                   break;
13998                 case ODK_FILL:
13999                   fputs (" FILL       ", stdout);
14000                   /* XXX Print content of info word?  */
14001                   break;
14002                 case ODK_TAGS:
14003                   fputs (" TAGS       ", stdout);
14004                   /* XXX Print content of info word?  */
14005                   break;
14006                 case ODK_HWAND:
14007                   fputs (" HWAND     ", stdout);
14008                   if (option->info & OHWA0_R4KEOP_CHECKED)
14009                     fputs (" R4KEOP_CHECKED", stdout);
14010                   if (option->info & OHWA0_R4KEOP_CLEAN)
14011                     fputs (" R4KEOP_CLEAN", stdout);
14012                   break;
14013                 case ODK_HWOR:
14014                   fputs (" HWOR      ", stdout);
14015                   if (option->info & OHWA0_R4KEOP_CHECKED)
14016                     fputs (" R4KEOP_CHECKED", stdout);
14017                   if (option->info & OHWA0_R4KEOP_CLEAN)
14018                     fputs (" R4KEOP_CLEAN", stdout);
14019                   break;
14020                 case ODK_GP_GROUP:
14021                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
14022                           option->info & OGP_GROUP,
14023                           (option->info & OGP_SELF) >> 16);
14024                   break;
14025                 case ODK_IDENT:
14026                   printf (" IDENT     %#06lx  self-contained %#06lx",
14027                           option->info & OGP_GROUP,
14028                           (option->info & OGP_SELF) >> 16);
14029                   break;
14030                 default:
14031                   /* This shouldn't happen.  */
14032                   printf (" %3d ???     %d %lx",
14033                           option->kind, option->section, option->info);
14034                   break;
14035                 }
14036
14037               len = sizeof (* eopt);
14038               while (len < option->size)
14039                 {
14040                   char datum = * ((char *) eopt + offset + len);
14041
14042                   if (ISPRINT (datum))
14043                     printf ("%c", datum);
14044                   else
14045                     printf ("\\%03o", datum);
14046                   len ++;
14047                 }
14048               fputs ("\n", stdout);
14049
14050               offset += option->size;
14051               ++option;
14052             }
14053
14054           free (eopt);
14055         }
14056     }
14057
14058   if (conflicts_offset != 0 && conflictsno != 0)
14059     {
14060       Elf32_Conflict * iconf;
14061       size_t cnt;
14062
14063       if (dynamic_symbols == NULL)
14064         {
14065           error (_("conflict list found without a dynamic symbol table\n"));
14066           return 0;
14067         }
14068
14069       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
14070       if (iconf == NULL)
14071         {
14072           error (_("Out of memory allocating space for dynamic conflicts\n"));
14073           return 0;
14074         }
14075
14076       if (is_32bit_elf)
14077         {
14078           Elf32_External_Conflict * econf32;
14079
14080           econf32 = (Elf32_External_Conflict *)
14081               get_data (NULL, file, conflicts_offset, conflictsno,
14082                         sizeof (* econf32), _("conflict"));
14083           if (!econf32)
14084             return 0;
14085
14086           for (cnt = 0; cnt < conflictsno; ++cnt)
14087             iconf[cnt] = BYTE_GET (econf32[cnt]);
14088
14089           free (econf32);
14090         }
14091       else
14092         {
14093           Elf64_External_Conflict * econf64;
14094
14095           econf64 = (Elf64_External_Conflict *)
14096               get_data (NULL, file, conflicts_offset, conflictsno,
14097                         sizeof (* econf64), _("conflict"));
14098           if (!econf64)
14099             return 0;
14100
14101           for (cnt = 0; cnt < conflictsno; ++cnt)
14102             iconf[cnt] = BYTE_GET (econf64[cnt]);
14103
14104           free (econf64);
14105         }
14106
14107       printf (_("\nSection '.conflict' contains %lu entries:\n"),
14108               (unsigned long) conflictsno);
14109       puts (_("  Num:    Index       Value  Name"));
14110
14111       for (cnt = 0; cnt < conflictsno; ++cnt)
14112         {
14113           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
14114
14115           if (iconf[cnt] >= num_dynamic_syms)
14116             printf (_("<corrupt symbol index>"));
14117           else
14118             {
14119               Elf_Internal_Sym * psym;
14120
14121               psym = & dynamic_symbols[iconf[cnt]];
14122               print_vma (psym->st_value, FULL_HEX);
14123               putchar (' ');
14124               if (VALID_DYNAMIC_NAME (psym->st_name))
14125                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14126               else
14127                 printf (_("<corrupt: %14ld>"), psym->st_name);
14128             }
14129           putchar ('\n');
14130         }
14131
14132       free (iconf);
14133     }
14134
14135   if (pltgot != 0 && local_gotno != 0)
14136     {
14137       bfd_vma ent, local_end, global_end;
14138       size_t i, offset;
14139       unsigned char * data;
14140       unsigned char * data_end;
14141       int addr_size;
14142
14143       ent = pltgot;
14144       addr_size = (is_32bit_elf ? 4 : 8);
14145       local_end = pltgot + local_gotno * addr_size;
14146
14147       /* PR binutils/17533 file: 012-111227-0.004  */
14148       if (symtabno < gotsym)
14149         {
14150           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14151                  (unsigned long) gotsym, (unsigned long) symtabno);
14152           return 0;
14153         }
14154
14155       global_end = local_end + (symtabno - gotsym) * addr_size;
14156       /* PR 17531: file: 54c91a34.  */
14157       if (global_end < local_end)
14158         {
14159           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14160           return 0;
14161         }
14162
14163       offset = offset_from_vma (file, pltgot, global_end - pltgot);
14164       data = (unsigned char *) get_data (NULL, file, offset,
14165                                          global_end - pltgot, 1,
14166                                          _("Global Offset Table data"));
14167       if (data == NULL)
14168         return 0;
14169       data_end = data + (global_end - pltgot);
14170
14171       printf (_("\nPrimary GOT:\n"));
14172       printf (_(" Canonical gp value: "));
14173       print_vma (pltgot + 0x7ff0, LONG_HEX);
14174       printf ("\n\n");
14175
14176       printf (_(" Reserved entries:\n"));
14177       printf (_("  %*s %10s %*s Purpose\n"),
14178               addr_size * 2, _("Address"), _("Access"),
14179               addr_size * 2, _("Initial"));
14180       ent = print_mips_got_entry (data, pltgot, ent, data_end);
14181       printf (_(" Lazy resolver\n"));
14182       if (ent == (bfd_vma) -1)
14183         goto got_print_fail;
14184       if (data
14185           && (byte_get (data + ent - pltgot, addr_size)
14186               >> (addr_size * 8 - 1)) != 0)
14187         {
14188           ent = print_mips_got_entry (data, pltgot, ent, data_end);
14189           printf (_(" Module pointer (GNU extension)\n"));
14190           if (ent == (bfd_vma) -1)
14191             goto got_print_fail;
14192         }
14193       printf ("\n");
14194
14195       if (ent < local_end)
14196         {
14197           printf (_(" Local entries:\n"));
14198           printf ("  %*s %10s %*s\n",
14199                   addr_size * 2, _("Address"), _("Access"),
14200                   addr_size * 2, _("Initial"));
14201           while (ent < local_end)
14202             {
14203               ent = print_mips_got_entry (data, pltgot, ent, data_end);
14204               printf ("\n");
14205               if (ent == (bfd_vma) -1)
14206                 goto got_print_fail;
14207             }
14208           printf ("\n");
14209         }
14210
14211       if (gotsym < symtabno)
14212         {
14213           int sym_width;
14214
14215           printf (_(" Global entries:\n"));
14216           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
14217                   addr_size * 2, _("Address"),
14218                   _("Access"),
14219                   addr_size * 2, _("Initial"),
14220                   addr_size * 2, _("Sym.Val."),
14221                   _("Type"),
14222                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
14223                   _("Ndx"), _("Name"));
14224
14225           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
14226
14227           for (i = gotsym; i < symtabno; i++)
14228             {
14229               ent = print_mips_got_entry (data, pltgot, ent, data_end);
14230               printf (" ");
14231
14232               if (dynamic_symbols == NULL)
14233                 printf (_("<no dynamic symbols>"));
14234               else if (i < num_dynamic_syms)
14235                 {
14236                   Elf_Internal_Sym * psym = dynamic_symbols + i;
14237
14238                   print_vma (psym->st_value, LONG_HEX);
14239                   printf (" %-7s %3s ",
14240                           get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14241                           get_symbol_index_type (psym->st_shndx));
14242
14243                   if (VALID_DYNAMIC_NAME (psym->st_name))
14244                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14245                   else
14246                     printf (_("<corrupt: %14ld>"), psym->st_name);
14247                 }
14248               else
14249                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14250                         (unsigned long) i);
14251
14252               printf ("\n");
14253               if (ent == (bfd_vma) -1)
14254                 break;
14255             }
14256           printf ("\n");
14257         }
14258
14259     got_print_fail:
14260       if (data)
14261         free (data);
14262     }
14263
14264   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14265     {
14266       bfd_vma ent, end;
14267       size_t offset, rel_offset;
14268       unsigned long count, i;
14269       unsigned char * data;
14270       int addr_size, sym_width;
14271       Elf_Internal_Rela * rels;
14272
14273       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14274       if (pltrel == DT_RELA)
14275         {
14276           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14277             return 0;
14278         }
14279       else
14280         {
14281           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14282             return 0;
14283         }
14284
14285       ent = mips_pltgot;
14286       addr_size = (is_32bit_elf ? 4 : 8);
14287       end = mips_pltgot + (2 + count) * addr_size;
14288
14289       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
14290       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
14291                                          1, _("Procedure Linkage Table data"));
14292       if (data == NULL)
14293         return 0;
14294
14295       printf ("\nPLT GOT:\n\n");
14296       printf (_(" Reserved entries:\n"));
14297       printf (_("  %*s %*s Purpose\n"),
14298               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
14299       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14300       printf (_(" PLT lazy resolver\n"));
14301       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14302       printf (_(" Module pointer\n"));
14303       printf ("\n");
14304
14305       printf (_(" Entries:\n"));
14306       printf ("  %*s %*s %*s %-7s %3s %s\n",
14307               addr_size * 2, _("Address"),
14308               addr_size * 2, _("Initial"),
14309               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14310       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14311       for (i = 0; i < count; i++)
14312         {
14313           unsigned long idx = get_reloc_symindex (rels[i].r_info);
14314
14315           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14316           printf (" ");
14317
14318           if (idx >= num_dynamic_syms)
14319             printf (_("<corrupt symbol index: %lu>"), idx);
14320           else
14321             {
14322               Elf_Internal_Sym * psym = dynamic_symbols + idx;
14323
14324               print_vma (psym->st_value, LONG_HEX);
14325               printf (" %-7s %3s ",
14326                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14327                       get_symbol_index_type (psym->st_shndx));
14328               if (VALID_DYNAMIC_NAME (psym->st_name))
14329                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14330               else
14331                 printf (_("<corrupt: %14ld>"), psym->st_name);
14332             }
14333           printf ("\n");
14334         }
14335       printf ("\n");
14336
14337       if (data)
14338         free (data);
14339       free (rels);
14340     }
14341
14342   return 1;
14343 }
14344
14345 static int
14346 process_nds32_specific (FILE * file)
14347 {
14348   Elf_Internal_Shdr *sect = NULL;
14349
14350   sect = find_section (".nds32_e_flags");
14351   if (sect != NULL)
14352     {
14353       unsigned int *flag;
14354
14355       printf ("\nNDS32 elf flags section:\n");
14356       flag = get_data (NULL, file, sect->sh_offset, 1,
14357                        sect->sh_size, _("NDS32 elf flags section"));
14358
14359       switch ((*flag) & 0x3)
14360         {
14361         case 0:
14362           printf ("(VEC_SIZE):\tNo entry.\n");
14363           break;
14364         case 1:
14365           printf ("(VEC_SIZE):\t4 bytes\n");
14366           break;
14367         case 2:
14368           printf ("(VEC_SIZE):\t16 bytes\n");
14369           break;
14370         case 3:
14371           printf ("(VEC_SIZE):\treserved\n");
14372           break;
14373         }
14374     }
14375
14376   return TRUE;
14377 }
14378
14379 static int
14380 process_gnu_liblist (FILE * file)
14381 {
14382   Elf_Internal_Shdr * section;
14383   Elf_Internal_Shdr * string_sec;
14384   Elf32_External_Lib * elib;
14385   char * strtab;
14386   size_t strtab_size;
14387   size_t cnt;
14388   unsigned i;
14389
14390   if (! do_arch)
14391     return 0;
14392
14393   for (i = 0, section = section_headers;
14394        i < elf_header.e_shnum;
14395        i++, section++)
14396     {
14397       switch (section->sh_type)
14398         {
14399         case SHT_GNU_LIBLIST:
14400           if (section->sh_link >= elf_header.e_shnum)
14401             break;
14402
14403           elib = (Elf32_External_Lib *)
14404               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
14405                         _("liblist section data"));
14406
14407           if (elib == NULL)
14408             break;
14409           string_sec = section_headers + section->sh_link;
14410
14411           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14412                                       string_sec->sh_size,
14413                                       _("liblist string table"));
14414           if (strtab == NULL
14415               || section->sh_entsize != sizeof (Elf32_External_Lib))
14416             {
14417               free (elib);
14418               free (strtab);
14419               break;
14420             }
14421           strtab_size = string_sec->sh_size;
14422
14423           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14424                   printable_section_name (section),
14425                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
14426
14427           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
14428
14429           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14430                ++cnt)
14431             {
14432               Elf32_Lib liblist;
14433               time_t atime;
14434               char timebuf[20];
14435               struct tm * tmp;
14436
14437               liblist.l_name = BYTE_GET (elib[cnt].l_name);
14438               atime = BYTE_GET (elib[cnt].l_time_stamp);
14439               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14440               liblist.l_version = BYTE_GET (elib[cnt].l_version);
14441               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14442
14443               tmp = gmtime (&atime);
14444               snprintf (timebuf, sizeof (timebuf),
14445                         "%04u-%02u-%02uT%02u:%02u:%02u",
14446                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14447                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14448
14449               printf ("%3lu: ", (unsigned long) cnt);
14450               if (do_wide)
14451                 printf ("%-20s", liblist.l_name < strtab_size
14452                         ? strtab + liblist.l_name : _("<corrupt>"));
14453               else
14454                 printf ("%-20.20s", liblist.l_name < strtab_size
14455                         ? strtab + liblist.l_name : _("<corrupt>"));
14456               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14457                       liblist.l_version, liblist.l_flags);
14458             }
14459
14460           free (elib);
14461           free (strtab);
14462         }
14463     }
14464
14465   return 1;
14466 }
14467
14468 static const char *
14469 get_note_type (unsigned e_type)
14470 {
14471   static char buff[64];
14472
14473   if (elf_header.e_type == ET_CORE)
14474     switch (e_type)
14475       {
14476       case NT_AUXV:
14477         return _("NT_AUXV (auxiliary vector)");
14478       case NT_PRSTATUS:
14479         return _("NT_PRSTATUS (prstatus structure)");
14480       case NT_FPREGSET:
14481         return _("NT_FPREGSET (floating point registers)");
14482       case NT_PRPSINFO:
14483         return _("NT_PRPSINFO (prpsinfo structure)");
14484       case NT_TASKSTRUCT:
14485         return _("NT_TASKSTRUCT (task structure)");
14486       case NT_PRXFPREG:
14487         return _("NT_PRXFPREG (user_xfpregs structure)");
14488       case NT_PPC_VMX:
14489         return _("NT_PPC_VMX (ppc Altivec registers)");
14490       case NT_PPC_VSX:
14491         return _("NT_PPC_VSX (ppc VSX registers)");
14492       case NT_386_TLS:
14493         return _("NT_386_TLS (x86 TLS information)");
14494       case NT_386_IOPERM:
14495         return _("NT_386_IOPERM (x86 I/O permissions)");
14496       case NT_X86_XSTATE:
14497         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14498       case NT_S390_HIGH_GPRS:
14499         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14500       case NT_S390_TIMER:
14501         return _("NT_S390_TIMER (s390 timer register)");
14502       case NT_S390_TODCMP:
14503         return _("NT_S390_TODCMP (s390 TOD comparator register)");
14504       case NT_S390_TODPREG:
14505         return _("NT_S390_TODPREG (s390 TOD programmable register)");
14506       case NT_S390_CTRS:
14507         return _("NT_S390_CTRS (s390 control registers)");
14508       case NT_S390_PREFIX:
14509         return _("NT_S390_PREFIX (s390 prefix register)");
14510       case NT_S390_LAST_BREAK:
14511         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14512       case NT_S390_SYSTEM_CALL:
14513         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14514       case NT_S390_TDB:
14515         return _("NT_S390_TDB (s390 transaction diagnostic block)");
14516       case NT_ARM_VFP:
14517         return _("NT_ARM_VFP (arm VFP registers)");
14518       case NT_ARM_TLS:
14519         return _("NT_ARM_TLS (AArch TLS registers)");
14520       case NT_ARM_HW_BREAK:
14521         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14522       case NT_ARM_HW_WATCH:
14523         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14524       case NT_PSTATUS:
14525         return _("NT_PSTATUS (pstatus structure)");
14526       case NT_FPREGS:
14527         return _("NT_FPREGS (floating point registers)");
14528       case NT_PSINFO:
14529         return _("NT_PSINFO (psinfo structure)");
14530       case NT_LWPSTATUS:
14531         return _("NT_LWPSTATUS (lwpstatus_t structure)");
14532       case NT_LWPSINFO:
14533         return _("NT_LWPSINFO (lwpsinfo_t structure)");
14534       case NT_WIN32PSTATUS:
14535         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14536       case NT_SIGINFO:
14537         return _("NT_SIGINFO (siginfo_t data)");
14538       case NT_FILE:
14539         return _("NT_FILE (mapped files)");
14540       default:
14541         break;
14542       }
14543   else
14544     switch (e_type)
14545       {
14546       case NT_VERSION:
14547         return _("NT_VERSION (version)");
14548       case NT_ARCH:
14549         return _("NT_ARCH (architecture)");
14550       default:
14551         break;
14552       }
14553
14554   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14555   return buff;
14556 }
14557
14558 static int
14559 print_core_note (Elf_Internal_Note *pnote)
14560 {
14561   unsigned int addr_size = is_32bit_elf ? 4 : 8;
14562   bfd_vma count, page_size;
14563   unsigned char *descdata, *filenames, *descend;
14564
14565   if (pnote->type != NT_FILE)
14566     return 1;
14567
14568 #ifndef BFD64
14569   if (!is_32bit_elf)
14570     {
14571       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
14572       /* Still "successful".  */
14573       return 1;
14574     }
14575 #endif
14576
14577   if (pnote->descsz < 2 * addr_size)
14578     {
14579       printf (_("    Malformed note - too short for header\n"));
14580       return 0;
14581     }
14582
14583   descdata = (unsigned char *) pnote->descdata;
14584   descend = descdata + pnote->descsz;
14585
14586   if (descdata[pnote->descsz - 1] != '\0')
14587     {
14588       printf (_("    Malformed note - does not end with \\0\n"));
14589       return 0;
14590     }
14591
14592   count = byte_get (descdata, addr_size);
14593   descdata += addr_size;
14594
14595   page_size = byte_get (descdata, addr_size);
14596   descdata += addr_size;
14597
14598   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
14599     {
14600       printf (_("    Malformed note - too short for supplied file count\n"));
14601       return 0;
14602     }
14603
14604   printf (_("    Page size: "));
14605   print_vma (page_size, DEC);
14606   printf ("\n");
14607
14608   printf (_("    %*s%*s%*s\n"),
14609           (int) (2 + 2 * addr_size), _("Start"),
14610           (int) (4 + 2 * addr_size), _("End"),
14611           (int) (4 + 2 * addr_size), _("Page Offset"));
14612   filenames = descdata + count * 3 * addr_size;
14613   while (--count > 0)
14614     {
14615       bfd_vma start, end, file_ofs;
14616
14617       if (filenames == descend)
14618         {
14619           printf (_("    Malformed note - filenames end too early\n"));
14620           return 0;
14621         }
14622
14623       start = byte_get (descdata, addr_size);
14624       descdata += addr_size;
14625       end = byte_get (descdata, addr_size);
14626       descdata += addr_size;
14627       file_ofs = byte_get (descdata, addr_size);
14628       descdata += addr_size;
14629
14630       printf ("    ");
14631       print_vma (start, FULL_HEX);
14632       printf ("  ");
14633       print_vma (end, FULL_HEX);
14634       printf ("  ");
14635       print_vma (file_ofs, FULL_HEX);
14636       printf ("\n        %s\n", filenames);
14637
14638       filenames += 1 + strlen ((char *) filenames);
14639     }
14640
14641   return 1;
14642 }
14643
14644 static const char *
14645 get_gnu_elf_note_type (unsigned e_type)
14646 {
14647   static char buff[64];
14648
14649   switch (e_type)
14650     {
14651     case NT_GNU_ABI_TAG:
14652       return _("NT_GNU_ABI_TAG (ABI version tag)");
14653     case NT_GNU_HWCAP:
14654       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14655     case NT_GNU_BUILD_ID:
14656       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
14657     case NT_GNU_GOLD_VERSION:
14658       return _("NT_GNU_GOLD_VERSION (gold version)");
14659     default:
14660       break;
14661     }
14662
14663   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14664   return buff;
14665 }
14666
14667 static int
14668 print_gnu_note (Elf_Internal_Note *pnote)
14669 {
14670   switch (pnote->type)
14671     {
14672     case NT_GNU_BUILD_ID:
14673       {
14674         unsigned long i;
14675
14676         printf (_("    Build ID: "));
14677         for (i = 0; i < pnote->descsz; ++i)
14678           printf ("%02x", pnote->descdata[i] & 0xff);
14679         printf ("\n");
14680       }
14681       break;
14682
14683     case NT_GNU_ABI_TAG:
14684       {
14685         unsigned long os, major, minor, subminor;
14686         const char *osname;
14687
14688         /* PR 17531: file: 030-599401-0.004.  */
14689         if (pnote->descsz < 16)
14690           {
14691             printf (_("    <corrupt GNU_ABI_TAG>\n"));
14692             break;
14693           }
14694
14695         os = byte_get ((unsigned char *) pnote->descdata, 4);
14696         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
14697         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
14698         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
14699
14700         switch (os)
14701           {
14702           case GNU_ABI_TAG_LINUX:
14703             osname = "Linux";
14704             break;
14705           case GNU_ABI_TAG_HURD:
14706             osname = "Hurd";
14707             break;
14708           case GNU_ABI_TAG_SOLARIS:
14709             osname = "Solaris";
14710             break;
14711           case GNU_ABI_TAG_FREEBSD:
14712             osname = "FreeBSD";
14713             break;
14714           case GNU_ABI_TAG_NETBSD:
14715             osname = "NetBSD";
14716             break;
14717           default:
14718             osname = "Unknown";
14719             break;
14720           }
14721
14722         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
14723                 major, minor, subminor);
14724       }
14725       break;
14726
14727     case NT_GNU_GOLD_VERSION:
14728       {
14729         unsigned long i;
14730
14731         printf (_("    Version: "));
14732         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
14733           printf ("%c", pnote->descdata[i]);
14734         printf ("\n");
14735       }
14736       break;
14737     }
14738
14739   return 1;
14740 }
14741
14742 static const char *
14743 get_netbsd_elfcore_note_type (unsigned e_type)
14744 {
14745   static char buff[64];
14746
14747   if (e_type == NT_NETBSDCORE_PROCINFO)
14748     {
14749       /* NetBSD core "procinfo" structure.  */
14750       return _("NetBSD procinfo structure");
14751     }
14752
14753   /* As of Jan 2002 there are no other machine-independent notes
14754      defined for NetBSD core files.  If the note type is less
14755      than the start of the machine-dependent note types, we don't
14756      understand it.  */
14757
14758   if (e_type < NT_NETBSDCORE_FIRSTMACH)
14759     {
14760       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14761       return buff;
14762     }
14763
14764   switch (elf_header.e_machine)
14765     {
14766     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14767        and PT_GETFPREGS == mach+2.  */
14768
14769     case EM_OLD_ALPHA:
14770     case EM_ALPHA:
14771     case EM_SPARC:
14772     case EM_SPARC32PLUS:
14773     case EM_SPARCV9:
14774       switch (e_type)
14775         {
14776         case NT_NETBSDCORE_FIRSTMACH + 0:
14777           return _("PT_GETREGS (reg structure)");
14778         case NT_NETBSDCORE_FIRSTMACH + 2:
14779           return _("PT_GETFPREGS (fpreg structure)");
14780         default:
14781           break;
14782         }
14783       break;
14784
14785     /* On all other arch's, PT_GETREGS == mach+1 and
14786        PT_GETFPREGS == mach+3.  */
14787     default:
14788       switch (e_type)
14789         {
14790         case NT_NETBSDCORE_FIRSTMACH + 1:
14791           return _("PT_GETREGS (reg structure)");
14792         case NT_NETBSDCORE_FIRSTMACH + 3:
14793           return _("PT_GETFPREGS (fpreg structure)");
14794         default:
14795           break;
14796         }
14797     }
14798
14799   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
14800             e_type - NT_NETBSDCORE_FIRSTMACH);
14801   return buff;
14802 }
14803
14804 static const char *
14805 get_stapsdt_note_type (unsigned e_type)
14806 {
14807   static char buff[64];
14808
14809   switch (e_type)
14810     {
14811     case NT_STAPSDT:
14812       return _("NT_STAPSDT (SystemTap probe descriptors)");
14813
14814     default:
14815       break;
14816     }
14817
14818   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14819   return buff;
14820 }
14821
14822 static int
14823 print_stapsdt_note (Elf_Internal_Note *pnote)
14824 {
14825   int addr_size = is_32bit_elf ? 4 : 8;
14826   char *data = pnote->descdata;
14827   char *data_end = pnote->descdata + pnote->descsz;
14828   bfd_vma pc, base_addr, semaphore;
14829   char *provider, *probe, *arg_fmt;
14830
14831   pc = byte_get ((unsigned char *) data, addr_size);
14832   data += addr_size;
14833   base_addr = byte_get ((unsigned char *) data, addr_size);
14834   data += addr_size;
14835   semaphore = byte_get ((unsigned char *) data, addr_size);
14836   data += addr_size;
14837
14838   provider = data;
14839   data += strlen (data) + 1;
14840   probe = data;
14841   data += strlen (data) + 1;
14842   arg_fmt = data;
14843   data += strlen (data) + 1;
14844
14845   printf (_("    Provider: %s\n"), provider);
14846   printf (_("    Name: %s\n"), probe);
14847   printf (_("    Location: "));
14848   print_vma (pc, FULL_HEX);
14849   printf (_(", Base: "));
14850   print_vma (base_addr, FULL_HEX);
14851   printf (_(", Semaphore: "));
14852   print_vma (semaphore, FULL_HEX);
14853   printf ("\n");
14854   printf (_("    Arguments: %s\n"), arg_fmt);
14855
14856   return data == data_end;
14857 }
14858
14859 static const char *
14860 get_ia64_vms_note_type (unsigned e_type)
14861 {
14862   static char buff[64];
14863
14864   switch (e_type)
14865     {
14866     case NT_VMS_MHD:
14867       return _("NT_VMS_MHD (module header)");
14868     case NT_VMS_LNM:
14869       return _("NT_VMS_LNM (language name)");
14870     case NT_VMS_SRC:
14871       return _("NT_VMS_SRC (source files)");
14872     case NT_VMS_TITLE:
14873       return "NT_VMS_TITLE";
14874     case NT_VMS_EIDC:
14875       return _("NT_VMS_EIDC (consistency check)");
14876     case NT_VMS_FPMODE:
14877       return _("NT_VMS_FPMODE (FP mode)");
14878     case NT_VMS_LINKTIME:
14879       return "NT_VMS_LINKTIME";
14880     case NT_VMS_IMGNAM:
14881       return _("NT_VMS_IMGNAM (image name)");
14882     case NT_VMS_IMGID:
14883       return _("NT_VMS_IMGID (image id)");
14884     case NT_VMS_LINKID:
14885       return _("NT_VMS_LINKID (link id)");
14886     case NT_VMS_IMGBID:
14887       return _("NT_VMS_IMGBID (build id)");
14888     case NT_VMS_GSTNAM:
14889       return _("NT_VMS_GSTNAM (sym table name)");
14890     case NT_VMS_ORIG_DYN:
14891       return "NT_VMS_ORIG_DYN";
14892     case NT_VMS_PATCHTIME:
14893       return "NT_VMS_PATCHTIME";
14894     default:
14895       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14896       return buff;
14897     }
14898 }
14899
14900 static int
14901 print_ia64_vms_note (Elf_Internal_Note * pnote)
14902 {
14903   switch (pnote->type)
14904     {
14905     case NT_VMS_MHD:
14906       if (pnote->descsz > 36)
14907         {
14908           size_t l = strlen (pnote->descdata + 34);
14909           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
14910           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
14911           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
14912           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
14913         }
14914       else
14915         printf (_("    Invalid size\n"));
14916       break;
14917     case NT_VMS_LNM:
14918       printf (_("   Language: %s\n"), pnote->descdata);
14919       break;
14920 #ifdef BFD64
14921     case NT_VMS_FPMODE:
14922       printf (_("   Floating Point mode: "));
14923       printf ("0x%016" BFD_VMA_FMT "x\n",
14924               (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
14925       break;
14926     case NT_VMS_LINKTIME:
14927       printf (_("   Link time: "));
14928       print_vms_time
14929         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14930       printf ("\n");
14931       break;
14932     case NT_VMS_PATCHTIME:
14933       printf (_("   Patch time: "));
14934       print_vms_time
14935         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14936       printf ("\n");
14937       break;
14938     case NT_VMS_ORIG_DYN:
14939       printf (_("   Major id: %u,  minor id: %u\n"),
14940               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
14941               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
14942       printf (_("   Last modified  : "));
14943       print_vms_time
14944         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
14945       printf (_("\n   Link flags  : "));
14946       printf ("0x%016" BFD_VMA_FMT "x\n",
14947               (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
14948       printf (_("   Header flags: 0x%08x\n"),
14949               (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
14950       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
14951       break;
14952 #endif
14953     case NT_VMS_IMGNAM:
14954       printf (_("    Image name: %s\n"), pnote->descdata);
14955       break;
14956     case NT_VMS_GSTNAM:
14957       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
14958       break;
14959     case NT_VMS_IMGID:
14960       printf (_("    Image id: %s\n"), pnote->descdata);
14961       break;
14962     case NT_VMS_LINKID:
14963       printf (_("    Linker id: %s\n"), pnote->descdata);
14964       break;
14965     default:
14966       break;
14967     }
14968   return 1;
14969 }
14970
14971 /* Note that by the ELF standard, the name field is already null byte
14972    terminated, and namesz includes the terminating null byte.
14973    I.E. the value of namesz for the name "FSF" is 4.
14974
14975    If the value of namesz is zero, there is no name present.  */
14976 static int
14977 process_note (Elf_Internal_Note * pnote)
14978 {
14979   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
14980   const char * nt;
14981
14982   if (pnote->namesz == 0)
14983     /* If there is no note name, then use the default set of
14984        note type strings.  */
14985     nt = get_note_type (pnote->type);
14986
14987   else if (const_strneq (pnote->namedata, "GNU"))
14988     /* GNU-specific object file notes.  */
14989     nt = get_gnu_elf_note_type (pnote->type);
14990
14991   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
14992     /* NetBSD-specific core file notes.  */
14993     nt = get_netbsd_elfcore_note_type (pnote->type);
14994
14995   else if (strneq (pnote->namedata, "SPU/", 4))
14996     {
14997       /* SPU-specific core file notes.  */
14998       nt = pnote->namedata + 4;
14999       name = "SPU";
15000     }
15001
15002   else if (const_strneq (pnote->namedata, "IPF/VMS"))
15003     /* VMS/ia64-specific file notes.  */
15004     nt = get_ia64_vms_note_type (pnote->type);
15005
15006   else if (const_strneq (pnote->namedata, "stapsdt"))
15007     nt = get_stapsdt_note_type (pnote->type);
15008
15009   else
15010     /* Don't recognize this note name; just use the default set of
15011        note type strings.  */
15012     nt = get_note_type (pnote->type);
15013
15014   printf ("  %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
15015
15016   if (const_strneq (pnote->namedata, "IPF/VMS"))
15017     return print_ia64_vms_note (pnote);
15018   else if (const_strneq (pnote->namedata, "GNU"))
15019     return print_gnu_note (pnote);
15020   else if (const_strneq (pnote->namedata, "stapsdt"))
15021     return print_stapsdt_note (pnote);
15022   else if (const_strneq (pnote->namedata, "CORE"))
15023     return print_core_note (pnote);
15024   else
15025     return 1;
15026 }
15027
15028
15029 static int
15030 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
15031 {
15032   Elf_External_Note * pnotes;
15033   Elf_External_Note * external;
15034   int res = 1;
15035
15036   if (length <= 0)
15037     return 0;
15038
15039   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15040                                            _("notes"));
15041   if (pnotes == NULL)
15042     return 0;
15043
15044   external = pnotes;
15045
15046   printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15047           (unsigned long) offset, (unsigned long) length);
15048   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15049
15050   while ((char *) external < (char *) pnotes + length)
15051     {
15052       Elf_Internal_Note inote;
15053       size_t min_notesz;
15054       char *next;
15055       char * temp = NULL;
15056       size_t data_remaining = ((char *) pnotes + length) - (char *) external;
15057
15058       if (!is_ia64_vms ())
15059         {
15060           /* PR binutils/15191
15061              Make sure that there is enough data to read.  */
15062           min_notesz = offsetof (Elf_External_Note, name);
15063           if (data_remaining < min_notesz)
15064             {
15065               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15066                     (int) data_remaining);
15067               break;
15068             }
15069           inote.type     = BYTE_GET (external->type);
15070           inote.namesz   = BYTE_GET (external->namesz);
15071           inote.namedata = external->name;
15072           inote.descsz   = BYTE_GET (external->descsz);
15073           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15074           /* PR 17531: file: 3443835e.  */
15075           if (inote.descdata < (char *) pnotes)
15076             {
15077               warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15078               inote.descdata = inote.namedata;
15079               inote.namesz   = 0;
15080             }
15081           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15082           next = inote.descdata + align_power (inote.descsz, 2);
15083         }
15084       else
15085         {
15086           Elf64_External_VMS_Note *vms_external;
15087
15088           /* PR binutils/15191
15089              Make sure that there is enough data to read.  */
15090           min_notesz = offsetof (Elf64_External_VMS_Note, name);
15091           if (data_remaining < min_notesz)
15092             {
15093               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15094                     (int) data_remaining);
15095               break;
15096             }
15097
15098           vms_external = (Elf64_External_VMS_Note *) external;
15099           inote.type     = BYTE_GET (vms_external->type);
15100           inote.namesz   = BYTE_GET (vms_external->namesz);
15101           inote.namedata = vms_external->name;
15102           inote.descsz   = BYTE_GET (vms_external->descsz);
15103           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15104           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
15105           next = inote.descdata + align_power (inote.descsz, 3);
15106         }
15107
15108       if (inote.descdata < (char *) external + min_notesz
15109           || next < (char *) external + min_notesz
15110           /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
15111           || inote.namedata + inote.namesz < inote.namedata
15112           || inote.descdata + inote.descsz < inote.descdata
15113           || data_remaining < (size_t)(next - (char *) external))
15114         {
15115           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15116                 (unsigned long) ((char *) external - (char *) pnotes));
15117           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15118                 inote.type, inote.namesz, inote.descsz);
15119           break;
15120         }
15121
15122       external = (Elf_External_Note *) next;
15123
15124       /* Verify that name is null terminated.  It appears that at least
15125          one version of Linux (RedHat 6.0) generates corefiles that don't
15126          comply with the ELF spec by failing to include the null byte in
15127          namesz.  */
15128       if (inote.namedata[inote.namesz - 1] != '\0')
15129         {
15130           temp = (char *) malloc (inote.namesz + 1);
15131           if (temp == NULL)
15132             {
15133               error (_("Out of memory allocating space for inote name\n"));
15134               res = 0;
15135               break;
15136             }
15137
15138           strncpy (temp, inote.namedata, inote.namesz);
15139           temp[inote.namesz] = 0;
15140
15141           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
15142           inote.namedata = temp;
15143         }
15144
15145       res &= process_note (& inote);
15146
15147       if (temp != NULL)
15148         {
15149           free (temp);
15150           temp = NULL;
15151         }
15152     }
15153
15154   free (pnotes);
15155
15156   return res;
15157 }
15158
15159 static int
15160 process_corefile_note_segments (FILE * file)
15161 {
15162   Elf_Internal_Phdr * segment;
15163   unsigned int i;
15164   int res = 1;
15165
15166   if (! get_program_headers (file))
15167       return 0;
15168
15169   for (i = 0, segment = program_headers;
15170        i < elf_header.e_phnum;
15171        i++, segment++)
15172     {
15173       if (segment->p_type == PT_NOTE)
15174         res &= process_corefile_note_segment (file,
15175                                               (bfd_vma) segment->p_offset,
15176                                               (bfd_vma) segment->p_filesz);
15177     }
15178
15179   return res;
15180 }
15181
15182 static int
15183 process_note_sections (FILE * file)
15184 {
15185   Elf_Internal_Shdr * section;
15186   unsigned long i;
15187   int n = 0;
15188   int res = 1;
15189
15190   for (i = 0, section = section_headers;
15191        i < elf_header.e_shnum && section != NULL;
15192        i++, section++)
15193     if (section->sh_type == SHT_NOTE)
15194       {
15195         res &= process_corefile_note_segment (file,
15196                                               (bfd_vma) section->sh_offset,
15197                                               (bfd_vma) section->sh_size);
15198         n++;
15199       }
15200
15201   if (n == 0)
15202     /* Try processing NOTE segments instead.  */
15203     return process_corefile_note_segments (file);
15204
15205   return res;
15206 }
15207
15208 static int
15209 process_notes (FILE * file)
15210 {
15211   /* If we have not been asked to display the notes then do nothing.  */
15212   if (! do_notes)
15213     return 1;
15214
15215   if (elf_header.e_type != ET_CORE)
15216     return process_note_sections (file);
15217
15218   /* No program headers means no NOTE segment.  */
15219   if (elf_header.e_phnum > 0)
15220     return process_corefile_note_segments (file);
15221
15222   printf (_("No note segments present in the core file.\n"));
15223   return 1;
15224 }
15225
15226 static int
15227 process_arch_specific (FILE * file)
15228 {
15229   if (! do_arch)
15230     return 1;
15231
15232   switch (elf_header.e_machine)
15233     {
15234     case EM_ARM:
15235       return process_arm_specific (file);
15236     case EM_MIPS:
15237     case EM_MIPS_RS3_LE:
15238       return process_mips_specific (file);
15239       break;
15240     case EM_NDS32:
15241       return process_nds32_specific (file);
15242       break;
15243     case EM_PPC:
15244       return process_power_specific (file);
15245       break;
15246     case EM_SPARC:
15247     case EM_SPARC32PLUS:
15248     case EM_SPARCV9:
15249       return process_sparc_specific (file);
15250       break;
15251     case EM_TI_C6000:
15252       return process_tic6x_specific (file);
15253       break;
15254     case EM_MSP430:
15255       return process_msp430x_specific (file);
15256     default:
15257       break;
15258     }
15259   return 1;
15260 }
15261
15262 static int
15263 get_file_header (FILE * file)
15264 {
15265   /* Read in the identity array.  */
15266   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
15267     return 0;
15268
15269   /* Determine how to read the rest of the header.  */
15270   switch (elf_header.e_ident[EI_DATA])
15271     {
15272     default: /* fall through */
15273     case ELFDATANONE: /* fall through */
15274     case ELFDATA2LSB:
15275       byte_get = byte_get_little_endian;
15276       byte_put = byte_put_little_endian;
15277       break;
15278     case ELFDATA2MSB:
15279       byte_get = byte_get_big_endian;
15280       byte_put = byte_put_big_endian;
15281       break;
15282     }
15283
15284   /* For now we only support 32 bit and 64 bit ELF files.  */
15285   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
15286
15287   /* Read in the rest of the header.  */
15288   if (is_32bit_elf)
15289     {
15290       Elf32_External_Ehdr ehdr32;
15291
15292       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15293         return 0;
15294
15295       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
15296       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
15297       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
15298       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
15299       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
15300       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
15301       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
15302       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
15303       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15304       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
15305       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15306       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
15307       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
15308     }
15309   else
15310     {
15311       Elf64_External_Ehdr ehdr64;
15312
15313       /* If we have been compiled with sizeof (bfd_vma) == 4, then
15314          we will not be able to cope with the 64bit data found in
15315          64 ELF files.  Detect this now and abort before we start
15316          overwriting things.  */
15317       if (sizeof (bfd_vma) < 8)
15318         {
15319           error (_("This instance of readelf has been built without support for a\n\
15320 64 bit data type and so it cannot read 64 bit ELF files.\n"));
15321           return 0;
15322         }
15323
15324       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15325         return 0;
15326
15327       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
15328       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
15329       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
15330       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
15331       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
15332       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
15333       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
15334       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
15335       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15336       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
15337       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15338       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
15339       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
15340     }
15341
15342   if (elf_header.e_shoff)
15343     {
15344       /* There may be some extensions in the first section header.  Don't
15345          bomb if we can't read it.  */
15346       if (is_32bit_elf)
15347         get_32bit_section_headers (file, TRUE);
15348       else
15349         get_64bit_section_headers (file, TRUE);
15350     }
15351
15352   return 1;
15353 }
15354
15355 /* Process one ELF object file according to the command line options.
15356    This file may actually be stored in an archive.  The file is
15357    positioned at the start of the ELF object.  */
15358
15359 static int
15360 process_object (char * file_name, FILE * file)
15361 {
15362   unsigned int i;
15363
15364   if (! get_file_header (file))
15365     {
15366       error (_("%s: Failed to read file header\n"), file_name);
15367       return 1;
15368     }
15369
15370   /* Initialise per file variables.  */
15371   for (i = ARRAY_SIZE (version_info); i--;)
15372     version_info[i] = 0;
15373
15374   for (i = ARRAY_SIZE (dynamic_info); i--;)
15375     dynamic_info[i] = 0;
15376   dynamic_info_DT_GNU_HASH = 0;
15377
15378   /* Process the file.  */
15379   if (show_name)
15380     printf (_("\nFile: %s\n"), file_name);
15381
15382   /* Initialise the dump_sects array from the cmdline_dump_sects array.
15383      Note we do this even if cmdline_dump_sects is empty because we
15384      must make sure that the dump_sets array is zeroed out before each
15385      object file is processed.  */
15386   if (num_dump_sects > num_cmdline_dump_sects)
15387     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
15388
15389   if (num_cmdline_dump_sects > 0)
15390     {
15391       if (num_dump_sects == 0)
15392         /* A sneaky way of allocating the dump_sects array.  */
15393         request_dump_bynumber (num_cmdline_dump_sects, 0);
15394
15395       assert (num_dump_sects >= num_cmdline_dump_sects);
15396       memcpy (dump_sects, cmdline_dump_sects,
15397               num_cmdline_dump_sects * sizeof (* dump_sects));
15398     }
15399
15400   if (! process_file_header ())
15401     return 1;
15402
15403   if (! process_section_headers (file))
15404     {
15405       /* Without loaded section headers we cannot process lots of
15406          things.  */
15407       do_unwind = do_version = do_dump = do_arch = 0;
15408
15409       if (! do_using_dynamic)
15410         do_syms = do_dyn_syms = do_reloc = 0;
15411     }
15412
15413   if (! process_section_groups (file))
15414     {
15415       /* Without loaded section groups we cannot process unwind.  */
15416       do_unwind = 0;
15417     }
15418
15419   if (process_program_headers (file))
15420     process_dynamic_section (file);
15421
15422   process_relocs (file);
15423
15424   process_unwind (file);
15425
15426   process_symbol_table (file);
15427
15428   process_syminfo (file);
15429
15430   process_version_sections (file);
15431
15432   process_section_contents (file);
15433
15434   process_notes (file);
15435
15436   process_gnu_liblist (file);
15437
15438   process_arch_specific (file);
15439
15440   if (program_headers)
15441     {
15442       free (program_headers);
15443       program_headers = NULL;
15444     }
15445
15446   if (section_headers)
15447     {
15448       free (section_headers);
15449       section_headers = NULL;
15450     }
15451
15452   if (string_table)
15453     {
15454       free (string_table);
15455       string_table = NULL;
15456       string_table_length = 0;
15457     }
15458
15459   if (dynamic_strings)
15460     {
15461       free (dynamic_strings);
15462       dynamic_strings = NULL;
15463       dynamic_strings_length = 0;
15464     }
15465
15466   if (dynamic_symbols)
15467     {
15468       free (dynamic_symbols);
15469       dynamic_symbols = NULL;
15470       num_dynamic_syms = 0;
15471     }
15472
15473   if (dynamic_syminfo)
15474     {
15475       free (dynamic_syminfo);
15476       dynamic_syminfo = NULL;
15477     }
15478
15479   if (dynamic_section)
15480     {
15481       free (dynamic_section);
15482       dynamic_section = NULL;
15483     }
15484
15485   if (section_headers_groups)
15486     {
15487       free (section_headers_groups);
15488       section_headers_groups = NULL;
15489     }
15490
15491   if (section_groups)
15492     {
15493       struct group_list * g;
15494       struct group_list * next;
15495
15496       for (i = 0; i < group_count; i++)
15497         {
15498           for (g = section_groups [i].root; g != NULL; g = next)
15499             {
15500               next = g->next;
15501               free (g);
15502             }
15503         }
15504
15505       free (section_groups);
15506       section_groups = NULL;
15507     }
15508
15509   free_debug_memory ();
15510
15511   return 0;
15512 }
15513
15514 /* Process an ELF archive.
15515    On entry the file is positioned just after the ARMAG string.  */
15516
15517 static int
15518 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
15519 {
15520   struct archive_info arch;
15521   struct archive_info nested_arch;
15522   size_t got;
15523   int ret;
15524
15525   show_name = 1;
15526
15527   /* The ARCH structure is used to hold information about this archive.  */
15528   arch.file_name = NULL;
15529   arch.file = NULL;
15530   arch.index_array = NULL;
15531   arch.sym_table = NULL;
15532   arch.longnames = NULL;
15533
15534   /* The NESTED_ARCH structure is used as a single-item cache of information
15535      about a nested archive (when members of a thin archive reside within
15536      another regular archive file).  */
15537   nested_arch.file_name = NULL;
15538   nested_arch.file = NULL;
15539   nested_arch.index_array = NULL;
15540   nested_arch.sym_table = NULL;
15541   nested_arch.longnames = NULL;
15542
15543   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
15544     {
15545       ret = 1;
15546       goto out;
15547     }
15548
15549   if (do_archive_index)
15550     {
15551       if (arch.sym_table == NULL)
15552         error (_("%s: unable to dump the index as none was found\n"), file_name);
15553       else
15554         {
15555           unsigned long i, l;
15556           unsigned long current_pos;
15557
15558           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
15559                   file_name, (unsigned long) arch.index_num, arch.sym_size);
15560           current_pos = ftell (file);
15561
15562           for (i = l = 0; i < arch.index_num; i++)
15563             {
15564               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
15565                 {
15566                   char * member_name;
15567
15568                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
15569
15570                   if (member_name != NULL)
15571                     {
15572                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
15573
15574                       if (qualified_name != NULL)
15575                         {
15576                           printf (_("Contents of binary %s at offset "), qualified_name);
15577                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
15578                           putchar ('\n');
15579                           free (qualified_name);
15580                         }
15581                     }
15582                 }
15583
15584               if (l >= arch.sym_size)
15585                 {
15586                   error (_("%s: end of the symbol table reached before the end of the index\n"),
15587                          file_name);
15588                   break;
15589                 }
15590               /* PR 17531: file: 0b6630b2.  */
15591               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
15592               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
15593             }
15594
15595           if (arch.uses_64bit_indicies)
15596             l = (l + 7) & ~ 7;
15597           else
15598             l += l & 1;
15599
15600           if (l < arch.sym_size)
15601             error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15602                    file_name, arch.sym_size - l);
15603
15604           if (fseek (file, current_pos, SEEK_SET) != 0)
15605             {
15606               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
15607               ret = 1;
15608               goto out;
15609             }
15610         }
15611
15612       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
15613           && !do_segments && !do_header && !do_dump && !do_version
15614           && !do_histogram && !do_debugging && !do_arch && !do_notes
15615           && !do_section_groups && !do_dyn_syms)
15616         {
15617           ret = 0; /* Archive index only.  */
15618           goto out;
15619         }
15620     }
15621
15622   ret = 0;
15623
15624   while (1)
15625     {
15626       char * name;
15627       size_t namelen;
15628       char * qualified_name;
15629
15630       /* Read the next archive header.  */
15631       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
15632         {
15633           error (_("%s: failed to seek to next archive header\n"), file_name);
15634           return 1;
15635         }
15636       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
15637       if (got != sizeof arch.arhdr)
15638         {
15639           if (got == 0)
15640             break;
15641           error (_("%s: failed to read archive header\n"), file_name);
15642           ret = 1;
15643           break;
15644         }
15645       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
15646         {
15647           error (_("%s: did not find a valid archive header\n"), arch.file_name);
15648           ret = 1;
15649           break;
15650         }
15651
15652       arch.next_arhdr_offset += sizeof arch.arhdr;
15653
15654       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
15655       if (archive_file_size & 01)
15656         ++archive_file_size;
15657
15658       name = get_archive_member_name (&arch, &nested_arch);
15659       if (name == NULL)
15660         {
15661           error (_("%s: bad archive file name\n"), file_name);
15662           ret = 1;
15663           break;
15664         }
15665       namelen = strlen (name);
15666
15667       qualified_name = make_qualified_name (&arch, &nested_arch, name);
15668       if (qualified_name == NULL)
15669         {
15670           error (_("%s: bad archive file name\n"), file_name);
15671           ret = 1;
15672           break;
15673         }
15674
15675       if (is_thin_archive && arch.nested_member_origin == 0)
15676         {
15677           /* This is a proxy for an external member of a thin archive.  */
15678           FILE * member_file;
15679           char * member_file_name = adjust_relative_path (file_name, name, namelen);
15680           if (member_file_name == NULL)
15681             {
15682               ret = 1;
15683               break;
15684             }
15685
15686           member_file = fopen (member_file_name, "rb");
15687           if (member_file == NULL)
15688             {
15689               error (_("Input file '%s' is not readable.\n"), member_file_name);
15690               free (member_file_name);
15691               ret = 1;
15692               break;
15693             }
15694
15695           archive_file_offset = arch.nested_member_origin;
15696
15697           ret |= process_object (qualified_name, member_file);
15698
15699           fclose (member_file);
15700           free (member_file_name);
15701         }
15702       else if (is_thin_archive)
15703         {
15704           /* PR 15140: Allow for corrupt thin archives.  */
15705           if (nested_arch.file == NULL)
15706             {
15707               error (_("%s: contains corrupt thin archive: %s\n"),
15708                      file_name, name);
15709               ret = 1;
15710               break;
15711             }
15712
15713           /* This is a proxy for a member of a nested archive.  */
15714           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
15715
15716           /* The nested archive file will have been opened and setup by
15717              get_archive_member_name.  */
15718           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
15719             {
15720               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
15721               ret = 1;
15722               break;
15723             }
15724
15725           ret |= process_object (qualified_name, nested_arch.file);
15726         }
15727       else
15728         {
15729           archive_file_offset = arch.next_arhdr_offset;
15730           arch.next_arhdr_offset += archive_file_size;
15731
15732           ret |= process_object (qualified_name, file);
15733         }
15734
15735       if (dump_sects != NULL)
15736         {
15737           free (dump_sects);
15738           dump_sects = NULL;
15739           num_dump_sects = 0;
15740         }
15741
15742       free (qualified_name);
15743     }
15744
15745  out:
15746   if (nested_arch.file != NULL)
15747     fclose (nested_arch.file);
15748   release_archive (&nested_arch);
15749   release_archive (&arch);
15750
15751   return ret;
15752 }
15753
15754 static int
15755 process_file (char * file_name)
15756 {
15757   FILE * file;
15758   struct stat statbuf;
15759   char armag[SARMAG];
15760   int ret;
15761
15762   if (stat (file_name, &statbuf) < 0)
15763     {
15764       if (errno == ENOENT)
15765         error (_("'%s': No such file\n"), file_name);
15766       else
15767         error (_("Could not locate '%s'.  System error message: %s\n"),
15768                file_name, strerror (errno));
15769       return 1;
15770     }
15771
15772   if (! S_ISREG (statbuf.st_mode))
15773     {
15774       error (_("'%s' is not an ordinary file\n"), file_name);
15775       return 1;
15776     }
15777
15778   file = fopen (file_name, "rb");
15779   if (file == NULL)
15780     {
15781       error (_("Input file '%s' is not readable.\n"), file_name);
15782       return 1;
15783     }
15784
15785   if (fread (armag, SARMAG, 1, file) != 1)
15786     {
15787       error (_("%s: Failed to read file's magic number\n"), file_name);
15788       fclose (file);
15789       return 1;
15790     }
15791
15792   current_file_size = (bfd_size_type) statbuf.st_size;
15793
15794   if (memcmp (armag, ARMAG, SARMAG) == 0)
15795     ret = process_archive (file_name, file, FALSE);
15796   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
15797     ret = process_archive (file_name, file, TRUE);
15798   else
15799     {
15800       if (do_archive_index)
15801         error (_("File %s is not an archive so its index cannot be displayed.\n"),
15802                file_name);
15803
15804       rewind (file);
15805       archive_file_size = archive_file_offset = 0;
15806       ret = process_object (file_name, file);
15807     }
15808
15809   fclose (file);
15810
15811   current_file_size = 0;
15812   return ret;
15813 }
15814
15815 #ifdef SUPPORT_DISASSEMBLY
15816 /* Needed by the i386 disassembler.  For extra credit, someone could
15817    fix this so that we insert symbolic addresses here, esp for GOT/PLT
15818    symbols.  */
15819
15820 void
15821 print_address (unsigned int addr, FILE * outfile)
15822 {
15823   fprintf (outfile,"0x%8.8x", addr);
15824 }
15825
15826 /* Needed by the i386 disassembler.  */
15827 void
15828 db_task_printsym (unsigned int addr)
15829 {
15830   print_address (addr, stderr);
15831 }
15832 #endif
15833
15834 int
15835 main (int argc, char ** argv)
15836 {
15837   int err;
15838
15839 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
15840   setlocale (LC_MESSAGES, "");
15841 #endif
15842 #if defined (HAVE_SETLOCALE)
15843   setlocale (LC_CTYPE, "");
15844 #endif
15845   bindtextdomain (PACKAGE, LOCALEDIR);
15846   textdomain (PACKAGE);
15847
15848   expandargv (&argc, &argv);
15849
15850   parse_args (argc, argv);
15851
15852   if (num_dump_sects > 0)
15853     {
15854       /* Make a copy of the dump_sects array.  */
15855       cmdline_dump_sects = (dump_type *)
15856           malloc (num_dump_sects * sizeof (* dump_sects));
15857       if (cmdline_dump_sects == NULL)
15858         error (_("Out of memory allocating dump request table.\n"));
15859       else
15860         {
15861           memcpy (cmdline_dump_sects, dump_sects,
15862                   num_dump_sects * sizeof (* dump_sects));
15863           num_cmdline_dump_sects = num_dump_sects;
15864         }
15865     }
15866
15867   if (optind < (argc - 1))
15868     show_name = 1;
15869
15870   err = 0;
15871   while (optind < argc)
15872     err |= process_file (argv[optind++]);
15873
15874   if (dump_sects != NULL)
15875     free (dump_sects);
15876   if (cmdline_dump_sects != NULL)
15877     free (cmdline_dump_sects);
15878
15879   return err;
15880 }