binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
   3    2008, 2009, 2010, 2011
   4    Free Software Foundation, Inc.
   5
   6    Originally developed by Eric Youngdale <eric@andante.jic.com>
   7    Modifications by Nick Clifton <nickc@redhat.com>
   8
   9    This file is part of GNU Binutils.
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program; if not, write to the Free Software
  23    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  24    02110-1301, USA.  */
  25 \f
  26 /* The difference between readelf and objdump:
  27
  28   Both programs are capable of displaying the contents of ELF format files,
  29   so why does the binutils project have two file dumpers ?
  30
  31   The reason is that objdump sees an ELF file through a BFD filter of the
  32   world; if BFD has a bug where, say, it disagrees about a machine constant
  33   in e_flags, then the odds are good that it will remain internally
  34   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
  35   GAS sees it the BFD way.  There was need for a tool to go find out what
  36   the file actually says.
  37
  38   This is why the readelf program does not link against the BFD library - it
  39   exists as an independent program to help verify the correct working of BFD.
  40
  41   There is also the case that readelf can provide more information about an
  42   ELF file than is provided by objdump.  In particular it can display DWARF
  43   debugging information which (at the moment) objdump cannot.  */
  44 \f
  45 #include "config.h"
  46 #include "sysdep.h"
  47 #include <assert.h>
  48 #include <sys/stat.h>
  49 #include <time.h>
  50 #ifdef HAVE_ZLIB_H
  51 #include <zlib.h>
  52 #endif
  53
  54 #if __GNUC__ >= 2
  55 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  56    as this will allow us to read in and parse 64bit and 32bit ELF files.
  57    Only do this if we believe that the compiler can support a 64 bit
  58    data type.  For now we only rely on GCC being able to do this.  */
  59 #define BFD64
  60 #endif
  61
  62 #include "bfd.h"
  63 #include "bucomm.h"
  64 #include "elfcomm.h"
  65 #include "dwarf.h"
  66
  67 #include "elf/common.h"
  68 #include "elf/external.h"
  69 #include "elf/internal.h"
  70
  71
  72 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  73    we can obtain the H8 reloc numbers.  We need these for the
  74    get_reloc_size() function.  We include h8.h again after defining
  75    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  76
  77 #include "elf/h8.h"
  78 #undef _ELF_H8_H
  79
  80 /* Undo the effects of #including reloc-macros.h.  */
  81
  82 #undef START_RELOC_NUMBERS
  83 #undef RELOC_NUMBER
  84 #undef FAKE_RELOC
  85 #undef EMPTY_RELOC
  86 #undef END_RELOC_NUMBERS
  87 #undef _RELOC_MACROS_H
  88
  89 /* The following headers use the elf/reloc-macros.h file to
  90    automatically generate relocation recognition functions
  91    such as elf_mips_reloc_type()  */
  92
  93 #define RELOC_MACROS_GEN_FUNC
  94
  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/fr30.h"
 107 #include "elf/frv.h"
 108 #include "elf/h8.h"
 109 #include "elf/hppa.h"
 110 #include "elf/i386.h"
 111 #include "elf/i370.h"
 112 #include "elf/i860.h"
 113 #include "elf/i960.h"
 114 #include "elf/ia64.h"
 115 #include "elf/ip2k.h"
 116 #include "elf/lm32.h"
 117 #include "elf/iq2000.h"
 118 #include "elf/m32c.h"
 119 #include "elf/m32r.h"
 120 #include "elf/m68k.h"
 121 #include "elf/m68hc11.h"
 122 #include "elf/mcore.h"
 123 #include "elf/mep.h"
 124 #include "elf/microblaze.h"
 125 #include "elf/mips.h"
 126 #include "elf/mmix.h"
 127 #include "elf/mn10200.h"
 128 #include "elf/mn10300.h"
 129 #include "elf/moxie.h"
 130 #include "elf/mt.h"
 131 #include "elf/msp430.h"
 132 #include "elf/or32.h"
 133 #include "elf/pj.h"
 134 #include "elf/ppc.h"
 135 #include "elf/ppc64.h"
 136 #include "elf/rx.h"
 137 #include "elf/s390.h"
 138 #include "elf/score.h"
 139 #include "elf/sh.h"
 140 #include "elf/sparc.h"
 141 #include "elf/spu.h"
 142 #include "elf/tic6x.h"
 143 #include "elf/v850.h"
 144 #include "elf/vax.h"
 145 #include "elf/x86-64.h"
 146 #include "elf/xc16x.h"
 147 #include "elf/xstormy16.h"
 148 #include "elf/xtensa.h"
 149
 150 #include "getopt.h"
 151 #include "libiberty.h"
 152 #include "safe-ctype.h"
 153 #include "filenames.h"
 154
 155 char * program_name = "readelf";
 156 static long archive_file_offset;
 157 static unsigned long archive_file_size;
 158 static unsigned long dynamic_addr;
 159 static bfd_size_type dynamic_size;
 160 static unsigned int dynamic_nent;
 161 static char * dynamic_strings;
 162 static unsigned long dynamic_strings_length;
 163 static char * string_table;
 164 static unsigned long string_table_length;
 165 static unsigned long num_dynamic_syms;
 166 static Elf_Internal_Sym * dynamic_symbols;
 167 static Elf_Internal_Syminfo * dynamic_syminfo;
 168 static unsigned long dynamic_syminfo_offset;
 169 static unsigned int dynamic_syminfo_nent;
 170 static char program_interpreter[PATH_MAX];
 171 static bfd_vma dynamic_info[DT_ENCODING];
 172 static bfd_vma dynamic_info_DT_GNU_HASH;
 173 static bfd_vma version_info[16];
 174 static Elf_Internal_Ehdr elf_header;
 175 static Elf_Internal_Shdr * section_headers;
 176 static Elf_Internal_Phdr * program_headers;
 177 static Elf_Internal_Dyn *  dynamic_section;
 178 static Elf_Internal_Shdr * symtab_shndx_hdr;
 179 static int show_name;
 180 static int do_dynamic;
 181 static int do_syms;
 182 static int do_dyn_syms;
 183 static int do_reloc;
 184 static int do_sections;
 185 static int do_section_groups;
 186 static int do_section_details;
 187 static int do_segments;
 188 static int do_unwind;
 189 static int do_using_dynamic;
 190 static int do_header;
 191 static int do_dump;
 192 static int do_version;
 193 static int do_histogram;
 194 static int do_debugging;
 195 static int do_arch;
 196 static int do_notes;
 197 static int do_archive_index;
 198 static int is_32bit_elf;
 199
 200 struct group_list
 201 {
 202   struct group_list * next;
 203   unsigned int section_index;
 204 };
 205
 206 struct group
 207 {
 208   struct group_list * root;
 209   unsigned int group_index;
 210 };
 211
 212 static size_t group_count;
 213 static struct group * section_groups;
 214 static struct group ** section_headers_groups;
 215
 216
 217 /* Flag bits indicating particular types of dump.  */
 218 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 219 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 220 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 221 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 222 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 223
 224 typedef unsigned char dump_type;
 225
 226 /* A linked list of the section names for which dumps were requested.  */
 227 struct dump_list_entry
 228 {
 229   char * name;
 230   dump_type type;
 231   struct dump_list_entry * next;
 232 };
 233 static struct dump_list_entry * dump_sects_byname;
 234
 235 /* A dynamic array of flags indicating for which sections a dump
 236    has been requested via command line switches.  */
 237 static dump_type *   cmdline_dump_sects = NULL;
 238 static unsigned int  num_cmdline_dump_sects = 0;
 239
 240 /* A dynamic array of flags indicating for which sections a dump of
 241    some kind has been requested.  It is reset on a per-object file
 242    basis and then initialised from the cmdline_dump_sects array,
 243    the results of interpreting the -w switch, and the
 244    dump_sects_byname list.  */
 245 static dump_type *   dump_sects = NULL;
 246 static unsigned int  num_dump_sects = 0;
 247
 248
 249 /* How to print a vma value.  */
 250 typedef enum print_mode
 251 {
 252   HEX,
 253   DEC,
 254   DEC_5,
 255   UNSIGNED,
 256   PREFIX_HEX,
 257   FULL_HEX,
 258   LONG_HEX
 259 }
 260 print_mode;
 261
 262 #define UNKNOWN -1
 263
 264 #define SECTION_NAME(X)                                         \
 265   ((X) == NULL ? _("<none>")                                    \
 266    : string_table == NULL ? _("<no-name>")                      \
 267    : ((X)->sh_name >= string_table_length ? _("<corrupt>")      \
 268   : string_table + (X)->sh_name))
 269
 270 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 271
 272 #define GET_ELF_SYMBOLS(file, section)                  \
 273   (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
 274    : get_64bit_elf_symbols (file, section))
 275
 276 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 277 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 278    already been called and verified that the string exists.  */
 279 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 280
 281 #define REMOVE_ARCH_BITS(ADDR)                  \
 282   do                                            \
 283     {                                           \
 284       if (elf_header.e_machine == EM_ARM)       \
 285         (ADDR) &= ~1;                           \
 286     }                                           \
 287   while (0)
 288 \f
 289 static void *
 290 get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
 291           const char * reason)
 292 {
 293   void * mvar;
 294
 295   if (size == 0 || nmemb == 0)
 296     return NULL;
 297
 298   if (fseek (file, archive_file_offset + offset, SEEK_SET))
 299     {
 300       error (_("Unable to seek to 0x%lx for %s\n"),
 301              (unsigned long) archive_file_offset + offset, reason);
 302       return NULL;
 303     }
 304
 305   mvar = var;
 306   if (mvar == NULL)
 307     {
 308       /* Check for overflow.  */
 309       if (nmemb < (~(size_t) 0 - 1) / size)
 310         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 311         mvar = malloc (size * nmemb + 1);
 312
 313       if (mvar == NULL)
 314         {
 315           error (_("Out of memory allocating 0x%lx bytes for %s\n"),
 316                  (unsigned long)(size * nmemb), reason);
 317           return NULL;
 318         }
 319
 320       ((char *) mvar)[size * nmemb] = '\0';
 321     }
 322
 323   if (fread (mvar, size, nmemb, file) != nmemb)
 324     {
 325       error (_("Unable to read in 0x%lx bytes of %s\n"),
 326              (unsigned long)(size * nmemb), reason);
 327       if (mvar != var)
 328         free (mvar);
 329       return NULL;
 330     }
 331
 332   return mvar;
 333 }
 334
 335 /* Print a VMA value.  */
 336
 337 static int
 338 print_vma (bfd_vma vma, print_mode mode)
 339 {
 340   int nc = 0;
 341
 342   switch (mode)
 343     {
 344     case FULL_HEX:
 345       nc = printf ("0x");
 346       /* Drop through.  */
 347
 348     case LONG_HEX:
 349 #ifdef BFD64
 350       if (is_32bit_elf)
 351         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 352 #endif
 353       printf_vma (vma);
 354       return nc + 16;
 355
 356     case DEC_5:
 357       if (vma <= 99999)
 358         return printf ("%5" BFD_VMA_FMT "d", vma);
 359       /* Drop through.  */
 360
 361     case PREFIX_HEX:
 362       nc = printf ("0x");
 363       /* Drop through.  */
 364
 365     case HEX:
 366       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 367
 368     case DEC:
 369       return printf ("%" BFD_VMA_FMT "d", vma);
 370
 371     case UNSIGNED:
 372       return printf ("%" BFD_VMA_FMT "u", vma);
 373     }
 374   return 0;
 375 }
 376
 377 /* Display a symbol on stdout.  Handles the display of non-printing characters.
 378
 379    If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
 380    truncating as necessary.  If WIDTH is negative then format the string to be
 381    exactly - WIDTH characters, truncating or padding as necessary.
 382
 383    Returns the number of emitted characters.  */
 384
 385 static unsigned int
 386 print_symbol (int width, const char *symbol)
 387 {
 388   const char *c;
 389   bfd_boolean extra_padding = FALSE;
 390   unsigned int num_printed = 0;
 391
 392   if (do_wide)
 393     {
 394       /* Set the width to a very large value.  This simplifies the
 395          code below.  */
 396       width = INT_MAX;
 397     }
 398   else if (width < 0)
 399     {
 400       /* Keep the width positive.  This also helps.  */
 401       width = - width;
 402       extra_padding = TRUE;
 403     }
 404
 405   while (width)
 406     {
 407       int len;
 408
 409       c = symbol;
 410
 411       /* Look for non-printing symbols inside the symbol's name.
 412          This test is triggered in particular by the names generated
 413          by the assembler for local labels.  */
 414       while (ISPRINT (*c))
 415         c++;
 416
 417       len = c - symbol;
 418
 419       if (len)
 420         {
 421           if (len > width)
 422             len = width;
 423
 424           printf ("%.*s", len, symbol);
 425
 426           width -= len;
 427           num_printed += len;
 428         }
 429
 430       if (*c == 0 || width == 0)
 431         break;
 432
 433       /* Now display the non-printing character, if
 434          there is room left in which to dipslay it.  */
 435       if ((unsigned char) *c < 32)
 436         {
 437           if (width < 2)
 438             break;
 439
 440           printf ("^%c", *c + 0x40);
 441
 442           width -= 2;
 443           num_printed += 2;
 444         }
 445       else
 446         {
 447           if (width < 6)
 448             break;
 449
 450           printf ("<0x%.2x>", (unsigned char) *c);
 451
 452           width -= 6;
 453           num_printed += 6;
 454         }
 455
 456       symbol = c + 1;
 457     }
 458
 459   if (extra_padding && width > 0)
 460     {
 461       /* Fill in the remaining spaces.  */
 462       printf ("%-*s", width, " ");
 463       num_printed += 2;
 464     }
 465
 466   return num_printed;
 467 }
 468
 469 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 470
 471 static Elf_Internal_Shdr *
 472 find_section (const char * name)
 473 {
 474   unsigned int i;
 475
 476   for (i = 0; i < elf_header.e_shnum; i++)
 477     if (streq (SECTION_NAME (section_headers + i), name))
 478       return section_headers + i;
 479
 480   return NULL;
 481 }
 482
 483 /* Return a pointer to a section containing ADDR, or NULL if no such
 484    section exists.  */
 485
 486 static Elf_Internal_Shdr *
 487 find_section_by_address (bfd_vma addr)
 488 {
 489   unsigned int i;
 490
 491   for (i = 0; i < elf_header.e_shnum; i++)
 492     {
 493       Elf_Internal_Shdr *sec = section_headers + i;
 494       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 495         return sec;
 496     }
 497
 498   return NULL;
 499 }
 500
 501 /* Read an unsigned LEB128 encoded value from p.  Set *PLEN to the number of
 502    bytes read.  */
 503
 504 static unsigned long
 505 read_uleb128 (unsigned char *data, unsigned int *length_return)
 506 {
 507   return read_leb128 (data, length_return, 0);
 508 }
 509
 510 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
 511    This OS has so many departures from the ELF standard that we test it at
 512    many places.  */
 513
 514 static inline int
 515 is_ia64_vms (void)
 516 {
 517   return elf_header.e_machine == EM_IA_64
 518     && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 519 }
 520
 521 /* Guess the relocation size commonly used by the specific machines.  */
 522
 523 static int
 524 guess_is_rela (unsigned int e_machine)
 525 {
 526   switch (e_machine)
 527     {
 528       /* Targets that use REL relocations.  */
 529     case EM_386:
 530     case EM_486:
 531     case EM_960:
 532     case EM_ARM:
 533     case EM_D10V:
 534     case EM_CYGNUS_D10V:
 535     case EM_DLX:
 536     case EM_MIPS:
 537     case EM_MIPS_RS3_LE:
 538     case EM_CYGNUS_M32R:
 539     case EM_OPENRISC:
 540     case EM_OR32:
 541     case EM_SCORE:
 542       return FALSE;
 543
 544       /* Targets that use RELA relocations.  */
 545     case EM_68K:
 546     case EM_860:
 547     case EM_ALPHA:
 548     case EM_ALTERA_NIOS2:
 549     case EM_AVR:
 550     case EM_AVR_OLD:
 551     case EM_BLACKFIN:
 552     case EM_CR16:
 553     case EM_CR16_OLD:
 554     case EM_CRIS:
 555     case EM_CRX:
 556     case EM_D30V:
 557     case EM_CYGNUS_D30V:
 558     case EM_FR30:
 559     case EM_CYGNUS_FR30:
 560     case EM_CYGNUS_FRV:
 561     case EM_H8S:
 562     case EM_H8_300:
 563     case EM_H8_300H:
 564     case EM_IA_64:
 565     case EM_IP2K:
 566     case EM_IP2K_OLD:
 567     case EM_IQ2000:
 568     case EM_LATTICEMICO32:
 569     case EM_M32C_OLD:
 570     case EM_M32C:
 571     case EM_M32R:
 572     case EM_MCORE:
 573     case EM_CYGNUS_MEP:
 574     case EM_MMIX:
 575     case EM_MN10200:
 576     case EM_CYGNUS_MN10200:
 577     case EM_MN10300:
 578     case EM_CYGNUS_MN10300:
 579     case EM_MOXIE:
 580     case EM_MSP430:
 581     case EM_MSP430_OLD:
 582     case EM_MT:
 583     case EM_NIOS32:
 584     case EM_PPC64:
 585     case EM_PPC:
 586     case EM_RX:
 587     case EM_S390:
 588     case EM_S390_OLD:
 589     case EM_SH:
 590     case EM_SPARC:
 591     case EM_SPARC32PLUS:
 592     case EM_SPARCV9:
 593     case EM_SPU:
 594     case EM_TI_C6000:
 595     case EM_V850:
 596     case EM_CYGNUS_V850:
 597     case EM_VAX:
 598     case EM_X86_64:
 599     case EM_L1OM:
 600     case EM_XSTORMY16:
 601     case EM_XTENSA:
 602     case EM_XTENSA_OLD:
 603     case EM_MICROBLAZE:
 604     case EM_MICROBLAZE_OLD:
 605       return TRUE;
 606
 607     case EM_68HC05:
 608     case EM_68HC08:
 609     case EM_68HC11:
 610     case EM_68HC16:
 611     case EM_FX66:
 612     case EM_ME16:
 613     case EM_MMA:
 614     case EM_NCPU:
 615     case EM_NDR1:
 616     case EM_PCP:
 617     case EM_ST100:
 618     case EM_ST19:
 619     case EM_ST7:
 620     case EM_ST9PLUS:
 621     case EM_STARCORE:
 622     case EM_SVX:
 623     case EM_TINYJ:
 624     default:
 625       warn (_("Don't know about relocations on this machine architecture\n"));
 626       return FALSE;
 627     }
 628 }
 629
 630 static int
 631 slurp_rela_relocs (FILE * file,
 632                    unsigned long rel_offset,
 633                    unsigned long rel_size,
 634                    Elf_Internal_Rela ** relasp,
 635                    unsigned long * nrelasp)
 636 {
 637   Elf_Internal_Rela * relas;
 638   unsigned long nrelas;
 639   unsigned int i;
 640
 641   if (is_32bit_elf)
 642     {
 643       Elf32_External_Rela * erelas;
 644
 645       erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
 646                                                  rel_size, _("relocs"));
 647       if (!erelas)
 648         return 0;
 649
 650       nrelas = rel_size / sizeof (Elf32_External_Rela);
 651
 652       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 653                                              sizeof (Elf_Internal_Rela));
 654
 655       if (relas == NULL)
 656         {
 657           free (erelas);
 658           error (_("out of memory parsing relocs\n"));
 659           return 0;
 660         }
 661
 662       for (i = 0; i < nrelas; i++)
 663         {
 664           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 665           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 666           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 667         }
 668
 669       free (erelas);
 670     }
 671   else
 672     {
 673       Elf64_External_Rela * erelas;
 674
 675       erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
 676                                                  rel_size, _("relocs"));
 677       if (!erelas)
 678         return 0;
 679
 680       nrelas = rel_size / sizeof (Elf64_External_Rela);
 681
 682       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 683                                              sizeof (Elf_Internal_Rela));
 684
 685       if (relas == NULL)
 686         {
 687           free (erelas);
 688           error (_("out of memory parsing relocs\n"));
 689           return 0;
 690         }
 691
 692       for (i = 0; i < nrelas; i++)
 693         {
 694           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 695           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 696           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 697
 698           /* The #ifdef BFD64 below is to prevent a compile time
 699              warning.  We know that if we do not have a 64 bit data
 700              type that we will never execute this code anyway.  */
 701 #ifdef BFD64
 702           if (elf_header.e_machine == EM_MIPS
 703               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 704             {
 705               /* In little-endian objects, r_info isn't really a
 706                  64-bit little-endian value: it has a 32-bit
 707                  little-endian symbol index followed by four
 708                  individual byte fields.  Reorder INFO
 709                  accordingly.  */
 710               bfd_vma inf = relas[i].r_info;
 711               inf = (((inf & 0xffffffff) << 32)
 712                       | ((inf >> 56) & 0xff)
 713                       | ((inf >> 40) & 0xff00)
 714                       | ((inf >> 24) & 0xff0000)
 715                       | ((inf >> 8) & 0xff000000));
 716               relas[i].r_info = inf;
 717             }
 718 #endif /* BFD64 */
 719         }
 720
 721       free (erelas);
 722     }
 723   *relasp = relas;
 724   *nrelasp = nrelas;
 725   return 1;
 726 }
 727
 728 static int
 729 slurp_rel_relocs (FILE * file,
 730                   unsigned long rel_offset,
 731                   unsigned long rel_size,
 732                   Elf_Internal_Rela ** relsp,
 733                   unsigned long * nrelsp)
 734 {
 735   Elf_Internal_Rela * rels;
 736   unsigned long nrels;
 737   unsigned int i;
 738
 739   if (is_32bit_elf)
 740     {
 741       Elf32_External_Rel * erels;
 742
 743       erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
 744                                                rel_size, _("relocs"));
 745       if (!erels)
 746         return 0;
 747
 748       nrels = rel_size / sizeof (Elf32_External_Rel);
 749
 750       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 751
 752       if (rels == NULL)
 753         {
 754           free (erels);
 755           error (_("out of memory parsing relocs\n"));
 756           return 0;
 757         }
 758
 759       for (i = 0; i < nrels; i++)
 760         {
 761           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 762           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 763           rels[i].r_addend = 0;
 764         }
 765
 766       free (erels);
 767     }
 768   else
 769     {
 770       Elf64_External_Rel * erels;
 771
 772       erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
 773                                                rel_size, _("relocs"));
 774       if (!erels)
 775         return 0;
 776
 777       nrels = rel_size / sizeof (Elf64_External_Rel);
 778
 779       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 780
 781       if (rels == NULL)
 782         {
 783           free (erels);
 784           error (_("out of memory parsing relocs\n"));
 785           return 0;
 786         }
 787
 788       for (i = 0; i < nrels; i++)
 789         {
 790           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 791           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 792           rels[i].r_addend = 0;
 793
 794           /* The #ifdef BFD64 below is to prevent a compile time
 795              warning.  We know that if we do not have a 64 bit data
 796              type that we will never execute this code anyway.  */
 797 #ifdef BFD64
 798           if (elf_header.e_machine == EM_MIPS
 799               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 800             {
 801               /* In little-endian objects, r_info isn't really a
 802                  64-bit little-endian value: it has a 32-bit
 803                  little-endian symbol index followed by four
 804                  individual byte fields.  Reorder INFO
 805                  accordingly.  */
 806               bfd_vma inf = rels[i].r_info;
 807               inf = (((inf & 0xffffffff) << 32)
 808                      | ((inf >> 56) & 0xff)
 809                      | ((inf >> 40) & 0xff00)
 810                      | ((inf >> 24) & 0xff0000)
 811                      | ((inf >> 8) & 0xff000000));
 812               rels[i].r_info = inf;
 813             }
 814 #endif /* BFD64 */
 815         }
 816
 817       free (erels);
 818     }
 819   *relsp = rels;
 820   *nrelsp = nrels;
 821   return 1;
 822 }
 823
 824 /* Returns the reloc type extracted from the reloc info field.  */
 825
 826 static unsigned int
 827 get_reloc_type (bfd_vma reloc_info)
 828 {
 829   if (is_32bit_elf)
 830     return ELF32_R_TYPE (reloc_info);
 831
 832   switch (elf_header.e_machine)
 833     {
 834     case EM_MIPS:
 835       /* Note: We assume that reloc_info has already been adjusted for us.  */
 836       return ELF64_MIPS_R_TYPE (reloc_info);
 837
 838     case EM_SPARCV9:
 839       return ELF64_R_TYPE_ID (reloc_info);
 840
 841     default:
 842       return ELF64_R_TYPE (reloc_info);
 843     }
 844 }
 845
 846 /* Return the symbol index extracted from the reloc info field.  */
 847
 848 static bfd_vma
 849 get_reloc_symindex (bfd_vma reloc_info)
 850 {
 851   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
 852 }
 853
 854 /* Display the contents of the relocation data found at the specified
 855    offset.  */
 856
 857 static void
 858 dump_relocations (FILE * file,
 859                   unsigned long rel_offset,
 860                   unsigned long rel_size,
 861                   Elf_Internal_Sym * symtab,
 862                   unsigned long nsyms,
 863                   char * strtab,
 864                   unsigned long strtablen,
 865                   int is_rela)
 866 {
 867   unsigned int i;
 868   Elf_Internal_Rela * rels;
 869
 870   if (is_rela == UNKNOWN)
 871     is_rela = guess_is_rela (elf_header.e_machine);
 872
 873   if (is_rela)
 874     {
 875       if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
 876         return;
 877     }
 878   else
 879     {
 880       if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
 881         return;
 882     }
 883
 884   if (is_32bit_elf)
 885     {
 886       if (is_rela)
 887         {
 888           if (do_wide)
 889             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
 890           else
 891             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
 892         }
 893       else
 894         {
 895           if (do_wide)
 896             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
 897           else
 898             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
 899         }
 900     }
 901   else
 902     {
 903       if (is_rela)
 904         {
 905           if (do_wide)
 906             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
 907           else
 908             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
 909         }
 910       else
 911         {
 912           if (do_wide)
 913             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
 914           else
 915             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
 916         }
 917     }
 918
 919   for (i = 0; i < rel_size; i++)
 920     {
 921       const char * rtype;
 922       bfd_vma offset;
 923       bfd_vma inf;
 924       bfd_vma symtab_index;
 925       bfd_vma type;
 926
 927       offset = rels[i].r_offset;
 928       inf    = rels[i].r_info;
 929
 930       type = get_reloc_type (inf);
 931       symtab_index = get_reloc_symindex  (inf);
 932
 933       if (is_32bit_elf)
 934         {
 935           printf ("%8.8lx  %8.8lx ",
 936                   (unsigned long) offset & 0xffffffff,
 937                   (unsigned long) inf & 0xffffffff);
 938         }
 939       else
 940         {
 941 #if BFD_HOST_64BIT_LONG
 942           printf (do_wide
 943                   ? "%16.16lx  %16.16lx "
 944                   : "%12.12lx  %12.12lx ",
 945                   offset, inf);
 946 #elif BFD_HOST_64BIT_LONG_LONG
 947 #ifndef __MSVCRT__
 948           printf (do_wide
 949                   ? "%16.16llx  %16.16llx "
 950                   : "%12.12llx  %12.12llx ",
 951                   offset, inf);
 952 #else
 953           printf (do_wide
 954                   ? "%16.16I64x  %16.16I64x "
 955                   : "%12.12I64x  %12.12I64x ",
 956                   offset, inf);
 957 #endif
 958 #else
 959           printf (do_wide
 960                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
 961                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
 962                   _bfd_int64_high (offset),
 963                   _bfd_int64_low (offset),
 964                   _bfd_int64_high (inf),
 965                   _bfd_int64_low (inf));
 966 #endif
 967         }
 968
 969       switch (elf_header.e_machine)
 970         {
 971         default:
 972           rtype = NULL;
 973           break;
 974
 975         case EM_M32R:
 976         case EM_CYGNUS_M32R:
 977           rtype = elf_m32r_reloc_type (type);
 978           break;
 979
 980         case EM_386:
 981         case EM_486:
 982           rtype = elf_i386_reloc_type (type);
 983           break;
 984
 985         case EM_68HC11:
 986         case EM_68HC12:
 987           rtype = elf_m68hc11_reloc_type (type);
 988           break;
 989
 990         case EM_68K:
 991           rtype = elf_m68k_reloc_type (type);
 992           break;
 993
 994         case EM_960:
 995           rtype = elf_i960_reloc_type (type);
 996           break;
 997
 998         case EM_AVR:
 999         case EM_AVR_OLD:
1000           rtype = elf_avr_reloc_type (type);
1001           break;
1002
1003         case EM_OLD_SPARCV9:
1004         case EM_SPARC32PLUS:
1005         case EM_SPARCV9:
1006         case EM_SPARC:
1007           rtype = elf_sparc_reloc_type (type);
1008           break;
1009
1010         case EM_SPU:
1011           rtype = elf_spu_reloc_type (type);
1012           break;
1013
1014         case EM_V850:
1015         case EM_CYGNUS_V850:
1016           rtype = v850_reloc_type (type);
1017           break;
1018
1019         case EM_D10V:
1020         case EM_CYGNUS_D10V:
1021           rtype = elf_d10v_reloc_type (type);
1022           break;
1023
1024         case EM_D30V:
1025         case EM_CYGNUS_D30V:
1026           rtype = elf_d30v_reloc_type (type);
1027           break;
1028
1029         case EM_DLX:
1030           rtype = elf_dlx_reloc_type (type);
1031           break;
1032
1033         case EM_SH:
1034           rtype = elf_sh_reloc_type (type);
1035           break;
1036
1037         case EM_MN10300:
1038         case EM_CYGNUS_MN10300:
1039           rtype = elf_mn10300_reloc_type (type);
1040           break;
1041
1042         case EM_MN10200:
1043         case EM_CYGNUS_MN10200:
1044           rtype = elf_mn10200_reloc_type (type);
1045           break;
1046
1047         case EM_FR30:
1048         case EM_CYGNUS_FR30:
1049           rtype = elf_fr30_reloc_type (type);
1050           break;
1051
1052         case EM_CYGNUS_FRV:
1053           rtype = elf_frv_reloc_type (type);
1054           break;
1055
1056         case EM_MCORE:
1057           rtype = elf_mcore_reloc_type (type);
1058           break;
1059
1060         case EM_MMIX:
1061           rtype = elf_mmix_reloc_type (type);
1062           break;
1063
1064         case EM_MOXIE:
1065           rtype = elf_moxie_reloc_type (type);
1066           break;
1067
1068         case EM_MSP430:
1069         case EM_MSP430_OLD:
1070           rtype = elf_msp430_reloc_type (type);
1071           break;
1072
1073         case EM_PPC:
1074           rtype = elf_ppc_reloc_type (type);
1075           break;
1076
1077         case EM_PPC64:
1078           rtype = elf_ppc64_reloc_type (type);
1079           break;
1080
1081         case EM_MIPS:
1082         case EM_MIPS_RS3_LE:
1083           rtype = elf_mips_reloc_type (type);
1084           break;
1085
1086         case EM_ALPHA:
1087           rtype = elf_alpha_reloc_type (type);
1088           break;
1089
1090         case EM_ARM:
1091           rtype = elf_arm_reloc_type (type);
1092           break;
1093
1094         case EM_ARC:
1095           rtype = elf_arc_reloc_type (type);
1096           break;
1097
1098         case EM_PARISC:
1099           rtype = elf_hppa_reloc_type (type);
1100           break;
1101
1102         case EM_H8_300:
1103         case EM_H8_300H:
1104         case EM_H8S:
1105           rtype = elf_h8_reloc_type (type);
1106           break;
1107
1108         case EM_OPENRISC:
1109         case EM_OR32:
1110           rtype = elf_or32_reloc_type (type);
1111           break;
1112
1113         case EM_PJ:
1114         case EM_PJ_OLD:
1115           rtype = elf_pj_reloc_type (type);
1116           break;
1117         case EM_IA_64:
1118           rtype = elf_ia64_reloc_type (type);
1119           break;
1120
1121         case EM_CRIS:
1122           rtype = elf_cris_reloc_type (type);
1123           break;
1124
1125         case EM_860:
1126           rtype = elf_i860_reloc_type (type);
1127           break;
1128
1129         case EM_X86_64:
1130         case EM_L1OM:
1131           rtype = elf_x86_64_reloc_type (type);
1132           break;
1133
1134         case EM_S370:
1135           rtype = i370_reloc_type (type);
1136           break;
1137
1138         case EM_S390_OLD:
1139         case EM_S390:
1140           rtype = elf_s390_reloc_type (type);
1141           break;
1142
1143         case EM_SCORE:
1144           rtype = elf_score_reloc_type (type);
1145           break;
1146
1147         case EM_XSTORMY16:
1148           rtype = elf_xstormy16_reloc_type (type);
1149           break;
1150
1151         case EM_CRX:
1152           rtype = elf_crx_reloc_type (type);
1153           break;
1154
1155         case EM_VAX:
1156           rtype = elf_vax_reloc_type (type);
1157           break;
1158
1159         case EM_IP2K:
1160         case EM_IP2K_OLD:
1161           rtype = elf_ip2k_reloc_type (type);
1162           break;
1163
1164         case EM_IQ2000:
1165           rtype = elf_iq2000_reloc_type (type);
1166           break;
1167
1168         case EM_XTENSA_OLD:
1169         case EM_XTENSA:
1170           rtype = elf_xtensa_reloc_type (type);
1171           break;
1172
1173         case EM_LATTICEMICO32:
1174           rtype = elf_lm32_reloc_type (type);
1175           break;
1176
1177         case EM_M32C_OLD:
1178         case EM_M32C:
1179           rtype = elf_m32c_reloc_type (type);
1180           break;
1181
1182         case EM_MT:
1183           rtype = elf_mt_reloc_type (type);
1184           break;
1185
1186         case EM_BLACKFIN:
1187           rtype = elf_bfin_reloc_type (type);
1188           break;
1189
1190         case EM_CYGNUS_MEP:
1191           rtype = elf_mep_reloc_type (type);
1192           break;
1193
1194         case EM_CR16:
1195         case EM_CR16_OLD:
1196           rtype = elf_cr16_reloc_type (type);
1197           break;
1198
1199         case EM_MICROBLAZE:
1200         case EM_MICROBLAZE_OLD:
1201           rtype = elf_microblaze_reloc_type (type);
1202           break;
1203
1204         case EM_RX:
1205           rtype = elf_rx_reloc_type (type);
1206           break;
1207
1208         case EM_XC16X:
1209         case EM_C166:
1210           rtype = elf_xc16x_reloc_type (type);
1211           break;
1212
1213         case EM_TI_C6000:
1214           rtype = elf_tic6x_reloc_type (type);
1215           break;
1216         }
1217
1218       if (rtype == NULL)
1219         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1220       else
1221         printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1222
1223       if (elf_header.e_machine == EM_ALPHA
1224           && rtype != NULL
1225           && streq (rtype, "R_ALPHA_LITUSE")
1226           && is_rela)
1227         {
1228           switch (rels[i].r_addend)
1229             {
1230             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1231             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1232             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1233             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1234             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1235             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1236             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1237             default: rtype = NULL;
1238             }
1239           if (rtype)
1240             printf (" (%s)", rtype);
1241           else
1242             {
1243               putchar (' ');
1244               printf (_("<unknown addend: %lx>"),
1245                       (unsigned long) rels[i].r_addend);
1246             }
1247         }
1248       else if (symtab_index)
1249         {
1250           if (symtab == NULL || symtab_index >= nsyms)
1251             printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1252           else
1253             {
1254               Elf_Internal_Sym * psym;
1255
1256               psym = symtab + symtab_index;
1257
1258               printf (" ");
1259
1260               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1261                 {
1262                   const char * name;
1263                   unsigned int len;
1264                   unsigned int width = is_32bit_elf ? 8 : 14;
1265
1266                   /* Relocations against GNU_IFUNC symbols do not use the value
1267                      of the symbol as the address to relocate against.  Instead
1268                      they invoke the function named by the symbol and use its
1269                      result as the address for relocation.
1270
1271                      To indicate this to the user, do not display the value of
1272                      the symbol in the "Symbols's Value" field.  Instead show
1273                      its name followed by () as a hint that the symbol is
1274                      invoked.  */
1275
1276                   if (strtab == NULL
1277                       || psym->st_name == 0
1278                       || psym->st_name >= strtablen)
1279                     name = "??";
1280                   else
1281                     name = strtab + psym->st_name;
1282
1283                   len = print_symbol (width, name);
1284                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1285                 }
1286               else
1287                 {
1288                   print_vma (psym->st_value, LONG_HEX);
1289
1290                   printf (is_32bit_elf ? "   " : " ");
1291                 }
1292
1293               if (psym->st_name == 0)
1294                 {
1295                   const char * sec_name = "<null>";
1296                   char name_buf[40];
1297
1298                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1299                     {
1300                       if (psym->st_shndx < elf_header.e_shnum)
1301                         sec_name
1302                           = SECTION_NAME (section_headers + psym->st_shndx);
1303                       else if (psym->st_shndx == SHN_ABS)
1304                         sec_name = "ABS";
1305                       else if (psym->st_shndx == SHN_COMMON)
1306                         sec_name = "COMMON";
1307                       else if ((elf_header.e_machine == EM_MIPS
1308                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1309                                || (elf_header.e_machine == EM_TI_C6000
1310                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1311                         sec_name = "SCOMMON";
1312                       else if (elf_header.e_machine == EM_MIPS
1313                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1314                         sec_name = "SUNDEF";
1315                       else if ((elf_header.e_machine == EM_X86_64
1316                                 || elf_header.e_machine == EM_L1OM)
1317                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1318                         sec_name = "LARGE_COMMON";
1319                       else if (elf_header.e_machine == EM_IA_64
1320                                && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1321                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1322                         sec_name = "ANSI_COM";
1323                       else if (is_ia64_vms ()
1324                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1325                         sec_name = "VMS_SYMVEC";
1326                       else
1327                         {
1328                           sprintf (name_buf, "<section 0x%x>",
1329                                    (unsigned int) psym->st_shndx);
1330                           sec_name = name_buf;
1331                         }
1332                     }
1333                   print_symbol (22, sec_name);
1334                 }
1335               else if (strtab == NULL)
1336                 printf (_("<string table index: %3ld>"), psym->st_name);
1337               else if (psym->st_name >= strtablen)
1338                 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1339               else
1340                 print_symbol (22, strtab + psym->st_name);
1341
1342               if (is_rela)
1343                 {
1344                   bfd_signed_vma off = rels[i].r_addend;
1345
1346                   if (off < 0)
1347                     printf (" - %" BFD_VMA_FMT "x", - off);
1348                   else
1349                     printf (" + %" BFD_VMA_FMT "x", off);
1350                 }
1351             }
1352         }
1353       else if (is_rela)
1354         {
1355           printf ("%*c", is_32bit_elf ?
1356                   (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
1357           print_vma (rels[i].r_addend, LONG_HEX);
1358         }
1359
1360       if (elf_header.e_machine == EM_SPARCV9
1361           && rtype != NULL
1362           && streq (rtype, "R_SPARC_OLO10"))
1363         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1364
1365       putchar ('\n');
1366
1367 #ifdef BFD64
1368       if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1369         {
1370           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1371           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1372           const char * rtype2 = elf_mips_reloc_type (type2);
1373           const char * rtype3 = elf_mips_reloc_type (type3);
1374
1375           printf ("                    Type2: ");
1376
1377           if (rtype2 == NULL)
1378             printf (_("unrecognized: %-7lx"),
1379                     (unsigned long) type2 & 0xffffffff);
1380           else
1381             printf ("%-17.17s", rtype2);
1382
1383           printf ("\n                    Type3: ");
1384
1385           if (rtype3 == NULL)
1386             printf (_("unrecognized: %-7lx"),
1387                     (unsigned long) type3 & 0xffffffff);
1388           else
1389             printf ("%-17.17s", rtype3);
1390
1391           putchar ('\n');
1392         }
1393 #endif /* BFD64 */
1394     }
1395
1396   free (rels);
1397 }
1398
1399 static const char *
1400 get_mips_dynamic_type (unsigned long type)
1401 {
1402   switch (type)
1403     {
1404     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1405     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1406     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1407     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1408     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1409     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1410     case DT_MIPS_MSYM: return "MIPS_MSYM";
1411     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1412     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1413     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1414     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1415     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1416     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1417     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1418     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1419     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1420     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1421     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1422     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1423     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1424     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1425     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1426     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1427     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1428     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1429     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1430     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1431     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1432     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1433     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1434     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1435     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1436     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1437     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1438     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1439     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1440     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1441     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1442     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1443     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1444     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1445     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1446     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1447     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1448     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1449     default:
1450       return NULL;
1451     }
1452 }
1453
1454 static const char *
1455 get_sparc64_dynamic_type (unsigned long type)
1456 {
1457   switch (type)
1458     {
1459     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1460     default:
1461       return NULL;
1462     }
1463 }
1464
1465 static const char *
1466 get_ppc_dynamic_type (unsigned long type)
1467 {
1468   switch (type)
1469     {
1470     case DT_PPC_GOT:    return "PPC_GOT";
1471     case DT_PPC_TLSOPT: return "PPC_TLSOPT";
1472     default:
1473       return NULL;
1474     }
1475 }
1476
1477 static const char *
1478 get_ppc64_dynamic_type (unsigned long type)
1479 {
1480   switch (type)
1481     {
1482     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1483     case DT_PPC64_OPD:    return "PPC64_OPD";
1484     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1485     case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
1486     default:
1487       return NULL;
1488     }
1489 }
1490
1491 static const char *
1492 get_parisc_dynamic_type (unsigned long type)
1493 {
1494   switch (type)
1495     {
1496     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1497     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1498     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1499     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1500     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1501     case DT_HP_PREINIT:         return "HP_PREINIT";
1502     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1503     case DT_HP_NEEDED:          return "HP_NEEDED";
1504     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1505     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1506     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1507     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1508     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1509     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1510     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1511     case DT_HP_FILTERED:        return "HP_FILTERED";
1512     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1513     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1514     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1515     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1516     case DT_PLT:                return "PLT";
1517     case DT_PLT_SIZE:           return "PLT_SIZE";
1518     case DT_DLT:                return "DLT";
1519     case DT_DLT_SIZE:           return "DLT_SIZE";
1520     default:
1521       return NULL;
1522     }
1523 }
1524
1525 static const char *
1526 get_ia64_dynamic_type (unsigned long type)
1527 {
1528   switch (type)
1529     {
1530     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1531     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1532     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1533     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1534     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1535     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1536     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1537     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1538     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1539     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1540     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1541     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1542     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1543     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1544     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1545     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1546     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1547     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1548     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1549     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1550     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1551     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1552     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1553     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1554     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1555     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1556     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1557     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1558     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1559     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1560     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1561     default:
1562       return NULL;
1563     }
1564 }
1565
1566 static const char *
1567 get_alpha_dynamic_type (unsigned long type)
1568 {
1569   switch (type)
1570     {
1571     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1572     default:
1573       return NULL;
1574     }
1575 }
1576
1577 static const char *
1578 get_score_dynamic_type (unsigned long type)
1579 {
1580   switch (type)
1581     {
1582     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1583     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1584     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1585     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1586     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1587     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1588     default:
1589       return NULL;
1590     }
1591 }
1592
1593 static const char *
1594 get_tic6x_dynamic_type (unsigned long type)
1595 {
1596   switch (type)
1597     {
1598     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1599     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1600     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
1601     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
1602     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
1603     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
1604     default:
1605       return NULL;
1606     }
1607 }
1608
1609 static const char *
1610 get_dynamic_type (unsigned long type)
1611 {
1612   static char buff[64];
1613
1614   switch (type)
1615     {
1616     case DT_NULL:       return "NULL";
1617     case DT_NEEDED:     return "NEEDED";
1618     case DT_PLTRELSZ:   return "PLTRELSZ";
1619     case DT_PLTGOT:     return "PLTGOT";
1620     case DT_HASH:       return "HASH";
1621     case DT_STRTAB:     return "STRTAB";
1622     case DT_SYMTAB:     return "SYMTAB";
1623     case DT_RELA:       return "RELA";
1624     case DT_RELASZ:     return "RELASZ";
1625     case DT_RELAENT:    return "RELAENT";
1626     case DT_STRSZ:      return "STRSZ";
1627     case DT_SYMENT:     return "SYMENT";
1628     case DT_INIT:       return "INIT";
1629     case DT_FINI:       return "FINI";
1630     case DT_SONAME:     return "SONAME";
1631     case DT_RPATH:      return "RPATH";
1632     case DT_SYMBOLIC:   return "SYMBOLIC";
1633     case DT_REL:        return "REL";
1634     case DT_RELSZ:      return "RELSZ";
1635     case DT_RELENT:     return "RELENT";
1636     case DT_PLTREL:     return "PLTREL";
1637     case DT_DEBUG:      return "DEBUG";
1638     case DT_TEXTREL:    return "TEXTREL";
1639     case DT_JMPREL:     return "JMPREL";
1640     case DT_BIND_NOW:   return "BIND_NOW";
1641     case DT_INIT_ARRAY: return "INIT_ARRAY";
1642     case DT_FINI_ARRAY: return "FINI_ARRAY";
1643     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1644     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1645     case DT_RUNPATH:    return "RUNPATH";
1646     case DT_FLAGS:      return "FLAGS";
1647
1648     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1649     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1650
1651     case DT_CHECKSUM:   return "CHECKSUM";
1652     case DT_PLTPADSZ:   return "PLTPADSZ";
1653     case DT_MOVEENT:    return "MOVEENT";
1654     case DT_MOVESZ:     return "MOVESZ";
1655     case DT_FEATURE:    return "FEATURE";
1656     case DT_POSFLAG_1:  return "POSFLAG_1";
1657     case DT_SYMINSZ:    return "SYMINSZ";
1658     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
1659
1660     case DT_ADDRRNGLO:  return "ADDRRNGLO";
1661     case DT_CONFIG:     return "CONFIG";
1662     case DT_DEPAUDIT:   return "DEPAUDIT";
1663     case DT_AUDIT:      return "AUDIT";
1664     case DT_PLTPAD:     return "PLTPAD";
1665     case DT_MOVETAB:    return "MOVETAB";
1666     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
1667
1668     case DT_VERSYM:     return "VERSYM";
1669
1670     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1671     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1672     case DT_RELACOUNT:  return "RELACOUNT";
1673     case DT_RELCOUNT:   return "RELCOUNT";
1674     case DT_FLAGS_1:    return "FLAGS_1";
1675     case DT_VERDEF:     return "VERDEF";
1676     case DT_VERDEFNUM:  return "VERDEFNUM";
1677     case DT_VERNEED:    return "VERNEED";
1678     case DT_VERNEEDNUM: return "VERNEEDNUM";
1679
1680     case DT_AUXILIARY:  return "AUXILIARY";
1681     case DT_USED:       return "USED";
1682     case DT_FILTER:     return "FILTER";
1683
1684     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1685     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1686     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1687     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1688     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1689     case DT_GNU_HASH:   return "GNU_HASH";
1690
1691     default:
1692       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1693         {
1694           const char * result;
1695
1696           switch (elf_header.e_machine)
1697             {
1698             case EM_MIPS:
1699             case EM_MIPS_RS3_LE:
1700               result = get_mips_dynamic_type (type);
1701               break;
1702             case EM_SPARCV9:
1703               result = get_sparc64_dynamic_type (type);
1704               break;
1705             case EM_PPC:
1706               result = get_ppc_dynamic_type (type);
1707               break;
1708             case EM_PPC64:
1709               result = get_ppc64_dynamic_type (type);
1710               break;
1711             case EM_IA_64:
1712               result = get_ia64_dynamic_type (type);
1713               break;
1714             case EM_ALPHA:
1715               result = get_alpha_dynamic_type (type);
1716               break;
1717             case EM_SCORE:
1718               result = get_score_dynamic_type (type);
1719               break;
1720             case EM_TI_C6000:
1721               result = get_tic6x_dynamic_type (type);
1722               break;
1723             default:
1724               result = NULL;
1725               break;
1726             }
1727
1728           if (result != NULL)
1729             return result;
1730
1731           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1732         }
1733       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1734                || (elf_header.e_machine == EM_PARISC
1735                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1736         {
1737           const char * result;
1738
1739           switch (elf_header.e_machine)
1740             {
1741             case EM_PARISC:
1742               result = get_parisc_dynamic_type (type);
1743               break;
1744             case EM_IA_64:
1745               result = get_ia64_dynamic_type (type);
1746               break;
1747             default:
1748               result = NULL;
1749               break;
1750             }
1751
1752           if (result != NULL)
1753             return result;
1754
1755           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1756                     type);
1757         }
1758       else
1759         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1760
1761       return buff;
1762     }
1763 }
1764
1765 static char *
1766 get_file_type (unsigned e_type)
1767 {
1768   static char buff[32];
1769
1770   switch (e_type)
1771     {
1772     case ET_NONE:       return _("NONE (None)");
1773     case ET_REL:        return _("REL (Relocatable file)");
1774     case ET_EXEC:       return _("EXEC (Executable file)");
1775     case ET_DYN:        return _("DYN (Shared object file)");
1776     case ET_CORE:       return _("CORE (Core file)");
1777
1778     default:
1779       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1780         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1781       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1782         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1783       else
1784         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1785       return buff;
1786     }
1787 }
1788
1789 static char *
1790 get_machine_name (unsigned e_machine)
1791 {
1792   static char buff[64]; /* XXX */
1793
1794   switch (e_machine)
1795     {
1796     case EM_NONE:               return _("None");
1797     case EM_M32:                return "WE32100";
1798     case EM_SPARC:              return "Sparc";
1799     case EM_SPU:                return "SPU";
1800     case EM_386:                return "Intel 80386";
1801     case EM_68K:                return "MC68000";
1802     case EM_88K:                return "MC88000";
1803     case EM_486:                return "Intel 80486";
1804     case EM_860:                return "Intel 80860";
1805     case EM_MIPS:               return "MIPS R3000";
1806     case EM_S370:               return "IBM System/370";
1807     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
1808     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
1809     case EM_PARISC:             return "HPPA";
1810     case EM_PPC_OLD:            return "Power PC (old)";
1811     case EM_SPARC32PLUS:        return "Sparc v8+" ;
1812     case EM_960:                return "Intel 90860";
1813     case EM_PPC:                return "PowerPC";
1814     case EM_PPC64:              return "PowerPC64";
1815     case EM_V800:               return "NEC V800";
1816     case EM_FR20:               return "Fujitsu FR20";
1817     case EM_RH32:               return "TRW RH32";
1818     case EM_MCORE:              return "MCORE";
1819     case EM_ARM:                return "ARM";
1820     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
1821     case EM_SH:                 return "Renesas / SuperH SH";
1822     case EM_SPARCV9:            return "Sparc v9";
1823     case EM_TRICORE:            return "Siemens Tricore";
1824     case EM_ARC:                return "ARC";
1825     case EM_H8_300:             return "Renesas H8/300";
1826     case EM_H8_300H:            return "Renesas H8/300H";
1827     case EM_H8S:                return "Renesas H8S";
1828     case EM_H8_500:             return "Renesas H8/500";
1829     case EM_IA_64:              return "Intel IA-64";
1830     case EM_MIPS_X:             return "Stanford MIPS-X";
1831     case EM_COLDFIRE:           return "Motorola Coldfire";
1832     case EM_68HC12:             return "Motorola M68HC12";
1833     case EM_ALPHA:              return "Alpha";
1834     case EM_CYGNUS_D10V:
1835     case EM_D10V:               return "d10v";
1836     case EM_CYGNUS_D30V:
1837     case EM_D30V:               return "d30v";
1838     case EM_CYGNUS_M32R:
1839     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
1840     case EM_CYGNUS_V850:
1841     case EM_V850:               return "Renesas v850";
1842     case EM_CYGNUS_MN10300:
1843     case EM_MN10300:            return "mn10300";
1844     case EM_CYGNUS_MN10200:
1845     case EM_MN10200:            return "mn10200";
1846     case EM_MOXIE:              return "Moxie";
1847     case EM_CYGNUS_FR30:
1848     case EM_FR30:               return "Fujitsu FR30";
1849     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
1850     case EM_PJ_OLD:
1851     case EM_PJ:                 return "picoJava";
1852     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
1853     case EM_PCP:                return "Siemens PCP";
1854     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
1855     case EM_NDR1:               return "Denso NDR1 microprocesspr";
1856     case EM_STARCORE:           return "Motorola Star*Core processor";
1857     case EM_ME16:               return "Toyota ME16 processor";
1858     case EM_ST100:              return "STMicroelectronics ST100 processor";
1859     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
1860     case EM_PDSP:               return "Sony DSP processor";
1861     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
1862     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
1863     case EM_FX66:               return "Siemens FX66 microcontroller";
1864     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1865     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
1866     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
1867     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
1868     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
1869     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
1870     case EM_SVX:                return "Silicon Graphics SVx";
1871     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
1872     case EM_VAX:                return "Digital VAX";
1873     case EM_AVR_OLD:
1874     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
1875     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
1876     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
1877     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
1878     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
1879     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
1880     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
1881     case EM_PRISM:              return "Vitesse Prism";
1882     case EM_X86_64:             return "Advanced Micro Devices X86-64";
1883     case EM_L1OM:               return "Intel L1OM";
1884     case EM_S390_OLD:
1885     case EM_S390:               return "IBM S/390";
1886     case EM_SCORE:              return "SUNPLUS S+Core";
1887     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
1888     case EM_OPENRISC:
1889     case EM_OR32:               return "OpenRISC";
1890     case EM_ARC_A5:             return "ARC International ARCompact processor";
1891     case EM_CRX:                return "National Semiconductor CRX microprocessor";
1892     case EM_DLX:                return "OpenDLX";
1893     case EM_IP2K_OLD:
1894     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
1895     case EM_IQ2000:             return "Vitesse IQ2000";
1896     case EM_XTENSA_OLD:
1897     case EM_XTENSA:             return "Tensilica Xtensa Processor";
1898     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
1899     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
1900     case EM_NS32K:              return "National Semiconductor 32000 series";
1901     case EM_TPC:                return "Tenor Network TPC processor";
1902     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
1903     case EM_MAX:                return "MAX Processor";
1904     case EM_CR:                 return "National Semiconductor CompactRISC";
1905     case EM_F2MC16:             return "Fujitsu F2MC16";
1906     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
1907     case EM_LATTICEMICO32:      return "Lattice Mico32";
1908     case EM_M32C_OLD:
1909     case EM_M32C:               return "Renesas M32c";
1910     case EM_MT:                 return "Morpho Techologies MT processor";
1911     case EM_BLACKFIN:           return "Analog Devices Blackfin";
1912     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
1913     case EM_SEP:                return "Sharp embedded microprocessor";
1914     case EM_ARCA:               return "Arca RISC microprocessor";
1915     case EM_UNICORE:            return "Unicore";
1916     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
1917     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
1918     case EM_NIOS32:             return "Altera Nios";
1919     case EM_ALTERA_NIOS2:       return "Altera Nios II";
1920     case EM_C166:
1921     case EM_XC16X:              return "Infineon Technologies xc16x";
1922     case EM_M16C:               return "Renesas M16C series microprocessors";
1923     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
1924     case EM_CE:                 return "Freescale Communication Engine RISC core";
1925     case EM_TSK3000:            return "Altium TSK3000 core";
1926     case EM_RS08:               return "Freescale RS08 embedded processor";
1927     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
1928     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
1929     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
1930     case EM_SE_C17:             return "Seiko Epson C17 family";
1931     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
1932     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
1933     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
1934     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
1935     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
1936     case EM_R32C:               return "Renesas R32C series microprocessors";
1937     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
1938     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
1939     case EM_8051:               return "Intel 8051 and variants";
1940     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
1941     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
1942     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
1943     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
1944     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
1945     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
1946     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
1947     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
1948     case EM_CR16:
1949     case EM_CR16_OLD:           return "National Semiconductor's CR16";
1950     case EM_MICROBLAZE:         return "Xilinx MicroBlaze";
1951     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
1952     case EM_RX:                 return "Renesas RX";
1953     case EM_METAG:              return "Imagination Technologies META processor architecture";
1954     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
1955     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
1956     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
1957     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
1958     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor family";
1959     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
1960     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
1961     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
1962     case EM_CUDA:               return "NVIDIA CUDA architecture";
1963     default:
1964       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
1965       return buff;
1966     }
1967 }
1968
1969 static void
1970 decode_ARM_machine_flags (unsigned e_flags, char buf[])
1971 {
1972   unsigned eabi;
1973   int unknown = 0;
1974
1975   eabi = EF_ARM_EABI_VERSION (e_flags);
1976   e_flags &= ~ EF_ARM_EABIMASK;
1977
1978   /* Handle "generic" ARM flags.  */
1979   if (e_flags & EF_ARM_RELEXEC)
1980     {
1981       strcat (buf, ", relocatable executable");
1982       e_flags &= ~ EF_ARM_RELEXEC;
1983     }
1984
1985   if (e_flags & EF_ARM_HASENTRY)
1986     {
1987       strcat (buf, ", has entry point");
1988       e_flags &= ~ EF_ARM_HASENTRY;
1989     }
1990
1991   /* Now handle EABI specific flags.  */
1992   switch (eabi)
1993     {
1994     default:
1995       strcat (buf, ", <unrecognized EABI>");
1996       if (e_flags)
1997         unknown = 1;
1998       break;
1999
2000     case EF_ARM_EABI_VER1:
2001       strcat (buf, ", Version1 EABI");
2002       while (e_flags)
2003         {
2004           unsigned flag;
2005
2006           /* Process flags one bit at a time.  */
2007           flag = e_flags & - e_flags;
2008           e_flags &= ~ flag;
2009
2010           switch (flag)
2011             {
2012             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2013               strcat (buf, ", sorted symbol tables");
2014               break;
2015
2016             default:
2017               unknown = 1;
2018               break;
2019             }
2020         }
2021       break;
2022
2023     case EF_ARM_EABI_VER2:
2024       strcat (buf, ", Version2 EABI");
2025       while (e_flags)
2026         {
2027           unsigned flag;
2028
2029           /* Process flags one bit at a time.  */
2030           flag = e_flags & - e_flags;
2031           e_flags &= ~ flag;
2032
2033           switch (flag)
2034             {
2035             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2036               strcat (buf, ", sorted symbol tables");
2037               break;
2038
2039             case EF_ARM_DYNSYMSUSESEGIDX:
2040               strcat (buf, ", dynamic symbols use segment index");
2041               break;
2042
2043             case EF_ARM_MAPSYMSFIRST:
2044               strcat (buf, ", mapping symbols precede others");
2045               break;
2046
2047             default:
2048               unknown = 1;
2049               break;
2050             }
2051         }
2052       break;
2053
2054     case EF_ARM_EABI_VER3:
2055       strcat (buf, ", Version3 EABI");
2056       break;
2057
2058     case EF_ARM_EABI_VER4:
2059       strcat (buf, ", Version4 EABI");
2060       goto eabi;
2061
2062     case EF_ARM_EABI_VER5:
2063       strcat (buf, ", Version5 EABI");
2064     eabi:
2065       while (e_flags)
2066         {
2067           unsigned flag;
2068
2069           /* Process flags one bit at a time.  */
2070           flag = e_flags & - e_flags;
2071           e_flags &= ~ flag;
2072
2073           switch (flag)
2074             {
2075             case EF_ARM_BE8:
2076               strcat (buf, ", BE8");
2077               break;
2078
2079             case EF_ARM_LE8:
2080               strcat (buf, ", LE8");
2081               break;
2082
2083             default:
2084               unknown = 1;
2085               break;
2086             }
2087         }
2088       break;
2089
2090     case EF_ARM_EABI_UNKNOWN:
2091       strcat (buf, ", GNU EABI");
2092       while (e_flags)
2093         {
2094           unsigned flag;
2095
2096           /* Process flags one bit at a time.  */
2097           flag = e_flags & - e_flags;
2098           e_flags &= ~ flag;
2099
2100           switch (flag)
2101             {
2102             case EF_ARM_INTERWORK:
2103               strcat (buf, ", interworking enabled");
2104               break;
2105
2106             case EF_ARM_APCS_26:
2107               strcat (buf, ", uses APCS/26");
2108               break;
2109
2110             case EF_ARM_APCS_FLOAT:
2111               strcat (buf, ", uses APCS/float");
2112               break;
2113
2114             case EF_ARM_PIC:
2115               strcat (buf, ", position independent");
2116               break;
2117
2118             case EF_ARM_ALIGN8:
2119               strcat (buf, ", 8 bit structure alignment");
2120               break;
2121
2122             case EF_ARM_NEW_ABI:
2123               strcat (buf, ", uses new ABI");
2124               break;
2125
2126             case EF_ARM_OLD_ABI:
2127               strcat (buf, ", uses old ABI");
2128               break;
2129
2130             case EF_ARM_SOFT_FLOAT:
2131               strcat (buf, ", software FP");
2132               break;
2133
2134             case EF_ARM_VFP_FLOAT:
2135               strcat (buf, ", VFP");
2136               break;
2137
2138             case EF_ARM_MAVERICK_FLOAT:
2139               strcat (buf, ", Maverick FP");
2140               break;
2141
2142             default:
2143               unknown = 1;
2144               break;
2145             }
2146         }
2147     }
2148
2149   if (unknown)
2150     strcat (buf,_(", <unknown>"));
2151 }
2152
2153 static char *
2154 get_machine_flags (unsigned e_flags, unsigned e_machine)
2155 {
2156   static char buf[1024];
2157
2158   buf[0] = '\0';
2159
2160   if (e_flags)
2161     {
2162       switch (e_machine)
2163         {
2164         default:
2165           break;
2166
2167         case EM_ARM:
2168           decode_ARM_machine_flags (e_flags, buf);
2169           break;
2170
2171         case EM_BLACKFIN:
2172           if (e_flags & EF_BFIN_PIC)
2173             strcat (buf, ", PIC");
2174
2175           if (e_flags & EF_BFIN_FDPIC)
2176             strcat (buf, ", FDPIC");
2177
2178           if (e_flags & EF_BFIN_CODE_IN_L1)
2179             strcat (buf, ", code in L1");
2180
2181           if (e_flags & EF_BFIN_DATA_IN_L1)
2182             strcat (buf, ", data in L1");
2183
2184           break;
2185
2186         case EM_CYGNUS_FRV:
2187           switch (e_flags & EF_FRV_CPU_MASK)
2188             {
2189             case EF_FRV_CPU_GENERIC:
2190               break;
2191
2192             default:
2193               strcat (buf, ", fr???");
2194               break;
2195
2196             case EF_FRV_CPU_FR300:
2197               strcat (buf, ", fr300");
2198               break;
2199
2200             case EF_FRV_CPU_FR400:
2201               strcat (buf, ", fr400");
2202               break;
2203             case EF_FRV_CPU_FR405:
2204               strcat (buf, ", fr405");
2205               break;
2206
2207             case EF_FRV_CPU_FR450:
2208               strcat (buf, ", fr450");
2209               break;
2210
2211             case EF_FRV_CPU_FR500:
2212               strcat (buf, ", fr500");
2213               break;
2214             case EF_FRV_CPU_FR550:
2215               strcat (buf, ", fr550");
2216               break;
2217
2218             case EF_FRV_CPU_SIMPLE:
2219               strcat (buf, ", simple");
2220               break;
2221             case EF_FRV_CPU_TOMCAT:
2222               strcat (buf, ", tomcat");
2223               break;
2224             }
2225           break;
2226
2227         case EM_68K:
2228           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2229             strcat (buf, ", m68000");
2230           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2231             strcat (buf, ", cpu32");
2232           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2233             strcat (buf, ", fido_a");
2234           else
2235             {
2236               char const * isa = _("unknown");
2237               char const * mac = _("unknown mac");
2238               char const * additional = NULL;
2239
2240               switch (e_flags & EF_M68K_CF_ISA_MASK)
2241                 {
2242                 case EF_M68K_CF_ISA_A_NODIV:
2243                   isa = "A";
2244                   additional = ", nodiv";
2245                   break;
2246                 case EF_M68K_CF_ISA_A:
2247                   isa = "A";
2248                   break;
2249                 case EF_M68K_CF_ISA_A_PLUS:
2250                   isa = "A+";
2251                   break;
2252                 case EF_M68K_CF_ISA_B_NOUSP:
2253                   isa = "B";
2254                   additional = ", nousp";
2255                   break;
2256                 case EF_M68K_CF_ISA_B:
2257                   isa = "B";
2258                   break;
2259                 case EF_M68K_CF_ISA_C:
2260                   isa = "C";
2261                   break;
2262                 case EF_M68K_CF_ISA_C_NODIV:
2263                   isa = "C";
2264                   additional = ", nodiv";
2265                   break;
2266                 }
2267               strcat (buf, ", cf, isa ");
2268               strcat (buf, isa);
2269               if (additional)
2270                 strcat (buf, additional);
2271               if (e_flags & EF_M68K_CF_FLOAT)
2272                 strcat (buf, ", float");
2273               switch (e_flags & EF_M68K_CF_MAC_MASK)
2274                 {
2275                 case 0:
2276                   mac = NULL;
2277                   break;
2278                 case EF_M68K_CF_MAC:
2279                   mac = "mac";
2280                   break;
2281                 case EF_M68K_CF_EMAC:
2282                   mac = "emac";
2283                   break;
2284                 case EF_M68K_CF_EMAC_B:
2285                   mac = "emac_b";
2286                   break;
2287                 }
2288               if (mac)
2289                 {
2290                   strcat (buf, ", ");
2291                   strcat (buf, mac);
2292                 }
2293             }
2294           break;
2295
2296         case EM_PPC:
2297           if (e_flags & EF_PPC_EMB)
2298             strcat (buf, ", emb");
2299
2300           if (e_flags & EF_PPC_RELOCATABLE)
2301             strcat (buf, _(", relocatable"));
2302
2303           if (e_flags & EF_PPC_RELOCATABLE_LIB)
2304             strcat (buf, _(", relocatable-lib"));
2305           break;
2306
2307         case EM_V850:
2308         case EM_CYGNUS_V850:
2309           switch (e_flags & EF_V850_ARCH)
2310             {
2311             case E_V850E2V3_ARCH:
2312               strcat (buf, ", v850e2v3");
2313               break;
2314             case E_V850E2_ARCH:
2315               strcat (buf, ", v850e2");
2316               break;
2317             case E_V850E1_ARCH:
2318               strcat (buf, ", v850e1");
2319               break;
2320             case E_V850E_ARCH:
2321               strcat (buf, ", v850e");
2322               break;
2323             case E_V850_ARCH:
2324               strcat (buf, ", v850");
2325               break;
2326             default:
2327               strcat (buf, _(", unknown v850 architecture variant"));
2328               break;
2329             }
2330           break;
2331
2332         case EM_M32R:
2333         case EM_CYGNUS_M32R:
2334           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2335             strcat (buf, ", m32r");
2336           break;
2337
2338         case EM_MIPS:
2339         case EM_MIPS_RS3_LE:
2340           if (e_flags & EF_MIPS_NOREORDER)
2341             strcat (buf, ", noreorder");
2342
2343           if (e_flags & EF_MIPS_PIC)
2344             strcat (buf, ", pic");
2345
2346           if (e_flags & EF_MIPS_CPIC)
2347             strcat (buf, ", cpic");
2348
2349           if (e_flags & EF_MIPS_UCODE)
2350             strcat (buf, ", ugen_reserved");
2351
2352           if (e_flags & EF_MIPS_ABI2)
2353             strcat (buf, ", abi2");
2354
2355           if (e_flags & EF_MIPS_OPTIONS_FIRST)
2356             strcat (buf, ", odk first");
2357
2358           if (e_flags & EF_MIPS_32BITMODE)
2359             strcat (buf, ", 32bitmode");
2360
2361           switch ((e_flags & EF_MIPS_MACH))
2362             {
2363             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2364             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2365             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2366             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2367             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2368             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2369             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2370             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2371             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
2372             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2373             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2374             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2375             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
2376             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2377             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2378             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
2379             case 0:
2380             /* We simply ignore the field in this case to avoid confusion:
2381                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2382                extension.  */
2383               break;
2384             default: strcat (buf, _(", unknown CPU")); break;
2385             }
2386
2387           switch ((e_flags & EF_MIPS_ABI))
2388             {
2389             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2390             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2391             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2392             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2393             case 0:
2394             /* We simply ignore the field in this case to avoid confusion:
2395                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2396                This means it is likely to be an o32 file, but not for
2397                sure.  */
2398               break;
2399             default: strcat (buf, _(", unknown ABI")); break;
2400             }
2401
2402           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2403             strcat (buf, ", mdmx");
2404
2405           if (e_flags & EF_MIPS_ARCH_ASE_M16)
2406             strcat (buf, ", mips16");
2407
2408           switch ((e_flags & EF_MIPS_ARCH))
2409             {
2410             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2411             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2412             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2413             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2414             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2415             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2416             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2417             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2418             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2419             default: strcat (buf, _(", unknown ISA")); break;
2420             }
2421
2422           if (e_flags & EF_SH_PIC)
2423             strcat (buf, ", pic");
2424
2425           if (e_flags & EF_SH_FDPIC)
2426             strcat (buf, ", fdpic");
2427           break;
2428
2429         case EM_SH:
2430           switch ((e_flags & EF_SH_MACH_MASK))
2431             {
2432             case EF_SH1: strcat (buf, ", sh1"); break;
2433             case EF_SH2: strcat (buf, ", sh2"); break;
2434             case EF_SH3: strcat (buf, ", sh3"); break;
2435             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2436             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2437             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2438             case EF_SH3E: strcat (buf, ", sh3e"); break;
2439             case EF_SH4: strcat (buf, ", sh4"); break;
2440             case EF_SH5: strcat (buf, ", sh5"); break;
2441             case EF_SH2E: strcat (buf, ", sh2e"); break;
2442             case EF_SH4A: strcat (buf, ", sh4a"); break;
2443             case EF_SH2A: strcat (buf, ", sh2a"); break;
2444             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2445             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2446             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2447             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2448             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2449             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2450             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2451             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2452             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2453             default: strcat (buf, _(", unknown ISA")); break;
2454             }
2455
2456           break;
2457
2458         case EM_SPARCV9:
2459           if (e_flags & EF_SPARC_32PLUS)
2460             strcat (buf, ", v8+");
2461
2462           if (e_flags & EF_SPARC_SUN_US1)
2463             strcat (buf, ", ultrasparcI");
2464
2465           if (e_flags & EF_SPARC_SUN_US3)
2466             strcat (buf, ", ultrasparcIII");
2467
2468           if (e_flags & EF_SPARC_HAL_R1)
2469             strcat (buf, ", halr1");
2470
2471           if (e_flags & EF_SPARC_LEDATA)
2472             strcat (buf, ", ledata");
2473
2474           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2475             strcat (buf, ", tso");
2476
2477           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2478             strcat (buf, ", pso");
2479
2480           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2481             strcat (buf, ", rmo");
2482           break;
2483
2484         case EM_PARISC:
2485           switch (e_flags & EF_PARISC_ARCH)
2486             {
2487             case EFA_PARISC_1_0:
2488               strcpy (buf, ", PA-RISC 1.0");
2489               break;
2490             case EFA_PARISC_1_1:
2491               strcpy (buf, ", PA-RISC 1.1");
2492               break;
2493             case EFA_PARISC_2_0:
2494               strcpy (buf, ", PA-RISC 2.0");
2495               break;
2496             default:
2497               break;
2498             }
2499           if (e_flags & EF_PARISC_TRAPNIL)
2500             strcat (buf, ", trapnil");
2501           if (e_flags & EF_PARISC_EXT)
2502             strcat (buf, ", ext");
2503           if (e_flags & EF_PARISC_LSB)
2504             strcat (buf, ", lsb");
2505           if (e_flags & EF_PARISC_WIDE)
2506             strcat (buf, ", wide");
2507           if (e_flags & EF_PARISC_NO_KABP)
2508             strcat (buf, ", no kabp");
2509           if (e_flags & EF_PARISC_LAZYSWAP)
2510             strcat (buf, ", lazyswap");
2511           break;
2512
2513         case EM_PJ:
2514         case EM_PJ_OLD:
2515           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2516             strcat (buf, ", new calling convention");
2517
2518           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2519             strcat (buf, ", gnu calling convention");
2520           break;
2521
2522         case EM_IA_64:
2523           if ((e_flags & EF_IA_64_ABI64))
2524             strcat (buf, ", 64-bit");
2525           else
2526             strcat (buf, ", 32-bit");
2527           if ((e_flags & EF_IA_64_REDUCEDFP))
2528             strcat (buf, ", reduced fp model");
2529           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2530             strcat (buf, ", no function descriptors, constant gp");
2531           else if ((e_flags & EF_IA_64_CONS_GP))
2532             strcat (buf, ", constant gp");
2533           if ((e_flags & EF_IA_64_ABSOLUTE))
2534             strcat (buf, ", absolute");
2535           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2536             {
2537               if ((e_flags & EF_IA_64_VMS_LINKAGES))
2538                 strcat (buf, ", vms_linkages");
2539               switch ((e_flags & EF_IA_64_VMS_COMCOD))
2540                 {
2541                 case EF_IA_64_VMS_COMCOD_SUCCESS:
2542                   break;
2543                 case EF_IA_64_VMS_COMCOD_WARNING:
2544                   strcat (buf, ", warning");
2545                   break;
2546                 case EF_IA_64_VMS_COMCOD_ERROR:
2547                   strcat (buf, ", error");
2548                   break;
2549                 case EF_IA_64_VMS_COMCOD_ABORT:
2550                   strcat (buf, ", abort");
2551                   break;
2552                 default:
2553                   abort ();
2554                 }
2555             }
2556           break;
2557
2558         case EM_VAX:
2559           if ((e_flags & EF_VAX_NONPIC))
2560             strcat (buf, ", non-PIC");
2561           if ((e_flags & EF_VAX_DFLOAT))
2562             strcat (buf, ", D-Float");
2563           if ((e_flags & EF_VAX_GFLOAT))
2564             strcat (buf, ", G-Float");
2565           break;
2566
2567         case EM_RX:
2568           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2569             strcat (buf, ", 64-bit doubles");
2570           if (e_flags & E_FLAG_RX_DSP)
2571             strcat (buf, ", dsp");
2572
2573         case EM_S390:
2574           if (e_flags & EF_S390_HIGH_GPRS)
2575             strcat (buf, ", highgprs");
2576
2577         case EM_TI_C6000:
2578           if ((e_flags & EF_C6000_REL))
2579             strcat (buf, ", relocatable module");
2580         }
2581     }
2582
2583   return buf;
2584 }
2585
2586 static const char *
2587 get_osabi_name (unsigned int osabi)
2588 {
2589   static char buff[32];
2590
2591   switch (osabi)
2592     {
2593     case ELFOSABI_NONE:         return "UNIX - System V";
2594     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
2595     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
2596     case ELFOSABI_LINUX:        return "UNIX - Linux";
2597     case ELFOSABI_HURD:         return "GNU/Hurd";
2598     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
2599     case ELFOSABI_AIX:          return "UNIX - AIX";
2600     case ELFOSABI_IRIX:         return "UNIX - IRIX";
2601     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
2602     case ELFOSABI_TRU64:        return "UNIX - TRU64";
2603     case ELFOSABI_MODESTO:      return "Novell - Modesto";
2604     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
2605     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
2606     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
2607     case ELFOSABI_AROS:         return "AROS";
2608     case ELFOSABI_FENIXOS:      return "FenixOS";
2609     default:
2610       if (osabi >= 64)
2611         switch (elf_header.e_machine)
2612           {
2613           case EM_ARM:
2614             switch (osabi)
2615               {
2616               case ELFOSABI_ARM:        return "ARM";
2617               default:
2618                 break;
2619               }
2620             break;
2621
2622           case EM_MSP430:
2623           case EM_MSP430_OLD:
2624             switch (osabi)
2625               {
2626               case ELFOSABI_STANDALONE: return _("Standalone App");
2627               default:
2628                 break;
2629               }
2630             break;
2631
2632           case EM_TI_C6000:
2633             switch (osabi)
2634               {
2635               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
2636               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
2637               default:
2638                 break;
2639               }
2640             break;
2641
2642           default:
2643             break;
2644           }
2645       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2646       return buff;
2647     }
2648 }
2649
2650 static const char *
2651 get_arm_segment_type (unsigned long type)
2652 {
2653   switch (type)
2654     {
2655     case PT_ARM_EXIDX:
2656       return "EXIDX";
2657     default:
2658       break;
2659     }
2660
2661   return NULL;
2662 }
2663
2664 static const char *
2665 get_mips_segment_type (unsigned long type)
2666 {
2667   switch (type)
2668     {
2669     case PT_MIPS_REGINFO:
2670       return "REGINFO";
2671     case PT_MIPS_RTPROC:
2672       return "RTPROC";
2673     case PT_MIPS_OPTIONS:
2674       return "OPTIONS";
2675     default:
2676       break;
2677     }
2678
2679   return NULL;
2680 }
2681
2682 static const char *
2683 get_parisc_segment_type (unsigned long type)
2684 {
2685   switch (type)
2686     {
2687     case PT_HP_TLS:             return "HP_TLS";
2688     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
2689     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
2690     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
2691     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
2692     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
2693     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
2694     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
2695     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
2696     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
2697     case PT_HP_PARALLEL:        return "HP_PARALLEL";
2698     case PT_HP_FASTBIND:        return "HP_FASTBIND";
2699     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
2700     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
2701     case PT_HP_STACK:           return "HP_STACK";
2702     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
2703     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
2704     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
2705     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
2706     default:
2707       break;
2708     }
2709
2710   return NULL;
2711 }
2712
2713 static const char *
2714 get_ia64_segment_type (unsigned long type)
2715 {
2716   switch (type)
2717     {
2718     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
2719     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
2720     case PT_HP_TLS:             return "HP_TLS";
2721     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
2722     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
2723     case PT_IA_64_HP_STACK:     return "HP_STACK";
2724     default:
2725       break;
2726     }
2727
2728   return NULL;
2729 }
2730
2731 static const char *
2732 get_tic6x_segment_type (unsigned long type)
2733 {
2734   switch (type)
2735     {
2736     case PT_C6000_PHATTR:       return "C6000_PHATTR";
2737     default:
2738       break;
2739     }
2740
2741   return NULL;
2742 }
2743
2744 static const char *
2745 get_segment_type (unsigned long p_type)
2746 {
2747   static char buff[32];
2748
2749   switch (p_type)
2750     {
2751     case PT_NULL:       return "NULL";
2752     case PT_LOAD:       return "LOAD";
2753     case PT_DYNAMIC:    return "DYNAMIC";
2754     case PT_INTERP:     return "INTERP";
2755     case PT_NOTE:       return "NOTE";
2756     case PT_SHLIB:      return "SHLIB";
2757     case PT_PHDR:       return "PHDR";
2758     case PT_TLS:        return "TLS";
2759
2760     case PT_GNU_EH_FRAME:
2761                         return "GNU_EH_FRAME";
2762     case PT_GNU_STACK:  return "GNU_STACK";
2763     case PT_GNU_RELRO:  return "GNU_RELRO";
2764
2765     default:
2766       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2767         {
2768           const char * result;
2769
2770           switch (elf_header.e_machine)
2771             {
2772             case EM_ARM:
2773               result = get_arm_segment_type (p_type);
2774               break;
2775             case EM_MIPS:
2776             case EM_MIPS_RS3_LE:
2777               result = get_mips_segment_type (p_type);
2778               break;
2779             case EM_PARISC:
2780               result = get_parisc_segment_type (p_type);
2781               break;
2782             case EM_IA_64:
2783               result = get_ia64_segment_type (p_type);
2784               break;
2785             case EM_TI_C6000:
2786               result = get_tic6x_segment_type (p_type);
2787               break;
2788             default:
2789               result = NULL;
2790               break;
2791             }
2792
2793           if (result != NULL)
2794             return result;
2795
2796           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2797         }
2798       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2799         {
2800           const char * result;
2801
2802           switch (elf_header.e_machine)
2803             {
2804             case EM_PARISC:
2805               result = get_parisc_segment_type (p_type);
2806               break;
2807             case EM_IA_64:
2808               result = get_ia64_segment_type (p_type);
2809               break;
2810             default:
2811               result = NULL;
2812               break;
2813             }
2814
2815           if (result != NULL)
2816             return result;
2817
2818           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2819         }
2820       else
2821         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
2822
2823       return buff;
2824     }
2825 }
2826
2827 static const char *
2828 get_mips_section_type_name (unsigned int sh_type)
2829 {
2830   switch (sh_type)
2831     {
2832     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
2833     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
2834     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
2835     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
2836     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
2837     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
2838     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
2839     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
2840     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
2841     case SHT_MIPS_RELD:          return "MIPS_RELD";
2842     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
2843     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
2844     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
2845     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
2846     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
2847     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
2848     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
2849     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
2850     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
2851     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
2852     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
2853     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
2854     case SHT_MIPS_LINE:          return "MIPS_LINE";
2855     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
2856     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
2857     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
2858     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
2859     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
2860     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
2861     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
2862     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
2863     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
2864     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
2865     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
2866     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
2867     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
2868     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
2869     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
2870     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2871     default:
2872       break;
2873     }
2874   return NULL;
2875 }
2876
2877 static const char *
2878 get_parisc_section_type_name (unsigned int sh_type)
2879 {
2880   switch (sh_type)
2881     {
2882     case SHT_PARISC_EXT:        return "PARISC_EXT";
2883     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
2884     case SHT_PARISC_DOC:        return "PARISC_DOC";
2885     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
2886     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
2887     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
2888     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
2889     default:
2890       break;
2891     }
2892   return NULL;
2893 }
2894
2895 static const char *
2896 get_ia64_section_type_name (unsigned int sh_type)
2897 {
2898   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
2899   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2900     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
2901
2902   switch (sh_type)
2903     {
2904     case SHT_IA_64_EXT:                return "IA_64_EXT";
2905     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
2906     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
2907     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
2908     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
2909     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
2910     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
2911     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
2912     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
2913     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
2914     default:
2915       break;
2916     }
2917   return NULL;
2918 }
2919
2920 static const char *
2921 get_x86_64_section_type_name (unsigned int sh_type)
2922 {
2923   switch (sh_type)
2924     {
2925     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
2926     default:
2927       break;
2928     }
2929   return NULL;
2930 }
2931
2932 static const char *
2933 get_arm_section_type_name (unsigned int sh_type)
2934 {
2935   switch (sh_type)
2936     {
2937     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
2938     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
2939     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
2940     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
2941     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
2942     default:
2943       break;
2944     }
2945   return NULL;
2946 }
2947
2948 static const char *
2949 get_tic6x_section_type_name (unsigned int sh_type)
2950 {
2951   switch (sh_type)
2952     {
2953     case SHT_C6000_UNWIND:
2954       return "C6000_UNWIND";
2955     case SHT_C6000_PREEMPTMAP:
2956       return "C6000_PREEMPTMAP";
2957     case SHT_C6000_ATTRIBUTES:
2958       return "C6000_ATTRIBUTES";
2959     case SHT_TI_ICODE:
2960       return "TI_ICODE";
2961     case SHT_TI_XREF:
2962       return "TI_XREF";
2963     case SHT_TI_HANDLER:
2964       return "TI_HANDLER";
2965     case SHT_TI_INITINFO:
2966       return "TI_INITINFO";
2967     case SHT_TI_PHATTRS:
2968       return "TI_PHATTRS";
2969     default:
2970       break;
2971     }
2972   return NULL;
2973 }
2974
2975 static const char *
2976 get_section_type_name (unsigned int sh_type)
2977 {
2978   static char buff[32];
2979
2980   switch (sh_type)
2981     {
2982     case SHT_NULL:              return "NULL";
2983     case SHT_PROGBITS:          return "PROGBITS";
2984     case SHT_SYMTAB:            return "SYMTAB";
2985     case SHT_STRTAB:            return "STRTAB";
2986     case SHT_RELA:              return "RELA";
2987     case SHT_HASH:              return "HASH";
2988     case SHT_DYNAMIC:           return "DYNAMIC";
2989     case SHT_NOTE:              return "NOTE";
2990     case SHT_NOBITS:            return "NOBITS";
2991     case SHT_REL:               return "REL";
2992     case SHT_SHLIB:             return "SHLIB";
2993     case SHT_DYNSYM:            return "DYNSYM";
2994     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
2995     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
2996     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
2997     case SHT_GNU_HASH:          return "GNU_HASH";
2998     case SHT_GROUP:             return "GROUP";
2999     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
3000     case SHT_GNU_verdef:        return "VERDEF";
3001     case SHT_GNU_verneed:       return "VERNEED";
3002     case SHT_GNU_versym:        return "VERSYM";
3003     case 0x6ffffff0:            return "VERSYM";
3004     case 0x6ffffffc:            return "VERDEF";
3005     case 0x7ffffffd:            return "AUXILIARY";
3006     case 0x7fffffff:            return "FILTER";
3007     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
3008
3009     default:
3010       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3011         {
3012           const char * result;
3013
3014           switch (elf_header.e_machine)
3015             {
3016             case EM_MIPS:
3017             case EM_MIPS_RS3_LE:
3018               result = get_mips_section_type_name (sh_type);
3019               break;
3020             case EM_PARISC:
3021               result = get_parisc_section_type_name (sh_type);
3022               break;
3023             case EM_IA_64:
3024               result = get_ia64_section_type_name (sh_type);
3025               break;
3026             case EM_X86_64:
3027             case EM_L1OM:
3028               result = get_x86_64_section_type_name (sh_type);
3029               break;
3030             case EM_ARM:
3031               result = get_arm_section_type_name (sh_type);
3032               break;
3033             case EM_TI_C6000:
3034               result = get_tic6x_section_type_name (sh_type);
3035               break;
3036             default:
3037               result = NULL;
3038               break;
3039             }
3040
3041           if (result != NULL)
3042             return result;
3043
3044           sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3045         }
3046       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3047         {
3048           const char * result;
3049
3050           switch (elf_header.e_machine)
3051             {
3052             case EM_IA_64:
3053               result = get_ia64_section_type_name (sh_type);
3054               break;
3055             default:
3056               result = NULL;
3057               break;
3058             }
3059
3060           if (result != NULL)
3061             return result;
3062
3063           sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3064         }
3065       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3066         sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3067       else
3068         snprintf (buff, sizeof (buff), _("<unknown>: %x"), sh_type);
3069
3070       return buff;
3071     }
3072 }
3073
3074 #define OPTION_DEBUG_DUMP       512
3075 #define OPTION_DYN_SYMS         513
3076
3077 static struct option options[] =
3078 {
3079   {"all",              no_argument, 0, 'a'},
3080   {"file-header",      no_argument, 0, 'h'},
3081   {"program-headers",  no_argument, 0, 'l'},
3082   {"headers",          no_argument, 0, 'e'},
3083   {"histogram",        no_argument, 0, 'I'},
3084   {"segments",         no_argument, 0, 'l'},
3085   {"sections",         no_argument, 0, 'S'},
3086   {"section-headers",  no_argument, 0, 'S'},
3087   {"section-groups",   no_argument, 0, 'g'},
3088   {"section-details",  no_argument, 0, 't'},
3089   {"full-section-name",no_argument, 0, 'N'},
3090   {"symbols",          no_argument, 0, 's'},
3091   {"syms",             no_argument, 0, 's'},
3092   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
3093   {"relocs",           no_argument, 0, 'r'},
3094   {"notes",            no_argument, 0, 'n'},
3095   {"dynamic",          no_argument, 0, 'd'},
3096   {"arch-specific",    no_argument, 0, 'A'},
3097   {"version-info",     no_argument, 0, 'V'},
3098   {"use-dynamic",      no_argument, 0, 'D'},
3099   {"unwind",           no_argument, 0, 'u'},
3100   {"archive-index",    no_argument, 0, 'c'},
3101   {"hex-dump",         required_argument, 0, 'x'},
3102   {"relocated-dump",   required_argument, 0, 'R'},
3103   {"string-dump",      required_argument, 0, 'p'},
3104 #ifdef SUPPORT_DISASSEMBLY
3105   {"instruction-dump", required_argument, 0, 'i'},
3106 #endif
3107   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
3108
3109   {"version",          no_argument, 0, 'v'},
3110   {"wide",             no_argument, 0, 'W'},
3111   {"help",             no_argument, 0, 'H'},
3112   {0,                  no_argument, 0, 0}
3113 };
3114
3115 static void
3116 usage (FILE * stream)
3117 {
3118   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3119   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3120   fprintf (stream, _(" Options are:\n\
3121   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3122   -h --file-header       Display the ELF file header\n\
3123   -l --program-headers   Display the program headers\n\
3124      --segments          An alias for --program-headers\n\
3125   -S --section-headers   Display the sections' header\n\
3126      --sections          An alias for --section-headers\n\
3127   -g --section-groups    Display the section groups\n\
3128   -t --section-details   Display the section details\n\
3129   -e --headers           Equivalent to: -h -l -S\n\
3130   -s --syms              Display the symbol table\n\
3131      --symbols           An alias for --syms\n\
3132   --dyn-syms             Display the dynamic symbol table\n\
3133   -n --notes             Display the core notes (if present)\n\
3134   -r --relocs            Display the relocations (if present)\n\
3135   -u --unwind            Display the unwind info (if present)\n\
3136   -d --dynamic           Display the dynamic section (if present)\n\
3137   -V --version-info      Display the version sections (if present)\n\
3138   -A --arch-specific     Display architecture specific information (if any).\n\
3139   -c --archive-index     Display the symbol/file index in an archive\n\
3140   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
3141   -x --hex-dump=<number|name>\n\
3142                          Dump the contents of section <number|name> as bytes\n\
3143   -p --string-dump=<number|name>\n\
3144                          Dump the contents of section <number|name> as strings\n\
3145   -R --relocated-dump=<number|name>\n\
3146                          Dump the contents of section <number|name> as relocated bytes\n\
3147   -w[lLiaprmfFsoRt] or\n\
3148   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3149                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3150                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges]\n\
3151                          Display the contents of DWARF2 debug sections\n"));
3152 #ifdef SUPPORT_DISASSEMBLY
3153   fprintf (stream, _("\
3154   -i --instruction-dump=<number|name>\n\
3155                          Disassemble the contents of section <number|name>\n"));
3156 #endif
3157   fprintf (stream, _("\
3158   -I --histogram         Display histogram of bucket list lengths\n\
3159   -W --wide              Allow output width to exceed 80 characters\n\
3160   @<file>                Read options from <file>\n\
3161   -H --help              Display this information\n\
3162   -v --version           Display the version number of readelf\n"));
3163
3164   if (REPORT_BUGS_TO[0] && stream == stdout)
3165     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3166
3167   exit (stream == stdout ? 0 : 1);
3168 }
3169
3170 /* Record the fact that the user wants the contents of section number
3171    SECTION to be displayed using the method(s) encoded as flags bits
3172    in TYPE.  Note, TYPE can be zero if we are creating the array for
3173    the first time.  */
3174
3175 static void
3176 request_dump_bynumber (unsigned int section, dump_type type)
3177 {
3178   if (section >= num_dump_sects)
3179     {
3180       dump_type * new_dump_sects;
3181
3182       new_dump_sects = (dump_type *) calloc (section + 1,
3183                                              sizeof (* dump_sects));
3184
3185       if (new_dump_sects == NULL)
3186         error (_("Out of memory allocating dump request table.\n"));
3187       else
3188         {
3189           /* Copy current flag settings.  */
3190           memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3191
3192           free (dump_sects);
3193
3194           dump_sects = new_dump_sects;
3195           num_dump_sects = section + 1;
3196         }
3197     }
3198
3199   if (dump_sects)
3200     dump_sects[section] |= type;
3201
3202   return;
3203 }
3204
3205 /* Request a dump by section name.  */
3206
3207 static void
3208 request_dump_byname (const char * section, dump_type type)
3209 {
3210   struct dump_list_entry * new_request;
3211
3212   new_request = (struct dump_list_entry *)
3213       malloc (sizeof (struct dump_list_entry));
3214   if (!new_request)
3215     error (_("Out of memory allocating dump request table.\n"));
3216
3217   new_request->name = strdup (section);
3218   if (!new_request->name)
3219     error (_("Out of memory allocating dump request table.\n"));
3220
3221   new_request->type = type;
3222
3223   new_request->next = dump_sects_byname;
3224   dump_sects_byname = new_request;
3225 }
3226
3227 static inline void
3228 request_dump (dump_type type)
3229 {
3230   int section;
3231   char * cp;
3232
3233   do_dump++;
3234   section = strtoul (optarg, & cp, 0);
3235
3236   if (! *cp && section >= 0)
3237     request_dump_bynumber (section, type);
3238   else
3239     request_dump_byname (optarg, type);
3240 }
3241
3242
3243 static void
3244 parse_args (int argc, char ** argv)
3245 {
3246   int c;
3247
3248   if (argc < 2)
3249     usage (stderr);
3250
3251   while ((c = getopt_long
3252           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3253     {
3254       switch (c)
3255         {
3256         case 0:
3257           /* Long options.  */
3258           break;
3259         case 'H':
3260           usage (stdout);
3261           break;
3262
3263         case 'a':
3264           do_syms++;
3265           do_reloc++;
3266           do_unwind++;
3267           do_dynamic++;
3268           do_header++;
3269           do_sections++;
3270           do_section_groups++;
3271           do_segments++;
3272           do_version++;
3273           do_histogram++;
3274           do_arch++;
3275           do_notes++;
3276           break;
3277         case 'g':
3278           do_section_groups++;
3279           break;
3280         case 't':
3281         case 'N':
3282           do_sections++;
3283           do_section_details++;
3284           break;
3285         case 'e':
3286           do_header++;
3287           do_sections++;
3288           do_segments++;
3289           break;
3290         case 'A':
3291           do_arch++;
3292           break;
3293         case 'D':
3294           do_using_dynamic++;
3295           break;
3296         case 'r':
3297           do_reloc++;
3298           break;
3299         case 'u':
3300           do_unwind++;
3301           break;
3302         case 'h':
3303           do_header++;
3304           break;
3305         case 'l':
3306           do_segments++;
3307           break;
3308         case 's':
3309           do_syms++;
3310           break;
3311         case 'S':
3312           do_sections++;
3313           break;
3314         case 'd':
3315           do_dynamic++;
3316           break;
3317         case 'I':
3318           do_histogram++;
3319           break;
3320         case 'n':
3321           do_notes++;
3322           break;
3323         case 'c':
3324           do_archive_index++;
3325           break;
3326         case 'x':
3327           request_dump (HEX_DUMP);
3328           break;
3329         case 'p':
3330           request_dump (STRING_DUMP);
3331           break;
3332         case 'R':
3333           request_dump (RELOC_DUMP);
3334           break;
3335         case 'w':
3336           do_dump++;
3337           if (optarg == 0)
3338             {
3339               do_debugging = 1;
3340               dwarf_select_sections_all ();
3341             }
3342           else
3343             {
3344               do_debugging = 0;
3345               dwarf_select_sections_by_letters (optarg);
3346             }
3347           break;
3348         case OPTION_DEBUG_DUMP:
3349           do_dump++;
3350           if (optarg == 0)
3351             do_debugging = 1;
3352           else
3353             {
3354               do_debugging = 0;
3355               dwarf_select_sections_by_names (optarg);
3356             }
3357           break;
3358         case OPTION_DYN_SYMS:
3359           do_dyn_syms++;
3360           break;
3361 #ifdef SUPPORT_DISASSEMBLY
3362         case 'i':
3363           request_dump (DISASS_DUMP);
3364           break;
3365 #endif
3366         case 'v':
3367           print_version (program_name);
3368           break;
3369         case 'V':
3370           do_version++;
3371           break;
3372         case 'W':
3373           do_wide++;
3374           break;
3375         default:
3376           /* xgettext:c-format */
3377           error (_("Invalid option '-%c'\n"), c);
3378           /* Drop through.  */
3379         case '?':
3380           usage (stderr);
3381         }
3382     }
3383
3384   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3385       && !do_segments && !do_header && !do_dump && !do_version
3386       && !do_histogram && !do_debugging && !do_arch && !do_notes
3387       && !do_section_groups && !do_archive_index
3388       && !do_dyn_syms)
3389     usage (stderr);
3390   else if (argc < 3)
3391     {
3392       warn (_("Nothing to do.\n"));
3393       usage (stderr);
3394     }
3395 }
3396
3397 static const char *
3398 get_elf_class (unsigned int elf_class)
3399 {
3400   static char buff[32];
3401
3402   switch (elf_class)
3403     {
3404     case ELFCLASSNONE: return _("none");
3405     case ELFCLASS32:   return "ELF32";
3406     case ELFCLASS64:   return "ELF64";
3407     default:
3408       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3409       return buff;
3410     }
3411 }
3412
3413 static const char *
3414 get_data_encoding (unsigned int encoding)
3415 {
3416   static char buff[32];
3417
3418   switch (encoding)
3419     {
3420     case ELFDATANONE: return _("none");
3421     case ELFDATA2LSB: return _("2's complement, little endian");
3422     case ELFDATA2MSB: return _("2's complement, big endian");
3423     default:
3424       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3425       return buff;
3426     }
3427 }
3428
3429 /* Decode the data held in 'elf_header'.  */
3430
3431 static int
3432 process_file_header (void)
3433 {
3434   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
3435       || elf_header.e_ident[EI_MAG1] != ELFMAG1
3436       || elf_header.e_ident[EI_MAG2] != ELFMAG2
3437       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3438     {
3439       error
3440         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3441       return 0;
3442     }
3443
3444   init_dwarf_regnames (elf_header.e_machine);
3445
3446   if (do_header)
3447     {
3448       int i;
3449
3450       printf (_("ELF Header:\n"));
3451       printf (_("  Magic:   "));
3452       for (i = 0; i < EI_NIDENT; i++)
3453         printf ("%2.2x ", elf_header.e_ident[i]);
3454       printf ("\n");
3455       printf (_("  Class:                             %s\n"),
3456               get_elf_class (elf_header.e_ident[EI_CLASS]));
3457       printf (_("  Data:                              %s\n"),
3458               get_data_encoding (elf_header.e_ident[EI_DATA]));
3459       printf (_("  Version:                           %d %s\n"),
3460               elf_header.e_ident[EI_VERSION],
3461               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3462                ? "(current)"
3463                : (elf_header.e_ident[EI_VERSION] != EV_NONE
3464                   ? _("<unknown: %lx>")
3465                   : "")));
3466       printf (_("  OS/ABI:                            %s\n"),
3467               get_osabi_name (elf_header.e_ident[EI_OSABI]));
3468       printf (_("  ABI Version:                       %d\n"),
3469               elf_header.e_ident[EI_ABIVERSION]);
3470       printf (_("  Type:                              %s\n"),
3471               get_file_type (elf_header.e_type));
3472       printf (_("  Machine:                           %s\n"),
3473               get_machine_name (elf_header.e_machine));
3474       printf (_("  Version:                           0x%lx\n"),
3475               (unsigned long) elf_header.e_version);
3476
3477       printf (_("  Entry point address:               "));
3478       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3479       printf (_("\n  Start of program headers:          "));
3480       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3481       printf (_(" (bytes into file)\n  Start of section headers:          "));
3482       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3483       printf (_(" (bytes into file)\n"));
3484
3485       printf (_("  Flags:                             0x%lx%s\n"),
3486               (unsigned long) elf_header.e_flags,
3487               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3488       printf (_("  Size of this header:               %ld (bytes)\n"),
3489               (long) elf_header.e_ehsize);
3490       printf (_("  Size of program headers:           %ld (bytes)\n"),
3491               (long) elf_header.e_phentsize);
3492       printf (_("  Number of program headers:         %ld"),
3493               (long) elf_header.e_phnum);
3494       if (section_headers != NULL
3495           && elf_header.e_phnum == PN_XNUM
3496           && section_headers[0].sh_info != 0)
3497         printf (" (%ld)", (long) section_headers[0].sh_info);
3498       putc ('\n', stdout);
3499       printf (_("  Size of section headers:           %ld (bytes)\n"),
3500               (long) elf_header.e_shentsize);
3501       printf (_("  Number of section headers:         %ld"),
3502               (long) elf_header.e_shnum);
3503       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
3504         printf (" (%ld)", (long) section_headers[0].sh_size);
3505       putc ('\n', stdout);
3506       printf (_("  Section header string table index: %ld"),
3507               (long) elf_header.e_shstrndx);
3508       if (section_headers != NULL
3509           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3510         printf (" (%u)", section_headers[0].sh_link);
3511       else if (elf_header.e_shstrndx != SHN_UNDEF
3512                && elf_header.e_shstrndx >= elf_header.e_shnum)
3513         printf (_(" <corrupt: out of range>"));
3514       putc ('\n', stdout);
3515     }
3516
3517   if (section_headers != NULL)
3518     {
3519       if (elf_header.e_phnum == PN_XNUM
3520           && section_headers[0].sh_info != 0)
3521         elf_header.e_phnum = section_headers[0].sh_info;
3522       if (elf_header.e_shnum == SHN_UNDEF)
3523         elf_header.e_shnum = section_headers[0].sh_size;
3524       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3525         elf_header.e_shstrndx = section_headers[0].sh_link;
3526       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3527         elf_header.e_shstrndx = SHN_UNDEF;
3528       free (section_headers);
3529       section_headers = NULL;
3530     }
3531
3532   return 1;
3533 }
3534
3535
3536 static int
3537 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3538 {
3539   Elf32_External_Phdr * phdrs;
3540   Elf32_External_Phdr * external;
3541   Elf_Internal_Phdr *   internal;
3542   unsigned int i;
3543
3544   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3545                                             elf_header.e_phentsize,
3546                                             elf_header.e_phnum,
3547                                             _("program headers"));
3548   if (!phdrs)
3549     return 0;
3550
3551   for (i = 0, internal = pheaders, external = phdrs;
3552        i < elf_header.e_phnum;
3553        i++, internal++, external++)
3554     {
3555       internal->p_type   = BYTE_GET (external->p_type);
3556       internal->p_offset = BYTE_GET (external->p_offset);
3557       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
3558       internal->p_paddr  = BYTE_GET (external->p_paddr);
3559       internal->p_filesz = BYTE_GET (external->p_filesz);
3560       internal->p_memsz  = BYTE_GET (external->p_memsz);
3561       internal->p_flags  = BYTE_GET (external->p_flags);
3562       internal->p_align  = BYTE_GET (external->p_align);
3563     }
3564
3565   free (phdrs);
3566
3567   return 1;
3568 }
3569
3570 static int
3571 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3572 {
3573   Elf64_External_Phdr * phdrs;
3574   Elf64_External_Phdr * external;
3575   Elf_Internal_Phdr *   internal;
3576   unsigned int i;
3577
3578   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3579                                             elf_header.e_phentsize,
3580                                             elf_header.e_phnum,
3581                                             _("program headers"));
3582   if (!phdrs)
3583     return 0;
3584
3585   for (i = 0, internal = pheaders, external = phdrs;
3586        i < elf_header.e_phnum;
3587        i++, internal++, external++)
3588     {
3589       internal->p_type   = BYTE_GET (external->p_type);
3590       internal->p_flags  = BYTE_GET (external->p_flags);
3591       internal->p_offset = BYTE_GET (external->p_offset);
3592       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
3593       internal->p_paddr  = BYTE_GET (external->p_paddr);
3594       internal->p_filesz = BYTE_GET (external->p_filesz);
3595       internal->p_memsz  = BYTE_GET (external->p_memsz);
3596       internal->p_align  = BYTE_GET (external->p_align);
3597     }
3598
3599   free (phdrs);
3600
3601   return 1;
3602 }
3603
3604 /* Returns 1 if the program headers were read into `program_headers'.  */
3605
3606 static int
3607 get_program_headers (FILE * file)
3608 {
3609   Elf_Internal_Phdr * phdrs;
3610
3611   /* Check cache of prior read.  */
3612   if (program_headers != NULL)
3613     return 1;
3614
3615   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3616                                          sizeof (Elf_Internal_Phdr));
3617
3618   if (phdrs == NULL)
3619     {
3620       error (_("Out of memory\n"));
3621       return 0;
3622     }
3623
3624   if (is_32bit_elf
3625       ? get_32bit_program_headers (file, phdrs)
3626       : get_64bit_program_headers (file, phdrs))
3627     {
3628       program_headers = phdrs;
3629       return 1;
3630     }
3631
3632   free (phdrs);
3633   return 0;
3634 }
3635
3636 /* Returns 1 if the program headers were loaded.  */
3637
3638 static int
3639 process_program_headers (FILE * file)
3640 {
3641   Elf_Internal_Phdr * segment;
3642   unsigned int i;
3643
3644   if (elf_header.e_phnum == 0)
3645     {
3646       /* PR binutils/12467.  */
3647       if (elf_header.e_phoff != 0)
3648         warn (_("possibly corrupt ELF header - it has a non-zero program"
3649                 " header offset, but no program headers"));
3650       else if (do_segments)
3651         printf (_("\nThere are no program headers in this file.\n"));
3652       return 0;
3653     }
3654
3655   if (do_segments && !do_header)
3656     {
3657       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3658       printf (_("Entry point "));
3659       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3660       printf (_("\nThere are %d program headers, starting at offset "),
3661               elf_header.e_phnum);
3662       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3663       printf ("\n");
3664     }
3665
3666   if (! get_program_headers (file))
3667       return 0;
3668
3669   if (do_segments)
3670     {
3671       if (elf_header.e_phnum > 1)
3672         printf (_("\nProgram Headers:\n"));
3673       else
3674         printf (_("\nProgram Headers:\n"));
3675
3676       if (is_32bit_elf)
3677         printf
3678           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
3679       else if (do_wide)
3680         printf
3681           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
3682       else
3683         {
3684           printf
3685             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
3686           printf
3687             (_("                 FileSiz            MemSiz              Flags  Align\n"));
3688         }
3689     }
3690
3691   dynamic_addr = 0;
3692   dynamic_size = 0;
3693
3694   for (i = 0, segment = program_headers;
3695        i < elf_header.e_phnum;
3696        i++, segment++)
3697     {
3698       if (do_segments)
3699         {
3700           printf ("  %-14.14s ", get_segment_type (segment->p_type));
3701
3702           if (is_32bit_elf)
3703             {
3704               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3705               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3706               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3707               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3708               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3709               printf ("%c%c%c ",
3710                       (segment->p_flags & PF_R ? 'R' : ' '),
3711                       (segment->p_flags & PF_W ? 'W' : ' '),
3712                       (segment->p_flags & PF_X ? 'E' : ' '));
3713               printf ("%#lx", (unsigned long) segment->p_align);
3714             }
3715           else if (do_wide)
3716             {
3717               if ((unsigned long) segment->p_offset == segment->p_offset)
3718                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3719               else
3720                 {
3721                   print_vma (segment->p_offset, FULL_HEX);
3722                   putchar (' ');
3723                 }
3724
3725               print_vma (segment->p_vaddr, FULL_HEX);
3726               putchar (' ');
3727               print_vma (segment->p_paddr, FULL_HEX);
3728               putchar (' ');
3729
3730               if ((unsigned long) segment->p_filesz == segment->p_filesz)
3731                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3732               else
3733                 {
3734                   print_vma (segment->p_filesz, FULL_HEX);
3735                   putchar (' ');
3736                 }
3737
3738               if ((unsigned long) segment->p_memsz == segment->p_memsz)
3739                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3740               else
3741                 {
3742                   print_vma (segment->p_offset, FULL_HEX);
3743                 }
3744
3745               printf (" %c%c%c ",
3746                       (segment->p_flags & PF_R ? 'R' : ' '),
3747                       (segment->p_flags & PF_W ? 'W' : ' '),
3748                       (segment->p_flags & PF_X ? 'E' : ' '));
3749
3750               if ((unsigned long) segment->p_align == segment->p_align)
3751                 printf ("%#lx", (unsigned long) segment->p_align);
3752               else
3753                 {
3754                   print_vma (segment->p_align, PREFIX_HEX);
3755                 }
3756             }
3757           else
3758             {
3759               print_vma (segment->p_offset, FULL_HEX);
3760               putchar (' ');
3761               print_vma (segment->p_vaddr, FULL_HEX);
3762               putchar (' ');
3763               print_vma (segment->p_paddr, FULL_HEX);
3764               printf ("\n                 ");
3765               print_vma (segment->p_filesz, FULL_HEX);
3766               putchar (' ');
3767               print_vma (segment->p_memsz, FULL_HEX);
3768               printf ("  %c%c%c    ",
3769                       (segment->p_flags & PF_R ? 'R' : ' '),
3770                       (segment->p_flags & PF_W ? 'W' : ' '),
3771                       (segment->p_flags & PF_X ? 'E' : ' '));
3772               print_vma (segment->p_align, HEX);
3773             }
3774         }
3775
3776       switch (segment->p_type)
3777         {
3778         case PT_DYNAMIC:
3779           if (dynamic_addr)
3780             error (_("more than one dynamic segment\n"));
3781
3782           /* By default, assume that the .dynamic section is the first
3783              section in the DYNAMIC segment.  */
3784           dynamic_addr = segment->p_offset;
3785           dynamic_size = segment->p_filesz;
3786
3787           /* Try to locate the .dynamic section. If there is
3788              a section header table, we can easily locate it.  */
3789           if (section_headers != NULL)
3790             {
3791               Elf_Internal_Shdr * sec;
3792
3793               sec = find_section (".dynamic");
3794               if (sec == NULL || sec->sh_size == 0)
3795                 {
3796                   /* A corresponding .dynamic section is expected, but on
3797                      IA-64/OpenVMS it is OK for it to be missing.  */
3798                   if (!is_ia64_vms ())
3799                     error (_("no .dynamic section in the dynamic segment\n"));
3800                   break;
3801                 }
3802
3803               if (sec->sh_type == SHT_NOBITS)
3804                 {
3805                   dynamic_size = 0;
3806                   break;
3807                 }
3808
3809               dynamic_addr = sec->sh_offset;
3810               dynamic_size = sec->sh_size;
3811
3812               if (dynamic_addr < segment->p_offset
3813                   || dynamic_addr > segment->p_offset + segment->p_filesz)
3814                 warn (_("the .dynamic section is not contained"
3815                         " within the dynamic segment\n"));
3816               else if (dynamic_addr > segment->p_offset)
3817                 warn (_("the .dynamic section is not the first section"
3818                         " in the dynamic segment.\n"));
3819             }
3820           break;
3821
3822         case PT_INTERP:
3823           if (fseek (file, archive_file_offset + (long) segment->p_offset,
3824                      SEEK_SET))
3825             error (_("Unable to find program interpreter name\n"));
3826           else
3827             {
3828               char fmt [32];
3829               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3830
3831               if (ret >= (int) sizeof (fmt) || ret < 0)
3832                 error (_("Internal error: failed to create format string to display program interpreter\n"));
3833
3834               program_interpreter[0] = 0;
3835               if (fscanf (file, fmt, program_interpreter) <= 0)
3836                 error (_("Unable to read program interpreter name\n"));
3837
3838               if (do_segments)
3839                 printf (_("\n      [Requesting program interpreter: %s]"),
3840                     program_interpreter);
3841             }
3842           break;
3843         }
3844
3845       if (do_segments)
3846         putc ('\n', stdout);
3847     }
3848
3849   if (do_segments && section_headers != NULL && string_table != NULL)
3850     {
3851       printf (_("\n Section to Segment mapping:\n"));
3852       printf (_("  Segment Sections...\n"));
3853
3854       for (i = 0; i < elf_header.e_phnum; i++)
3855         {
3856           unsigned int j;
3857           Elf_Internal_Shdr * section;
3858
3859           segment = program_headers + i;
3860           section = section_headers + 1;
3861
3862           printf ("   %2.2d     ", i);
3863
3864           for (j = 1; j < elf_header.e_shnum; j++, section++)
3865             {
3866               if (!ELF_TBSS_SPECIAL (section, segment)
3867                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
3868                 printf ("%s ", SECTION_NAME (section));
3869             }
3870
3871           putc ('\n',stdout);
3872         }
3873     }
3874
3875   return 1;
3876 }
3877
3878
3879 /* Find the file offset corresponding to VMA by using the program headers.  */
3880
3881 static long
3882 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
3883 {
3884   Elf_Internal_Phdr * seg;
3885
3886   if (! get_program_headers (file))
3887     {
3888       warn (_("Cannot interpret virtual addresses without program headers.\n"));
3889       return (long) vma;
3890     }
3891
3892   for (seg = program_headers;
3893        seg < program_headers + elf_header.e_phnum;
3894        ++seg)
3895     {
3896       if (seg->p_type != PT_LOAD)
3897         continue;
3898
3899       if (vma >= (seg->p_vaddr & -seg->p_align)
3900           && vma + size <= seg->p_vaddr + seg->p_filesz)
3901         return vma - seg->p_vaddr + seg->p_offset;
3902     }
3903
3904   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3905         (unsigned long) vma);
3906   return (long) vma;
3907 }
3908
3909
3910 static int
3911 get_32bit_section_headers (FILE * file, unsigned int num)
3912 {
3913   Elf32_External_Shdr * shdrs;
3914   Elf_Internal_Shdr *   internal;
3915   unsigned int i;
3916
3917   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3918                                             elf_header.e_shentsize, num,
3919                                             _("section headers"));
3920   if (!shdrs)
3921     return 0;
3922
3923   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3924                                                    sizeof (Elf_Internal_Shdr));
3925
3926   if (section_headers == NULL)
3927     {
3928       error (_("Out of memory\n"));
3929       return 0;
3930     }
3931
3932   for (i = 0, internal = section_headers;
3933        i < num;
3934        i++, internal++)
3935     {
3936       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
3937       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
3938       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
3939       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
3940       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
3941       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
3942       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
3943       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
3944       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3945       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
3946     }
3947
3948   free (shdrs);
3949
3950   return 1;
3951 }
3952
3953 static int
3954 get_64bit_section_headers (FILE * file, unsigned int num)
3955 {
3956   Elf64_External_Shdr * shdrs;
3957   Elf_Internal_Shdr *   internal;
3958   unsigned int i;
3959
3960   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3961                                             elf_header.e_shentsize, num,
3962                                             _("section headers"));
3963   if (!shdrs)
3964     return 0;
3965
3966   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3967                                                    sizeof (Elf_Internal_Shdr));
3968
3969   if (section_headers == NULL)
3970     {
3971       error (_("Out of memory\n"));
3972       return 0;
3973     }
3974
3975   for (i = 0, internal = section_headers;
3976        i < num;
3977        i++, internal++)
3978     {
3979       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
3980       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
3981       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
3982       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
3983       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
3984       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
3985       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
3986       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
3987       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
3988       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3989     }
3990
3991   free (shdrs);
3992
3993   return 1;
3994 }
3995
3996 static Elf_Internal_Sym *
3997 get_32bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
3998 {
3999   unsigned long number;
4000   Elf32_External_Sym * esyms = NULL;
4001   Elf_External_Sym_Shndx * shndx;
4002   Elf_Internal_Sym * isyms = NULL;
4003   Elf_Internal_Sym * psym;
4004   unsigned int j;
4005
4006   /* Run some sanity checks first.  */
4007   if (section->sh_entsize == 0)
4008     {
4009       error (_("sh_entsize is zero\n"));
4010       return NULL;
4011     }
4012
4013   number = section->sh_size / section->sh_entsize;
4014
4015   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4016     {
4017       error (_("Invalid sh_entsize\n"));
4018       return NULL;
4019     }
4020
4021   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4022                                            section->sh_size, _("symbols"));
4023   if (esyms == NULL)
4024     return NULL;
4025
4026   shndx = NULL;
4027   if (symtab_shndx_hdr != NULL
4028       && (symtab_shndx_hdr->sh_link
4029           == (unsigned long) (section - section_headers)))
4030     {
4031       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4032                                                    symtab_shndx_hdr->sh_offset,
4033                                                    1, symtab_shndx_hdr->sh_size,
4034                                                    _("symtab shndx"));
4035       if (shndx == NULL)
4036         goto exit_point;
4037     }
4038
4039   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4040
4041   if (isyms == NULL)
4042     {
4043       error (_("Out of memory\n"));
4044       goto exit_point;
4045     }
4046
4047   for (j = 0, psym = isyms; j < number; j++, psym++)
4048     {
4049       psym->st_name  = BYTE_GET (esyms[j].st_name);
4050       psym->st_value = BYTE_GET (esyms[j].st_value);
4051       psym->st_size  = BYTE_GET (esyms[j].st_size);
4052       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4053       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4054         psym->st_shndx
4055           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4056       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4057         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4058       psym->st_info  = BYTE_GET (esyms[j].st_info);
4059       psym->st_other = BYTE_GET (esyms[j].st_other);
4060     }
4061
4062  exit_point:
4063   if (shndx)
4064     free (shndx);
4065   if (esyms)
4066     free (esyms);
4067
4068   return isyms;
4069 }
4070
4071 static Elf_Internal_Sym *
4072 get_64bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
4073 {
4074   unsigned long number;
4075   Elf64_External_Sym * esyms;
4076   Elf_External_Sym_Shndx * shndx;
4077   Elf_Internal_Sym * isyms;
4078   Elf_Internal_Sym * psym;
4079   unsigned int j;
4080
4081   /* Run some sanity checks first.  */
4082   if (section->sh_entsize == 0)
4083     {
4084       error (_("sh_entsize is zero\n"));
4085       return NULL;
4086     }
4087
4088   number = section->sh_size / section->sh_entsize;
4089
4090   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4091     {
4092       error (_("Invalid sh_entsize\n"));
4093       return NULL;
4094     }
4095
4096   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4097                                            section->sh_size, _("symbols"));
4098   if (!esyms)
4099     return NULL;
4100
4101   shndx = NULL;
4102   if (symtab_shndx_hdr != NULL
4103       && (symtab_shndx_hdr->sh_link
4104           == (unsigned long) (section - section_headers)))
4105     {
4106       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4107                                                    symtab_shndx_hdr->sh_offset,
4108                                                    1, symtab_shndx_hdr->sh_size,
4109                                                    _("symtab shndx"));
4110       if (!shndx)
4111         {
4112           free (esyms);
4113           return NULL;
4114         }
4115     }
4116
4117   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4118
4119   if (isyms == NULL)
4120     {
4121       error (_("Out of memory\n"));
4122       if (shndx)
4123         free (shndx);
4124       free (esyms);
4125       return NULL;
4126     }
4127
4128   for (j = 0, psym = isyms;
4129        j < number;
4130        j++, psym++)
4131     {
4132       psym->st_name  = BYTE_GET (esyms[j].st_name);
4133       psym->st_info  = BYTE_GET (esyms[j].st_info);
4134       psym->st_other = BYTE_GET (esyms[j].st_other);
4135       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4136       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4137         psym->st_shndx
4138           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4139       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4140         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4141       psym->st_value = BYTE_GET (esyms[j].st_value);
4142       psym->st_size  = BYTE_GET (esyms[j].st_size);
4143     }
4144
4145   if (shndx)
4146     free (shndx);
4147   free (esyms);
4148
4149   return isyms;
4150 }
4151
4152 static const char *
4153 get_elf_section_flags (bfd_vma sh_flags)
4154 {
4155   static char buff[1024];
4156   char * p = buff;
4157   int field_size = is_32bit_elf ? 8 : 16;
4158   int sindex;
4159   int size = sizeof (buff) - (field_size + 4 + 1);
4160   bfd_vma os_flags = 0;
4161   bfd_vma proc_flags = 0;
4162   bfd_vma unknown_flags = 0;
4163   static const struct
4164     {
4165       const char * str;
4166       int len;
4167     }
4168   flags [] =
4169     {
4170       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
4171       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
4172       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
4173       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
4174       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
4175       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
4176       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4177       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4178       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
4179       /*  9 */ { STRING_COMMA_LEN ("TLS") },
4180       /* IA-64 specific.  */
4181       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4182       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4183       /* IA-64 OpenVMS specific.  */
4184       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4185       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4186       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4187       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4188       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4189       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4190       /* Generic.  */
4191       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4192       /* SPARC specific.  */
4193       /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4194     };
4195
4196   if (do_section_details)
4197     {
4198       sprintf (buff, "[%*.*lx]: ",
4199                field_size, field_size, (unsigned long) sh_flags);
4200       p += field_size + 4;
4201     }
4202
4203   while (sh_flags)
4204     {
4205       bfd_vma flag;
4206
4207       flag = sh_flags & - sh_flags;
4208       sh_flags &= ~ flag;
4209
4210       if (do_section_details)
4211         {
4212           switch (flag)
4213             {
4214             case SHF_WRITE:             sindex = 0; break;
4215             case SHF_ALLOC:             sindex = 1; break;
4216             case SHF_EXECINSTR:         sindex = 2; break;
4217             case SHF_MERGE:             sindex = 3; break;
4218             case SHF_STRINGS:           sindex = 4; break;
4219             case SHF_INFO_LINK:         sindex = 5; break;
4220             case SHF_LINK_ORDER:        sindex = 6; break;
4221             case SHF_OS_NONCONFORMING:  sindex = 7; break;
4222             case SHF_GROUP:             sindex = 8; break;
4223             case SHF_TLS:               sindex = 9; break;
4224             case SHF_EXCLUDE:           sindex = 18; break;
4225
4226             default:
4227               sindex = -1;
4228               switch (elf_header.e_machine)
4229                 {
4230                 case EM_IA_64:
4231                   if (flag == SHF_IA_64_SHORT)
4232                     sindex = 10;
4233                   else if (flag == SHF_IA_64_NORECOV)
4234                     sindex = 11;
4235 #ifdef BFD64
4236                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4237                     switch (flag)
4238                       {
4239                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
4240                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
4241                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
4242                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
4243                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4244                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
4245                       default:                        break;
4246                       }
4247 #endif
4248                   break;
4249
4250                 case EM_386:
4251                 case EM_486:
4252                 case EM_X86_64:
4253                 case EM_L1OM:
4254                 case EM_OLD_SPARCV9:
4255                 case EM_SPARC32PLUS:
4256                 case EM_SPARCV9:
4257                 case EM_SPARC:
4258                   if (flag == SHF_ORDERED)
4259                     sindex = 19;
4260                   break;
4261                 default:
4262                   break;
4263                 }
4264             }
4265
4266           if (sindex != -1)
4267             {
4268               if (p != buff + field_size + 4)
4269                 {
4270                   if (size < (10 + 2))
4271                     abort ();
4272                   size -= 2;
4273                   *p++ = ',';
4274                   *p++ = ' ';
4275                 }
4276
4277               size -= flags [sindex].len;
4278               p = stpcpy (p, flags [sindex].str);
4279             }
4280           else if (flag & SHF_MASKOS)
4281             os_flags |= flag;
4282           else if (flag & SHF_MASKPROC)
4283             proc_flags |= flag;
4284           else
4285             unknown_flags |= flag;
4286         }
4287       else
4288         {
4289           switch (flag)
4290             {
4291             case SHF_WRITE:             *p = 'W'; break;
4292             case SHF_ALLOC:             *p = 'A'; break;
4293             case SHF_EXECINSTR:         *p = 'X'; break;
4294             case SHF_MERGE:             *p = 'M'; break;
4295             case SHF_STRINGS:           *p = 'S'; break;
4296             case SHF_INFO_LINK:         *p = 'I'; break;
4297             case SHF_LINK_ORDER:        *p = 'L'; break;
4298             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
4299             case SHF_GROUP:             *p = 'G'; break;
4300             case SHF_TLS:               *p = 'T'; break;
4301             case SHF_EXCLUDE:           *p = 'E'; break;
4302
4303             default:
4304               if ((elf_header.e_machine == EM_X86_64
4305                    || elf_header.e_machine == EM_L1OM)
4306                   && flag == SHF_X86_64_LARGE)
4307                 *p = 'l';
4308               else if (flag & SHF_MASKOS)
4309                 {
4310                   *p = 'o';
4311                   sh_flags &= ~ SHF_MASKOS;
4312                 }
4313               else if (flag & SHF_MASKPROC)
4314                 {
4315                   *p = 'p';
4316                   sh_flags &= ~ SHF_MASKPROC;
4317                 }
4318               else
4319                 *p = 'x';
4320               break;
4321             }
4322           p++;
4323         }
4324     }
4325
4326   if (do_section_details)
4327     {
4328       if (os_flags)
4329         {
4330           size -= 5 + field_size;
4331           if (p != buff + field_size + 4)
4332             {
4333               if (size < (2 + 1))
4334                 abort ();
4335               size -= 2;
4336               *p++ = ',';
4337               *p++ = ' ';
4338             }
4339           sprintf (p, "OS (%*.*lx)", field_size, field_size,
4340                    (unsigned long) os_flags);
4341           p += 5 + field_size;
4342         }
4343       if (proc_flags)
4344         {
4345           size -= 7 + field_size;
4346           if (p != buff + field_size + 4)
4347             {
4348               if (size < (2 + 1))
4349                 abort ();
4350               size -= 2;
4351               *p++ = ',';
4352               *p++ = ' ';
4353             }
4354           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4355                    (unsigned long) proc_flags);
4356           p += 7 + field_size;
4357         }
4358       if (unknown_flags)
4359         {
4360           size -= 10 + field_size;
4361           if (p != buff + field_size + 4)
4362             {
4363               if (size < (2 + 1))
4364                 abort ();
4365               size -= 2;
4366               *p++ = ',';
4367               *p++ = ' ';
4368             }
4369           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
4370                    (unsigned long) unknown_flags);
4371           p += 10 + field_size;
4372         }
4373     }
4374
4375   *p = '\0';
4376   return buff;
4377 }
4378
4379 static int
4380 process_section_headers (FILE * file)
4381 {
4382   Elf_Internal_Shdr * section;
4383   unsigned int i;
4384
4385   section_headers = NULL;
4386
4387   if (elf_header.e_shnum == 0)
4388     {
4389       /* PR binutils/12467.  */
4390       if (elf_header.e_shoff != 0)
4391         warn (_("possibly corrupt ELF file header - it has a non-zero"
4392                 " section header offset, but no section headers\n"));
4393       else if (do_sections)
4394         printf (_("\nThere are no sections in this file.\n"));
4395
4396       return 1;
4397     }
4398
4399   if (do_sections && !do_header)
4400     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4401             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4402
4403   if (is_32bit_elf)
4404     {
4405       if (! get_32bit_section_headers (file, elf_header.e_shnum))
4406         return 0;
4407     }
4408   else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4409     return 0;
4410
4411   /* Read in the string table, so that we have names to display.  */
4412   if (elf_header.e_shstrndx != SHN_UNDEF
4413        && elf_header.e_shstrndx < elf_header.e_shnum)
4414     {
4415       section = section_headers + elf_header.e_shstrndx;
4416
4417       if (section->sh_size != 0)
4418         {
4419           string_table = (char *) get_data (NULL, file, section->sh_offset,
4420                                             1, section->sh_size,
4421                                             _("string table"));
4422
4423           string_table_length = string_table != NULL ? section->sh_size : 0;
4424         }
4425     }
4426
4427   /* Scan the sections for the dynamic symbol table
4428      and dynamic string table and debug sections.  */
4429   dynamic_symbols = NULL;
4430   dynamic_strings = NULL;
4431   dynamic_syminfo = NULL;
4432   symtab_shndx_hdr = NULL;
4433
4434   eh_addr_size = is_32bit_elf ? 4 : 8;
4435   switch (elf_header.e_machine)
4436     {
4437     case EM_MIPS:
4438     case EM_MIPS_RS3_LE:
4439       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4440          FDE addresses.  However, the ABI also has a semi-official ILP32
4441          variant for which the normal FDE address size rules apply.
4442
4443          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4444          section, where XX is the size of longs in bits.  Unfortunately,
4445          earlier compilers provided no way of distinguishing ILP32 objects
4446          from LP64 objects, so if there's any doubt, we should assume that
4447          the official LP64 form is being used.  */
4448       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4449           && find_section (".gcc_compiled_long32") == NULL)
4450         eh_addr_size = 8;
4451       break;
4452
4453     case EM_H8_300:
4454     case EM_H8_300H:
4455       switch (elf_header.e_flags & EF_H8_MACH)
4456         {
4457         case E_H8_MACH_H8300:
4458         case E_H8_MACH_H8300HN:
4459         case E_H8_MACH_H8300SN:
4460         case E_H8_MACH_H8300SXN:
4461           eh_addr_size = 2;
4462           break;
4463         case E_H8_MACH_H8300H:
4464         case E_H8_MACH_H8300S:
4465         case E_H8_MACH_H8300SX:
4466           eh_addr_size = 4;
4467           break;
4468         }
4469       break;
4470
4471     case EM_M32C_OLD:
4472     case EM_M32C:
4473       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4474         {
4475         case EF_M32C_CPU_M16C:
4476           eh_addr_size = 2;
4477           break;
4478         }
4479       break;
4480     }
4481
4482 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4483   do                                                                        \
4484     {                                                                       \
4485       size_t expected_entsize                                               \
4486         = is_32bit_elf ? size32 : size64;                                   \
4487       if (section->sh_entsize != expected_entsize)                          \
4488         error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4489                i, (unsigned long int) section->sh_entsize,                  \
4490                (unsigned long int) expected_entsize);                       \
4491       section->sh_entsize = expected_entsize;                               \
4492     }                                                                       \
4493   while (0)
4494 #define CHECK_ENTSIZE(section, i, type) \
4495   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
4496                         sizeof (Elf64_External_##type))
4497
4498   for (i = 0, section = section_headers;
4499        i < elf_header.e_shnum;
4500        i++, section++)
4501     {
4502       char * name = SECTION_NAME (section);
4503
4504       if (section->sh_type == SHT_DYNSYM)
4505         {
4506           if (dynamic_symbols != NULL)
4507             {
4508               error (_("File contains multiple dynamic symbol tables\n"));
4509               continue;
4510             }
4511
4512           CHECK_ENTSIZE (section, i, Sym);
4513           num_dynamic_syms = section->sh_size / section->sh_entsize;
4514           dynamic_symbols = GET_ELF_SYMBOLS (file, section);
4515         }
4516       else if (section->sh_type == SHT_STRTAB
4517                && streq (name, ".dynstr"))
4518         {
4519           if (dynamic_strings != NULL)
4520             {
4521               error (_("File contains multiple dynamic string tables\n"));
4522               continue;
4523             }
4524
4525           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4526                                                1, section->sh_size,
4527                                                _("dynamic strings"));
4528           dynamic_strings_length = section->sh_size;
4529         }
4530       else if (section->sh_type == SHT_SYMTAB_SHNDX)
4531         {
4532           if (symtab_shndx_hdr != NULL)
4533             {
4534               error (_("File contains multiple symtab shndx tables\n"));
4535               continue;
4536             }
4537           symtab_shndx_hdr = section;
4538         }
4539       else if (section->sh_type == SHT_SYMTAB)
4540         CHECK_ENTSIZE (section, i, Sym);
4541       else if (section->sh_type == SHT_GROUP)
4542         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4543       else if (section->sh_type == SHT_REL)
4544         CHECK_ENTSIZE (section, i, Rel);
4545       else if (section->sh_type == SHT_RELA)
4546         CHECK_ENTSIZE (section, i, Rela);
4547       else if ((do_debugging || do_debug_info || do_debug_abbrevs
4548                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
4549                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
4550                 || do_debug_str || do_debug_loc || do_debug_ranges)
4551                && (const_strneq (name, ".debug_")
4552                    || const_strneq (name, ".zdebug_")))
4553         {
4554           if (name[1] == 'z')
4555             name += sizeof (".zdebug_") - 1;
4556           else
4557             name += sizeof (".debug_") - 1;
4558
4559           if (do_debugging
4560               || (do_debug_info     && streq (name, "info"))
4561               || (do_debug_info     && streq (name, "types"))
4562               || (do_debug_abbrevs  && streq (name, "abbrev"))
4563               || (do_debug_lines    && streq (name, "line"))
4564               || (do_debug_pubnames && streq (name, "pubnames"))
4565               || (do_debug_pubtypes && streq (name, "pubtypes"))
4566               || (do_debug_aranges  && streq (name, "aranges"))
4567               || (do_debug_ranges   && streq (name, "ranges"))
4568               || (do_debug_frames   && streq (name, "frame"))
4569               || (do_debug_macinfo  && streq (name, "macinfo"))
4570               || (do_debug_str      && streq (name, "str"))
4571               || (do_debug_loc      && streq (name, "loc"))
4572               )
4573             request_dump_bynumber (i, DEBUG_DUMP);
4574         }
4575       /* Linkonce section to be combined with .debug_info at link time.  */
4576       else if ((do_debugging || do_debug_info)
4577                && const_strneq (name, ".gnu.linkonce.wi."))
4578         request_dump_bynumber (i, DEBUG_DUMP);
4579       else if (do_debug_frames && streq (name, ".eh_frame"))
4580         request_dump_bynumber (i, DEBUG_DUMP);
4581       else if (do_gdb_index && streq (name, ".gdb_index"))
4582         request_dump_bynumber (i, DEBUG_DUMP);
4583       /* Trace sections for Itanium VMS.  */
4584       else if ((do_debugging || do_trace_info || do_trace_abbrevs
4585                 || do_trace_aranges)
4586                && const_strneq (name, ".trace_"))
4587         {
4588           name += sizeof (".trace_") - 1;
4589
4590           if (do_debugging
4591               || (do_trace_info     && streq (name, "info"))
4592               || (do_trace_abbrevs  && streq (name, "abbrev"))
4593               || (do_trace_aranges  && streq (name, "aranges"))
4594               )
4595             request_dump_bynumber (i, DEBUG_DUMP);
4596         }
4597
4598     }
4599
4600   if (! do_sections)
4601     return 1;
4602
4603   if (elf_header.e_shnum > 1)
4604     printf (_("\nSection Headers:\n"));
4605   else
4606     printf (_("\nSection Header:\n"));
4607
4608   if (is_32bit_elf)
4609     {
4610       if (do_section_details)
4611         {
4612           printf (_("  [Nr] Name\n"));
4613           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
4614         }
4615       else
4616         printf
4617           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
4618     }
4619   else if (do_wide)
4620     {
4621       if (do_section_details)
4622         {
4623           printf (_("  [Nr] Name\n"));
4624           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
4625         }
4626       else
4627         printf
4628           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
4629     }
4630   else
4631     {
4632       if (do_section_details)
4633         {
4634           printf (_("  [Nr] Name\n"));
4635           printf (_("       Type              Address          Offset            Link\n"));
4636           printf (_("       Size              EntSize          Info              Align\n"));
4637         }
4638       else
4639         {
4640           printf (_("  [Nr] Name              Type             Address           Offset\n"));
4641           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
4642         }
4643     }
4644
4645   if (do_section_details)
4646     printf (_("       Flags\n"));
4647
4648   for (i = 0, section = section_headers;
4649        i < elf_header.e_shnum;
4650        i++, section++)
4651     {
4652       if (do_section_details)
4653         {
4654           printf ("  [%2u] %s\n",
4655                   i,
4656                   SECTION_NAME (section));
4657           if (is_32bit_elf || do_wide)
4658             printf ("       %-15.15s ",
4659                     get_section_type_name (section->sh_type));
4660         }
4661       else
4662         printf ((do_wide ? "  [%2u] %-17s %-15s "
4663                          : "  [%2u] %-17.17s %-15.15s "),
4664                 i,
4665                 SECTION_NAME (section),
4666                 get_section_type_name (section->sh_type));
4667
4668       if (is_32bit_elf)
4669         {
4670           const char * link_too_big = NULL;
4671
4672           print_vma (section->sh_addr, LONG_HEX);
4673
4674           printf ( " %6.6lx %6.6lx %2.2lx",
4675                    (unsigned long) section->sh_offset,
4676                    (unsigned long) section->sh_size,
4677                    (unsigned long) section->sh_entsize);
4678
4679           if (do_section_details)
4680             fputs ("  ", stdout);
4681           else
4682             printf (" %3s ", get_elf_section_flags (section->sh_flags));
4683
4684           if (section->sh_link >= elf_header.e_shnum)
4685             {
4686               link_too_big = "";
4687               /* The sh_link value is out of range.  Normally this indicates
4688                  an error but it can have special values in Solaris binaries.  */
4689               switch (elf_header.e_machine)
4690                 {
4691                 case EM_386:
4692                 case EM_486:
4693                 case EM_X86_64:
4694                 case EM_L1OM:
4695                 case EM_OLD_SPARCV9:
4696                 case EM_SPARC32PLUS:
4697                 case EM_SPARCV9:
4698                 case EM_SPARC:
4699                   if (section->sh_link == (SHN_BEFORE & 0xffff))
4700                     link_too_big = "BEFORE";
4701                   else if (section->sh_link == (SHN_AFTER & 0xffff))
4702                     link_too_big = "AFTER";
4703                   break;
4704                 default:
4705                   break;
4706                 }
4707             }
4708
4709           if (do_section_details)
4710             {
4711               if (link_too_big != NULL && * link_too_big)
4712                 printf ("<%s> ", link_too_big);
4713               else
4714                 printf ("%2u ", section->sh_link);
4715               printf ("%3u %2lu\n", section->sh_info,
4716                       (unsigned long) section->sh_addralign);
4717             }
4718           else
4719             printf ("%2u %3u %2lu\n",
4720                     section->sh_link,
4721                     section->sh_info,
4722                     (unsigned long) section->sh_addralign);
4723
4724           if (link_too_big && ! * link_too_big)
4725             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4726                   i, section->sh_link);
4727         }
4728       else if (do_wide)
4729         {
4730           print_vma (section->sh_addr, LONG_HEX);
4731
4732           if ((long) section->sh_offset == section->sh_offset)
4733             printf (" %6.6lx", (unsigned long) section->sh_offset);
4734           else
4735             {
4736               putchar (' ');
4737               print_vma (section->sh_offset, LONG_HEX);
4738             }
4739
4740           if ((unsigned long) section->sh_size == section->sh_size)
4741             printf (" %6.6lx", (unsigned long) section->sh_size);
4742           else
4743             {
4744               putchar (' ');
4745               print_vma (section->sh_size, LONG_HEX);
4746             }
4747
4748           if ((unsigned long) section->sh_entsize == section->sh_entsize)
4749             printf (" %2.2lx", (unsigned long) section->sh_entsize);
4750           else
4751             {
4752               putchar (' ');
4753               print_vma (section->sh_entsize, LONG_HEX);
4754             }
4755
4756           if (do_section_details)
4757             fputs ("  ", stdout);
4758           else
4759             printf (" %3s ", get_elf_section_flags (section->sh_flags));
4760
4761           printf ("%2u %3u ", section->sh_link, section->sh_info);
4762
4763           if ((unsigned long) section->sh_addralign == section->sh_addralign)
4764             printf ("%2lu\n", (unsigned long) section->sh_addralign);
4765           else
4766             {
4767               print_vma (section->sh_addralign, DEC);
4768               putchar ('\n');
4769             }
4770         }
4771       else if (do_section_details)
4772         {
4773           printf ("       %-15.15s  ",
4774                   get_section_type_name (section->sh_type));
4775           print_vma (section->sh_addr, LONG_HEX);
4776           if ((long) section->sh_offset == section->sh_offset)
4777             printf ("  %16.16lx", (unsigned long) section->sh_offset);
4778           else
4779             {
4780               printf ("  ");
4781               print_vma (section->sh_offset, LONG_HEX);
4782             }
4783           printf ("  %u\n       ", section->sh_link);
4784           print_vma (section->sh_size, LONG_HEX);
4785           putchar (' ');
4786           print_vma (section->sh_entsize, LONG_HEX);
4787
4788           printf ("  %-16u  %lu\n",
4789                   section->sh_info,
4790                   (unsigned long) section->sh_addralign);
4791         }
4792       else
4793         {
4794           putchar (' ');
4795           print_vma (section->sh_addr, LONG_HEX);
4796           if ((long) section->sh_offset == section->sh_offset)
4797             printf ("  %8.8lx", (unsigned long) section->sh_offset);
4798           else
4799             {
4800               printf ("  ");
4801               print_vma (section->sh_offset, LONG_HEX);
4802             }
4803           printf ("\n       ");
4804           print_vma (section->sh_size, LONG_HEX);
4805           printf ("  ");
4806           print_vma (section->sh_entsize, LONG_HEX);
4807
4808           printf (" %3s ", get_elf_section_flags (section->sh_flags));
4809
4810           printf ("     %2u   %3u     %lu\n",
4811                   section->sh_link,
4812                   section->sh_info,
4813                   (unsigned long) section->sh_addralign);
4814         }
4815
4816       if (do_section_details)
4817         printf ("       %s\n", get_elf_section_flags (section->sh_flags));
4818     }
4819
4820   if (!do_section_details)
4821     {
4822       if (elf_header.e_machine == EM_X86_64
4823           || elf_header.e_machine == EM_L1OM)
4824         printf (_("Key to Flags:\n\
4825   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
4826   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4827   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4828       else
4829         printf (_("Key to Flags:\n\
4830   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4831   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4832   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4833     }
4834
4835   return 1;
4836 }
4837
4838 static const char *
4839 get_group_flags (unsigned int flags)
4840 {
4841   static char buff[32];
4842   switch (flags)
4843     {
4844     case 0:
4845       return "";
4846
4847     case GRP_COMDAT:
4848       return "COMDAT ";
4849
4850    default:
4851       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
4852       break;
4853     }
4854   return buff;
4855 }
4856
4857 static int
4858 process_section_groups (FILE * file)
4859 {
4860   Elf_Internal_Shdr * section;
4861   unsigned int i;
4862   struct group * group;
4863   Elf_Internal_Shdr * symtab_sec;
4864   Elf_Internal_Shdr * strtab_sec;
4865   Elf_Internal_Sym * symtab;
4866   char * strtab;
4867   size_t strtab_size;
4868
4869   /* Don't process section groups unless needed.  */
4870   if (!do_unwind && !do_section_groups)
4871     return 1;
4872
4873   if (elf_header.e_shnum == 0)
4874     {
4875       if (do_section_groups)
4876         printf (_("\nThere are no sections to group in this file.\n"));
4877
4878       return 1;
4879     }
4880
4881   if (section_headers == NULL)
4882     {
4883       error (_("Section headers are not available!\n"));
4884       abort ();
4885     }
4886
4887   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
4888                                                      sizeof (struct group *));
4889
4890   if (section_headers_groups == NULL)
4891     {
4892       error (_("Out of memory\n"));
4893       return 0;
4894     }
4895
4896   /* Scan the sections for the group section.  */
4897   group_count = 0;
4898   for (i = 0, section = section_headers;
4899        i < elf_header.e_shnum;
4900        i++, section++)
4901     if (section->sh_type == SHT_GROUP)
4902       group_count++;
4903
4904   if (group_count == 0)
4905     {
4906       if (do_section_groups)
4907         printf (_("\nThere are no section groups in this file.\n"));
4908
4909       return 1;
4910     }
4911
4912   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
4913
4914   if (section_groups == NULL)
4915     {
4916       error (_("Out of memory\n"));
4917       return 0;
4918     }
4919
4920   symtab_sec = NULL;
4921   strtab_sec = NULL;
4922   symtab = NULL;
4923   strtab = NULL;
4924   strtab_size = 0;
4925   for (i = 0, section = section_headers, group = section_groups;
4926        i < elf_header.e_shnum;
4927        i++, section++)
4928     {
4929       if (section->sh_type == SHT_GROUP)
4930         {
4931           char * name = SECTION_NAME (section);
4932           char * group_name;
4933           unsigned char * start;
4934           unsigned char * indices;
4935           unsigned int entry, j, size;
4936           Elf_Internal_Shdr * sec;
4937           Elf_Internal_Sym * sym;
4938
4939           /* Get the symbol table.  */
4940           if (section->sh_link >= elf_header.e_shnum
4941               || ((sec = section_headers + section->sh_link)->sh_type
4942                   != SHT_SYMTAB))
4943             {
4944               error (_("Bad sh_link in group section `%s'\n"), name);
4945               continue;
4946             }
4947
4948           if (symtab_sec != sec)
4949             {
4950               symtab_sec = sec;
4951               if (symtab)
4952                 free (symtab);
4953               symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4954             }
4955
4956           if (symtab == NULL)
4957             {
4958               error (_("Corrupt header in group section `%s'\n"), name);
4959               continue;
4960             }
4961
4962           sym = symtab + section->sh_info;
4963
4964           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4965             {
4966               if (sym->st_shndx == 0
4967                   || sym->st_shndx >= elf_header.e_shnum)
4968                 {
4969                   error (_("Bad sh_info in group section `%s'\n"), name);
4970                   continue;
4971                 }
4972
4973               group_name = SECTION_NAME (section_headers + sym->st_shndx);
4974               strtab_sec = NULL;
4975               if (strtab)
4976                 free (strtab);
4977               strtab = NULL;
4978               strtab_size = 0;
4979             }
4980           else
4981             {
4982               /* Get the string table.  */
4983               if (symtab_sec->sh_link >= elf_header.e_shnum)
4984                 {
4985                   strtab_sec = NULL;
4986                   if (strtab)
4987                     free (strtab);
4988                   strtab = NULL;
4989                   strtab_size = 0;
4990                 }
4991               else if (strtab_sec
4992                        != (sec = section_headers + symtab_sec->sh_link))
4993                 {
4994                   strtab_sec = sec;
4995                   if (strtab)
4996                     free (strtab);
4997                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
4998                                               1, strtab_sec->sh_size,
4999                                               _("string table"));
5000                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5001                 }
5002               group_name = sym->st_name < strtab_size
5003                 ? strtab + sym->st_name : _("<corrupt>");
5004             }
5005
5006           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5007                                               1, section->sh_size,
5008                                               _("section data"));
5009
5010           indices = start;
5011           size = (section->sh_size / section->sh_entsize) - 1;
5012           entry = byte_get (indices, 4);
5013           indices += 4;
5014
5015           if (do_section_groups)
5016             {
5017               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5018                       get_group_flags (entry), i, name, group_name, size);
5019
5020               printf (_("   [Index]    Name\n"));
5021             }
5022
5023           group->group_index = i;
5024
5025           for (j = 0; j < size; j++)
5026             {
5027               struct group_list * g;
5028
5029               entry = byte_get (indices, 4);
5030               indices += 4;
5031
5032               if (entry >= elf_header.e_shnum)
5033                 {
5034                   error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5035                          entry, i, elf_header.e_shnum - 1);
5036                   continue;
5037                 }
5038
5039               if (section_headers_groups [entry] != NULL)
5040                 {
5041                   if (entry)
5042                     {
5043                       error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5044                              entry, i,
5045                              section_headers_groups [entry]->group_index);
5046                       continue;
5047                     }
5048                   else
5049                     {
5050                       /* Intel C/C++ compiler may put section 0 in a
5051                          section group. We just warn it the first time
5052                          and ignore it afterwards.  */
5053                       static int warned = 0;
5054                       if (!warned)
5055                         {
5056                           error (_("section 0 in group section [%5u]\n"),
5057                                  section_headers_groups [entry]->group_index);
5058                           warned++;
5059                         }
5060                     }
5061                 }
5062
5063               section_headers_groups [entry] = group;
5064
5065               if (do_section_groups)
5066                 {
5067                   sec = section_headers + entry;
5068                   printf ("   [%5u]   %s\n", entry, SECTION_NAME (sec));
5069                 }
5070
5071               g = (struct group_list *) xmalloc (sizeof (struct group_list));
5072               g->section_index = entry;
5073               g->next = group->root;
5074               group->root = g;
5075             }
5076
5077           if (start)
5078             free (start);
5079
5080           group++;
5081         }
5082     }
5083
5084   if (symtab)
5085     free (symtab);
5086   if (strtab)
5087     free (strtab);
5088   return 1;
5089 }
5090
5091 /* Data used to display dynamic fixups.  */
5092
5093 struct ia64_vms_dynfixup
5094 {
5095   bfd_vma needed_ident;         /* Library ident number.  */
5096   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
5097   bfd_vma fixup_needed;         /* Index of the library.  */
5098   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
5099   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
5100 };
5101
5102 /* Data used to display dynamic relocations.  */
5103
5104 struct ia64_vms_dynimgrela
5105 {
5106   bfd_vma img_rela_cnt;         /* Number of relocations.  */
5107   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
5108 };
5109
5110 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5111    library).  */
5112
5113 static void
5114 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5115                               const char *strtab, unsigned int strtab_sz)
5116 {
5117   Elf64_External_VMS_IMAGE_FIXUP *imfs;
5118   long i;
5119   const char *lib_name;
5120
5121   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5122                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
5123                    _("dynamic section image fixups"));
5124   if (!imfs)
5125     return;
5126
5127   if (fixup->needed < strtab_sz)
5128     lib_name = strtab + fixup->needed;
5129   else
5130     {
5131       warn ("corrupt library name index of 0x%lx found in dynamic entry",
5132             (unsigned long) fixup->needed);
5133       lib_name = "???";
5134     }
5135   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5136           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5137   printf
5138     (_("Seg Offset           Type                             SymVec DataType\n"));
5139
5140   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5141     {
5142       unsigned int type;
5143       const char *rtype;
5144
5145       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5146       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5147       type = BYTE_GET (imfs [i].type);
5148       rtype = elf_ia64_reloc_type (type);
5149       if (rtype == NULL)
5150         printf (" 0x%08x                       ", type);
5151       else
5152         printf (" %-32s ", rtype);
5153       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5154       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5155     }
5156
5157   free (imfs);
5158 }
5159
5160 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
5161
5162 static void
5163 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5164 {
5165   Elf64_External_VMS_IMAGE_RELA *imrs;
5166   long i;
5167
5168   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5169                    1, imgrela->img_rela_cnt * sizeof (*imrs),
5170                    _("dynamic section image relas"));
5171   if (!imrs)
5172     return;
5173
5174   printf (_("\nImage relocs\n"));
5175   printf
5176     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
5177
5178   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5179     {
5180       unsigned int type;
5181       const char *rtype;
5182
5183       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5184       printf ("%08" BFD_VMA_FMT "x ",
5185               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5186       type = BYTE_GET (imrs [i].type);
5187       rtype = elf_ia64_reloc_type (type);
5188       if (rtype == NULL)
5189         printf ("0x%08x                      ", type);
5190       else
5191         printf ("%-31s ", rtype);
5192       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5193       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5194       printf ("%08" BFD_VMA_FMT "x\n",
5195               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5196     }
5197
5198   free (imrs);
5199 }
5200
5201 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
5202
5203 static int
5204 process_ia64_vms_dynamic_relocs (FILE *file)
5205 {
5206   struct ia64_vms_dynfixup fixup;
5207   struct ia64_vms_dynimgrela imgrela;
5208   Elf_Internal_Dyn *entry;
5209   int res = 0;
5210   bfd_vma strtab_off = 0;
5211   bfd_vma strtab_sz = 0;
5212   char *strtab = NULL;
5213
5214   memset (&fixup, 0, sizeof (fixup));
5215   memset (&imgrela, 0, sizeof (imgrela));
5216
5217   /* Note: the order of the entries is specified by the OpenVMS specs.  */
5218   for (entry = dynamic_section;
5219        entry < dynamic_section + dynamic_nent;
5220        entry++)
5221     {
5222       switch (entry->d_tag)
5223         {
5224         case DT_IA_64_VMS_STRTAB_OFFSET:
5225           strtab_off = entry->d_un.d_val;
5226           break;
5227         case DT_STRSZ:
5228           strtab_sz = entry->d_un.d_val;
5229           if (strtab == NULL)
5230             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5231                                1, strtab_sz, _("dynamic string section"));
5232           break;
5233
5234         case DT_IA_64_VMS_NEEDED_IDENT:
5235           fixup.needed_ident = entry->d_un.d_val;
5236           break;
5237         case DT_NEEDED:
5238           fixup.needed = entry->d_un.d_val;
5239           break;
5240         case DT_IA_64_VMS_FIXUP_NEEDED:
5241           fixup.fixup_needed = entry->d_un.d_val;
5242           break;
5243         case DT_IA_64_VMS_FIXUP_RELA_CNT:
5244           fixup.fixup_rela_cnt = entry->d_un.d_val;
5245           break;
5246         case DT_IA_64_VMS_FIXUP_RELA_OFF:
5247           fixup.fixup_rela_off = entry->d_un.d_val;
5248           res++;
5249           dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5250           break;
5251
5252         case DT_IA_64_VMS_IMG_RELA_CNT:
5253           imgrela.img_rela_cnt = entry->d_un.d_val;
5254           break;
5255         case DT_IA_64_VMS_IMG_RELA_OFF:
5256           imgrela.img_rela_off = entry->d_un.d_val;
5257           res++;
5258           dump_ia64_vms_dynamic_relocs (file, &imgrela);
5259           break;
5260
5261         default:
5262           break;
5263         }
5264     }
5265
5266   if (strtab != NULL)
5267     free (strtab);
5268
5269   return res;
5270 }
5271
5272 static struct
5273 {
5274   const char * name;
5275   int reloc;
5276   int size;
5277   int rela;
5278 } dynamic_relocations [] =
5279 {
5280     { "REL", DT_REL, DT_RELSZ, FALSE },
5281     { "RELA", DT_RELA, DT_RELASZ, TRUE },
5282     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5283 };
5284
5285 /* Process the reloc section.  */
5286
5287 static int
5288 process_relocs (FILE * file)
5289 {
5290   unsigned long rel_size;
5291   unsigned long rel_offset;
5292
5293
5294   if (!do_reloc)
5295     return 1;
5296
5297   if (do_using_dynamic)
5298     {
5299       int is_rela;
5300       const char * name;
5301       int has_dynamic_reloc;
5302       unsigned int i;
5303
5304       has_dynamic_reloc = 0;
5305
5306       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5307         {
5308           is_rela = dynamic_relocations [i].rela;
5309           name = dynamic_relocations [i].name;
5310           rel_size = dynamic_info [dynamic_relocations [i].size];
5311           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5312
5313           has_dynamic_reloc |= rel_size;
5314
5315           if (is_rela == UNKNOWN)
5316             {
5317               if (dynamic_relocations [i].reloc == DT_JMPREL)
5318                 switch (dynamic_info[DT_PLTREL])
5319                   {
5320                   case DT_REL:
5321                     is_rela = FALSE;
5322                     break;
5323                   case DT_RELA:
5324                     is_rela = TRUE;
5325                     break;
5326                   }
5327             }
5328
5329           if (rel_size)
5330             {
5331               printf
5332                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5333                  name, rel_offset, rel_size);
5334
5335               dump_relocations (file,
5336                                 offset_from_vma (file, rel_offset, rel_size),
5337                                 rel_size,
5338                                 dynamic_symbols, num_dynamic_syms,
5339                                 dynamic_strings, dynamic_strings_length, is_rela);
5340             }
5341         }
5342
5343       if (is_ia64_vms ())
5344         has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5345
5346       if (! has_dynamic_reloc)
5347         printf (_("\nThere are no dynamic relocations in this file.\n"));
5348     }
5349   else
5350     {
5351       Elf_Internal_Shdr * section;
5352       unsigned long i;
5353       int found = 0;
5354
5355       for (i = 0, section = section_headers;
5356            i < elf_header.e_shnum;
5357            i++, section++)
5358         {
5359           if (   section->sh_type != SHT_RELA
5360               && section->sh_type != SHT_REL)
5361             continue;
5362
5363           rel_offset = section->sh_offset;
5364           rel_size   = section->sh_size;
5365
5366           if (rel_size)
5367             {
5368               Elf_Internal_Shdr * strsec;
5369               int is_rela;
5370
5371               printf (_("\nRelocation section "));
5372
5373               if (string_table == NULL)
5374                 printf ("%d", section->sh_name);
5375               else
5376                 printf (_("'%s'"), SECTION_NAME (section));
5377
5378               printf (_(" at offset 0x%lx contains %lu entries:\n"),
5379                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5380
5381               is_rela = section->sh_type == SHT_RELA;
5382
5383               if (section->sh_link != 0
5384                   && section->sh_link < elf_header.e_shnum)
5385                 {
5386                   Elf_Internal_Shdr * symsec;
5387                   Elf_Internal_Sym *  symtab;
5388                   unsigned long nsyms;
5389                   unsigned long strtablen = 0;
5390                   char * strtab = NULL;
5391
5392                   symsec = section_headers + section->sh_link;
5393                   if (symsec->sh_type != SHT_SYMTAB
5394                       && symsec->sh_type != SHT_DYNSYM)
5395                     continue;
5396
5397                   nsyms = symsec->sh_size / symsec->sh_entsize;
5398                   symtab = GET_ELF_SYMBOLS (file, symsec);
5399
5400                   if (symtab == NULL)
5401                     continue;
5402
5403                   if (symsec->sh_link != 0
5404                       && symsec->sh_link < elf_header.e_shnum)
5405                     {
5406                       strsec = section_headers + symsec->sh_link;
5407
5408                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5409                                                   1, strsec->sh_size,
5410                                                   _("string table"));
5411                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
5412                     }
5413
5414                   dump_relocations (file, rel_offset, rel_size,
5415                                     symtab, nsyms, strtab, strtablen, is_rela);
5416                   if (strtab)
5417                     free (strtab);
5418                   free (symtab);
5419                 }
5420               else
5421                 dump_relocations (file, rel_offset, rel_size,
5422                                   NULL, 0, NULL, 0, is_rela);
5423
5424               found = 1;
5425             }
5426         }
5427
5428       if (! found)
5429         printf (_("\nThere are no relocations in this file.\n"));
5430     }
5431
5432   return 1;
5433 }
5434
5435 /* Process the unwind section.  */
5436
5437 #include "unwind-ia64.h"
5438
5439 /* An absolute address consists of a section and an offset.  If the
5440    section is NULL, the offset itself is the address, otherwise, the
5441    address equals to LOAD_ADDRESS(section) + offset.  */
5442
5443 struct absaddr
5444   {
5445     unsigned short section;
5446     bfd_vma offset;
5447   };
5448
5449 #define ABSADDR(a) \
5450   ((a).section \
5451    ? section_headers [(a).section].sh_addr + (a).offset \
5452    : (a).offset)
5453
5454 struct ia64_unw_table_entry
5455   {
5456     struct absaddr start;
5457     struct absaddr end;
5458     struct absaddr info;
5459   };
5460
5461 struct ia64_unw_aux_info
5462   {
5463
5464     struct ia64_unw_table_entry *table; /* Unwind table.  */
5465     unsigned long table_len;    /* Length of unwind table.  */
5466     unsigned char * info;       /* Unwind info.  */
5467     unsigned long info_size;    /* Size of unwind info.  */
5468     bfd_vma info_addr;          /* starting address of unwind info.  */
5469     bfd_vma seg_base;           /* Starting address of segment.  */
5470     Elf_Internal_Sym * symtab;  /* The symbol table.  */
5471     unsigned long nsyms;        /* Number of symbols.  */
5472     char * strtab;              /* The string table.  */
5473     unsigned long strtab_size;  /* Size of string table.  */
5474   };
5475
5476 static void
5477 find_symbol_for_address (Elf_Internal_Sym * symtab,
5478                          unsigned long nsyms,
5479                          const char * strtab,
5480                          unsigned long strtab_size,
5481                          struct absaddr addr,
5482                          const char ** symname,
5483                          bfd_vma * offset)
5484 {
5485   bfd_vma dist = 0x100000;
5486   Elf_Internal_Sym * sym;
5487   Elf_Internal_Sym * best = NULL;
5488   unsigned long i;
5489
5490   REMOVE_ARCH_BITS (addr.offset);
5491
5492   for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
5493     {
5494       bfd_vma value = sym->st_value;
5495
5496       REMOVE_ARCH_BITS (value);
5497
5498       if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5499           && sym->st_name != 0
5500           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
5501           && addr.offset >= value
5502           && addr.offset - value < dist)
5503         {
5504           best = sym;
5505           dist = addr.offset - value;
5506           if (!dist)
5507             break;
5508         }
5509     }
5510   if (best)
5511     {
5512       *symname = (best->st_name >= strtab_size
5513                   ? _("<corrupt>") : strtab + best->st_name);
5514       *offset = dist;
5515       return;
5516     }
5517   *symname = NULL;
5518   *offset = addr.offset;
5519 }
5520
5521 static void
5522 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
5523 {
5524   struct ia64_unw_table_entry * tp;
5525   int in_body;
5526
5527   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5528     {
5529       bfd_vma stamp;
5530       bfd_vma offset;
5531       const unsigned char * dp;
5532       const unsigned char * head;
5533       const char * procname;
5534
5535       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5536                                aux->strtab_size, tp->start, &procname, &offset);
5537
5538       fputs ("\n<", stdout);
5539
5540       if (procname)
5541         {
5542           fputs (procname, stdout);
5543
5544           if (offset)
5545             printf ("+%lx", (unsigned long) offset);
5546         }
5547
5548       fputs (">: [", stdout);
5549       print_vma (tp->start.offset, PREFIX_HEX);
5550       fputc ('-', stdout);
5551       print_vma (tp->end.offset, PREFIX_HEX);
5552       printf ("], info at +0x%lx\n",
5553               (unsigned long) (tp->info.offset - aux->seg_base));
5554
5555       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5556       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5557
5558       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5559               (unsigned) UNW_VER (stamp),
5560               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5561               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5562               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5563               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5564
5565       if (UNW_VER (stamp) != 1)
5566         {
5567           printf (_("\tUnknown version.\n"));
5568           continue;
5569         }
5570
5571       in_body = 0;
5572       for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5573         dp = unw_decode (dp, in_body, & in_body);
5574     }
5575 }
5576
5577 static int
5578 slurp_ia64_unwind_table (FILE * file,
5579                          struct ia64_unw_aux_info * aux,
5580                          Elf_Internal_Shdr * sec)
5581 {
5582   unsigned long size, nrelas, i;
5583   Elf_Internal_Phdr * seg;
5584   struct ia64_unw_table_entry * tep;
5585   Elf_Internal_Shdr * relsec;
5586   Elf_Internal_Rela * rela;
5587   Elf_Internal_Rela * rp;
5588   unsigned char * table;
5589   unsigned char * tp;
5590   Elf_Internal_Sym * sym;
5591   const char * relname;
5592
5593   /* First, find the starting address of the segment that includes
5594      this section: */
5595
5596   if (elf_header.e_phnum)
5597     {
5598       if (! get_program_headers (file))
5599           return 0;
5600
5601       for (seg = program_headers;
5602            seg < program_headers + elf_header.e_phnum;
5603            ++seg)
5604         {
5605           if (seg->p_type != PT_LOAD)
5606             continue;
5607
5608           if (sec->sh_addr >= seg->p_vaddr
5609               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5610             {
5611               aux->seg_base = seg->p_vaddr;
5612               break;
5613             }
5614         }
5615     }
5616
5617   /* Second, build the unwind table from the contents of the unwind section:  */
5618   size = sec->sh_size;
5619   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5620                                       _("unwind table"));
5621   if (!table)
5622     return 0;
5623
5624   aux->table = (struct ia64_unw_table_entry *)
5625       xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5626   tep = aux->table;
5627   for (tp = table; tp < table + size; ++tep)
5628     {
5629       tep->start.section = SHN_UNDEF;
5630       tep->end.section   = SHN_UNDEF;
5631       tep->info.section  = SHN_UNDEF;
5632       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5633       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5634       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5635       tep->start.offset += aux->seg_base;
5636       tep->end.offset   += aux->seg_base;
5637       tep->info.offset  += aux->seg_base;
5638     }
5639   free (table);
5640
5641   /* Third, apply any relocations to the unwind table:  */
5642   for (relsec = section_headers;
5643        relsec < section_headers + elf_header.e_shnum;
5644        ++relsec)
5645     {
5646       if (relsec->sh_type != SHT_RELA
5647           || relsec->sh_info >= elf_header.e_shnum
5648           || section_headers + relsec->sh_info != sec)
5649         continue;
5650
5651       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5652                               & rela, & nrelas))
5653         return 0;
5654
5655       for (rp = rela; rp < rela + nrelas; ++rp)
5656         {
5657           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5658           sym = aux->symtab + get_reloc_symindex (rp->r_info);
5659
5660           if (! const_strneq (relname, "R_IA64_SEGREL"))
5661             {
5662               warn (_("Skipping unexpected relocation type %s\n"), relname);
5663               continue;
5664             }
5665
5666           i = rp->r_offset / (3 * eh_addr_size);
5667
5668           switch (rp->r_offset/eh_addr_size % 3)
5669             {
5670             case 0:
5671               aux->table[i].start.section = sym->st_shndx;
5672               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
5673               break;
5674             case 1:
5675               aux->table[i].end.section   = sym->st_shndx;
5676               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
5677               break;
5678             case 2:
5679               aux->table[i].info.section  = sym->st_shndx;
5680               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
5681               break;
5682             default:
5683               break;
5684             }
5685         }
5686
5687       free (rela);
5688     }
5689
5690   aux->table_len = size / (3 * eh_addr_size);
5691   return 1;
5692 }
5693
5694 static int
5695 ia64_process_unwind (FILE * file)
5696 {
5697   Elf_Internal_Shdr * sec;
5698   Elf_Internal_Shdr * unwsec = NULL;
5699   Elf_Internal_Shdr * strsec;
5700   unsigned long i, unwcount = 0, unwstart = 0;
5701   struct ia64_unw_aux_info aux;
5702
5703   memset (& aux, 0, sizeof (aux));
5704
5705   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5706     {
5707       if (sec->sh_type == SHT_SYMTAB
5708           && sec->sh_link < elf_header.e_shnum)
5709         {
5710           aux.nsyms = sec->sh_size / sec->sh_entsize;
5711           aux.symtab = GET_ELF_SYMBOLS (file, sec);
5712
5713           strsec = section_headers + sec->sh_link;
5714           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5715                                           1, strsec->sh_size,
5716                                           _("string table"));
5717           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5718         }
5719       else if (sec->sh_type == SHT_IA_64_UNWIND)
5720         unwcount++;
5721     }
5722
5723   if (!unwcount)
5724     printf (_("\nThere are no unwind sections in this file.\n"));
5725
5726   while (unwcount-- > 0)
5727     {
5728       char * suffix;
5729       size_t len, len2;
5730
5731       for (i = unwstart, sec = section_headers + unwstart;
5732            i < elf_header.e_shnum; ++i, ++sec)
5733         if (sec->sh_type == SHT_IA_64_UNWIND)
5734           {
5735             unwsec = sec;
5736             break;
5737           }
5738
5739       unwstart = i + 1;
5740       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5741
5742       if ((unwsec->sh_flags & SHF_GROUP) != 0)
5743         {
5744           /* We need to find which section group it is in.  */
5745           struct group_list * g = section_headers_groups [i]->root;
5746
5747           for (; g != NULL; g = g->next)
5748             {
5749               sec = section_headers + g->section_index;
5750
5751               if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
5752                 break;
5753             }
5754
5755           if (g == NULL)
5756             i = elf_header.e_shnum;
5757         }
5758       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
5759         {
5760           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
5761           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5762           suffix = SECTION_NAME (unwsec) + len;
5763           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5764                ++i, ++sec)
5765             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5766                 && streq (SECTION_NAME (sec) + len2, suffix))
5767               break;
5768         }
5769       else
5770         {
5771           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5772              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
5773           len = sizeof (ELF_STRING_ia64_unwind) - 1;
5774           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5775           suffix = "";
5776           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
5777             suffix = SECTION_NAME (unwsec) + len;
5778           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5779                ++i, ++sec)
5780             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5781                 && streq (SECTION_NAME (sec) + len2, suffix))
5782               break;
5783         }
5784
5785       if (i == elf_header.e_shnum)
5786         {
5787           printf (_("\nCould not find unwind info section for "));
5788
5789           if (string_table == NULL)
5790             printf ("%d", unwsec->sh_name);
5791           else
5792             printf (_("'%s'"), SECTION_NAME (unwsec));
5793         }
5794       else
5795         {
5796           aux.info_size = sec->sh_size;
5797           aux.info_addr = sec->sh_addr;
5798           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
5799                                                  aux.info_size,
5800                                                  _("unwind info"));
5801
5802           printf (_("\nUnwind section "));
5803
5804           if (string_table == NULL)
5805             printf ("%d", unwsec->sh_name);
5806           else
5807             printf (_("'%s'"), SECTION_NAME (unwsec));
5808
5809           printf (_(" at offset 0x%lx contains %lu entries:\n"),
5810                   (unsigned long) unwsec->sh_offset,
5811                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
5812
5813           (void) slurp_ia64_unwind_table (file, & aux, unwsec);
5814
5815           if (aux.table_len > 0)
5816             dump_ia64_unwind (& aux);
5817
5818           if (aux.table)
5819             free ((char *) aux.table);
5820           if (aux.info)
5821             free ((char *) aux.info);
5822           aux.table = NULL;
5823           aux.info = NULL;
5824         }
5825     }
5826
5827   if (aux.symtab)
5828     free (aux.symtab);
5829   if (aux.strtab)
5830     free ((char *) aux.strtab);
5831
5832   return 1;
5833 }
5834
5835 struct hppa_unw_table_entry
5836   {
5837     struct absaddr start;
5838     struct absaddr end;
5839     unsigned int Cannot_unwind:1;                       /* 0 */
5840     unsigned int Millicode:1;                   /* 1 */
5841     unsigned int Millicode_save_sr0:1;          /* 2 */
5842     unsigned int Region_description:2;          /* 3..4 */
5843     unsigned int reserved1:1;                   /* 5 */
5844     unsigned int Entry_SR:1;                    /* 6 */
5845     unsigned int Entry_FR:4;     /* number saved */     /* 7..10 */
5846     unsigned int Entry_GR:5;     /* number saved */     /* 11..15 */
5847     unsigned int Args_stored:1;                 /* 16 */
5848     unsigned int Variable_Frame:1;                      /* 17 */
5849     unsigned int Separate_Package_Body:1;               /* 18 */
5850     unsigned int Frame_Extension_Millicode:1;   /* 19 */
5851     unsigned int Stack_Overflow_Check:1;                /* 20 */
5852     unsigned int Two_Instruction_SP_Increment:1;        /* 21 */
5853     unsigned int Ada_Region:1;                  /* 22 */
5854     unsigned int cxx_info:1;                    /* 23 */
5855     unsigned int cxx_try_catch:1;                       /* 24 */
5856     unsigned int sched_entry_seq:1;                     /* 25 */
5857     unsigned int reserved2:1;                   /* 26 */
5858     unsigned int Save_SP:1;                             /* 27 */
5859     unsigned int Save_RP:1;                             /* 28 */
5860     unsigned int Save_MRP_in_frame:1;           /* 29 */
5861     unsigned int extn_ptr_defined:1;            /* 30 */
5862     unsigned int Cleanup_defined:1;                     /* 31 */
5863
5864     unsigned int MPE_XL_interrupt_marker:1;             /* 0 */
5865     unsigned int HP_UX_interrupt_marker:1;              /* 1 */
5866     unsigned int Large_frame:1;                 /* 2 */
5867     unsigned int Pseudo_SP_Set:1;                       /* 3 */
5868     unsigned int reserved4:1;                   /* 4 */
5869     unsigned int Total_frame_size:27;           /* 5..31 */
5870   };
5871
5872 struct hppa_unw_aux_info
5873   {
5874     struct hppa_unw_table_entry *table; /* Unwind table.  */
5875     unsigned long table_len;    /* Length of unwind table.  */
5876     bfd_vma seg_base;           /* Starting address of segment.  */
5877     Elf_Internal_Sym * symtab;  /* The symbol table.  */
5878     unsigned long nsyms;        /* Number of symbols.  */
5879     char * strtab;              /* The string table.  */
5880     unsigned long strtab_size;  /* Size of string table.  */
5881   };
5882
5883 static void
5884 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
5885 {
5886   struct hppa_unw_table_entry * tp;
5887
5888   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5889     {
5890       bfd_vma offset;
5891       const char * procname;
5892
5893       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5894                                aux->strtab_size, tp->start, &procname,
5895                                &offset);
5896
5897       fputs ("\n<", stdout);
5898
5899       if (procname)
5900         {
5901           fputs (procname, stdout);
5902
5903           if (offset)
5904             printf ("+%lx", (unsigned long) offset);
5905         }
5906
5907       fputs (">: [", stdout);
5908       print_vma (tp->start.offset, PREFIX_HEX);
5909       fputc ('-', stdout);
5910       print_vma (tp->end.offset, PREFIX_HEX);
5911       printf ("]\n\t");
5912
5913 #define PF(_m) if (tp->_m) printf (#_m " ");
5914 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5915       PF(Cannot_unwind);
5916       PF(Millicode);
5917       PF(Millicode_save_sr0);
5918       /* PV(Region_description);  */
5919       PF(Entry_SR);
5920       PV(Entry_FR);
5921       PV(Entry_GR);
5922       PF(Args_stored);
5923       PF(Variable_Frame);
5924       PF(Separate_Package_Body);
5925       PF(Frame_Extension_Millicode);
5926       PF(Stack_Overflow_Check);
5927       PF(Two_Instruction_SP_Increment);
5928       PF(Ada_Region);
5929       PF(cxx_info);
5930       PF(cxx_try_catch);
5931       PF(sched_entry_seq);
5932       PF(Save_SP);
5933       PF(Save_RP);
5934       PF(Save_MRP_in_frame);
5935       PF(extn_ptr_defined);
5936       PF(Cleanup_defined);
5937       PF(MPE_XL_interrupt_marker);
5938       PF(HP_UX_interrupt_marker);
5939       PF(Large_frame);
5940       PF(Pseudo_SP_Set);
5941       PV(Total_frame_size);
5942 #undef PF
5943 #undef PV
5944     }
5945
5946   printf ("\n");
5947 }
5948
5949 static int
5950 slurp_hppa_unwind_table (FILE * file,
5951                          struct hppa_unw_aux_info * aux,
5952                          Elf_Internal_Shdr * sec)
5953 {
5954   unsigned long size, unw_ent_size, nentries, nrelas, i;
5955   Elf_Internal_Phdr * seg;
5956   struct hppa_unw_table_entry * tep;
5957   Elf_Internal_Shdr * relsec;
5958   Elf_Internal_Rela * rela;
5959   Elf_Internal_Rela * rp;
5960   unsigned char * table;
5961   unsigned char * tp;
5962   Elf_Internal_Sym * sym;
5963   const char * relname;
5964
5965   /* First, find the starting address of the segment that includes
5966      this section.  */
5967
5968   if (elf_header.e_phnum)
5969     {
5970       if (! get_program_headers (file))
5971         return 0;
5972
5973       for (seg = program_headers;
5974            seg < program_headers + elf_header.e_phnum;
5975            ++seg)
5976         {
5977           if (seg->p_type != PT_LOAD)
5978             continue;
5979
5980           if (sec->sh_addr >= seg->p_vaddr
5981               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5982             {
5983               aux->seg_base = seg->p_vaddr;
5984               break;
5985             }
5986         }
5987     }
5988
5989   /* Second, build the unwind table from the contents of the unwind
5990      section.  */
5991   size = sec->sh_size;
5992   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5993                                       _("unwind table"));
5994   if (!table)
5995     return 0;
5996
5997   unw_ent_size = 16;
5998   nentries = size / unw_ent_size;
5999   size = unw_ent_size * nentries;
6000
6001   tep = aux->table = (struct hppa_unw_table_entry *)
6002       xcmalloc (nentries, sizeof (aux->table[0]));
6003
6004   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6005     {
6006       unsigned int tmp1, tmp2;
6007
6008       tep->start.section = SHN_UNDEF;
6009       tep->end.section   = SHN_UNDEF;
6010
6011       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6012       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6013       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6014       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6015
6016       tep->start.offset += aux->seg_base;
6017       tep->end.offset   += aux->seg_base;
6018
6019       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6020       tep->Millicode = (tmp1 >> 30) & 0x1;
6021       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6022       tep->Region_description = (tmp1 >> 27) & 0x3;
6023       tep->reserved1 = (tmp1 >> 26) & 0x1;
6024       tep->Entry_SR = (tmp1 >> 25) & 0x1;
6025       tep->Entry_FR = (tmp1 >> 21) & 0xf;
6026       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6027       tep->Args_stored = (tmp1 >> 15) & 0x1;
6028       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6029       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6030       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6031       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6032       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6033       tep->Ada_Region = (tmp1 >> 9) & 0x1;
6034       tep->cxx_info = (tmp1 >> 8) & 0x1;
6035       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6036       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6037       tep->reserved2 = (tmp1 >> 5) & 0x1;
6038       tep->Save_SP = (tmp1 >> 4) & 0x1;
6039       tep->Save_RP = (tmp1 >> 3) & 0x1;
6040       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6041       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6042       tep->Cleanup_defined = tmp1 & 0x1;
6043
6044       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6045       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6046       tep->Large_frame = (tmp2 >> 29) & 0x1;
6047       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6048       tep->reserved4 = (tmp2 >> 27) & 0x1;
6049       tep->Total_frame_size = tmp2 & 0x7ffffff;
6050     }
6051   free (table);
6052
6053   /* Third, apply any relocations to the unwind table.  */
6054   for (relsec = section_headers;
6055        relsec < section_headers + elf_header.e_shnum;
6056        ++relsec)
6057     {
6058       if (relsec->sh_type != SHT_RELA
6059           || relsec->sh_info >= elf_header.e_shnum
6060           || section_headers + relsec->sh_info != sec)
6061         continue;
6062
6063       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6064                               & rela, & nrelas))
6065         return 0;
6066
6067       for (rp = rela; rp < rela + nrelas; ++rp)
6068         {
6069           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6070           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6071
6072           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
6073           if (! const_strneq (relname, "R_PARISC_SEGREL"))
6074             {
6075               warn (_("Skipping unexpected relocation type %s\n"), relname);
6076               continue;
6077             }
6078
6079           i = rp->r_offset / unw_ent_size;
6080
6081           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6082             {
6083             case 0:
6084               aux->table[i].start.section = sym->st_shndx;
6085               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
6086               break;
6087             case 1:
6088               aux->table[i].end.section   = sym->st_shndx;
6089               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
6090               break;
6091             default:
6092               break;
6093             }
6094         }
6095
6096       free (rela);
6097     }
6098
6099   aux->table_len = nentries;
6100
6101   return 1;
6102 }
6103
6104 static int
6105 hppa_process_unwind (FILE * file)
6106 {
6107   struct hppa_unw_aux_info aux;
6108   Elf_Internal_Shdr * unwsec = NULL;
6109   Elf_Internal_Shdr * strsec;
6110   Elf_Internal_Shdr * sec;
6111   unsigned long i;
6112
6113   memset (& aux, 0, sizeof (aux));
6114
6115   if (string_table == NULL)
6116     return 1;
6117
6118   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6119     {
6120       if (sec->sh_type == SHT_SYMTAB
6121           && sec->sh_link < elf_header.e_shnum)
6122         {
6123           aux.nsyms = sec->sh_size / sec->sh_entsize;
6124           aux.symtab = GET_ELF_SYMBOLS (file, sec);
6125
6126           strsec = section_headers + sec->sh_link;
6127           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6128                                           1, strsec->sh_size,
6129                                           _("string table"));
6130           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6131         }
6132       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6133         unwsec = sec;
6134     }
6135
6136   if (!unwsec)
6137     printf (_("\nThere are no unwind sections in this file.\n"));
6138
6139   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6140     {
6141       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6142         {
6143           printf (_("\nUnwind section "));
6144           printf (_("'%s'"), SECTION_NAME (sec));
6145
6146           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6147                   (unsigned long) sec->sh_offset,
6148                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6149
6150           slurp_hppa_unwind_table (file, &aux, sec);
6151           if (aux.table_len > 0)
6152             dump_hppa_unwind (&aux);
6153
6154           if (aux.table)
6155             free ((char *) aux.table);
6156           aux.table = NULL;
6157         }
6158     }
6159
6160   if (aux.symtab)
6161     free (aux.symtab);
6162   if (aux.strtab)
6163     free ((char *) aux.strtab);
6164
6165   return 1;
6166 }
6167
6168 struct arm_section
6169 {
6170   unsigned char *data;
6171
6172   Elf_Internal_Shdr *sec;
6173   Elf_Internal_Rela *rela;
6174   unsigned long nrelas;
6175   unsigned int rel_type;
6176
6177   Elf_Internal_Rela *next_rela;
6178 };
6179
6180 struct arm_unw_aux_info
6181 {
6182   FILE *file;
6183
6184   Elf_Internal_Sym *symtab;     /* The symbol table.  */
6185   unsigned long nsyms;          /* Number of symbols.  */
6186   char *strtab;                 /* The string table.  */
6187   unsigned long strtab_size;    /* Size of string table.  */
6188 };
6189
6190 static const char *
6191 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6192                         bfd_vma fn, struct absaddr addr)
6193 {
6194   const char *procname;
6195   bfd_vma sym_offset;
6196
6197   if (addr.section == SHN_UNDEF)
6198     addr.offset = fn;
6199
6200   find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6201                            aux->strtab_size, addr, &procname,
6202                            &sym_offset);
6203
6204   print_vma (fn, PREFIX_HEX);
6205
6206   if (procname)
6207     {
6208       fputs (" <", stdout);
6209       fputs (procname, stdout);
6210
6211       if (sym_offset)
6212         printf ("+0x%lx", (unsigned long) sym_offset);
6213       fputc ('>', stdout);
6214     }
6215
6216   return procname;
6217 }
6218
6219 static void
6220 arm_free_section (struct arm_section *arm_sec)
6221 {
6222   if (arm_sec->data != NULL)
6223     free (arm_sec->data);
6224
6225   if (arm_sec->rela != NULL)
6226     free (arm_sec->rela);
6227 }
6228
6229 static int
6230 arm_section_get_word (struct arm_unw_aux_info *aux,
6231                       struct arm_section *arm_sec,
6232                       Elf_Internal_Shdr *sec, bfd_vma word_offset,
6233                       unsigned int *wordp, struct absaddr *addr)
6234 {
6235   Elf_Internal_Rela *rp;
6236   Elf_Internal_Sym *sym;
6237   const char * relname;
6238   unsigned int word;
6239   bfd_boolean wrapped;
6240
6241   addr->section = SHN_UNDEF;
6242   addr->offset = 0;
6243
6244   if (sec != arm_sec->sec)
6245     {
6246       Elf_Internal_Shdr *relsec;
6247
6248       arm_free_section (arm_sec);
6249
6250       arm_sec->sec = sec;
6251       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6252                                 sec->sh_size, _("unwind data"));
6253
6254       arm_sec->rela = NULL;
6255       arm_sec->nrelas = 0;
6256
6257       for (relsec = section_headers;
6258            relsec < section_headers + elf_header.e_shnum;
6259            ++relsec)
6260         {
6261           if (relsec->sh_info >= elf_header.e_shnum
6262               || section_headers + relsec->sh_info != sec)
6263             continue;
6264
6265           if (relsec->sh_type == SHT_REL)
6266             {
6267               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6268                                      relsec->sh_size,
6269                                      & arm_sec->rela, & arm_sec->nrelas))
6270                 return 0;
6271               break;
6272             }
6273           else if (relsec->sh_type == SHT_RELA)
6274             {
6275               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6276                                       relsec->sh_size,
6277                                       & arm_sec->rela, & arm_sec->nrelas))
6278                 return 0;
6279               break;
6280             }
6281         }
6282
6283       arm_sec->next_rela = arm_sec->rela;
6284     }
6285
6286   if (arm_sec->data == NULL)
6287     return 0;
6288
6289   word = byte_get (arm_sec->data + word_offset, 4);
6290
6291   wrapped = FALSE;
6292   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6293     {
6294       bfd_vma prelval, offset;
6295
6296       if (rp->r_offset > word_offset && !wrapped)
6297         {
6298           rp = arm_sec->rela;
6299           wrapped = TRUE;
6300         }
6301       if (rp->r_offset > word_offset)
6302         break;
6303
6304       if (rp->r_offset & 3)
6305         {
6306           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6307                 (unsigned long) rp->r_offset);
6308           continue;
6309         }
6310
6311       if (rp->r_offset < word_offset)
6312         continue;
6313
6314       switch (elf_header.e_machine)
6315         {
6316         case EM_ARM:
6317           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6318           break;
6319
6320         case EM_TI_C6000:
6321           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6322           break;
6323
6324         default:
6325             abort();
6326         }
6327
6328       if (streq (relname, "R_ARM_NONE")
6329           || streq (relname, "R_C6000_NONE"))
6330         continue;
6331
6332       if (!(streq (relname, "R_ARM_PREL31")
6333             || streq (relname, "R_C6000_PREL31")))
6334         {
6335           warn (_("Skipping unexpected relocation type %s\n"), relname);
6336           continue;
6337         }
6338
6339       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6340
6341       if (arm_sec->rel_type == SHT_REL)
6342         {
6343           offset = word & 0x7fffffff;
6344           if (offset & 0x40000000)
6345             offset |= ~ (bfd_vma) 0x7fffffff;
6346         }
6347       else
6348         offset = rp->r_addend;
6349
6350       offset += sym->st_value;
6351       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6352
6353       if (streq (relname, "R_C6000_PREL31"))
6354         prelval >>= 1;
6355
6356       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6357       addr->section = sym->st_shndx;
6358       addr->offset = offset;
6359       break;
6360     }
6361
6362   *wordp = word;
6363   arm_sec->next_rela = rp;
6364
6365   return 1;
6366 }
6367
6368 static const char *tic6x_unwind_regnames[16] = {
6369     "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6370     "A14", "A13", "A12", "A11", "A10",
6371     "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"};
6372
6373 static void
6374 decode_tic6x_unwind_regmask (unsigned int mask)
6375 {
6376   int i;
6377
6378   for (i = 12; mask; mask >>= 1, i--)
6379     {
6380       if (mask & 1)
6381         {
6382           fputs (tic6x_unwind_regnames[i], stdout);
6383           if (mask > 1)
6384             fputs (", ", stdout);
6385         }
6386     }
6387 }
6388
6389 #define ADVANCE                                                 \
6390   if (remaining == 0 && more_words)                             \
6391     {                                                           \
6392       data_offset += 4;                                         \
6393       if (!arm_section_get_word (aux, data_arm_sec, data_sec,   \
6394                                  data_offset, &word, &addr))    \
6395         return;                                                 \
6396       remaining = 4;                                            \
6397       more_words--;                                             \
6398     }                                                           \
6399
6400 #define GET_OP(OP)                      \
6401   ADVANCE;                              \
6402   if (remaining)                        \
6403     {                                   \
6404       remaining--;                      \
6405       (OP) = word >> 24;                \
6406       word <<= 8;                       \
6407     }                                   \
6408   else                                  \
6409     {                                   \
6410       printf (_("[Truncated opcode]\n"));       \
6411       return;                           \
6412     }                                   \
6413   printf ("0x%02x ", OP)
6414
6415 static void
6416 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6417                             unsigned int word, unsigned int remaining,
6418                             unsigned int more_words,
6419                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6420                             struct arm_section *data_arm_sec)
6421 {
6422   struct absaddr addr;
6423
6424   /* Decode the unwinding instructions.  */
6425   while (1)
6426     {
6427       unsigned int op, op2;
6428
6429       ADVANCE;
6430       if (remaining == 0)
6431         break;
6432       remaining--;
6433       op = word >> 24;
6434       word <<= 8;
6435
6436       printf ("  0x%02x ", op);
6437
6438       if ((op & 0xc0) == 0x00)
6439         {
6440           int offset = ((op & 0x3f) << 2) + 4;
6441
6442           printf ("     vsp = vsp + %d", offset);
6443         }
6444       else if ((op & 0xc0) == 0x40)
6445         {
6446           int offset = ((op & 0x3f) << 2) + 4;
6447
6448           printf ("     vsp = vsp - %d", offset);
6449         }
6450       else if ((op & 0xf0) == 0x80)
6451         {
6452           GET_OP (op2);
6453           if (op == 0x80 && op2 == 0)
6454             printf (_("Refuse to unwind"));
6455           else
6456             {
6457               unsigned int mask = ((op & 0x0f) << 8) | op2;
6458               int first = 1;
6459               int i;
6460
6461               printf ("pop {");
6462               for (i = 0; i < 12; i++)
6463                 if (mask & (1 << i))
6464                   {
6465                     if (first)
6466                       first = 0;
6467                     else
6468                       printf (", ");
6469                     printf ("r%d", 4 + i);
6470                   }
6471               printf ("}");
6472             }
6473         }
6474       else if ((op & 0xf0) == 0x90)
6475         {
6476           if (op == 0x9d || op == 0x9f)
6477             printf (_("     [Reserved]"));
6478           else
6479             printf ("     vsp = r%d", op & 0x0f);
6480         }
6481       else if ((op & 0xf0) == 0xa0)
6482         {
6483           int end = 4 + (op & 0x07);
6484           int first = 1;
6485           int i;
6486
6487           printf ("     pop {");
6488           for (i = 4; i <= end; i++)
6489             {
6490               if (first)
6491                 first = 0;
6492               else
6493                 printf (", ");
6494               printf ("r%d", i);
6495             }
6496           if (op & 0x08)
6497             {
6498               if (first)
6499                 printf (", ");
6500               printf ("r14");
6501             }
6502           printf ("}");
6503         }
6504       else if (op == 0xb0)
6505         printf (_("     finish"));
6506       else if (op == 0xb1)
6507         {
6508           GET_OP (op2);
6509           if (op2 == 0 || (op2 & 0xf0) != 0)
6510             printf (_("[Spare]"));
6511           else
6512             {
6513               unsigned int mask = op2 & 0x0f;
6514               int first = 1;
6515               int i;
6516
6517               printf ("pop {");
6518               for (i = 0; i < 12; i++)
6519                 if (mask & (1 << i))
6520                   {
6521                     if (first)
6522                       first = 0;
6523                     else
6524                       printf (", ");
6525                     printf ("r%d", i);
6526                   }
6527               printf ("}");
6528             }
6529         }
6530       else if (op == 0xb2)
6531         {
6532           unsigned char buf[9];
6533           unsigned int i, len;
6534           unsigned long offset;
6535
6536           for (i = 0; i < sizeof (buf); i++)
6537             {
6538               GET_OP (buf[i]);
6539               if ((buf[i] & 0x80) == 0)
6540                 break;
6541             }
6542           assert (i < sizeof (buf));
6543           offset = read_uleb128 (buf, &len);
6544           assert (len == i + 1);
6545           offset = offset * 4 + 0x204;
6546           printf ("vsp = vsp + %ld", offset);
6547         }
6548       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
6549         {
6550           unsigned int first, last;
6551
6552           GET_OP (op2);
6553           first = op2 >> 4;
6554           last = op2 & 0x0f;
6555           if (op == 0xc8)
6556             first = first + 16;
6557           printf ("pop {D%d", first);
6558           if (last)
6559             printf ("-D%d", first + last);
6560           printf ("}");
6561         }
6562       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6563         {
6564           unsigned int count = op & 0x07;
6565
6566           printf ("pop {D8");
6567           if (count)
6568             printf ("-D%d", 8 + count);
6569           printf ("}");
6570         }
6571       else if (op >= 0xc0 && op <= 0xc5)
6572         {
6573           unsigned int count = op & 0x07;
6574
6575           printf ("     pop {wR10");
6576           if (count)
6577             printf ("-wR%d", 10 + count);
6578           printf ("}");
6579         }
6580       else if (op == 0xc6)
6581         {
6582           unsigned int first, last;
6583
6584           GET_OP (op2);
6585           first = op2 >> 4;
6586           last = op2 & 0x0f;
6587           printf ("pop {wR%d", first);
6588           if (last)
6589             printf ("-wR%d", first + last);
6590           printf ("}");
6591         }
6592       else if (op == 0xc7)
6593         {
6594           GET_OP (op2);
6595           if (op2 == 0 || (op2 & 0xf0) != 0)
6596             printf (_("[Spare]"));
6597           else
6598             {
6599               unsigned int mask = op2 & 0x0f;
6600               int first = 1;
6601               int i;
6602
6603               printf ("pop {");
6604               for (i = 0; i < 4; i++)
6605                 if (mask & (1 << i))
6606                   {
6607                     if (first)
6608                       first = 0;
6609                     else
6610                       printf (", ");
6611                     printf ("wCGR%d", i);
6612                   }
6613               printf ("}");
6614             }
6615         }
6616       else
6617         printf (_("     [unsupported opcode]"));
6618       printf ("\n");
6619     }
6620 }
6621
6622 static void
6623 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6624                             unsigned int word, unsigned int remaining,
6625                             unsigned int more_words,
6626                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6627                             struct arm_section *data_arm_sec)
6628 {
6629   struct absaddr addr;
6630
6631   /* Decode the unwinding instructions.  */
6632   while (1)
6633     {
6634       unsigned int op, op2;
6635
6636       ADVANCE;
6637       if (remaining == 0)
6638         break;
6639       remaining--;
6640       op = word >> 24;
6641       word <<= 8;
6642
6643       printf (_("  0x%02x "), op);
6644
6645       if ((op & 0xc0) == 0x00)
6646         {
6647           int offset = ((op & 0x3f) << 3) + 8;
6648           printf (_("     sp = sp + %d"), offset);
6649         }
6650       else if ((op & 0xc0) == 0x80)
6651         {
6652           GET_OP (op2);
6653           if (op == 0x80 && op2 == 0)
6654             printf (_("Refuse to unwind"));
6655           else
6656             {
6657               unsigned int mask = ((op & 0x1f) << 8) | op2;
6658               if (op & 0x20)
6659                 printf ("pop compact {");
6660               else
6661                 printf ("pop {");
6662
6663               decode_tic6x_unwind_regmask (mask);
6664               printf("}");
6665             }
6666         }
6667       else if ((op & 0xf0) == 0xc0)
6668         {
6669           unsigned int reg;
6670           unsigned int nregs;
6671           unsigned int i;
6672           const char *name;
6673           struct {
6674               unsigned int offset;
6675               unsigned int reg;
6676           } regpos[16];
6677
6678           /* Scan entire instruction first so that GET_OP output is not
6679              interleaved with disassembly.  */
6680           nregs = 0;
6681           for (i = 0; nregs < (op & 0xf); i++)
6682             {
6683               GET_OP (op2);
6684               reg = op2 >> 4;
6685               if (reg != 0xf)
6686                 {
6687                   regpos[nregs].offset = i * 2;
6688                   regpos[nregs].reg = reg;
6689                   nregs++;
6690                 }
6691
6692               reg = op2 & 0xf;
6693               if (reg != 0xf)
6694                 {
6695                   regpos[nregs].offset = i * 2 + 1;
6696                   regpos[nregs].reg = reg;
6697                   nregs++;
6698                 }
6699             }
6700
6701           printf (_("pop frame {"));
6702           reg = nregs - 1;
6703           for (i = i * 2; i > 0; i--)
6704             {
6705               if (regpos[reg].offset == i - 1)
6706                 {
6707                   name = tic6x_unwind_regnames[regpos[reg].reg];
6708                   if (reg > 0)
6709                     reg--;
6710                 }
6711               else
6712                 name = _("[pad]");
6713
6714               fputs (name, stdout);
6715               if (i > 1)
6716                 printf (", ");
6717             }
6718
6719           printf ("}");
6720         }
6721       else if (op == 0xd0)
6722         printf ("     MOV FP, SP");
6723       else if (op == 0xd1)
6724         printf ("     __c6xabi_pop_rts");
6725       else if (op == 0xd2)
6726         {
6727           unsigned char buf[9];
6728           unsigned int i, len;
6729           unsigned long offset;
6730           for (i = 0; i < sizeof (buf); i++)
6731             {
6732               GET_OP (buf[i]);
6733               if ((buf[i] & 0x80) == 0)
6734                 break;
6735             }
6736           assert (i < sizeof (buf));
6737           offset = read_uleb128 (buf, &len);
6738           assert (len == i + 1);
6739           offset = offset * 8 + 0x408;
6740           printf (_("sp = sp + %ld"), offset);
6741         }
6742       else if ((op & 0xf0) == 0xe0)
6743         {
6744           if ((op & 0x0f) == 7)
6745             printf ("     RETURN");
6746           else
6747             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
6748         }
6749       else
6750         {
6751           printf (_("     [unsupported opcode]"));
6752         }
6753       putchar ('\n');
6754     }
6755 }
6756
6757 static bfd_vma
6758 expand_prel31 (bfd_vma word, bfd_vma where)
6759 {
6760   bfd_vma offset;
6761
6762   offset = word & 0x7fffffff;
6763   if (offset & 0x40000000)
6764     offset |= ~ (bfd_vma) 0x7fffffff;
6765
6766   if (elf_header.e_machine == EM_TI_C6000)
6767     offset <<= 1;
6768
6769   return offset + where;
6770 }
6771
6772 static void
6773 decode_arm_unwind (struct arm_unw_aux_info *aux,
6774                    unsigned int word, unsigned int remaining,
6775                    bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6776                    struct arm_section *data_arm_sec)
6777 {
6778   int per_index;
6779   unsigned int more_words = 0;
6780   struct absaddr addr;
6781
6782   if (remaining == 0)
6783     {
6784       /* Fetch the first word.  */
6785       if (!arm_section_get_word (aux, data_arm_sec, data_sec, data_offset,
6786                                  &word, &addr))
6787         return;
6788       remaining = 4;
6789     }
6790
6791   if ((word & 0x80000000) == 0)
6792     {
6793       /* Expand prel31 for personality routine.  */
6794       bfd_vma fn;
6795       const char *procname;
6796
6797       fn = expand_prel31 (word, data_sec->sh_addr + data_offset);
6798       printf (_("  Personality routine: "));
6799       procname = arm_print_vma_and_name (aux, fn, addr);
6800       fputc ('\n', stdout);
6801
6802       /* The GCC personality routines use the standard compact
6803          encoding, starting with one byte giving the number of
6804          words.  */
6805       if (procname != NULL
6806           && (const_strneq (procname, "__gcc_personality_v0")
6807               || const_strneq (procname, "__gxx_personality_v0")
6808               || const_strneq (procname, "__gcj_personality_v0")
6809               || const_strneq (procname, "__gnu_objc_personality_v0")))
6810         {
6811           remaining = 0;
6812           more_words = 1;
6813           ADVANCE;
6814           if (!remaining)
6815             {
6816               printf (_("  [Truncated data]\n"));
6817               return;
6818             }
6819           more_words = word >> 24;
6820           word <<= 8;
6821           remaining--;
6822           per_index = -1;
6823         }
6824       else
6825         return;
6826     }
6827   else
6828     {
6829
6830       per_index = (word >> 24) & 0x7f;
6831       printf (_("  Compact model %d\n"), per_index);
6832       if (per_index == 0)
6833         {
6834           more_words = 0;
6835           word <<= 8;
6836           remaining--;
6837         }
6838       else if (per_index < 3)
6839         {
6840           more_words = (word >> 16) & 0xff;
6841           word <<= 16;
6842           remaining -= 2;
6843         }
6844     }
6845
6846   switch (elf_header.e_machine)
6847     {
6848     case EM_ARM:
6849       if (per_index < 3)
6850         {
6851           decode_arm_unwind_bytecode (aux, word, remaining, more_words,
6852                                       data_offset, data_sec, data_arm_sec);
6853         }
6854       else
6855         printf ("  [reserved]\n");
6856       break;
6857
6858     case EM_TI_C6000:
6859       if (per_index < 3)
6860         {
6861           decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
6862                                       data_offset, data_sec, data_arm_sec);
6863         }
6864       else if (per_index < 5)
6865         {
6866           if (((word >> 17) & 0x7f) == 0x7f)
6867             printf (_("  Restore stack from frame pointer\n"));
6868           else
6869             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
6870           printf (_("  Registers restored: "));
6871           if (per_index == 4)
6872             printf (" (compact) ");
6873           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
6874           putchar ('\n');
6875           printf (_("  Return register: %s\n"),
6876                   tic6x_unwind_regnames[word & 0xf]);
6877         }
6878       else
6879         printf ("  [reserved]\n");
6880       break;
6881
6882     default:
6883       abort ();
6884     }
6885
6886   /* Decode the descriptors.  Not implemented.  */
6887 }
6888
6889 static void
6890 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
6891 {
6892   struct arm_section exidx_arm_sec, extab_arm_sec;
6893   unsigned int i, exidx_len;
6894
6895   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
6896   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
6897   exidx_len = exidx_sec->sh_size / 8;
6898
6899   for (i = 0; i < exidx_len; i++)
6900     {
6901       unsigned int exidx_fn, exidx_entry;
6902       struct absaddr fn_addr, entry_addr;
6903       bfd_vma fn;
6904
6905       fputc ('\n', stdout);
6906
6907       if (!arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6908                                  8 * i, &exidx_fn, &fn_addr)
6909           || !arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6910                                     8 * i + 4, &exidx_entry, &entry_addr))
6911         {
6912           arm_free_section (&exidx_arm_sec);
6913           arm_free_section (&extab_arm_sec);
6914           return;
6915         }
6916
6917       fn = expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
6918
6919       arm_print_vma_and_name (aux, fn, entry_addr);
6920       fputs (": ", stdout);
6921
6922       if (exidx_entry == 1)
6923         {
6924           print_vma (exidx_entry, PREFIX_HEX);
6925           fputs (" [cantunwind]\n", stdout);
6926         }
6927       else if (exidx_entry & 0x80000000)
6928         {
6929           print_vma (exidx_entry, PREFIX_HEX);
6930           fputc ('\n', stdout);
6931           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
6932         }
6933       else
6934         {
6935           bfd_vma table, table_offset = 0;
6936           Elf_Internal_Shdr *table_sec;
6937
6938           fputs ("@", stdout);
6939           table = expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
6940           print_vma (table, PREFIX_HEX);
6941           printf ("\n");
6942
6943           /* Locate the matching .ARM.extab.  */
6944           if (entry_addr.section != SHN_UNDEF
6945               && entry_addr.section < elf_header.e_shnum)
6946             {
6947               table_sec = section_headers + entry_addr.section;
6948               table_offset = entry_addr.offset;
6949             }
6950           else
6951             {
6952               table_sec = find_section_by_address (table);
6953               if (table_sec != NULL)
6954                 table_offset = table - table_sec->sh_addr;
6955             }
6956           if (table_sec == NULL)
6957             {
6958               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
6959                     (unsigned long) table);
6960               continue;
6961             }
6962           decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
6963                              &extab_arm_sec);
6964         }
6965     }
6966
6967   printf ("\n");
6968
6969   arm_free_section (&exidx_arm_sec);
6970   arm_free_section (&extab_arm_sec);
6971 }
6972
6973 /* Used for both ARM and C6X unwinding tables.  */
6974 static int
6975 arm_process_unwind (FILE *file)
6976 {
6977   struct arm_unw_aux_info aux;
6978   Elf_Internal_Shdr *unwsec = NULL;
6979   Elf_Internal_Shdr *strsec;
6980   Elf_Internal_Shdr *sec;
6981   unsigned long i;
6982   unsigned int sec_type;
6983
6984   memset (& aux, 0, sizeof (aux));
6985   aux.file = file;
6986
6987   switch (elf_header.e_machine)
6988     {
6989     case EM_ARM:
6990       sec_type = SHT_ARM_EXIDX;
6991       break;
6992
6993     case EM_TI_C6000:
6994       sec_type = SHT_C6000_UNWIND;
6995       break;
6996
6997     default:
6998         abort();
6999     }
7000
7001   if (string_table == NULL)
7002     return 1;
7003
7004   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7005     {
7006       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7007         {
7008           aux.nsyms = sec->sh_size / sec->sh_entsize;
7009           aux.symtab = GET_ELF_SYMBOLS (file, sec);
7010
7011           strsec = section_headers + sec->sh_link;
7012           aux.strtab = get_data (NULL, file, strsec->sh_offset,
7013                                  1, strsec->sh_size, _("string table"));
7014           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7015         }
7016       else if (sec->sh_type == sec_type)
7017         unwsec = sec;
7018     }
7019
7020   if (!unwsec)
7021     printf (_("\nThere are no unwind sections in this file.\n"));
7022
7023   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7024     {
7025       if (sec->sh_type == sec_type)
7026         {
7027           printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7028                   SECTION_NAME (sec),
7029                   (unsigned long) sec->sh_offset,
7030                   (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7031
7032           dump_arm_unwind (&aux, sec);
7033         }
7034     }
7035
7036   if (aux.symtab)
7037     free (aux.symtab);
7038   if (aux.strtab)
7039     free ((char *) aux.strtab);
7040
7041   return 1;
7042 }
7043
7044 static int
7045 process_unwind (FILE * file)
7046 {
7047   struct unwind_handler
7048   {
7049     int machtype;
7050     int (* handler)(FILE *);
7051   } handlers[] =
7052   {
7053     { EM_ARM, arm_process_unwind },
7054     { EM_IA_64, ia64_process_unwind },
7055     { EM_PARISC, hppa_process_unwind },
7056     { EM_TI_C6000, arm_process_unwind },
7057     { 0, 0 }
7058   };
7059   int i;
7060
7061   if (!do_unwind)
7062     return 1;
7063
7064   for (i = 0; handlers[i].handler != NULL; i++)
7065     if (elf_header.e_machine == handlers[i].machtype)
7066       return handlers[i].handler (file);
7067
7068   printf (_("\nThere are no unwind sections in this file.\n"));
7069   return 1;
7070 }
7071
7072 static void
7073 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
7074 {
7075   switch (entry->d_tag)
7076     {
7077     case DT_MIPS_FLAGS:
7078       if (entry->d_un.d_val == 0)
7079         printf (_("NONE\n"));
7080       else
7081         {
7082           static const char * opts[] =
7083           {
7084             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7085             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7086             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7087             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7088             "RLD_ORDER_SAFE"
7089           };
7090           unsigned int cnt;
7091           int first = 1;
7092
7093           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
7094             if (entry->d_un.d_val & (1 << cnt))
7095               {
7096                 printf ("%s%s", first ? "" : " ", opts[cnt]);
7097                 first = 0;
7098               }
7099           puts ("");
7100         }
7101       break;
7102
7103     case DT_MIPS_IVERSION:
7104       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7105         printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry->d_un.d_val));
7106       else
7107         printf (_("<corrupt: %ld>\n"), (long) entry->d_un.d_ptr);
7108       break;
7109
7110     case DT_MIPS_TIME_STAMP:
7111       {
7112         char timebuf[20];
7113         struct tm * tmp;
7114
7115         time_t atime = entry->d_un.d_val;
7116         tmp = gmtime (&atime);
7117         snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7118                   tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7119                   tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7120         printf (_("Time Stamp: %s\n"), timebuf);
7121       }
7122       break;
7123
7124     case DT_MIPS_RLD_VERSION:
7125     case DT_MIPS_LOCAL_GOTNO:
7126     case DT_MIPS_CONFLICTNO:
7127     case DT_MIPS_LIBLISTNO:
7128     case DT_MIPS_SYMTABNO:
7129     case DT_MIPS_UNREFEXTNO:
7130     case DT_MIPS_HIPAGENO:
7131     case DT_MIPS_DELTA_CLASS_NO:
7132     case DT_MIPS_DELTA_INSTANCE_NO:
7133     case DT_MIPS_DELTA_RELOC_NO:
7134     case DT_MIPS_DELTA_SYM_NO:
7135     case DT_MIPS_DELTA_CLASSSYM_NO:
7136     case DT_MIPS_COMPACT_SIZE:
7137       printf ("%ld\n", (long) entry->d_un.d_ptr);
7138       break;
7139
7140     default:
7141       printf ("%#lx\n", (unsigned long) entry->d_un.d_ptr);
7142     }
7143 }
7144
7145 static void
7146 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
7147 {
7148   switch (entry->d_tag)
7149     {
7150     case DT_HP_DLD_FLAGS:
7151       {
7152         static struct
7153         {
7154           long int bit;
7155           const char * str;
7156         }
7157         flags[] =
7158         {
7159           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7160           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7161           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7162           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7163           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7164           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7165           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7166           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7167           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7168           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
7169           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7170           { DT_HP_GST, "HP_GST" },
7171           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7172           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7173           { DT_HP_NODELETE, "HP_NODELETE" },
7174           { DT_HP_GROUP, "HP_GROUP" },
7175           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
7176         };
7177         int first = 1;
7178         size_t cnt;
7179         bfd_vma val = entry->d_un.d_val;
7180
7181         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
7182           if (val & flags[cnt].bit)
7183             {
7184               if (! first)
7185                 putchar (' ');
7186               fputs (flags[cnt].str, stdout);
7187               first = 0;
7188               val ^= flags[cnt].bit;
7189             }
7190
7191         if (val != 0 || first)
7192           {
7193             if (! first)
7194               putchar (' ');
7195             print_vma (val, HEX);
7196           }
7197       }
7198       break;
7199
7200     default:
7201       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7202       break;
7203     }
7204   putchar ('\n');
7205 }
7206
7207 #ifdef BFD64
7208
7209 /* VMS vs Unix time offset and factor.  */
7210
7211 #define VMS_EPOCH_OFFSET 35067168000000000LL
7212 #define VMS_GRANULARITY_FACTOR 10000000
7213
7214 /* Display a VMS time in a human readable format.  */
7215
7216 static void
7217 print_vms_time (bfd_int64_t vmstime)
7218 {
7219   struct tm *tm;
7220   time_t unxtime;
7221
7222   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7223   tm = gmtime (&unxtime);
7224   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7225           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7226           tm->tm_hour, tm->tm_min, tm->tm_sec);
7227 }
7228 #endif /* BFD64 */
7229
7230 static void
7231 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
7232 {
7233   switch (entry->d_tag)
7234     {
7235     case DT_IA_64_PLT_RESERVE:
7236       /* First 3 slots reserved.  */
7237       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7238       printf (" -- ");
7239       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
7240       break;
7241
7242     case DT_IA_64_VMS_LINKTIME:
7243 #ifdef BFD64
7244       print_vms_time (entry->d_un.d_val);
7245 #endif
7246       break;
7247
7248     case DT_IA_64_VMS_LNKFLAGS:
7249       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7250       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7251         printf (" CALL_DEBUG");
7252       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7253         printf (" NOP0BUFS");
7254       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7255         printf (" P0IMAGE");
7256       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7257         printf (" MKTHREADS");
7258       if (entry->d_un.d_val & VMS_LF_UPCALLS)
7259         printf (" UPCALLS");
7260       if (entry->d_un.d_val & VMS_LF_IMGSTA)
7261         printf (" IMGSTA");
7262       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7263         printf (" INITIALIZE");
7264       if (entry->d_un.d_val & VMS_LF_MAIN)
7265         printf (" MAIN");
7266       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7267         printf (" EXE_INIT");
7268       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7269         printf (" TBK_IN_IMG");
7270       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7271         printf (" DBG_IN_IMG");
7272       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7273         printf (" TBK_IN_DSF");
7274       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7275         printf (" DBG_IN_DSF");
7276       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7277         printf (" SIGNATURES");
7278       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7279         printf (" REL_SEG_OFF");
7280       break;
7281
7282     default:
7283       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7284       break;
7285     }
7286   putchar ('\n');
7287 }
7288
7289 static int
7290 get_32bit_dynamic_section (FILE * file)
7291 {
7292   Elf32_External_Dyn * edyn;
7293   Elf32_External_Dyn * ext;
7294   Elf_Internal_Dyn * entry;
7295
7296   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7297                                           dynamic_size, _("dynamic section"));
7298   if (!edyn)
7299     return 0;
7300
7301 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7302    might not have the luxury of section headers.  Look for the DT_NULL
7303    terminator to determine the number of entries.  */
7304   for (ext = edyn, dynamic_nent = 0;
7305        (char *) ext < (char *) edyn + dynamic_size;
7306        ext++)
7307     {
7308       dynamic_nent++;
7309       if (BYTE_GET (ext->d_tag) == DT_NULL)
7310         break;
7311     }
7312
7313   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7314                                                   sizeof (* entry));
7315   if (dynamic_section == NULL)
7316     {
7317       error (_("Out of memory\n"));
7318       free (edyn);
7319       return 0;
7320     }
7321
7322   for (ext = edyn, entry = dynamic_section;
7323        entry < dynamic_section + dynamic_nent;
7324        ext++, entry++)
7325     {
7326       entry->d_tag      = BYTE_GET (ext->d_tag);
7327       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7328     }
7329
7330   free (edyn);
7331
7332   return 1;
7333 }
7334
7335 static int
7336 get_64bit_dynamic_section (FILE * file)
7337 {
7338   Elf64_External_Dyn * edyn;
7339   Elf64_External_Dyn * ext;
7340   Elf_Internal_Dyn * entry;
7341
7342   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7343                                           dynamic_size, _("dynamic section"));
7344   if (!edyn)
7345     return 0;
7346
7347 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7348    might not have the luxury of section headers.  Look for the DT_NULL
7349    terminator to determine the number of entries.  */
7350   for (ext = edyn, dynamic_nent = 0;
7351        (char *) ext < (char *) edyn + dynamic_size;
7352        ext++)
7353     {
7354       dynamic_nent++;
7355       if (BYTE_GET (ext->d_tag) == DT_NULL)
7356         break;
7357     }
7358
7359   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7360                                                   sizeof (* entry));
7361   if (dynamic_section == NULL)
7362     {
7363       error (_("Out of memory\n"));
7364       free (edyn);
7365       return 0;
7366     }
7367
7368   for (ext = edyn, entry = dynamic_section;
7369        entry < dynamic_section + dynamic_nent;
7370        ext++, entry++)
7371     {
7372       entry->d_tag      = BYTE_GET (ext->d_tag);
7373       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7374     }
7375
7376   free (edyn);
7377
7378   return 1;
7379 }
7380
7381 static void
7382 print_dynamic_flags (bfd_vma flags)
7383 {
7384   int first = 1;
7385
7386   while (flags)
7387     {
7388       bfd_vma flag;
7389
7390       flag = flags & - flags;
7391       flags &= ~ flag;
7392
7393       if (first)
7394         first = 0;
7395       else
7396         putc (' ', stdout);
7397
7398       switch (flag)
7399         {
7400         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
7401         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
7402         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
7403         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
7404         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
7405         default:                fputs (_("unknown"), stdout); break;
7406         }
7407     }
7408   puts ("");
7409 }
7410
7411 /* Parse and display the contents of the dynamic section.  */
7412
7413 static int
7414 process_dynamic_section (FILE * file)
7415 {
7416   Elf_Internal_Dyn * entry;
7417
7418   if (dynamic_size == 0)
7419     {
7420       if (do_dynamic)
7421         printf (_("\nThere is no dynamic section in this file.\n"));
7422
7423       return 1;
7424     }
7425
7426   if (is_32bit_elf)
7427     {
7428       if (! get_32bit_dynamic_section (file))
7429         return 0;
7430     }
7431   else if (! get_64bit_dynamic_section (file))
7432     return 0;
7433
7434   /* Find the appropriate symbol table.  */
7435   if (dynamic_symbols == NULL)
7436     {
7437       for (entry = dynamic_section;
7438            entry < dynamic_section + dynamic_nent;
7439            ++entry)
7440         {
7441           Elf_Internal_Shdr section;
7442
7443           if (entry->d_tag != DT_SYMTAB)
7444             continue;
7445
7446           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7447
7448           /* Since we do not know how big the symbol table is,
7449              we default to reading in the entire file (!) and
7450              processing that.  This is overkill, I know, but it
7451              should work.  */
7452           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
7453
7454           if (archive_file_offset != 0)
7455             section.sh_size = archive_file_size - section.sh_offset;
7456           else
7457             {
7458               if (fseek (file, 0, SEEK_END))
7459                 error (_("Unable to seek to end of file!\n"));
7460
7461               section.sh_size = ftell (file) - section.sh_offset;
7462             }
7463
7464           if (is_32bit_elf)
7465             section.sh_entsize = sizeof (Elf32_External_Sym);
7466           else
7467             section.sh_entsize = sizeof (Elf64_External_Sym);
7468
7469           num_dynamic_syms = section.sh_size / section.sh_entsize;
7470           if (num_dynamic_syms < 1)
7471             {
7472               error (_("Unable to determine the number of symbols to load\n"));
7473               continue;
7474             }
7475
7476           dynamic_symbols = GET_ELF_SYMBOLS (file, &section);
7477         }
7478     }
7479
7480   /* Similarly find a string table.  */
7481   if (dynamic_strings == NULL)
7482     {
7483       for (entry = dynamic_section;
7484            entry < dynamic_section + dynamic_nent;
7485            ++entry)
7486         {
7487           unsigned long offset;
7488           long str_tab_len;
7489
7490           if (entry->d_tag != DT_STRTAB)
7491             continue;
7492
7493           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7494
7495           /* Since we do not know how big the string table is,
7496              we default to reading in the entire file (!) and
7497              processing that.  This is overkill, I know, but it
7498              should work.  */
7499
7500           offset = offset_from_vma (file, entry->d_un.d_val, 0);
7501
7502           if (archive_file_offset != 0)
7503             str_tab_len = archive_file_size - offset;
7504           else
7505             {
7506               if (fseek (file, 0, SEEK_END))
7507                 error (_("Unable to seek to end of file\n"));
7508               str_tab_len = ftell (file) - offset;
7509             }
7510
7511           if (str_tab_len < 1)
7512             {
7513               error
7514                 (_("Unable to determine the length of the dynamic string table\n"));
7515               continue;
7516             }
7517
7518           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7519                                                str_tab_len,
7520                                                _("dynamic string table"));
7521           dynamic_strings_length = str_tab_len;
7522           break;
7523         }
7524     }
7525
7526   /* And find the syminfo section if available.  */
7527   if (dynamic_syminfo == NULL)
7528     {
7529       unsigned long syminsz = 0;
7530
7531       for (entry = dynamic_section;
7532            entry < dynamic_section + dynamic_nent;
7533            ++entry)
7534         {
7535           if (entry->d_tag == DT_SYMINENT)
7536             {
7537               /* Note: these braces are necessary to avoid a syntax
7538                  error from the SunOS4 C compiler.  */
7539               assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7540             }
7541           else if (entry->d_tag == DT_SYMINSZ)
7542             syminsz = entry->d_un.d_val;
7543           else if (entry->d_tag == DT_SYMINFO)
7544             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7545                                                       syminsz);
7546         }
7547
7548       if (dynamic_syminfo_offset != 0 && syminsz != 0)
7549         {
7550           Elf_External_Syminfo * extsyminfo;
7551           Elf_External_Syminfo * extsym;
7552           Elf_Internal_Syminfo * syminfo;
7553
7554           /* There is a syminfo section.  Read the data.  */
7555           extsyminfo = (Elf_External_Syminfo *)
7556               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7557                         _("symbol information"));
7558           if (!extsyminfo)
7559             return 0;
7560
7561           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
7562           if (dynamic_syminfo == NULL)
7563             {
7564               error (_("Out of memory\n"));
7565               return 0;
7566             }
7567
7568           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
7569           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7570                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7571                ++syminfo, ++extsym)
7572             {
7573               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7574               syminfo->si_flags = BYTE_GET (extsym->si_flags);
7575             }
7576
7577           free (extsyminfo);
7578         }
7579     }
7580
7581   if (do_dynamic && dynamic_addr)
7582     printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7583             dynamic_addr, dynamic_nent);
7584   if (do_dynamic)
7585     printf (_("  Tag        Type                         Name/Value\n"));
7586
7587   for (entry = dynamic_section;
7588        entry < dynamic_section + dynamic_nent;
7589        entry++)
7590     {
7591       if (do_dynamic)
7592         {
7593           const char * dtype;
7594
7595           putchar (' ');
7596           print_vma (entry->d_tag, FULL_HEX);
7597           dtype = get_dynamic_type (entry->d_tag);
7598           printf (" (%s)%*s", dtype,
7599                   ((is_32bit_elf ? 27 : 19)
7600                    - (int) strlen (dtype)),
7601                   " ");
7602         }
7603
7604       switch (entry->d_tag)
7605         {
7606         case DT_FLAGS:
7607           if (do_dynamic)
7608             print_dynamic_flags (entry->d_un.d_val);
7609           break;
7610
7611         case DT_AUXILIARY:
7612         case DT_FILTER:
7613         case DT_CONFIG:
7614         case DT_DEPAUDIT:
7615         case DT_AUDIT:
7616           if (do_dynamic)
7617             {
7618               switch (entry->d_tag)
7619                 {
7620                 case DT_AUXILIARY:
7621                   printf (_("Auxiliary library"));
7622                   break;
7623
7624                 case DT_FILTER:
7625                   printf (_("Filter library"));
7626                   break;
7627
7628                 case DT_CONFIG:
7629                   printf (_("Configuration file"));
7630                   break;
7631
7632                 case DT_DEPAUDIT:
7633                   printf (_("Dependency audit library"));
7634                   break;
7635
7636                 case DT_AUDIT:
7637                   printf (_("Audit library"));
7638                   break;
7639                 }
7640
7641               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7642                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
7643               else
7644                 {
7645                   printf (": ");
7646                   print_vma (entry->d_un.d_val, PREFIX_HEX);
7647                   putchar ('\n');
7648                 }
7649             }
7650           break;
7651
7652         case DT_FEATURE:
7653           if (do_dynamic)
7654             {
7655               printf (_("Flags:"));
7656
7657               if (entry->d_un.d_val == 0)
7658                 printf (_(" None\n"));
7659               else
7660                 {
7661                   unsigned long int val = entry->d_un.d_val;
7662
7663                   if (val & DTF_1_PARINIT)
7664                     {
7665                       printf (" PARINIT");
7666                       val ^= DTF_1_PARINIT;
7667                     }
7668                   if (val & DTF_1_CONFEXP)
7669                     {
7670                       printf (" CONFEXP");
7671                       val ^= DTF_1_CONFEXP;
7672                     }
7673                   if (val != 0)
7674                     printf (" %lx", val);
7675                   puts ("");
7676                 }
7677             }
7678           break;
7679
7680         case DT_POSFLAG_1:
7681           if (do_dynamic)
7682             {
7683               printf (_("Flags:"));
7684
7685               if (entry->d_un.d_val == 0)
7686                 printf (_(" None\n"));
7687               else
7688                 {
7689                   unsigned long int val = entry->d_un.d_val;
7690
7691                   if (val & DF_P1_LAZYLOAD)
7692                     {
7693                       printf (" LAZYLOAD");
7694                       val ^= DF_P1_LAZYLOAD;
7695                     }
7696                   if (val & DF_P1_GROUPPERM)
7697                     {
7698                       printf (" GROUPPERM");
7699                       val ^= DF_P1_GROUPPERM;
7700                     }
7701                   if (val != 0)
7702                     printf (" %lx", val);
7703                   puts ("");
7704                 }
7705             }
7706           break;
7707
7708         case DT_FLAGS_1:
7709           if (do_dynamic)
7710             {
7711               printf (_("Flags:"));
7712               if (entry->d_un.d_val == 0)
7713                 printf (_(" None\n"));
7714               else
7715                 {
7716                   unsigned long int val = entry->d_un.d_val;
7717
7718                   if (val & DF_1_NOW)
7719                     {
7720                       printf (" NOW");
7721                       val ^= DF_1_NOW;
7722                     }
7723                   if (val & DF_1_GLOBAL)
7724                     {
7725                       printf (" GLOBAL");
7726                       val ^= DF_1_GLOBAL;
7727                     }
7728                   if (val & DF_1_GROUP)
7729                     {
7730                       printf (" GROUP");
7731                       val ^= DF_1_GROUP;
7732                     }
7733                   if (val & DF_1_NODELETE)
7734                     {
7735                       printf (" NODELETE");
7736                       val ^= DF_1_NODELETE;
7737                     }
7738                   if (val & DF_1_LOADFLTR)
7739                     {
7740                       printf (" LOADFLTR");
7741                       val ^= DF_1_LOADFLTR;
7742                     }
7743                   if (val & DF_1_INITFIRST)
7744                     {
7745                       printf (" INITFIRST");
7746                       val ^= DF_1_INITFIRST;
7747                     }
7748                   if (val & DF_1_NOOPEN)
7749                     {
7750                       printf (" NOOPEN");
7751                       val ^= DF_1_NOOPEN;
7752                     }
7753                   if (val & DF_1_ORIGIN)
7754                     {
7755                       printf (" ORIGIN");
7756                       val ^= DF_1_ORIGIN;
7757                     }
7758                   if (val & DF_1_DIRECT)
7759                     {
7760                       printf (" DIRECT");
7761                       val ^= DF_1_DIRECT;
7762                     }
7763                   if (val & DF_1_TRANS)
7764                     {
7765                       printf (" TRANS");
7766                       val ^= DF_1_TRANS;
7767                     }
7768                   if (val & DF_1_INTERPOSE)
7769                     {
7770                       printf (" INTERPOSE");
7771                       val ^= DF_1_INTERPOSE;
7772                     }
7773                   if (val & DF_1_NODEFLIB)
7774                     {
7775                       printf (" NODEFLIB");
7776                       val ^= DF_1_NODEFLIB;
7777                     }
7778                   if (val & DF_1_NODUMP)
7779                     {
7780                       printf (" NODUMP");
7781                       val ^= DF_1_NODUMP;
7782                     }
7783                   if (val & DF_1_CONLFAT)
7784                     {
7785                       printf (" CONLFAT");
7786                       val ^= DF_1_CONLFAT;
7787                     }
7788                   if (val != 0)
7789                     printf (" %lx", val);
7790                   puts ("");
7791                 }
7792             }
7793           break;
7794
7795         case DT_PLTREL:
7796           dynamic_info[entry->d_tag] = entry->d_un.d_val;
7797           if (do_dynamic)
7798             puts (get_dynamic_type (entry->d_un.d_val));
7799           break;
7800
7801         case DT_NULL    :
7802         case DT_NEEDED  :
7803         case DT_PLTGOT  :
7804         case DT_HASH    :
7805         case DT_STRTAB  :
7806         case DT_SYMTAB  :
7807         case DT_RELA    :
7808         case DT_INIT    :
7809         case DT_FINI    :
7810         case DT_SONAME  :
7811         case DT_RPATH   :
7812         case DT_SYMBOLIC:
7813         case DT_REL     :
7814         case DT_DEBUG   :
7815         case DT_TEXTREL :
7816         case DT_JMPREL  :
7817         case DT_RUNPATH :
7818           dynamic_info[entry->d_tag] = entry->d_un.d_val;
7819
7820           if (do_dynamic)
7821             {
7822               char * name;
7823
7824               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7825                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
7826               else
7827                 name = NULL;
7828
7829               if (name)
7830                 {
7831                   switch (entry->d_tag)
7832                     {
7833                     case DT_NEEDED:
7834                       printf (_("Shared library: [%s]"), name);
7835
7836                       if (streq (name, program_interpreter))
7837                         printf (_(" program interpreter"));
7838                       break;
7839
7840                     case DT_SONAME:
7841                       printf (_("Library soname: [%s]"), name);
7842                       break;
7843
7844                     case DT_RPATH:
7845                       printf (_("Library rpath: [%s]"), name);
7846                       break;
7847
7848                     case DT_RUNPATH:
7849                       printf (_("Library runpath: [%s]"), name);
7850                       break;
7851
7852                     default:
7853                       print_vma (entry->d_un.d_val, PREFIX_HEX);
7854                       break;
7855                     }
7856                 }
7857               else
7858                 print_vma (entry->d_un.d_val, PREFIX_HEX);
7859
7860               putchar ('\n');
7861             }
7862           break;
7863
7864         case DT_PLTRELSZ:
7865         case DT_RELASZ  :
7866         case DT_STRSZ   :
7867         case DT_RELSZ   :
7868         case DT_RELAENT :
7869         case DT_SYMENT  :
7870         case DT_RELENT  :
7871           dynamic_info[entry->d_tag] = entry->d_un.d_val;
7872         case DT_PLTPADSZ:
7873         case DT_MOVEENT :
7874         case DT_MOVESZ  :
7875         case DT_INIT_ARRAYSZ:
7876         case DT_FINI_ARRAYSZ:
7877         case DT_GNU_CONFLICTSZ:
7878         case DT_GNU_LIBLISTSZ:
7879           if (do_dynamic)
7880             {
7881               print_vma (entry->d_un.d_val, UNSIGNED);
7882               printf (_(" (bytes)\n"));
7883             }
7884           break;
7885
7886         case DT_VERDEFNUM:
7887         case DT_VERNEEDNUM:
7888         case DT_RELACOUNT:
7889         case DT_RELCOUNT:
7890           if (do_dynamic)
7891             {
7892               print_vma (entry->d_un.d_val, UNSIGNED);
7893               putchar ('\n');
7894             }
7895           break;
7896
7897         case DT_SYMINSZ:
7898         case DT_SYMINENT:
7899         case DT_SYMINFO:
7900         case DT_USED:
7901         case DT_INIT_ARRAY:
7902         case DT_FINI_ARRAY:
7903           if (do_dynamic)
7904             {
7905               if (entry->d_tag == DT_USED
7906                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
7907                 {
7908                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
7909
7910                   if (*name)
7911                     {
7912                       printf (_("Not needed object: [%s]\n"), name);
7913                       break;
7914                     }
7915                 }
7916
7917               print_vma (entry->d_un.d_val, PREFIX_HEX);
7918               putchar ('\n');
7919             }
7920           break;
7921
7922         case DT_BIND_NOW:
7923           /* The value of this entry is ignored.  */
7924           if (do_dynamic)
7925             putchar ('\n');
7926           break;
7927
7928         case DT_GNU_PRELINKED:
7929           if (do_dynamic)
7930             {
7931               struct tm * tmp;
7932               time_t atime = entry->d_un.d_val;
7933
7934               tmp = gmtime (&atime);
7935               printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7936                       tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7937                       tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7938
7939             }
7940           break;
7941
7942         case DT_GNU_HASH:
7943           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
7944           if (do_dynamic)
7945             {
7946               print_vma (entry->d_un.d_val, PREFIX_HEX);
7947               putchar ('\n');
7948             }
7949           break;
7950
7951         default:
7952           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
7953             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
7954               entry->d_un.d_val;
7955
7956           if (do_dynamic)
7957             {
7958               switch (elf_header.e_machine)
7959                 {
7960                 case EM_MIPS:
7961                 case EM_MIPS_RS3_LE:
7962                   dynamic_section_mips_val (entry);
7963                   break;
7964                 case EM_PARISC:
7965                   dynamic_section_parisc_val (entry);
7966                   break;
7967                 case EM_IA_64:
7968                   dynamic_section_ia64_val (entry);
7969                   break;
7970                 default:
7971                   print_vma (entry->d_un.d_val, PREFIX_HEX);
7972                   putchar ('\n');
7973                 }
7974             }
7975           break;
7976         }
7977     }
7978
7979   return 1;
7980 }
7981
7982 static char *
7983 get_ver_flags (unsigned int flags)
7984 {
7985   static char buff[32];
7986
7987   buff[0] = 0;
7988
7989   if (flags == 0)
7990     return _("none");
7991
7992   if (flags & VER_FLG_BASE)
7993     strcat (buff, "BASE ");
7994
7995   if (flags & VER_FLG_WEAK)
7996     {
7997       if (flags & VER_FLG_BASE)
7998         strcat (buff, "| ");
7999
8000       strcat (buff, "WEAK ");
8001     }
8002
8003   if (flags & VER_FLG_INFO)
8004     {
8005       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8006         strcat (buff, "| ");
8007
8008       strcat (buff, "INFO ");
8009     }
8010
8011   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
8012     strcat (buff, _("| <unknown>"));
8013
8014   return buff;
8015 }
8016
8017 /* Display the contents of the version sections.  */
8018
8019 static int
8020 process_version_sections (FILE * file)
8021 {
8022   Elf_Internal_Shdr * section;
8023   unsigned i;
8024   int found = 0;
8025
8026   if (! do_version)
8027     return 1;
8028
8029   for (i = 0, section = section_headers;
8030        i < elf_header.e_shnum;
8031        i++, section++)
8032     {
8033       switch (section->sh_type)
8034         {
8035         case SHT_GNU_verdef:
8036           {
8037             Elf_External_Verdef * edefs;
8038             unsigned int idx;
8039             unsigned int cnt;
8040             char * endbuf;
8041
8042             found = 1;
8043
8044             printf
8045               (_("\nVersion definition section '%s' contains %u entries:\n"),
8046                SECTION_NAME (section), section->sh_info);
8047
8048             printf (_("  Addr: 0x"));
8049             printf_vma (section->sh_addr);
8050             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8051                     (unsigned long) section->sh_offset, section->sh_link,
8052                     section->sh_link < elf_header.e_shnum
8053                     ? SECTION_NAME (section_headers + section->sh_link)
8054                     : _("<corrupt>"));
8055
8056             edefs = (Elf_External_Verdef *)
8057                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8058                           _("version definition section"));
8059             endbuf = (char *) edefs + section->sh_size;
8060             if (!edefs)
8061               break;
8062
8063             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8064               {
8065                 char * vstart;
8066                 Elf_External_Verdef * edef;
8067                 Elf_Internal_Verdef ent;
8068                 Elf_External_Verdaux * eaux;
8069                 Elf_Internal_Verdaux aux;
8070                 int j;
8071                 int isum;
8072
8073                 /* Check for negative or very large indicies.  */
8074                 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
8075                   break;
8076
8077                 vstart = ((char *) edefs) + idx;
8078                 if (vstart + sizeof (*edef) > endbuf)
8079                   break;
8080
8081                 edef = (Elf_External_Verdef *) vstart;
8082
8083                 ent.vd_version = BYTE_GET (edef->vd_version);
8084                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
8085                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
8086                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
8087                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
8088                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
8089                 ent.vd_next    = BYTE_GET (edef->vd_next);
8090
8091                 printf (_("  %#06x: Rev: %d  Flags: %s"),
8092                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8093
8094                 printf (_("  Index: %d  Cnt: %d  "),
8095                         ent.vd_ndx, ent.vd_cnt);
8096
8097                 /* Check for overflow.  */
8098                 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
8099                     || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
8100                   break;
8101
8102                 vstart += ent.vd_aux;
8103
8104                 eaux = (Elf_External_Verdaux *) vstart;
8105
8106                 aux.vda_name = BYTE_GET (eaux->vda_name);
8107                 aux.vda_next = BYTE_GET (eaux->vda_next);
8108
8109                 if (VALID_DYNAMIC_NAME (aux.vda_name))
8110                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
8111                 else
8112                   printf (_("Name index: %ld\n"), aux.vda_name);
8113
8114                 isum = idx + ent.vd_aux;
8115
8116                 for (j = 1; j < ent.vd_cnt; j++)
8117                   {
8118                     /* Check for overflow.  */
8119                     if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
8120                         || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
8121                       break;
8122
8123                     isum   += aux.vda_next;
8124                     vstart += aux.vda_next;
8125
8126                     eaux = (Elf_External_Verdaux *) vstart;
8127                     if (vstart + sizeof (*eaux) > endbuf)
8128                       break;
8129
8130                     aux.vda_name = BYTE_GET (eaux->vda_name);
8131                     aux.vda_next = BYTE_GET (eaux->vda_next);
8132
8133                     if (VALID_DYNAMIC_NAME (aux.vda_name))
8134                       printf (_("  %#06x: Parent %d: %s\n"),
8135                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
8136                     else
8137                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
8138                               isum, j, aux.vda_name);
8139                   }
8140
8141                 if (j < ent.vd_cnt)
8142                   printf (_("  Version def aux past end of section\n"));
8143
8144                 idx += ent.vd_next;
8145               }
8146
8147             if (cnt < section->sh_info)
8148               printf (_("  Version definition past end of section\n"));
8149
8150             free (edefs);
8151           }
8152           break;
8153
8154         case SHT_GNU_verneed:
8155           {
8156             Elf_External_Verneed * eneed;
8157             unsigned int idx;
8158             unsigned int cnt;
8159             char * endbuf;
8160
8161             found = 1;
8162
8163             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8164                     SECTION_NAME (section), section->sh_info);
8165
8166             printf (_(" Addr: 0x"));
8167             printf_vma (section->sh_addr);
8168             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8169                     (unsigned long) section->sh_offset, section->sh_link,
8170                     section->sh_link < elf_header.e_shnum
8171                     ? SECTION_NAME (section_headers + section->sh_link)
8172                     : _("<corrupt>"));
8173
8174             eneed = (Elf_External_Verneed *) get_data (NULL, file,
8175                                                        section->sh_offset, 1,
8176                                                        section->sh_size,
8177                                                        _("version need section"));
8178             endbuf = (char *) eneed + section->sh_size;
8179             if (!eneed)
8180               break;
8181
8182             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8183               {
8184                 Elf_External_Verneed * entry;
8185                 Elf_Internal_Verneed ent;
8186                 int j;
8187                 int isum;
8188                 char * vstart;
8189
8190                 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
8191                   break;
8192
8193                 vstart = ((char *) eneed) + idx;
8194                 if (vstart + sizeof (*entry) > endbuf)
8195                   break;
8196
8197                 entry = (Elf_External_Verneed *) vstart;
8198
8199                 ent.vn_version = BYTE_GET (entry->vn_version);
8200                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
8201                 ent.vn_file    = BYTE_GET (entry->vn_file);
8202                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
8203                 ent.vn_next    = BYTE_GET (entry->vn_next);
8204
8205                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
8206
8207                 if (VALID_DYNAMIC_NAME (ent.vn_file))
8208                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
8209                 else
8210                   printf (_("  File: %lx"), ent.vn_file);
8211
8212                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
8213
8214                 /* Check for overflow.  */
8215                 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
8216                     || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
8217                   break;
8218
8219                 vstart += ent.vn_aux;
8220
8221                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8222                   {
8223                     Elf_External_Vernaux * eaux;
8224                     Elf_Internal_Vernaux aux;
8225
8226                     if (vstart + sizeof (*eaux) > endbuf)
8227                       break;
8228                     eaux = (Elf_External_Vernaux *) vstart;
8229
8230                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
8231                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
8232                     aux.vna_other = BYTE_GET (eaux->vna_other);
8233                     aux.vna_name  = BYTE_GET (eaux->vna_name);
8234                     aux.vna_next  = BYTE_GET (eaux->vna_next);
8235
8236                     if (VALID_DYNAMIC_NAME (aux.vna_name))
8237                       printf (_("  %#06x:   Name: %s"),
8238                               isum, GET_DYNAMIC_NAME (aux.vna_name));
8239                     else
8240                       printf (_("  %#06x:   Name index: %lx"),
8241                               isum, aux.vna_name);
8242
8243                     printf (_("  Flags: %s  Version: %d\n"),
8244                             get_ver_flags (aux.vna_flags), aux.vna_other);
8245
8246                     /* Check for overflow.  */
8247                     if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
8248                         || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
8249                       break;
8250
8251                     isum   += aux.vna_next;
8252                     vstart += aux.vna_next;
8253                   }
8254                 if (j < ent.vn_cnt)
8255                   printf (_("  Version need aux past end of section\n"));
8256
8257                 idx += ent.vn_next;
8258               }
8259             if (cnt < section->sh_info)
8260               printf (_("  Version need past end of section\n"));
8261
8262             free (eneed);
8263           }
8264           break;
8265
8266         case SHT_GNU_versym:
8267           {
8268             Elf_Internal_Shdr * link_section;
8269             int total;
8270             int cnt;
8271             unsigned char * edata;
8272             unsigned short * data;
8273             char * strtab;
8274             Elf_Internal_Sym * symbols;
8275             Elf_Internal_Shdr * string_sec;
8276             long off;
8277
8278             if (section->sh_link >= elf_header.e_shnum)
8279               break;
8280
8281             link_section = section_headers + section->sh_link;
8282             total = section->sh_size / sizeof (Elf_External_Versym);
8283
8284             if (link_section->sh_link >= elf_header.e_shnum)
8285               break;
8286
8287             found = 1;
8288
8289             symbols = GET_ELF_SYMBOLS (file, link_section);
8290             if (symbols == NULL)
8291               break;
8292
8293             string_sec = section_headers + link_section->sh_link;
8294
8295             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8296                                         string_sec->sh_size,
8297                                         _("version string table"));
8298             if (!strtab)
8299               {
8300                 free (symbols);
8301                 break;
8302               }
8303
8304             printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8305                     SECTION_NAME (section), total);
8306
8307             printf (_(" Addr: "));
8308             printf_vma (section->sh_addr);
8309             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8310                     (unsigned long) section->sh_offset, section->sh_link,
8311                     SECTION_NAME (link_section));
8312
8313             off = offset_from_vma (file,
8314                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8315                                    total * sizeof (short));
8316             edata = (unsigned char *) get_data (NULL, file, off, total,
8317                                                 sizeof (short),
8318                                                 _("version symbol data"));
8319             if (!edata)
8320               {
8321                 free (strtab);
8322                 free (symbols);
8323                 break;
8324               }
8325
8326             data = (short unsigned int *) cmalloc (total, sizeof (short));
8327
8328             for (cnt = total; cnt --;)
8329               data[cnt] = byte_get (edata + cnt * sizeof (short),
8330                                     sizeof (short));
8331
8332             free (edata);
8333
8334             for (cnt = 0; cnt < total; cnt += 4)
8335               {
8336                 int j, nn;
8337                 int check_def, check_need;
8338                 char * name;
8339
8340                 printf ("  %03x:", cnt);
8341
8342                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
8343                   switch (data[cnt + j])
8344                     {
8345                     case 0:
8346                       fputs (_("   0 (*local*)    "), stdout);
8347                       break;
8348
8349                     case 1:
8350                       fputs (_("   1 (*global*)   "), stdout);
8351                       break;
8352
8353                     default:
8354                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8355                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
8356
8357                       /* If this index value is greater than the size of the symbols
8358                          array, break to avoid an out-of-bounds read,  */
8359                       if ((unsigned long)(cnt + j) >=
8360                          ((unsigned long)link_section->sh_size /
8361                           (unsigned long)link_section->sh_entsize))
8362                         {
8363                           warn (_("invalid index into symbol array\n"));
8364                           break;
8365                         }
8366
8367                       check_def = 1;
8368                       check_need = 1;
8369                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8370                           || section_headers[symbols[cnt + j].st_shndx].sh_type
8371                              != SHT_NOBITS)
8372                         {
8373                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
8374                             check_def = 0;
8375                           else
8376                             check_need = 0;
8377                         }
8378
8379                       if (check_need
8380                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
8381                         {
8382                           Elf_Internal_Verneed ivn;
8383                           unsigned long offset;
8384
8385                           offset = offset_from_vma
8386                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8387                              sizeof (Elf_External_Verneed));
8388
8389                           do
8390                             {
8391                               Elf_Internal_Vernaux ivna;
8392                               Elf_External_Verneed evn;
8393                               Elf_External_Vernaux evna;
8394                               unsigned long a_off;
8395
8396                               get_data (&evn, file, offset, sizeof (evn), 1,
8397                                         _("version need"));
8398
8399                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
8400                               ivn.vn_next = BYTE_GET (evn.vn_next);
8401
8402                               a_off = offset + ivn.vn_aux;
8403
8404                               do
8405                                 {
8406                                   get_data (&evna, file, a_off, sizeof (evna),
8407                                             1, _("version need aux (2)"));
8408
8409                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
8410                                   ivna.vna_other = BYTE_GET (evna.vna_other);
8411
8412                                   a_off += ivna.vna_next;
8413                                 }
8414                               while (ivna.vna_other != data[cnt + j]
8415                                      && ivna.vna_next != 0);
8416
8417                               if (ivna.vna_other == data[cnt + j])
8418                                 {
8419                                   ivna.vna_name = BYTE_GET (evna.vna_name);
8420
8421                                   if (ivna.vna_name >= string_sec->sh_size)
8422                                     name = _("*invalid*");
8423                                   else
8424                                     name = strtab + ivna.vna_name;
8425                                   nn += printf ("(%s%-*s",
8426                                                 name,
8427                                                 12 - (int) strlen (name),
8428                                                 ")");
8429                                   check_def = 0;
8430                                   break;
8431                                 }
8432
8433                               offset += ivn.vn_next;
8434                             }
8435                           while (ivn.vn_next);
8436                         }
8437
8438                       if (check_def && data[cnt + j] != 0x8001
8439                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8440                         {
8441                           Elf_Internal_Verdef ivd;
8442                           Elf_External_Verdef evd;
8443                           unsigned long offset;
8444
8445                           offset = offset_from_vma
8446                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8447                              sizeof evd);
8448
8449                           do
8450                             {
8451                               get_data (&evd, file, offset, sizeof (evd), 1,
8452                                         _("version def"));
8453
8454                               ivd.vd_next = BYTE_GET (evd.vd_next);
8455                               ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
8456
8457                               offset += ivd.vd_next;
8458                             }
8459                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
8460                                  && ivd.vd_next != 0);
8461
8462                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
8463                             {
8464                               Elf_External_Verdaux evda;
8465                               Elf_Internal_Verdaux ivda;
8466
8467                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
8468
8469                               get_data (&evda, file,
8470                                         offset - ivd.vd_next + ivd.vd_aux,
8471                                         sizeof (evda), 1,
8472                                         _("version def aux"));
8473
8474                               ivda.vda_name = BYTE_GET (evda.vda_name);
8475
8476                               if (ivda.vda_name >= string_sec->sh_size)
8477                                 name = _("*invalid*");
8478                               else
8479                                 name = strtab + ivda.vda_name;
8480                               nn += printf ("(%s%-*s",
8481                                             name,
8482                                             12 - (int) strlen (name),
8483                                             ")");
8484                             }
8485                         }
8486
8487                       if (nn < 18)
8488                         printf ("%*c", 18 - nn, ' ');
8489                     }
8490
8491                 putchar ('\n');
8492               }
8493
8494             free (data);
8495             free (strtab);
8496             free (symbols);
8497           }
8498           break;
8499
8500         default:
8501           break;
8502         }
8503     }
8504
8505   if (! found)
8506     printf (_("\nNo version information found in this file.\n"));
8507
8508   return 1;
8509 }
8510
8511 static const char *
8512 get_symbol_binding (unsigned int binding)
8513 {
8514   static char buff[32];
8515
8516   switch (binding)
8517     {
8518     case STB_LOCAL:     return "LOCAL";
8519     case STB_GLOBAL:    return "GLOBAL";
8520     case STB_WEAK:      return "WEAK";
8521     default:
8522       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
8523         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8524                   binding);
8525       else if (binding >= STB_LOOS && binding <= STB_HIOS)
8526         {
8527           if (binding == STB_GNU_UNIQUE
8528               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8529                   /* GNU/Linux is still using the default value 0.  */
8530                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8531             return "UNIQUE";
8532           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8533         }
8534       else
8535         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
8536       return buff;
8537     }
8538 }
8539
8540 static const char *
8541 get_symbol_type (unsigned int type)
8542 {
8543   static char buff[32];
8544
8545   switch (type)
8546     {
8547     case STT_NOTYPE:    return "NOTYPE";
8548     case STT_OBJECT:    return "OBJECT";
8549     case STT_FUNC:      return "FUNC";
8550     case STT_SECTION:   return "SECTION";
8551     case STT_FILE:      return "FILE";
8552     case STT_COMMON:    return "COMMON";
8553     case STT_TLS:       return "TLS";
8554     case STT_RELC:      return "RELC";
8555     case STT_SRELC:     return "SRELC";
8556     default:
8557       if (type >= STT_LOPROC && type <= STT_HIPROC)
8558         {
8559           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
8560             return "THUMB_FUNC";
8561
8562           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
8563             return "REGISTER";
8564
8565           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8566             return "PARISC_MILLI";
8567
8568           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
8569         }
8570       else if (type >= STT_LOOS && type <= STT_HIOS)
8571         {
8572           if (elf_header.e_machine == EM_PARISC)
8573             {
8574               if (type == STT_HP_OPAQUE)
8575                 return "HP_OPAQUE";
8576               if (type == STT_HP_STUB)
8577                 return "HP_STUB";
8578             }
8579
8580           if (type == STT_GNU_IFUNC
8581               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8582                   /* GNU/Linux is still using the default value 0.  */
8583                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8584             return "IFUNC";
8585
8586           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
8587         }
8588       else
8589         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
8590       return buff;
8591     }
8592 }
8593
8594 static const char *
8595 get_symbol_visibility (unsigned int visibility)
8596 {
8597   switch (visibility)
8598     {
8599     case STV_DEFAULT:   return "DEFAULT";
8600     case STV_INTERNAL:  return "INTERNAL";
8601     case STV_HIDDEN:    return "HIDDEN";
8602     case STV_PROTECTED: return "PROTECTED";
8603     default: abort ();
8604     }
8605 }
8606
8607 static const char *
8608 get_mips_symbol_other (unsigned int other)
8609 {
8610   switch (other)
8611     {
8612     case STO_OPTIONAL:  return "OPTIONAL";
8613     case STO_MIPS16:    return "MIPS16";
8614     case STO_MIPS_PLT:  return "MIPS PLT";
8615     case STO_MIPS_PIC:  return "MIPS PIC";
8616     default:            return NULL;
8617     }
8618 }
8619
8620 static const char *
8621 get_ia64_symbol_other (unsigned int other)
8622 {
8623   if (is_ia64_vms ())
8624     {
8625       static char res[32];
8626
8627       res[0] = 0;
8628
8629       /* Function types is for images and .STB files only.  */
8630       switch (elf_header.e_type)
8631         {
8632         case ET_DYN:
8633         case ET_EXEC:
8634           switch (VMS_ST_FUNC_TYPE (other))
8635             {
8636             case VMS_SFT_CODE_ADDR:
8637               strcat (res, " CA");
8638               break;
8639             case VMS_SFT_SYMV_IDX:
8640               strcat (res, " VEC");
8641               break;
8642             case VMS_SFT_FD:
8643               strcat (res, " FD");
8644               break;
8645             case VMS_SFT_RESERVE:
8646               strcat (res, " RSV");
8647               break;
8648             default:
8649               abort ();
8650             }
8651           break;
8652         default:
8653           break;
8654         }
8655       switch (VMS_ST_LINKAGE (other))
8656         {
8657         case VMS_STL_IGNORE:
8658           strcat (res, " IGN");
8659           break;
8660         case VMS_STL_RESERVE:
8661           strcat (res, " RSV");
8662           break;
8663         case VMS_STL_STD:
8664           strcat (res, " STD");
8665           break;
8666         case VMS_STL_LNK:
8667           strcat (res, " LNK");
8668           break;
8669         default:
8670           abort ();
8671         }
8672
8673       if (res[0] != 0)
8674         return res + 1;
8675       else
8676         return res;
8677     }
8678   return NULL;
8679 }
8680
8681 static const char *
8682 get_symbol_other (unsigned int other)
8683 {
8684   const char * result = NULL;
8685   static char buff [32];
8686
8687   if (other == 0)
8688     return "";
8689
8690   switch (elf_header.e_machine)
8691     {
8692     case EM_MIPS:
8693       result = get_mips_symbol_other (other);
8694       break;
8695     case EM_IA_64:
8696       result = get_ia64_symbol_other (other);
8697       break;
8698     default:
8699       break;
8700     }
8701
8702   if (result)
8703     return result;
8704
8705   snprintf (buff, sizeof buff, _("<other>: %x"), other);
8706   return buff;
8707 }
8708
8709 static const char *
8710 get_symbol_index_type (unsigned int type)
8711 {
8712   static char buff[32];
8713
8714   switch (type)
8715     {
8716     case SHN_UNDEF:     return "UND";
8717     case SHN_ABS:       return "ABS";
8718     case SHN_COMMON:    return "COM";
8719     default:
8720       if (type == SHN_IA_64_ANSI_COMMON
8721           && elf_header.e_machine == EM_IA_64
8722           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
8723         return "ANSI_COM";
8724       else if ((elf_header.e_machine == EM_X86_64
8725                 || elf_header.e_machine == EM_L1OM)
8726                && type == SHN_X86_64_LCOMMON)
8727         return "LARGE_COM";
8728       else if ((type == SHN_MIPS_SCOMMON
8729                 && elf_header.e_machine == EM_MIPS)
8730                || (type == SHN_TIC6X_SCOMMON
8731                    && elf_header.e_machine == EM_TI_C6000))
8732         return "SCOM";
8733       else if (type == SHN_MIPS_SUNDEFINED
8734                && elf_header.e_machine == EM_MIPS)
8735         return "SUND";
8736       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
8737         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
8738       else if (type >= SHN_LOOS && type <= SHN_HIOS)
8739         sprintf (buff, "OS [0x%04x]", type & 0xffff);
8740       else if (type >= SHN_LORESERVE)
8741         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
8742       else
8743         sprintf (buff, "%3d", type);
8744       break;
8745     }
8746
8747   return buff;
8748 }
8749
8750 static bfd_vma *
8751 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
8752 {
8753   unsigned char * e_data;
8754   bfd_vma * i_data;
8755
8756   e_data = (unsigned char *) cmalloc (number, ent_size);
8757
8758   if (e_data == NULL)
8759     {
8760       error (_("Out of memory\n"));
8761       return NULL;
8762     }
8763
8764   if (fread (e_data, ent_size, number, file) != number)
8765     {
8766       error (_("Unable to read in dynamic data\n"));
8767       return NULL;
8768     }
8769
8770   i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
8771
8772   if (i_data == NULL)
8773     {
8774       error (_("Out of memory\n"));
8775       free (e_data);
8776       return NULL;
8777     }
8778
8779   while (number--)
8780     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
8781
8782   free (e_data);
8783
8784   return i_data;
8785 }
8786
8787 static void
8788 print_dynamic_symbol (bfd_vma si, unsigned long hn)
8789 {
8790   Elf_Internal_Sym * psym;
8791   int n;
8792
8793   psym = dynamic_symbols + si;
8794
8795   n = print_vma (si, DEC_5);
8796   if (n < 5)
8797     fputs ("     " + n, stdout);
8798   printf (" %3lu: ", hn);
8799   print_vma (psym->st_value, LONG_HEX);
8800   putchar (' ');
8801   print_vma (psym->st_size, DEC_5);
8802
8803   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8804   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8805   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
8806   /* Check to see if any other bits in the st_other field are set.
8807      Note - displaying this information disrupts the layout of the
8808      table being generated, but for the moment this case is very
8809      rare.  */
8810   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8811     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8812   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
8813   if (VALID_DYNAMIC_NAME (psym->st_name))
8814     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
8815   else
8816     printf (_(" <corrupt: %14ld>"), psym->st_name);
8817   putchar ('\n');
8818 }
8819
8820 /* Dump the symbol table.  */
8821 static int
8822 process_symbol_table (FILE * file)
8823 {
8824   Elf_Internal_Shdr * section;
8825   bfd_vma nbuckets = 0;
8826   bfd_vma nchains = 0;
8827   bfd_vma * buckets = NULL;
8828   bfd_vma * chains = NULL;
8829   bfd_vma ngnubuckets = 0;
8830   bfd_vma * gnubuckets = NULL;
8831   bfd_vma * gnuchains = NULL;
8832   bfd_vma gnusymidx = 0;
8833
8834   if (!do_syms && !do_dyn_syms && !do_histogram)
8835     return 1;
8836
8837   if (dynamic_info[DT_HASH]
8838       && (do_histogram
8839           || (do_using_dynamic
8840               && !do_dyn_syms
8841               && dynamic_strings != NULL)))
8842     {
8843       unsigned char nb[8];
8844       unsigned char nc[8];
8845       int hash_ent_size = 4;
8846
8847       if ((elf_header.e_machine == EM_ALPHA
8848            || elf_header.e_machine == EM_S390
8849            || elf_header.e_machine == EM_S390_OLD)
8850           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
8851         hash_ent_size = 8;
8852
8853       if (fseek (file,
8854                  (archive_file_offset
8855                   + offset_from_vma (file, dynamic_info[DT_HASH],
8856                                      sizeof nb + sizeof nc)),
8857                  SEEK_SET))
8858         {
8859           error (_("Unable to seek to start of dynamic information\n"));
8860           goto no_hash;
8861         }
8862
8863       if (fread (nb, hash_ent_size, 1, file) != 1)
8864         {
8865           error (_("Failed to read in number of buckets\n"));
8866           goto no_hash;
8867         }
8868
8869       if (fread (nc, hash_ent_size, 1, file) != 1)
8870         {
8871           error (_("Failed to read in number of chains\n"));
8872           goto no_hash;
8873         }
8874
8875       nbuckets = byte_get (nb, hash_ent_size);
8876       nchains  = byte_get (nc, hash_ent_size);
8877
8878       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
8879       chains  = get_dynamic_data (file, nchains, hash_ent_size);
8880
8881     no_hash:
8882       if (buckets == NULL || chains == NULL)
8883         {
8884           if (do_using_dynamic)
8885             return 0;
8886           free (buckets);
8887           free (chains);
8888           buckets = NULL;
8889           chains = NULL;
8890           nbuckets = 0;
8891           nchains = 0;
8892         }
8893     }
8894
8895   if (dynamic_info_DT_GNU_HASH
8896       && (do_histogram
8897           || (do_using_dynamic
8898               && !do_dyn_syms
8899               && dynamic_strings != NULL)))
8900     {
8901       unsigned char nb[16];
8902       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
8903       bfd_vma buckets_vma;
8904
8905       if (fseek (file,
8906                  (archive_file_offset
8907                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
8908                                      sizeof nb)),
8909                  SEEK_SET))
8910         {
8911           error (_("Unable to seek to start of dynamic information\n"));
8912           goto no_gnu_hash;
8913         }
8914
8915       if (fread (nb, 16, 1, file) != 1)
8916         {
8917           error (_("Failed to read in number of buckets\n"));
8918           goto no_gnu_hash;
8919         }
8920
8921       ngnubuckets = byte_get (nb, 4);
8922       gnusymidx = byte_get (nb + 4, 4);
8923       bitmaskwords = byte_get (nb + 8, 4);
8924       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
8925       if (is_32bit_elf)
8926         buckets_vma += bitmaskwords * 4;
8927       else
8928         buckets_vma += bitmaskwords * 8;
8929
8930       if (fseek (file,
8931                  (archive_file_offset
8932                   + offset_from_vma (file, buckets_vma, 4)),
8933                  SEEK_SET))
8934         {
8935           error (_("Unable to seek to start of dynamic information\n"));
8936           goto no_gnu_hash;
8937         }
8938
8939       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
8940
8941       if (gnubuckets == NULL)
8942         goto no_gnu_hash;
8943
8944       for (i = 0; i < ngnubuckets; i++)
8945         if (gnubuckets[i] != 0)
8946           {
8947             if (gnubuckets[i] < gnusymidx)
8948               return 0;
8949
8950             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
8951               maxchain = gnubuckets[i];
8952           }
8953
8954       if (maxchain == 0xffffffff)
8955         goto no_gnu_hash;
8956
8957       maxchain -= gnusymidx;
8958
8959       if (fseek (file,
8960                  (archive_file_offset
8961                   + offset_from_vma (file, buckets_vma
8962                                            + 4 * (ngnubuckets + maxchain), 4)),
8963                  SEEK_SET))
8964         {
8965           error (_("Unable to seek to start of dynamic information\n"));
8966           goto no_gnu_hash;
8967         }
8968
8969       do
8970         {
8971           if (fread (nb, 4, 1, file) != 1)
8972             {
8973               error (_("Failed to determine last chain length\n"));
8974               goto no_gnu_hash;
8975             }
8976
8977           if (maxchain + 1 == 0)
8978             goto no_gnu_hash;
8979
8980           ++maxchain;
8981         }
8982       while ((byte_get (nb, 4) & 1) == 0);
8983
8984       if (fseek (file,
8985                  (archive_file_offset
8986                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
8987                  SEEK_SET))
8988         {
8989           error (_("Unable to seek to start of dynamic information\n"));
8990           goto no_gnu_hash;
8991         }
8992
8993       gnuchains = get_dynamic_data (file, maxchain, 4);
8994
8995     no_gnu_hash:
8996       if (gnuchains == NULL)
8997         {
8998           free (gnubuckets);
8999           gnubuckets = NULL;
9000           ngnubuckets = 0;
9001           if (do_using_dynamic)
9002             return 0;
9003         }
9004     }
9005
9006   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9007       && do_syms
9008       && do_using_dynamic
9009       && dynamic_strings != NULL)
9010     {
9011       unsigned long hn;
9012
9013       if (dynamic_info[DT_HASH])
9014         {
9015           bfd_vma si;
9016
9017           printf (_("\nSymbol table for image:\n"));
9018           if (is_32bit_elf)
9019             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9020           else
9021             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9022
9023           for (hn = 0; hn < nbuckets; hn++)
9024             {
9025               if (! buckets[hn])
9026                 continue;
9027
9028               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9029                 print_dynamic_symbol (si, hn);
9030             }
9031         }
9032
9033       if (dynamic_info_DT_GNU_HASH)
9034         {
9035           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9036           if (is_32bit_elf)
9037             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9038           else
9039             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9040
9041           for (hn = 0; hn < ngnubuckets; ++hn)
9042             if (gnubuckets[hn] != 0)
9043               {
9044                 bfd_vma si = gnubuckets[hn];
9045                 bfd_vma off = si - gnusymidx;
9046
9047                 do
9048                   {
9049                     print_dynamic_symbol (si, hn);
9050                     si++;
9051                   }
9052                 while ((gnuchains[off++] & 1) == 0);
9053               }
9054         }
9055     }
9056   else if (do_dyn_syms || (do_syms && !do_using_dynamic))
9057     {
9058       unsigned int i;
9059
9060       for (i = 0, section = section_headers;
9061            i < elf_header.e_shnum;
9062            i++, section++)
9063         {
9064           unsigned int si;
9065           char * strtab = NULL;
9066           unsigned long int strtab_size = 0;
9067           Elf_Internal_Sym * symtab;
9068           Elf_Internal_Sym * psym;
9069
9070           if ((section->sh_type != SHT_SYMTAB
9071                && section->sh_type != SHT_DYNSYM)
9072               || (!do_syms
9073                   && section->sh_type == SHT_SYMTAB))
9074             continue;
9075
9076           if (section->sh_entsize == 0)
9077             {
9078               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9079                       SECTION_NAME (section));
9080               continue;
9081             }
9082
9083           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9084                   SECTION_NAME (section),
9085                   (unsigned long) (section->sh_size / section->sh_entsize));
9086
9087           if (is_32bit_elf)
9088             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
9089           else
9090             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
9091
9092           symtab = GET_ELF_SYMBOLS (file, section);
9093           if (symtab == NULL)
9094             continue;
9095
9096           if (section->sh_link == elf_header.e_shstrndx)
9097             {
9098               strtab = string_table;
9099               strtab_size = string_table_length;
9100             }
9101           else if (section->sh_link < elf_header.e_shnum)
9102             {
9103               Elf_Internal_Shdr * string_sec;
9104
9105               string_sec = section_headers + section->sh_link;
9106
9107               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9108                                           1, string_sec->sh_size,
9109                                           _("string table"));
9110               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
9111             }
9112
9113           for (si = 0, psym = symtab;
9114                si < section->sh_size / section->sh_entsize;
9115                si++, psym++)
9116             {
9117               printf ("%6d: ", si);
9118               print_vma (psym->st_value, LONG_HEX);
9119               putchar (' ');
9120               print_vma (psym->st_size, DEC_5);
9121               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9122               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9123               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9124               /* Check to see if any other bits in the st_other field are set.
9125                  Note - displaying this information disrupts the layout of the
9126                  table being generated, but for the moment this case is very rare.  */
9127               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9128                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9129               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
9130               print_symbol (25, psym->st_name < strtab_size
9131                             ? strtab + psym->st_name : _("<corrupt>"));
9132
9133               if (section->sh_type == SHT_DYNSYM &&
9134                   version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9135                 {
9136                   unsigned char data[2];
9137                   unsigned short vers_data;
9138                   unsigned long offset;
9139                   int is_nobits;
9140                   int check_def;
9141
9142                   offset = offset_from_vma
9143                     (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9144                      sizeof data + si * sizeof (vers_data));
9145
9146                   get_data (&data, file, offset + si * sizeof (vers_data),
9147                             sizeof (data), 1, _("version data"));
9148
9149                   vers_data = byte_get (data, 2);
9150
9151                   is_nobits = (psym->st_shndx < elf_header.e_shnum
9152                                && section_headers[psym->st_shndx].sh_type
9153                                   == SHT_NOBITS);
9154
9155                   check_def = (psym->st_shndx != SHN_UNDEF);
9156
9157                   if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
9158                     {
9159                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
9160                           && (is_nobits || ! check_def))
9161                         {
9162                           Elf_External_Verneed evn;
9163                           Elf_Internal_Verneed ivn;
9164                           Elf_Internal_Vernaux ivna;
9165
9166                           /* We must test both.  */
9167                           offset = offset_from_vma
9168                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9169                              sizeof evn);
9170
9171                           do
9172                             {
9173                               unsigned long vna_off;
9174
9175                               get_data (&evn, file, offset, sizeof (evn), 1,
9176                                         _("version need"));
9177
9178                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9179                               ivn.vn_next = BYTE_GET (evn.vn_next);
9180
9181                               vna_off = offset + ivn.vn_aux;
9182
9183                               do
9184                                 {
9185                                   Elf_External_Vernaux evna;
9186
9187                                   get_data (&evna, file, vna_off,
9188                                             sizeof (evna), 1,
9189                                             _("version need aux (3)"));
9190
9191                                   ivna.vna_other = BYTE_GET (evna.vna_other);
9192                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
9193                                   ivna.vna_name  = BYTE_GET (evna.vna_name);
9194
9195                                   vna_off += ivna.vna_next;
9196                                 }
9197                               while (ivna.vna_other != vers_data
9198                                      && ivna.vna_next != 0);
9199
9200                               if (ivna.vna_other == vers_data)
9201                                 break;
9202
9203                               offset += ivn.vn_next;
9204                             }
9205                           while (ivn.vn_next != 0);
9206
9207                           if (ivna.vna_other == vers_data)
9208                             {
9209                               printf ("@%s (%d)",
9210                                       ivna.vna_name < strtab_size
9211                                       ? strtab + ivna.vna_name : _("<corrupt>"),
9212                                       ivna.vna_other);
9213                               check_def = 0;
9214                             }
9215                           else if (! is_nobits)
9216                             error (_("bad dynamic symbol\n"));
9217                           else
9218                             check_def = 1;
9219                         }
9220
9221                       if (check_def)
9222                         {
9223                           if (vers_data != 0x8001
9224                               && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9225                             {
9226                               Elf_Internal_Verdef ivd;
9227                               Elf_Internal_Verdaux ivda;
9228                               Elf_External_Verdaux evda;
9229                               unsigned long off;
9230
9231                               off = offset_from_vma
9232                                 (file,
9233                                  version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9234                                  sizeof (Elf_External_Verdef));
9235
9236                               do
9237                                 {
9238                                   Elf_External_Verdef evd;
9239
9240                                   get_data (&evd, file, off, sizeof (evd),
9241                                             1, _("version def"));
9242
9243                                   ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9244                                   ivd.vd_aux = BYTE_GET (evd.vd_aux);
9245                                   ivd.vd_next = BYTE_GET (evd.vd_next);
9246
9247                                   off += ivd.vd_next;
9248                                 }
9249                               while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
9250                                      && ivd.vd_next != 0);
9251
9252                               off -= ivd.vd_next;
9253                               off += ivd.vd_aux;
9254
9255                               get_data (&evda, file, off, sizeof (evda),
9256                                         1, _("version def aux"));
9257
9258                               ivda.vda_name = BYTE_GET (evda.vda_name);
9259
9260                               if (psym->st_name != ivda.vda_name)
9261                                 printf ((vers_data & VERSYM_HIDDEN)
9262                                         ? "@%s" : "@@%s",
9263                                         ivda.vda_name < strtab_size
9264                                         ? strtab + ivda.vda_name : _("<corrupt>"));
9265                             }
9266                         }
9267                     }
9268                 }
9269
9270               putchar ('\n');
9271             }
9272
9273           free (symtab);
9274           if (strtab != string_table)
9275             free (strtab);
9276         }
9277     }
9278   else if (do_syms)
9279     printf
9280       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9281
9282   if (do_histogram && buckets != NULL)
9283     {
9284       unsigned long * lengths;
9285       unsigned long * counts;
9286       unsigned long hn;
9287       bfd_vma si;
9288       unsigned long maxlength = 0;
9289       unsigned long nzero_counts = 0;
9290       unsigned long nsyms = 0;
9291
9292       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9293               (unsigned long) nbuckets);
9294       printf (_(" Length  Number     %% of total  Coverage\n"));
9295
9296       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
9297       if (lengths == NULL)
9298         {
9299           error (_("Out of memory\n"));
9300           return 0;
9301         }
9302       for (hn = 0; hn < nbuckets; ++hn)
9303         {
9304           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
9305             {
9306               ++nsyms;
9307               if (maxlength < ++lengths[hn])
9308                 ++maxlength;
9309             }
9310         }
9311
9312       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9313       if (counts == NULL)
9314         {
9315           error (_("Out of memory\n"));
9316           return 0;
9317         }
9318
9319       for (hn = 0; hn < nbuckets; ++hn)
9320         ++counts[lengths[hn]];
9321
9322       if (nbuckets > 0)
9323         {
9324           unsigned long i;
9325           printf ("      0  %-10lu (%5.1f%%)\n",
9326                   counts[0], (counts[0] * 100.0) / nbuckets);
9327           for (i = 1; i <= maxlength; ++i)
9328             {
9329               nzero_counts += counts[i] * i;
9330               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
9331                       i, counts[i], (counts[i] * 100.0) / nbuckets,
9332                       (nzero_counts * 100.0) / nsyms);
9333             }
9334         }
9335
9336       free (counts);
9337       free (lengths);
9338     }
9339
9340   if (buckets != NULL)
9341     {
9342       free (buckets);
9343       free (chains);
9344     }
9345
9346   if (do_histogram && gnubuckets != NULL)
9347     {
9348       unsigned long * lengths;
9349       unsigned long * counts;
9350       unsigned long hn;
9351       unsigned long maxlength = 0;
9352       unsigned long nzero_counts = 0;
9353       unsigned long nsyms = 0;
9354
9355       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
9356       if (lengths == NULL)
9357         {
9358           error (_("Out of memory\n"));
9359           return 0;
9360         }
9361
9362       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9363               (unsigned long) ngnubuckets);
9364       printf (_(" Length  Number     %% of total  Coverage\n"));
9365
9366       for (hn = 0; hn < ngnubuckets; ++hn)
9367         if (gnubuckets[hn] != 0)
9368           {
9369             bfd_vma off, length = 1;
9370
9371             for (off = gnubuckets[hn] - gnusymidx;
9372                  (gnuchains[off] & 1) == 0; ++off)
9373               ++length;
9374             lengths[hn] = length;
9375             if (length > maxlength)
9376               maxlength = length;
9377             nsyms += length;
9378           }
9379
9380       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9381       if (counts == NULL)
9382         {
9383           error (_("Out of memory\n"));
9384           return 0;
9385         }
9386
9387       for (hn = 0; hn < ngnubuckets; ++hn)
9388         ++counts[lengths[hn]];
9389
9390       if (ngnubuckets > 0)
9391         {
9392           unsigned long j;
9393           printf ("      0  %-10lu (%5.1f%%)\n",
9394                   counts[0], (counts[0] * 100.0) / ngnubuckets);
9395           for (j = 1; j <= maxlength; ++j)
9396             {
9397               nzero_counts += counts[j] * j;
9398               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
9399                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9400                       (nzero_counts * 100.0) / nsyms);
9401             }
9402         }
9403
9404       free (counts);
9405       free (lengths);
9406       free (gnubuckets);
9407       free (gnuchains);
9408     }
9409
9410   return 1;
9411 }
9412
9413 static int
9414 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
9415 {
9416   unsigned int i;
9417
9418   if (dynamic_syminfo == NULL
9419       || !do_dynamic)
9420     /* No syminfo, this is ok.  */
9421     return 1;
9422
9423   /* There better should be a dynamic symbol section.  */
9424   if (dynamic_symbols == NULL || dynamic_strings == NULL)
9425     return 0;
9426
9427   if (dynamic_addr)
9428     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9429             dynamic_syminfo_offset, dynamic_syminfo_nent);
9430
9431   printf (_(" Num: Name                           BoundTo     Flags\n"));
9432   for (i = 0; i < dynamic_syminfo_nent; ++i)
9433     {
9434       unsigned short int flags = dynamic_syminfo[i].si_flags;
9435
9436       printf ("%4d: ", i);
9437       if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9438         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9439       else
9440         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
9441       putchar (' ');
9442
9443       switch (dynamic_syminfo[i].si_boundto)
9444         {
9445         case SYMINFO_BT_SELF:
9446           fputs ("SELF       ", stdout);
9447           break;
9448         case SYMINFO_BT_PARENT:
9449           fputs ("PARENT     ", stdout);
9450           break;
9451         default:
9452           if (dynamic_syminfo[i].si_boundto > 0
9453               && dynamic_syminfo[i].si_boundto < dynamic_nent
9454               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
9455             {
9456               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
9457               putchar (' ' );
9458             }
9459           else
9460             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9461           break;
9462         }
9463
9464       if (flags & SYMINFO_FLG_DIRECT)
9465         printf (" DIRECT");
9466       if (flags & SYMINFO_FLG_PASSTHRU)
9467         printf (" PASSTHRU");
9468       if (flags & SYMINFO_FLG_COPY)
9469         printf (" COPY");
9470       if (flags & SYMINFO_FLG_LAZYLOAD)
9471         printf (" LAZYLOAD");
9472
9473       puts ("");
9474     }
9475
9476   return 1;
9477 }
9478
9479 /* Check to see if the given reloc needs to be handled in a target specific
9480    manner.  If so then process the reloc and return TRUE otherwise return
9481    FALSE.  */
9482
9483 static bfd_boolean
9484 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9485                                 unsigned char *     start,
9486                                 Elf_Internal_Sym *  symtab)
9487 {
9488   unsigned int reloc_type = get_reloc_type (reloc->r_info);
9489
9490   switch (elf_header.e_machine)
9491     {
9492     case EM_MN10300:
9493     case EM_CYGNUS_MN10300:
9494       {
9495         static Elf_Internal_Sym * saved_sym = NULL;
9496
9497         switch (reloc_type)
9498           {
9499           case 34: /* R_MN10300_ALIGN */
9500             return TRUE;
9501           case 33: /* R_MN10300_SYM_DIFF */
9502             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9503             return TRUE;
9504           case 1: /* R_MN10300_32 */
9505           case 2: /* R_MN10300_16 */
9506             if (saved_sym != NULL)
9507               {
9508                 bfd_vma value;
9509
9510                 value = reloc->r_addend
9511                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9512                      - saved_sym->st_value);
9513
9514                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
9515
9516                 saved_sym = NULL;
9517                 return TRUE;
9518               }
9519             break;
9520           default:
9521             if (saved_sym != NULL)
9522               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9523             break;
9524           }
9525         break;
9526       }
9527     }
9528
9529   return FALSE;
9530 }
9531
9532 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9533    DWARF debug sections.  This is a target specific test.  Note - we do not
9534    go through the whole including-target-headers-multiple-times route, (as
9535    we have already done with <elf/h8.h>) because this would become very
9536    messy and even then this function would have to contain target specific
9537    information (the names of the relocs instead of their numeric values).
9538    FIXME: This is not the correct way to solve this problem.  The proper way
9539    is to have target specific reloc sizing and typing functions created by
9540    the reloc-macros.h header, in the same way that it already creates the
9541    reloc naming functions.  */
9542
9543 static bfd_boolean
9544 is_32bit_abs_reloc (unsigned int reloc_type)
9545 {
9546   switch (elf_header.e_machine)
9547     {
9548     case EM_386:
9549     case EM_486:
9550       return reloc_type == 1; /* R_386_32.  */
9551     case EM_68K:
9552       return reloc_type == 1; /* R_68K_32.  */
9553     case EM_860:
9554       return reloc_type == 1; /* R_860_32.  */
9555     case EM_960:
9556       return reloc_type == 2; /* R_960_32.  */
9557     case EM_ALPHA:
9558       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
9559     case EM_ARC:
9560       return reloc_type == 1; /* R_ARC_32.  */
9561     case EM_ARM:
9562       return reloc_type == 2; /* R_ARM_ABS32 */
9563     case EM_AVR_OLD:
9564     case EM_AVR:
9565       return reloc_type == 1;
9566     case EM_BLACKFIN:
9567       return reloc_type == 0x12; /* R_byte4_data.  */
9568     case EM_CRIS:
9569       return reloc_type == 3; /* R_CRIS_32.  */
9570     case EM_CR16:
9571     case EM_CR16_OLD:
9572       return reloc_type == 3; /* R_CR16_NUM32.  */
9573     case EM_CRX:
9574       return reloc_type == 15; /* R_CRX_NUM32.  */
9575     case EM_CYGNUS_FRV:
9576       return reloc_type == 1;
9577     case EM_CYGNUS_D10V:
9578     case EM_D10V:
9579       return reloc_type == 6; /* R_D10V_32.  */
9580     case EM_CYGNUS_D30V:
9581     case EM_D30V:
9582       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
9583     case EM_DLX:
9584       return reloc_type == 3; /* R_DLX_RELOC_32.  */
9585     case EM_CYGNUS_FR30:
9586     case EM_FR30:
9587       return reloc_type == 3; /* R_FR30_32.  */
9588     case EM_H8S:
9589     case EM_H8_300:
9590     case EM_H8_300H:
9591       return reloc_type == 1; /* R_H8_DIR32.  */
9592     case EM_IA_64:
9593       return reloc_type == 0x65; /* R_IA64_SECREL32LSB.  */
9594     case EM_IP2K_OLD:
9595     case EM_IP2K:
9596       return reloc_type == 2; /* R_IP2K_32.  */
9597     case EM_IQ2000:
9598       return reloc_type == 2; /* R_IQ2000_32.  */
9599     case EM_LATTICEMICO32:
9600       return reloc_type == 3; /* R_LM32_32.  */
9601     case EM_M32C_OLD:
9602     case EM_M32C:
9603       return reloc_type == 3; /* R_M32C_32.  */
9604     case EM_M32R:
9605       return reloc_type == 34; /* R_M32R_32_RELA.  */
9606     case EM_MCORE:
9607       return reloc_type == 1; /* R_MCORE_ADDR32.  */
9608     case EM_CYGNUS_MEP:
9609       return reloc_type == 4; /* R_MEP_32.  */
9610     case EM_MICROBLAZE:
9611       return reloc_type == 1; /* R_MICROBLAZE_32.  */
9612     case EM_MIPS:
9613       return reloc_type == 2; /* R_MIPS_32.  */
9614     case EM_MMIX:
9615       return reloc_type == 4; /* R_MMIX_32.  */
9616     case EM_CYGNUS_MN10200:
9617     case EM_MN10200:
9618       return reloc_type == 1; /* R_MN10200_32.  */
9619     case EM_CYGNUS_MN10300:
9620     case EM_MN10300:
9621       return reloc_type == 1; /* R_MN10300_32.  */
9622     case EM_MOXIE:
9623       return reloc_type == 1; /* R_MOXIE_32.  */
9624     case EM_MSP430_OLD:
9625     case EM_MSP430:
9626       return reloc_type == 1; /* R_MSP43_32.  */
9627     case EM_MT:
9628       return reloc_type == 2; /* R_MT_32.  */
9629     case EM_ALTERA_NIOS2:
9630     case EM_NIOS32:
9631       return reloc_type == 1; /* R_NIOS_32.  */
9632     case EM_OPENRISC:
9633     case EM_OR32:
9634       return reloc_type == 1; /* R_OR32_32.  */
9635     case EM_PARISC:
9636       return (reloc_type == 1 /* R_PARISC_DIR32.  */
9637               || reloc_type == 41); /* R_PARISC_SECREL32.  */
9638     case EM_PJ:
9639     case EM_PJ_OLD:
9640       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
9641     case EM_PPC64:
9642       return reloc_type == 1; /* R_PPC64_ADDR32.  */
9643     case EM_PPC:
9644       return reloc_type == 1; /* R_PPC_ADDR32.  */
9645     case EM_RX:
9646       return reloc_type == 1; /* R_RX_DIR32.  */
9647     case EM_S370:
9648       return reloc_type == 1; /* R_I370_ADDR31.  */
9649     case EM_S390_OLD:
9650     case EM_S390:
9651       return reloc_type == 4; /* R_S390_32.  */
9652     case EM_SCORE:
9653       return reloc_type == 8; /* R_SCORE_ABS32.  */
9654     case EM_SH:
9655       return reloc_type == 1; /* R_SH_DIR32.  */
9656     case EM_SPARC32PLUS:
9657     case EM_SPARCV9:
9658     case EM_SPARC:
9659       return reloc_type == 3 /* R_SPARC_32.  */
9660         || reloc_type == 23; /* R_SPARC_UA32.  */
9661     case EM_SPU:
9662       return reloc_type == 6; /* R_SPU_ADDR32 */
9663     case EM_TI_C6000:
9664       return reloc_type == 1; /* R_C6000_ABS32.  */
9665     case EM_CYGNUS_V850:
9666     case EM_V850:
9667       return reloc_type == 6; /* R_V850_ABS32.  */
9668     case EM_VAX:
9669       return reloc_type == 1; /* R_VAX_32.  */
9670     case EM_X86_64:
9671     case EM_L1OM:
9672       return reloc_type == 10; /* R_X86_64_32.  */
9673     case EM_XC16X:
9674     case EM_C166:
9675       return reloc_type == 3; /* R_XC16C_ABS_32.  */
9676     case EM_XSTORMY16:
9677       return reloc_type == 1; /* R_XSTROMY16_32.  */
9678     case EM_XTENSA_OLD:
9679     case EM_XTENSA:
9680       return reloc_type == 1; /* R_XTENSA_32.  */
9681     default:
9682       error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9683              elf_header.e_machine);
9684       abort ();
9685     }
9686 }
9687
9688 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9689    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
9690
9691 static bfd_boolean
9692 is_32bit_pcrel_reloc (unsigned int reloc_type)
9693 {
9694   switch (elf_header.e_machine)
9695     {
9696     case EM_386:
9697     case EM_486:
9698       return reloc_type == 2;  /* R_386_PC32.  */
9699     case EM_68K:
9700       return reloc_type == 4;  /* R_68K_PC32.  */
9701     case EM_ALPHA:
9702       return reloc_type == 10; /* R_ALPHA_SREL32.  */
9703     case EM_ARM:
9704       return reloc_type == 3;  /* R_ARM_REL32 */
9705     case EM_MICROBLAZE:
9706       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
9707     case EM_PARISC:
9708       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
9709     case EM_PPC:
9710       return reloc_type == 26; /* R_PPC_REL32.  */
9711     case EM_PPC64:
9712       return reloc_type == 26; /* R_PPC64_REL32.  */
9713     case EM_S390_OLD:
9714     case EM_S390:
9715       return reloc_type == 5;  /* R_390_PC32.  */
9716     case EM_SH:
9717       return reloc_type == 2;  /* R_SH_REL32.  */
9718     case EM_SPARC32PLUS:
9719     case EM_SPARCV9:
9720     case EM_SPARC:
9721       return reloc_type == 6;  /* R_SPARC_DISP32.  */
9722     case EM_SPU:
9723       return reloc_type == 13; /* R_SPU_REL32.  */
9724     case EM_X86_64:
9725     case EM_L1OM:
9726       return reloc_type == 2;  /* R_X86_64_PC32.  */
9727     case EM_XTENSA_OLD:
9728     case EM_XTENSA:
9729       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
9730     default:
9731       /* Do not abort or issue an error message here.  Not all targets use
9732          pc-relative 32-bit relocs in their DWARF debug information and we
9733          have already tested for target coverage in is_32bit_abs_reloc.  A
9734          more helpful warning message will be generated by apply_relocations
9735          anyway, so just return.  */
9736       return FALSE;
9737     }
9738 }
9739
9740 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9741    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
9742
9743 static bfd_boolean
9744 is_64bit_abs_reloc (unsigned int reloc_type)
9745 {
9746   switch (elf_header.e_machine)
9747     {
9748     case EM_ALPHA:
9749       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
9750     case EM_IA_64:
9751       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
9752     case EM_PARISC:
9753       return reloc_type == 80; /* R_PARISC_DIR64.  */
9754     case EM_PPC64:
9755       return reloc_type == 38; /* R_PPC64_ADDR64.  */
9756     case EM_SPARC32PLUS:
9757     case EM_SPARCV9:
9758     case EM_SPARC:
9759       return reloc_type == 54; /* R_SPARC_UA64.  */
9760     case EM_X86_64:
9761     case EM_L1OM:
9762       return reloc_type == 1; /* R_X86_64_64.  */
9763     case EM_S390_OLD:
9764     case EM_S390:
9765       return reloc_type == 22;  /* R_S390_64 */
9766     case EM_MIPS:
9767       return reloc_type == 18;  /* R_MIPS_64 */
9768     default:
9769       return FALSE;
9770     }
9771 }
9772
9773 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9774    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
9775
9776 static bfd_boolean
9777 is_64bit_pcrel_reloc (unsigned int reloc_type)
9778 {
9779   switch (elf_header.e_machine)
9780     {
9781     case EM_ALPHA:
9782       return reloc_type == 11; /* R_ALPHA_SREL64 */
9783     case EM_IA_64:
9784       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB */
9785     case EM_PARISC:
9786       return reloc_type == 72; /* R_PARISC_PCREL64 */
9787     case EM_PPC64:
9788       return reloc_type == 44; /* R_PPC64_REL64 */
9789     case EM_SPARC32PLUS:
9790     case EM_SPARCV9:
9791     case EM_SPARC:
9792       return reloc_type == 46; /* R_SPARC_DISP64 */
9793     case EM_X86_64:
9794     case EM_L1OM:
9795       return reloc_type == 24; /* R_X86_64_PC64 */
9796     case EM_S390_OLD:
9797     case EM_S390:
9798       return reloc_type == 23;  /* R_S390_PC64 */
9799     default:
9800       return FALSE;
9801     }
9802 }
9803
9804 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9805    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
9806
9807 static bfd_boolean
9808 is_24bit_abs_reloc (unsigned int reloc_type)
9809 {
9810   switch (elf_header.e_machine)
9811     {
9812     case EM_CYGNUS_MN10200:
9813     case EM_MN10200:
9814       return reloc_type == 4; /* R_MN10200_24.  */
9815     default:
9816       return FALSE;
9817     }
9818 }
9819
9820 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9821    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
9822
9823 static bfd_boolean
9824 is_16bit_abs_reloc (unsigned int reloc_type)
9825 {
9826   switch (elf_header.e_machine)
9827     {
9828     case EM_AVR_OLD:
9829     case EM_AVR:
9830       return reloc_type == 4; /* R_AVR_16.  */
9831     case EM_CYGNUS_D10V:
9832     case EM_D10V:
9833       return reloc_type == 3; /* R_D10V_16.  */
9834     case EM_H8S:
9835     case EM_H8_300:
9836     case EM_H8_300H:
9837       return reloc_type == R_H8_DIR16;
9838     case EM_IP2K_OLD:
9839     case EM_IP2K:
9840       return reloc_type == 1; /* R_IP2K_16.  */
9841     case EM_M32C_OLD:
9842     case EM_M32C:
9843       return reloc_type == 1; /* R_M32C_16 */
9844     case EM_MSP430_OLD:
9845     case EM_MSP430:
9846       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
9847     case EM_ALTERA_NIOS2:
9848     case EM_NIOS32:
9849       return reloc_type == 9; /* R_NIOS_16.  */
9850     case EM_TI_C6000:
9851       return reloc_type == 2; /* R_C6000_ABS16.  */
9852     case EM_XC16X:
9853     case EM_C166:
9854       return reloc_type == 2; /* R_XC16C_ABS_16.  */
9855     default:
9856       return FALSE;
9857     }
9858 }
9859
9860 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9861    relocation entries (possibly formerly used for SHT_GROUP sections).  */
9862
9863 static bfd_boolean
9864 is_none_reloc (unsigned int reloc_type)
9865 {
9866   switch (elf_header.e_machine)
9867     {
9868     case EM_68K:     /* R_68K_NONE.  */
9869     case EM_386:     /* R_386_NONE.  */
9870     case EM_SPARC32PLUS:
9871     case EM_SPARCV9:
9872     case EM_SPARC:   /* R_SPARC_NONE.  */
9873     case EM_MIPS:    /* R_MIPS_NONE.  */
9874     case EM_PARISC:  /* R_PARISC_NONE.  */
9875     case EM_ALPHA:   /* R_ALPHA_NONE.  */
9876     case EM_PPC:     /* R_PPC_NONE.  */
9877     case EM_PPC64:   /* R_PPC64_NONE.  */
9878     case EM_ARM:     /* R_ARM_NONE.  */
9879     case EM_IA_64:   /* R_IA64_NONE.  */
9880     case EM_SH:      /* R_SH_NONE.  */
9881     case EM_S390_OLD:
9882     case EM_S390:    /* R_390_NONE.  */
9883     case EM_CRIS:    /* R_CRIS_NONE.  */
9884     case EM_X86_64:  /* R_X86_64_NONE.  */
9885     case EM_L1OM:    /* R_X86_64_NONE.  */
9886     case EM_MN10300: /* R_MN10300_NONE.  */
9887     case EM_MOXIE:   /* R_MOXIE_NONE.  */
9888     case EM_M32R:    /* R_M32R_NONE.  */
9889     case EM_TI_C6000:/* R_C6000_NONE.  */
9890     case EM_XC16X:
9891     case EM_C166:    /* R_XC16X_NONE.  */
9892       return reloc_type == 0;
9893     case EM_XTENSA_OLD:
9894     case EM_XTENSA:
9895       return (reloc_type == 0      /* R_XTENSA_NONE.  */
9896               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
9897               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
9898               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
9899     }
9900   return FALSE;
9901 }
9902
9903 /* Apply relocations to a section.
9904    Note: So far support has been added only for those relocations
9905    which can be found in debug sections.
9906    FIXME: Add support for more relocations ?  */
9907
9908 static void
9909 apply_relocations (void * file,
9910                    Elf_Internal_Shdr * section,
9911                    unsigned char * start)
9912 {
9913   Elf_Internal_Shdr * relsec;
9914   unsigned char * end = start + section->sh_size;
9915
9916   if (elf_header.e_type != ET_REL)
9917     return;
9918
9919   /* Find the reloc section associated with the section.  */
9920   for (relsec = section_headers;
9921        relsec < section_headers + elf_header.e_shnum;
9922        ++relsec)
9923     {
9924       bfd_boolean is_rela;
9925       unsigned long num_relocs;
9926       Elf_Internal_Rela * relocs;
9927       Elf_Internal_Rela * rp;
9928       Elf_Internal_Shdr * symsec;
9929       Elf_Internal_Sym * symtab;
9930       Elf_Internal_Sym * sym;
9931
9932       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9933           || relsec->sh_info >= elf_header.e_shnum
9934           || section_headers + relsec->sh_info != section
9935           || relsec->sh_size == 0
9936           || relsec->sh_link >= elf_header.e_shnum)
9937         continue;
9938
9939       is_rela = relsec->sh_type == SHT_RELA;
9940
9941       if (is_rela)
9942         {
9943           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
9944                                   relsec->sh_size, & relocs, & num_relocs))
9945             return;
9946         }
9947       else
9948         {
9949           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
9950                                  relsec->sh_size, & relocs, & num_relocs))
9951             return;
9952         }
9953
9954       /* SH uses RELA but uses in place value instead of the addend field.  */
9955       if (elf_header.e_machine == EM_SH)
9956         is_rela = FALSE;
9957
9958       symsec = section_headers + relsec->sh_link;
9959       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec);
9960
9961       for (rp = relocs; rp < relocs + num_relocs; ++rp)
9962         {
9963           bfd_vma         addend;
9964           unsigned int    reloc_type;
9965           unsigned int    reloc_size;
9966           unsigned char * rloc;
9967
9968           reloc_type = get_reloc_type (rp->r_info);
9969
9970           if (target_specific_reloc_handling (rp, start, symtab))
9971             continue;
9972           else if (is_none_reloc (reloc_type))
9973             continue;
9974           else if (is_32bit_abs_reloc (reloc_type)
9975                    || is_32bit_pcrel_reloc (reloc_type))
9976             reloc_size = 4;
9977           else if (is_64bit_abs_reloc (reloc_type)
9978                    || is_64bit_pcrel_reloc (reloc_type))
9979             reloc_size = 8;
9980           else if (is_24bit_abs_reloc (reloc_type))
9981             reloc_size = 3;
9982           else if (is_16bit_abs_reloc (reloc_type))
9983             reloc_size = 2;
9984           else
9985             {
9986               warn (_("unable to apply unsupported reloc type %d to section %s\n"),
9987                     reloc_type, SECTION_NAME (section));
9988               continue;
9989             }
9990
9991           rloc = start + rp->r_offset;
9992           if ((rloc + reloc_size) > end)
9993             {
9994               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
9995                     (unsigned long) rp->r_offset,
9996                     SECTION_NAME (section));
9997               continue;
9998             }
9999
10000           sym = symtab + get_reloc_symindex (rp->r_info);
10001
10002           /* If the reloc has a symbol associated with it,
10003              make sure that it is of an appropriate type.
10004
10005              Relocations against symbols without type can happen.
10006              Gcc -feliminate-dwarf2-dups may generate symbols
10007              without type for debug info.
10008
10009              Icc generates relocations against function symbols
10010              instead of local labels.
10011
10012              Relocations against object symbols can happen, eg when
10013              referencing a global array.  For an example of this see
10014              the _clz.o binary in libgcc.a.  */
10015           if (sym != symtab
10016               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
10017             {
10018               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10019                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
10020                     (long int)(rp - relocs),
10021                     SECTION_NAME (relsec));
10022               continue;
10023             }
10024
10025           addend = 0;
10026           if (is_rela)
10027             addend += rp->r_addend;
10028           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10029              partial_inplace.  */
10030           if (!is_rela
10031               || (elf_header.e_machine == EM_XTENSA
10032                   && reloc_type == 1)
10033               || ((elf_header.e_machine == EM_PJ
10034                    || elf_header.e_machine == EM_PJ_OLD)
10035                   && reloc_type == 1)
10036               || ((elf_header.e_machine == EM_D30V
10037                    || elf_header.e_machine == EM_CYGNUS_D30V)
10038                   && reloc_type == 12))
10039             addend += byte_get (rloc, reloc_size);
10040
10041           if (is_32bit_pcrel_reloc (reloc_type)
10042               || is_64bit_pcrel_reloc (reloc_type))
10043             {
10044               /* On HPPA, all pc-relative relocations are biased by 8.  */
10045               if (elf_header.e_machine == EM_PARISC)
10046                 addend -= 8;
10047               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
10048                         reloc_size);
10049             }
10050           else
10051             byte_put (rloc, addend + sym->st_value, reloc_size);
10052         }
10053
10054       free (symtab);
10055       free (relocs);
10056       break;
10057     }
10058 }
10059
10060 #ifdef SUPPORT_DISASSEMBLY
10061 static int
10062 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10063 {
10064   printf (_("\nAssembly dump of section %s\n"),
10065           SECTION_NAME (section));
10066
10067   /* XXX -- to be done --- XXX */
10068
10069   return 1;
10070 }
10071 #endif
10072
10073 /* Reads in the contents of SECTION from FILE, returning a pointer
10074    to a malloc'ed buffer or NULL if something went wrong.  */
10075
10076 static char *
10077 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10078 {
10079   bfd_size_type num_bytes;
10080
10081   num_bytes = section->sh_size;
10082
10083   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10084     {
10085       printf (_("\nSection '%s' has no data to dump.\n"),
10086               SECTION_NAME (section));
10087       return NULL;
10088     }
10089
10090   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10091                              _("section contents"));
10092 }
10093
10094
10095 static void
10096 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10097 {
10098   Elf_Internal_Shdr * relsec;
10099   bfd_size_type num_bytes;
10100   char * data;
10101   char * end;
10102   char * start;
10103   char * name = SECTION_NAME (section);
10104   bfd_boolean some_strings_shown;
10105
10106   start = get_section_contents (section, file);
10107   if (start == NULL)
10108     return;
10109
10110   printf (_("\nString dump of section '%s':\n"), name);
10111
10112   /* If the section being dumped has relocations against it the user might
10113      be expecting these relocations to have been applied.  Check for this
10114      case and issue a warning message in order to avoid confusion.
10115      FIXME: Maybe we ought to have an option that dumps a section with
10116      relocs applied ?  */
10117   for (relsec = section_headers;
10118        relsec < section_headers + elf_header.e_shnum;
10119        ++relsec)
10120     {
10121       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10122           || relsec->sh_info >= elf_header.e_shnum
10123           || section_headers + relsec->sh_info != section
10124           || relsec->sh_size == 0
10125           || relsec->sh_link >= elf_header.e_shnum)
10126         continue;
10127
10128       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10129       break;
10130     }
10131
10132   num_bytes = section->sh_size;
10133   data = start;
10134   end  = start + num_bytes;
10135   some_strings_shown = FALSE;
10136
10137   while (data < end)
10138     {
10139       while (!ISPRINT (* data))
10140         if (++ data >= end)
10141           break;
10142
10143       if (data < end)
10144         {
10145 #ifndef __MSVCRT__
10146           /* PR 11128: Use two separate invocations in order to work
10147              around bugs in the Solaris 8 implementation of printf.  */
10148           printf ("  [%6tx]  ", data - start);
10149           printf ("%s\n", data);
10150 #else
10151           printf ("  [%6Ix]  %s\n", (size_t) (data - start), data);
10152 #endif
10153           data += strlen (data);
10154           some_strings_shown = TRUE;
10155         }
10156     }
10157
10158   if (! some_strings_shown)
10159     printf (_("  No strings found in this section."));
10160
10161   free (start);
10162
10163   putchar ('\n');
10164 }
10165
10166 static void
10167 dump_section_as_bytes (Elf_Internal_Shdr * section,
10168                        FILE * file,
10169                        bfd_boolean relocate)
10170 {
10171   Elf_Internal_Shdr * relsec;
10172   bfd_size_type bytes;
10173   bfd_vma addr;
10174   unsigned char * data;
10175   unsigned char * start;
10176
10177   start = (unsigned char *) get_section_contents (section, file);
10178   if (start == NULL)
10179     return;
10180
10181   printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10182
10183   if (relocate)
10184     {
10185       apply_relocations (file, section, start);
10186     }
10187   else
10188     {
10189       /* If the section being dumped has relocations against it the user might
10190          be expecting these relocations to have been applied.  Check for this
10191          case and issue a warning message in order to avoid confusion.
10192          FIXME: Maybe we ought to have an option that dumps a section with
10193          relocs applied ?  */
10194       for (relsec = section_headers;
10195            relsec < section_headers + elf_header.e_shnum;
10196            ++relsec)
10197         {
10198           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10199               || relsec->sh_info >= elf_header.e_shnum
10200               || section_headers + relsec->sh_info != section
10201               || relsec->sh_size == 0
10202               || relsec->sh_link >= elf_header.e_shnum)
10203             continue;
10204
10205           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10206           break;
10207         }
10208     }
10209
10210   addr = section->sh_addr;
10211   bytes = section->sh_size;
10212   data = start;
10213
10214   while (bytes)
10215     {
10216       int j;
10217       int k;
10218       int lbytes;
10219
10220       lbytes = (bytes > 16 ? 16 : bytes);
10221
10222       printf ("  0x%8.8lx ", (unsigned long) addr);
10223
10224       for (j = 0; j < 16; j++)
10225         {
10226           if (j < lbytes)
10227             printf ("%2.2x", data[j]);
10228           else
10229             printf ("  ");
10230
10231           if ((j & 3) == 3)
10232             printf (" ");
10233         }
10234
10235       for (j = 0; j < lbytes; j++)
10236         {
10237           k = data[j];
10238           if (k >= ' ' && k < 0x7f)
10239             printf ("%c", k);
10240           else
10241             printf (".");
10242         }
10243
10244       putchar ('\n');
10245
10246       data  += lbytes;
10247       addr  += lbytes;
10248       bytes -= lbytes;
10249     }
10250
10251   free (start);
10252
10253   putchar ('\n');
10254 }
10255
10256 /* Uncompresses a section that was compressed using zlib, in place.  */
10257
10258 static int
10259 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10260                              dwarf_size_type *size ATTRIBUTE_UNUSED)
10261 {
10262 #ifndef HAVE_ZLIB_H
10263   return FALSE;
10264 #else
10265   dwarf_size_type compressed_size = *size;
10266   unsigned char * compressed_buffer = *buffer;
10267   dwarf_size_type uncompressed_size;
10268   unsigned char * uncompressed_buffer;
10269   z_stream strm;
10270   int rc;
10271   dwarf_size_type header_size = 12;
10272
10273   /* Read the zlib header.  In this case, it should be "ZLIB" followed
10274      by the uncompressed section size, 8 bytes in big-endian order.  */
10275   if (compressed_size < header_size
10276       || ! streq ((char *) compressed_buffer, "ZLIB"))
10277     return 0;
10278
10279   uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10280   uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10281   uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10282   uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10283   uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10284   uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10285   uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10286   uncompressed_size += compressed_buffer[11];
10287
10288   /* It is possible the section consists of several compressed
10289      buffers concatenated together, so we uncompress in a loop.  */
10290   strm.zalloc = NULL;
10291   strm.zfree = NULL;
10292   strm.opaque = NULL;
10293   strm.avail_in = compressed_size - header_size;
10294   strm.next_in = (Bytef *) compressed_buffer + header_size;
10295   strm.avail_out = uncompressed_size;
10296   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
10297
10298   rc = inflateInit (& strm);
10299   while (strm.avail_in > 0)
10300     {
10301       if (rc != Z_OK)
10302         goto fail;
10303       strm.next_out = ((Bytef *) uncompressed_buffer
10304                        + (uncompressed_size - strm.avail_out));
10305       rc = inflate (&strm, Z_FINISH);
10306       if (rc != Z_STREAM_END)
10307         goto fail;
10308       rc = inflateReset (& strm);
10309     }
10310   rc = inflateEnd (& strm);
10311   if (rc != Z_OK
10312       || strm.avail_out != 0)
10313     goto fail;
10314
10315   free (compressed_buffer);
10316   *buffer = uncompressed_buffer;
10317   *size = uncompressed_size;
10318   return 1;
10319
10320  fail:
10321   free (uncompressed_buffer);
10322   /* Indicate decompression failure.  */
10323   *buffer = NULL;
10324   return 0;
10325 #endif  /* HAVE_ZLIB_H */
10326 }
10327
10328 static int
10329 load_specific_debug_section (enum dwarf_section_display_enum debug,
10330                              Elf_Internal_Shdr * sec, void * file)
10331 {
10332   struct dwarf_section * section = &debug_displays [debug].section;
10333   char buf [64];
10334
10335   /* If it is already loaded, do nothing.  */
10336   if (section->start != NULL)
10337     return 1;
10338
10339   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10340   section->address = sec->sh_addr;
10341   section->size = sec->sh_size;
10342   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10343                                                sec->sh_offset, 1,
10344                                                sec->sh_size, buf);
10345   if (uncompress_section_contents (&section->start, &section->size))
10346     sec->sh_size = section->size;
10347
10348   if (section->start == NULL)
10349     return 0;
10350
10351   if (debug_displays [debug].relocate)
10352     apply_relocations ((FILE *) file, sec, section->start);
10353
10354   return 1;
10355 }
10356
10357 int
10358 load_debug_section (enum dwarf_section_display_enum debug, void * file)
10359 {
10360   struct dwarf_section * section = &debug_displays [debug].section;
10361   Elf_Internal_Shdr * sec;
10362
10363   /* Locate the debug section.  */
10364   sec = find_section (section->uncompressed_name);
10365   if (sec != NULL)
10366     section->name = section->uncompressed_name;
10367   else
10368     {
10369       sec = find_section (section->compressed_name);
10370       if (sec != NULL)
10371         section->name = section->compressed_name;
10372     }
10373   if (sec == NULL)
10374     return 0;
10375
10376   return load_specific_debug_section (debug, sec, (FILE *) file);
10377 }
10378
10379 void
10380 free_debug_section (enum dwarf_section_display_enum debug)
10381 {
10382   struct dwarf_section * section = &debug_displays [debug].section;
10383
10384   if (section->start == NULL)
10385     return;
10386
10387   free ((char *) section->start);
10388   section->start = NULL;
10389   section->address = 0;
10390   section->size = 0;
10391 }
10392
10393 static int
10394 display_debug_section (Elf_Internal_Shdr * section, FILE * file)
10395 {
10396   char * name = SECTION_NAME (section);
10397   bfd_size_type length;
10398   int result = 1;
10399   int i;
10400
10401   length = section->sh_size;
10402   if (length == 0)
10403     {
10404       printf (_("\nSection '%s' has no debugging data.\n"), name);
10405       return 0;
10406     }
10407   if (section->sh_type == SHT_NOBITS)
10408     {
10409       /* There is no point in dumping the contents of a debugging section
10410          which has the NOBITS type - the bits in the file will be random.
10411          This can happen when a file containing a .eh_frame section is
10412          stripped with the --only-keep-debug command line option.  */
10413       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10414       return 0;
10415     }
10416
10417   if (const_strneq (name, ".gnu.linkonce.wi."))
10418     name = ".debug_info";
10419
10420   /* See if we know how to display the contents of this section.  */
10421   for (i = 0; i < max; i++)
10422     if (streq (debug_displays[i].section.uncompressed_name, name)
10423         || streq (debug_displays[i].section.compressed_name, name))
10424       {
10425         struct dwarf_section * sec = &debug_displays [i].section;
10426         int secondary = (section != find_section (name));
10427
10428         if (secondary)
10429           free_debug_section ((enum dwarf_section_display_enum) i);
10430
10431         if (streq (sec->uncompressed_name, name))
10432           sec->name = sec->uncompressed_name;
10433         else
10434           sec->name = sec->compressed_name;
10435         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10436                                          section, file))
10437           {
10438             result &= debug_displays[i].display (sec, file);
10439
10440             if (secondary || (i != info && i != abbrev))
10441               free_debug_section ((enum dwarf_section_display_enum) i);
10442           }
10443
10444         break;
10445       }
10446
10447   if (i == max)
10448     {
10449       printf (_("Unrecognized debug section: %s\n"), name);
10450       result = 0;
10451     }
10452
10453   return result;
10454 }
10455
10456 /* Set DUMP_SECTS for all sections where dumps were requested
10457    based on section name.  */
10458
10459 static void
10460 initialise_dumps_byname (void)
10461 {
10462   struct dump_list_entry * cur;
10463
10464   for (cur = dump_sects_byname; cur; cur = cur->next)
10465     {
10466       unsigned int i;
10467       int any;
10468
10469       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10470         if (streq (SECTION_NAME (section_headers + i), cur->name))
10471           {
10472             request_dump_bynumber (i, cur->type);
10473             any = 1;
10474           }
10475
10476       if (!any)
10477         warn (_("Section '%s' was not dumped because it does not exist!\n"),
10478               cur->name);
10479     }
10480 }
10481
10482 static void
10483 process_section_contents (FILE * file)
10484 {
10485   Elf_Internal_Shdr * section;
10486   unsigned int i;
10487
10488   if (! do_dump)
10489     return;
10490
10491   initialise_dumps_byname ();
10492
10493   for (i = 0, section = section_headers;
10494        i < elf_header.e_shnum && i < num_dump_sects;
10495        i++, section++)
10496     {
10497 #ifdef SUPPORT_DISASSEMBLY
10498       if (dump_sects[i] & DISASS_DUMP)
10499         disassemble_section (section, file);
10500 #endif
10501       if (dump_sects[i] & HEX_DUMP)
10502         dump_section_as_bytes (section, file, FALSE);
10503
10504       if (dump_sects[i] & RELOC_DUMP)
10505         dump_section_as_bytes (section, file, TRUE);
10506
10507       if (dump_sects[i] & STRING_DUMP)
10508         dump_section_as_strings (section, file);
10509
10510       if (dump_sects[i] & DEBUG_DUMP)
10511         display_debug_section (section, file);
10512     }
10513
10514   /* Check to see if the user requested a
10515      dump of a section that does not exist.  */
10516   while (i++ < num_dump_sects)
10517     if (dump_sects[i])
10518       warn (_("Section %d was not dumped because it does not exist!\n"), i);
10519 }
10520
10521 static void
10522 process_mips_fpe_exception (int mask)
10523 {
10524   if (mask)
10525     {
10526       int first = 1;
10527       if (mask & OEX_FPU_INEX)
10528         fputs ("INEX", stdout), first = 0;
10529       if (mask & OEX_FPU_UFLO)
10530         printf ("%sUFLO", first ? "" : "|"), first = 0;
10531       if (mask & OEX_FPU_OFLO)
10532         printf ("%sOFLO", first ? "" : "|"), first = 0;
10533       if (mask & OEX_FPU_DIV0)
10534         printf ("%sDIV0", first ? "" : "|"), first = 0;
10535       if (mask & OEX_FPU_INVAL)
10536         printf ("%sINVAL", first ? "" : "|");
10537     }
10538   else
10539     fputs ("0", stdout);
10540 }
10541
10542 /* ARM EABI attributes section.  */
10543 typedef struct
10544 {
10545   int tag;
10546   const char * name;
10547   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
10548   int type;
10549   const char ** table;
10550 } arm_attr_public_tag;
10551
10552 static const char * arm_attr_tag_CPU_arch[] =
10553   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
10554    "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
10555 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
10556 static const char * arm_attr_tag_THUMB_ISA_use[] =
10557   {"No", "Thumb-1", "Thumb-2"};
10558 static const char * arm_attr_tag_FP_arch[] =
10559   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
10560 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
10561 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
10562   {"No", "NEONv1", "NEONv1 with Fused-MAC"};
10563 static const char * arm_attr_tag_PCS_config[] =
10564   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10565    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
10566 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
10567   {"V6", "SB", "TLS", "Unused"};
10568 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
10569   {"Absolute", "PC-relative", "SB-relative", "None"};
10570 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
10571   {"Absolute", "PC-relative", "None"};
10572 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
10573   {"None", "direct", "GOT-indirect"};
10574 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
10575   {"None", "??? 1", "2", "??? 3", "4"};
10576 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
10577 static const char * arm_attr_tag_ABI_FP_denormal[] =
10578   {"Unused", "Needed", "Sign only"};
10579 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
10580 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
10581 static const char * arm_attr_tag_ABI_FP_number_model[] =
10582   {"Unused", "Finite", "RTABI", "IEEE 754"};
10583 static const char * arm_attr_tag_ABI_enum_size[] =
10584   {"Unused", "small", "int", "forced to int"};
10585 static const char * arm_attr_tag_ABI_HardFP_use[] =
10586   {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
10587 static const char * arm_attr_tag_ABI_VFP_args[] =
10588   {"AAPCS", "VFP registers", "custom"};
10589 static const char * arm_attr_tag_ABI_WMMX_args[] =
10590   {"AAPCS", "WMMX registers", "custom"};
10591 static const char * arm_attr_tag_ABI_optimization_goals[] =
10592   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10593     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
10594 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
10595   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10596     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
10597 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
10598 static const char * arm_attr_tag_FP_HP_extension[] =
10599   {"Not Allowed", "Allowed"};
10600 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
10601   {"None", "IEEE 754", "Alternative Format"};
10602 static const char * arm_attr_tag_MPextension_use[] =
10603   {"Not Allowed", "Allowed"};
10604 static const char * arm_attr_tag_DIV_use[] =
10605   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
10606     "Allowed in v7-A with integer division extension"};
10607 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
10608 static const char * arm_attr_tag_Virtualization_use[] =
10609   {"Not Allowed", "TrustZone", "Virtualization Extensions",
10610     "TrustZone and Virtualization Extensions"};
10611 static const char * arm_attr_tag_MPextension_use_legacy[] =
10612   {"Not Allowed", "Allowed"};
10613
10614 #define LOOKUP(id, name) \
10615   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
10616 static arm_attr_public_tag arm_attr_public_tags[] =
10617 {
10618   {4, "CPU_raw_name", 1, NULL},
10619   {5, "CPU_name", 1, NULL},
10620   LOOKUP(6, CPU_arch),
10621   {7, "CPU_arch_profile", 0, NULL},
10622   LOOKUP(8, ARM_ISA_use),
10623   LOOKUP(9, THUMB_ISA_use),
10624   LOOKUP(10, FP_arch),
10625   LOOKUP(11, WMMX_arch),
10626   LOOKUP(12, Advanced_SIMD_arch),
10627   LOOKUP(13, PCS_config),
10628   LOOKUP(14, ABI_PCS_R9_use),
10629   LOOKUP(15, ABI_PCS_RW_data),
10630   LOOKUP(16, ABI_PCS_RO_data),
10631   LOOKUP(17, ABI_PCS_GOT_use),
10632   LOOKUP(18, ABI_PCS_wchar_t),
10633   LOOKUP(19, ABI_FP_rounding),
10634   LOOKUP(20, ABI_FP_denormal),
10635   LOOKUP(21, ABI_FP_exceptions),
10636   LOOKUP(22, ABI_FP_user_exceptions),
10637   LOOKUP(23, ABI_FP_number_model),
10638   {24, "ABI_align_needed", 0, NULL},
10639   {25, "ABI_align_preserved", 0, NULL},
10640   LOOKUP(26, ABI_enum_size),
10641   LOOKUP(27, ABI_HardFP_use),
10642   LOOKUP(28, ABI_VFP_args),
10643   LOOKUP(29, ABI_WMMX_args),
10644   LOOKUP(30, ABI_optimization_goals),
10645   LOOKUP(31, ABI_FP_optimization_goals),
10646   {32, "compatibility", 0, NULL},
10647   LOOKUP(34, CPU_unaligned_access),
10648   LOOKUP(36, FP_HP_extension),
10649   LOOKUP(38, ABI_FP_16bit_format),
10650   LOOKUP(42, MPextension_use),
10651   LOOKUP(44, DIV_use),
10652   {64, "nodefaults", 0, NULL},
10653   {65, "also_compatible_with", 0, NULL},
10654   LOOKUP(66, T2EE_use),
10655   {67, "conformance", 1, NULL},
10656   LOOKUP(68, Virtualization_use),
10657   LOOKUP(70, MPextension_use_legacy)
10658 };
10659 #undef LOOKUP
10660
10661 static unsigned char *
10662 display_arm_attribute (unsigned char * p)
10663 {
10664   int tag;
10665   unsigned int len;
10666   int val;
10667   arm_attr_public_tag * attr;
10668   unsigned i;
10669   int type;
10670
10671   tag = read_uleb128 (p, &len);
10672   p += len;
10673   attr = NULL;
10674   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
10675     {
10676       if (arm_attr_public_tags[i].tag == tag)
10677         {
10678           attr = &arm_attr_public_tags[i];
10679           break;
10680         }
10681     }
10682
10683   if (attr)
10684     {
10685       printf ("  Tag_%s: ", attr->name);
10686       switch (attr->type)
10687         {
10688         case 0:
10689           switch (tag)
10690             {
10691             case 7: /* Tag_CPU_arch_profile.  */
10692               val = read_uleb128 (p, &len);
10693               p += len;
10694               switch (val)
10695                 {
10696                 case 0: printf (_("None\n")); break;
10697                 case 'A': printf (_("Application\n")); break;
10698                 case 'R': printf (_("Realtime\n")); break;
10699                 case 'M': printf (_("Microcontroller\n")); break;
10700                 case 'S': printf (_("Application or Realtime\n")); break;
10701                 default: printf ("??? (%d)\n", val); break;
10702                 }
10703               break;
10704
10705             case 24: /* Tag_align_needed.  */
10706               val = read_uleb128 (p, &len);
10707               p += len;
10708               switch (val)
10709                 {
10710                 case 0: printf (_("None\n")); break;
10711                 case 1: printf (_("8-byte\n")); break;
10712                 case 2: printf (_("4-byte\n")); break;
10713                 case 3: printf ("??? 3\n"); break;
10714                 default:
10715                   if (val <= 12)
10716                     printf (_("8-byte and up to %d-byte extended\n"),
10717                             1 << val);
10718                   else
10719                     printf ("??? (%d)\n", val);
10720                   break;
10721                 }
10722               break;
10723
10724             case 25: /* Tag_align_preserved.  */
10725               val = read_uleb128 (p, &len);
10726               p += len;
10727               switch (val)
10728                 {
10729                 case 0: printf (_("None\n")); break;
10730                 case 1: printf (_("8-byte, except leaf SP\n")); break;
10731                 case 2: printf (_("8-byte\n")); break;
10732                 case 3: printf ("??? 3\n"); break;
10733                 default:
10734                   if (val <= 12)
10735                     printf (_("8-byte and up to %d-byte extended\n"),
10736                             1 << val);
10737                   else
10738                     printf ("??? (%d)\n", val);
10739                   break;
10740                 }
10741               break;
10742
10743             case 32: /* Tag_compatibility.  */
10744               val = read_uleb128 (p, &len);
10745               p += len;
10746               printf (_("flag = %d, vendor = %s\n"), val, p);
10747               p += strlen ((char *) p) + 1;
10748               break;
10749
10750             case 64: /* Tag_nodefaults.  */
10751               p++;
10752               printf (_("True\n"));
10753               break;
10754
10755             case 65: /* Tag_also_compatible_with.  */
10756               val = read_uleb128 (p, &len);
10757               p += len;
10758               if (val == 6 /* Tag_CPU_arch.  */)
10759                 {
10760                   val = read_uleb128 (p, &len);
10761                   p += len;
10762                   if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
10763                     printf ("??? (%d)\n", val);
10764                   else
10765                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
10766                 }
10767               else
10768                 printf ("???\n");
10769               while (*(p++) != '\0' /* NUL terminator.  */);
10770               break;
10771
10772             default:
10773               abort ();
10774             }
10775           return p;
10776
10777         case 1:
10778         case 2:
10779           type = attr->type;
10780           break;
10781
10782         default:
10783           assert (attr->type & 0x80);
10784           val = read_uleb128 (p, &len);
10785           p += len;
10786           type = attr->type & 0x7f;
10787           if (val >= type)
10788             printf ("??? (%d)\n", val);
10789           else
10790             printf ("%s\n", attr->table[val]);
10791           return p;
10792         }
10793     }
10794   else
10795     {
10796       if (tag & 1)
10797         type = 1; /* String.  */
10798       else
10799         type = 2; /* uleb128.  */
10800       printf ("  Tag_unknown_%d: ", tag);
10801     }
10802
10803   if (type == 1)
10804     {
10805       printf ("\"%s\"\n", p);
10806       p += strlen ((char *) p) + 1;
10807     }
10808   else
10809     {
10810       val = read_uleb128 (p, &len);
10811       p += len;
10812       printf ("%d (0x%x)\n", val, val);
10813     }
10814
10815   return p;
10816 }
10817
10818 static unsigned char *
10819 display_gnu_attribute (unsigned char * p,
10820                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
10821 {
10822   int tag;
10823   unsigned int len;
10824   int val;
10825   int type;
10826
10827   tag = read_uleb128 (p, &len);
10828   p += len;
10829
10830   /* Tag_compatibility is the only generic GNU attribute defined at
10831      present.  */
10832   if (tag == 32)
10833     {
10834       val = read_uleb128 (p, &len);
10835       p += len;
10836       printf (_("flag = %d, vendor = %s\n"), val, p);
10837       p += strlen ((char *) p) + 1;
10838       return p;
10839     }
10840
10841   if ((tag & 2) == 0 && display_proc_gnu_attribute)
10842     return display_proc_gnu_attribute (p, tag);
10843
10844   if (tag & 1)
10845     type = 1; /* String.  */
10846   else
10847     type = 2; /* uleb128.  */
10848   printf ("  Tag_unknown_%d: ", tag);
10849
10850   if (type == 1)
10851     {
10852       printf ("\"%s\"\n", p);
10853       p += strlen ((char *) p) + 1;
10854     }
10855   else
10856     {
10857       val = read_uleb128 (p, &len);
10858       p += len;
10859       printf ("%d (0x%x)\n", val, val);
10860     }
10861
10862   return p;
10863 }
10864
10865 static unsigned char *
10866 display_power_gnu_attribute (unsigned char * p, int tag)
10867 {
10868   int type;
10869   unsigned int len;
10870   int val;
10871
10872   if (tag == Tag_GNU_Power_ABI_FP)
10873     {
10874       val = read_uleb128 (p, &len);
10875       p += len;
10876       printf ("  Tag_GNU_Power_ABI_FP: ");
10877
10878       switch (val)
10879         {
10880         case 0:
10881           printf (_("Hard or soft float\n"));
10882           break;
10883         case 1:
10884           printf (_("Hard float\n"));
10885           break;
10886         case 2:
10887           printf (_("Soft float\n"));
10888           break;
10889         case 3:
10890           printf (_("Single-precision hard float\n"));
10891           break;
10892         default:
10893           printf ("??? (%d)\n", val);
10894           break;
10895         }
10896       return p;
10897    }
10898
10899   if (tag == Tag_GNU_Power_ABI_Vector)
10900     {
10901       val = read_uleb128 (p, &len);
10902       p += len;
10903       printf ("  Tag_GNU_Power_ABI_Vector: ");
10904       switch (val)
10905         {
10906         case 0:
10907           printf (_("Any\n"));
10908           break;
10909         case 1:
10910           printf (_("Generic\n"));
10911           break;
10912         case 2:
10913           printf ("AltiVec\n");
10914           break;
10915         case 3:
10916           printf ("SPE\n");
10917           break;
10918         default:
10919           printf ("??? (%d)\n", val);
10920           break;
10921         }
10922       return p;
10923    }
10924
10925   if (tag == Tag_GNU_Power_ABI_Struct_Return)
10926     {
10927       val = read_uleb128 (p, &len);
10928       p += len;
10929       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
10930       switch (val)
10931        {
10932        case 0:
10933          printf (_("Any\n"));
10934          break;
10935        case 1:
10936          printf ("r3/r4\n");
10937          break;
10938        case 2:
10939          printf (_("Memory\n"));
10940          break;
10941        default:
10942          printf ("??? (%d)\n", val);
10943          break;
10944        }
10945       return p;
10946     }
10947
10948   if (tag & 1)
10949     type = 1; /* String.  */
10950   else
10951     type = 2; /* uleb128.  */
10952   printf ("  Tag_unknown_%d: ", tag);
10953
10954   if (type == 1)
10955     {
10956       printf ("\"%s\"\n", p);
10957       p += strlen ((char *) p) + 1;
10958     }
10959   else
10960     {
10961       val = read_uleb128 (p, &len);
10962       p += len;
10963       printf ("%d (0x%x)\n", val, val);
10964     }
10965
10966   return p;
10967 }
10968
10969 static unsigned char *
10970 display_mips_gnu_attribute (unsigned char * p, int tag)
10971 {
10972   int type;
10973   unsigned int len;
10974   int val;
10975
10976   if (tag == Tag_GNU_MIPS_ABI_FP)
10977     {
10978       val = read_uleb128 (p, &len);
10979       p += len;
10980       printf ("  Tag_GNU_MIPS_ABI_FP: ");
10981
10982       switch (val)
10983         {
10984         case 0:
10985           printf (_("Hard or soft float\n"));
10986           break;
10987         case 1:
10988           printf (_("Hard float (double precision)\n"));
10989           break;
10990         case 2:
10991           printf (_("Hard float (single precision)\n"));
10992           break;
10993         case 3:
10994           printf (_("Soft float\n"));
10995           break;
10996         case 4:
10997           printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
10998           break;
10999         default:
11000           printf ("??? (%d)\n", val);
11001           break;
11002         }
11003       return p;
11004    }
11005
11006   if (tag & 1)
11007     type = 1; /* String.  */
11008   else
11009     type = 2; /* uleb128.  */
11010   printf ("  Tag_unknown_%d: ", tag);
11011
11012   if (type == 1)
11013     {
11014       printf ("\"%s\"\n", p);
11015       p += strlen ((char *) p) + 1;
11016     }
11017   else
11018     {
11019       val = read_uleb128 (p, &len);
11020       p += len;
11021       printf ("%d (0x%x)\n", val, val);
11022     }
11023
11024   return p;
11025 }
11026
11027 static unsigned char *
11028 display_tic6x_attribute (unsigned char * p)
11029 {
11030   int tag;
11031   unsigned int len;
11032   int val;
11033
11034   tag = read_uleb128 (p, &len);
11035   p += len;
11036
11037   switch (tag)
11038     {
11039     case Tag_ISA:
11040       val = read_uleb128 (p, &len);
11041       p += len;
11042       printf ("  Tag_ISA: ");
11043
11044       switch (val)
11045         {
11046         case C6XABI_Tag_ISA_none:
11047           printf (_("None\n"));
11048           break;
11049         case C6XABI_Tag_ISA_C62X:
11050           printf ("C62x\n");
11051           break;
11052         case C6XABI_Tag_ISA_C67X:
11053           printf ("C67x\n");
11054           break;
11055         case C6XABI_Tag_ISA_C67XP:
11056           printf ("C67x+\n");
11057           break;
11058         case C6XABI_Tag_ISA_C64X:
11059           printf ("C64x\n");
11060           break;
11061         case C6XABI_Tag_ISA_C64XP:
11062           printf ("C64x+\n");
11063           break;
11064         case C6XABI_Tag_ISA_C674X:
11065           printf ("C674x\n");
11066           break;
11067         default:
11068           printf ("??? (%d)\n", val);
11069           break;
11070         }
11071       return p;
11072
11073     case Tag_ABI_wchar_t:
11074       val = read_uleb128 (p, &len);
11075       p += len;
11076       printf ("  Tag_ABI_wchar_t: ");
11077       switch (val)
11078         {
11079         case 0:
11080           printf (_("Not used\n"));
11081           break;
11082         case 1:
11083           printf (_("2 bytes\n"));
11084           break;
11085         case 2:
11086           printf (_("4 bytes\n"));
11087           break;
11088         default:
11089           printf ("??? (%d)\n", val);
11090           break;
11091         }
11092       return p;
11093
11094     case Tag_ABI_stack_align_needed:
11095       val = read_uleb128 (p, &len);
11096       p += len;
11097       printf ("  Tag_ABI_stack_align_needed: ");
11098       switch (val)
11099         {
11100         case 0:
11101           printf (_("8-byte\n"));
11102           break;
11103         case 1:
11104           printf (_("16-byte\n"));
11105           break;
11106         default:
11107           printf ("??? (%d)\n", val);
11108           break;
11109         }
11110       return p;
11111
11112     case Tag_ABI_stack_align_preserved:
11113       val = read_uleb128 (p, &len);
11114       p += len;
11115       printf ("  Tag_ABI_stack_align_preserved: ");
11116       switch (val)
11117         {
11118         case 0:
11119           printf (_("8-byte\n"));
11120           break;
11121         case 1:
11122           printf (_("16-byte\n"));
11123           break;
11124         default:
11125           printf ("??? (%d)\n", val);
11126           break;
11127         }
11128       return p;
11129
11130     case Tag_ABI_DSBT:
11131       val = read_uleb128 (p, &len);
11132       p += len;
11133       printf ("  Tag_ABI_DSBT: ");
11134       switch (val)
11135         {
11136         case 0:
11137           printf (_("DSBT addressing not used\n"));
11138           break;
11139         case 1:
11140           printf (_("DSBT addressing used\n"));
11141           break;
11142         default:
11143           printf ("??? (%d)\n", val);
11144           break;
11145         }
11146       return p;
11147
11148     case Tag_ABI_PID:
11149       val = read_uleb128 (p, &len);
11150       p += len;
11151       printf ("  Tag_ABI_PID: ");
11152       switch (val)
11153         {
11154         case 0:
11155           printf (_("Data addressing position-dependent\n"));
11156           break;
11157         case 1:
11158           printf (_("Data addressing position-independent, GOT near DP\n"));
11159           break;
11160         case 2:
11161           printf (_("Data addressing position-independent, GOT far from DP\n"));
11162           break;
11163         default:
11164           printf ("??? (%d)\n", val);
11165           break;
11166         }
11167       return p;
11168
11169     case Tag_ABI_PIC:
11170       val = read_uleb128 (p, &len);
11171       p += len;
11172       printf ("  Tag_ABI_PIC: ");
11173       switch (val)
11174         {
11175         case 0:
11176           printf (_("Code addressing position-dependent\n"));
11177           break;
11178         case 1:
11179           printf (_("Code addressing position-independent\n"));
11180           break;
11181         default:
11182           printf ("??? (%d)\n", val);
11183           break;
11184         }
11185       return p;
11186
11187     case Tag_ABI_array_object_alignment:
11188       val = read_uleb128 (p, &len);
11189       p += len;
11190       printf ("  Tag_ABI_array_object_alignment: ");
11191       switch (val)
11192         {
11193         case 0:
11194           printf (_("8-byte\n"));
11195           break;
11196         case 1:
11197           printf (_("4-byte\n"));
11198           break;
11199         case 2:
11200           printf (_("16-byte\n"));
11201           break;
11202         default:
11203           printf ("??? (%d)\n", val);
11204           break;
11205         }
11206       return p;
11207
11208     case Tag_ABI_array_object_align_expected:
11209       val = read_uleb128 (p, &len);
11210       p += len;
11211       printf ("  Tag_ABI_array_object_align_expected: ");
11212       switch (val)
11213         {
11214         case 0:
11215           printf (_("8-byte\n"));
11216           break;
11217         case 1:
11218           printf (_("4-byte\n"));
11219           break;
11220         case 2:
11221           printf (_("16-byte\n"));
11222           break;
11223         default:
11224           printf ("??? (%d)\n", val);
11225           break;
11226         }
11227       return p;
11228
11229     case Tag_ABI_compatibility:
11230       val = read_uleb128 (p, &len);
11231       p += len;
11232       printf ("  Tag_ABI_compatibility: ");
11233       printf (_("flag = %d, vendor = %s\n"), val, p);
11234       p += strlen ((char *) p) + 1;
11235       return p;
11236
11237     case Tag_ABI_conformance:
11238       printf ("  Tag_ABI_conformance: ");
11239       printf ("\"%s\"\n", p);
11240       p += strlen ((char *) p) + 1;
11241       return p;
11242     }
11243
11244   printf ("  Tag_unknown_%d: ", tag);
11245
11246   if (tag & 1)
11247     {
11248       printf ("\"%s\"\n", p);
11249       p += strlen ((char *) p) + 1;
11250     }
11251   else
11252     {
11253       val = read_uleb128 (p, &len);
11254       p += len;
11255       printf ("%d (0x%x)\n", val, val);
11256     }
11257
11258   return p;
11259 }
11260
11261 static int
11262 process_attributes (FILE * file,
11263                     const char * public_name,
11264                     unsigned int proc_type,
11265                     unsigned char * (* display_pub_attribute) (unsigned char *),
11266                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11267 {
11268   Elf_Internal_Shdr * sect;
11269   unsigned char * contents;
11270   unsigned char * p;
11271   unsigned char * end;
11272   bfd_vma section_len;
11273   bfd_vma len;
11274   unsigned i;
11275
11276   /* Find the section header so that we get the size.  */
11277   for (i = 0, sect = section_headers;
11278        i < elf_header.e_shnum;
11279        i++, sect++)
11280     {
11281       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11282         continue;
11283
11284       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11285                                              sect->sh_size, _("attributes"));
11286       if (contents == NULL)
11287         continue;
11288
11289       p = contents;
11290       if (*p == 'A')
11291         {
11292           len = sect->sh_size - 1;
11293           p++;
11294
11295           while (len > 0)
11296             {
11297               int namelen;
11298               bfd_boolean public_section;
11299               bfd_boolean gnu_section;
11300
11301               section_len = byte_get (p, 4);
11302               p += 4;
11303
11304               if (section_len > len)
11305                 {
11306                   printf (_("ERROR: Bad section length (%d > %d)\n"),
11307                           (int) section_len, (int) len);
11308                   section_len = len;
11309                 }
11310
11311               len -= section_len;
11312               printf (_("Attribute Section: %s\n"), p);
11313
11314               if (public_name && streq ((char *) p, public_name))
11315                 public_section = TRUE;
11316               else
11317                 public_section = FALSE;
11318
11319               if (streq ((char *) p, "gnu"))
11320                 gnu_section = TRUE;
11321               else
11322                 gnu_section = FALSE;
11323
11324               namelen = strlen ((char *) p) + 1;
11325               p += namelen;
11326               section_len -= namelen + 4;
11327
11328               while (section_len > 0)
11329                 {
11330                   int tag = *(p++);
11331                   int val;
11332                   bfd_vma size;
11333
11334                   size = byte_get (p, 4);
11335                   if (size > section_len)
11336                     {
11337                       printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11338                               (int) size, (int) section_len);
11339                       size = section_len;
11340                     }
11341
11342                   section_len -= size;
11343                   end = p + size - 1;
11344                   p += 4;
11345
11346                   switch (tag)
11347                     {
11348                     case 1:
11349                       printf (_("File Attributes\n"));
11350                       break;
11351                     case 2:
11352                       printf (_("Section Attributes:"));
11353                       goto do_numlist;
11354                     case 3:
11355                       printf (_("Symbol Attributes:"));
11356                     do_numlist:
11357                       for (;;)
11358                         {
11359                           unsigned int j;
11360
11361                           val = read_uleb128 (p, &j);
11362                           p += j;
11363                           if (val == 0)
11364                             break;
11365                           printf (" %d", val);
11366                         }
11367                       printf ("\n");
11368                       break;
11369                     default:
11370                       printf (_("Unknown tag: %d\n"), tag);
11371                       public_section = FALSE;
11372                       break;
11373                     }
11374
11375                   if (public_section)
11376                     {
11377                       while (p < end)
11378                         p = display_pub_attribute (p);
11379                     }
11380                   else if (gnu_section)
11381                     {
11382                       while (p < end)
11383                         p = display_gnu_attribute (p,
11384                                                    display_proc_gnu_attribute);
11385                     }
11386                   else
11387                     {
11388                       /* ??? Do something sensible, like dump hex.  */
11389                       printf (_("  Unknown section contexts\n"));
11390                       p = end;
11391                     }
11392                 }
11393             }
11394         }
11395       else
11396         printf (_("Unknown format '%c'\n"), *p);
11397
11398       free (contents);
11399     }
11400   return 1;
11401 }
11402
11403 static int
11404 process_arm_specific (FILE * file)
11405 {
11406   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
11407                              display_arm_attribute, NULL);
11408 }
11409
11410 static int
11411 process_power_specific (FILE * file)
11412 {
11413   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11414                              display_power_gnu_attribute);
11415 }
11416
11417 static int
11418 process_tic6x_specific (FILE * file)
11419 {
11420   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
11421                              display_tic6x_attribute, NULL);
11422 }
11423
11424 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11425    Print the Address, Access and Initial fields of an entry at VMA ADDR
11426    and return the VMA of the next entry.  */
11427
11428 static bfd_vma
11429 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
11430 {
11431   printf ("  ");
11432   print_vma (addr, LONG_HEX);
11433   printf (" ");
11434   if (addr < pltgot + 0xfff0)
11435     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
11436   else
11437     printf ("%10s", "");
11438   printf (" ");
11439   if (data == NULL)
11440     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
11441   else
11442     {
11443       bfd_vma entry;
11444
11445       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11446       print_vma (entry, LONG_HEX);
11447     }
11448   return addr + (is_32bit_elf ? 4 : 8);
11449 }
11450
11451 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11452    PLTGOT.  Print the Address and Initial fields of an entry at VMA
11453    ADDR and return the VMA of the next entry.  */
11454
11455 static bfd_vma
11456 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
11457 {
11458   printf ("  ");
11459   print_vma (addr, LONG_HEX);
11460   printf (" ");
11461   if (data == NULL)
11462     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
11463   else
11464     {
11465       bfd_vma entry;
11466
11467       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11468       print_vma (entry, LONG_HEX);
11469     }
11470   return addr + (is_32bit_elf ? 4 : 8);
11471 }
11472
11473 static int
11474 process_mips_specific (FILE * file)
11475 {
11476   Elf_Internal_Dyn * entry;
11477   size_t liblist_offset = 0;
11478   size_t liblistno = 0;
11479   size_t conflictsno = 0;
11480   size_t options_offset = 0;
11481   size_t conflicts_offset = 0;
11482   size_t pltrelsz = 0;
11483   size_t pltrel = 0;
11484   bfd_vma pltgot = 0;
11485   bfd_vma mips_pltgot = 0;
11486   bfd_vma jmprel = 0;
11487   bfd_vma local_gotno = 0;
11488   bfd_vma gotsym = 0;
11489   bfd_vma symtabno = 0;
11490
11491   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11492                       display_mips_gnu_attribute);
11493
11494   /* We have a lot of special sections.  Thanks SGI!  */
11495   if (dynamic_section == NULL)
11496     /* No information available.  */
11497     return 0;
11498
11499   for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
11500     switch (entry->d_tag)
11501       {
11502       case DT_MIPS_LIBLIST:
11503         liblist_offset
11504           = offset_from_vma (file, entry->d_un.d_val,
11505                              liblistno * sizeof (Elf32_External_Lib));
11506         break;
11507       case DT_MIPS_LIBLISTNO:
11508         liblistno = entry->d_un.d_val;
11509         break;
11510       case DT_MIPS_OPTIONS:
11511         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
11512         break;
11513       case DT_MIPS_CONFLICT:
11514         conflicts_offset
11515           = offset_from_vma (file, entry->d_un.d_val,
11516                              conflictsno * sizeof (Elf32_External_Conflict));
11517         break;
11518       case DT_MIPS_CONFLICTNO:
11519         conflictsno = entry->d_un.d_val;
11520         break;
11521       case DT_PLTGOT:
11522         pltgot = entry->d_un.d_ptr;
11523         break;
11524       case DT_MIPS_LOCAL_GOTNO:
11525         local_gotno = entry->d_un.d_val;
11526         break;
11527       case DT_MIPS_GOTSYM:
11528         gotsym = entry->d_un.d_val;
11529         break;
11530       case DT_MIPS_SYMTABNO:
11531         symtabno = entry->d_un.d_val;
11532         break;
11533       case DT_MIPS_PLTGOT:
11534         mips_pltgot = entry->d_un.d_ptr;
11535         break;
11536       case DT_PLTREL:
11537         pltrel = entry->d_un.d_val;
11538         break;
11539       case DT_PLTRELSZ:
11540         pltrelsz = entry->d_un.d_val;
11541         break;
11542       case DT_JMPREL:
11543         jmprel = entry->d_un.d_ptr;
11544         break;
11545       default:
11546         break;
11547       }
11548
11549   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
11550     {
11551       Elf32_External_Lib * elib;
11552       size_t cnt;
11553
11554       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
11555                                               liblistno,
11556                                               sizeof (Elf32_External_Lib),
11557                                               _("liblist"));
11558       if (elib)
11559         {
11560           printf (_("\nSection '.liblist' contains %lu entries:\n"),
11561                   (unsigned long) liblistno);
11562           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
11563                  stdout);
11564
11565           for (cnt = 0; cnt < liblistno; ++cnt)
11566             {
11567               Elf32_Lib liblist;
11568               time_t atime;
11569               char timebuf[20];
11570               struct tm * tmp;
11571
11572               liblist.l_name = BYTE_GET (elib[cnt].l_name);
11573               atime = BYTE_GET (elib[cnt].l_time_stamp);
11574               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11575               liblist.l_version = BYTE_GET (elib[cnt].l_version);
11576               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11577
11578               tmp = gmtime (&atime);
11579               snprintf (timebuf, sizeof (timebuf),
11580                         "%04u-%02u-%02uT%02u:%02u:%02u",
11581                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11582                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
11583
11584               printf ("%3lu: ", (unsigned long) cnt);
11585               if (VALID_DYNAMIC_NAME (liblist.l_name))
11586                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
11587               else
11588                 printf (_("<corrupt: %9ld>"), liblist.l_name);
11589               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
11590                       liblist.l_version);
11591
11592               if (liblist.l_flags == 0)
11593                 puts (_(" NONE"));
11594               else
11595                 {
11596                   static const struct
11597                   {
11598                     const char * name;
11599                     int bit;
11600                   }
11601                   l_flags_vals[] =
11602                   {
11603                     { " EXACT_MATCH", LL_EXACT_MATCH },
11604                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
11605                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
11606                     { " EXPORTS", LL_EXPORTS },
11607                     { " DELAY_LOAD", LL_DELAY_LOAD },
11608                     { " DELTA", LL_DELTA }
11609                   };
11610                   int flags = liblist.l_flags;
11611                   size_t fcnt;
11612
11613                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
11614                     if ((flags & l_flags_vals[fcnt].bit) != 0)
11615                       {
11616                         fputs (l_flags_vals[fcnt].name, stdout);
11617                         flags ^= l_flags_vals[fcnt].bit;
11618                       }
11619                   if (flags != 0)
11620                     printf (" %#x", (unsigned int) flags);
11621
11622                   puts ("");
11623                 }
11624             }
11625
11626           free (elib);
11627         }
11628     }
11629
11630   if (options_offset != 0)
11631     {
11632       Elf_External_Options * eopt;
11633       Elf_Internal_Shdr * sect = section_headers;
11634       Elf_Internal_Options * iopt;
11635       Elf_Internal_Options * option;
11636       size_t offset;
11637       int cnt;
11638
11639       /* Find the section header so that we get the size.  */
11640       while (sect->sh_type != SHT_MIPS_OPTIONS)
11641         ++sect;
11642
11643       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
11644                                                 sect->sh_size, _("options"));
11645       if (eopt)
11646         {
11647           iopt = (Elf_Internal_Options *)
11648               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
11649           if (iopt == NULL)
11650             {
11651               error (_("Out of memory\n"));
11652               return 0;
11653             }
11654
11655           offset = cnt = 0;
11656           option = iopt;
11657
11658           while (offset < sect->sh_size)
11659             {
11660               Elf_External_Options * eoption;
11661
11662               eoption = (Elf_External_Options *) ((char *) eopt + offset);
11663
11664               option->kind = BYTE_GET (eoption->kind);
11665               option->size = BYTE_GET (eoption->size);
11666               option->section = BYTE_GET (eoption->section);
11667               option->info = BYTE_GET (eoption->info);
11668
11669               offset += option->size;
11670
11671               ++option;
11672               ++cnt;
11673             }
11674
11675           printf (_("\nSection '%s' contains %d entries:\n"),
11676                   SECTION_NAME (sect), cnt);
11677
11678           option = iopt;
11679
11680           while (cnt-- > 0)
11681             {
11682               size_t len;
11683
11684               switch (option->kind)
11685                 {
11686                 case ODK_NULL:
11687                   /* This shouldn't happen.  */
11688                   printf (" NULL       %d %lx", option->section, option->info);
11689                   break;
11690                 case ODK_REGINFO:
11691                   printf (" REGINFO    ");
11692                   if (elf_header.e_machine == EM_MIPS)
11693                     {
11694                       /* 32bit form.  */
11695                       Elf32_External_RegInfo * ereg;
11696                       Elf32_RegInfo reginfo;
11697
11698                       ereg = (Elf32_External_RegInfo *) (option + 1);
11699                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11700                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11701                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11702                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11703                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11704                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11705
11706                       printf ("GPR %08lx  GP 0x%lx\n",
11707                               reginfo.ri_gprmask,
11708                               (unsigned long) reginfo.ri_gp_value);
11709                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
11710                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11711                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11712                     }
11713                   else
11714                     {
11715                       /* 64 bit form.  */
11716                       Elf64_External_RegInfo * ereg;
11717                       Elf64_Internal_RegInfo reginfo;
11718
11719                       ereg = (Elf64_External_RegInfo *) (option + 1);
11720                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
11721                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11722                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11723                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11724                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11725                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
11726
11727                       printf ("GPR %08lx  GP 0x",
11728                               reginfo.ri_gprmask);
11729                       printf_vma (reginfo.ri_gp_value);
11730                       printf ("\n");
11731
11732                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
11733                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11734                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11735                     }
11736                   ++option;
11737                   continue;
11738                 case ODK_EXCEPTIONS:
11739                   fputs (" EXCEPTIONS fpe_min(", stdout);
11740                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
11741                   fputs (") fpe_max(", stdout);
11742                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
11743                   fputs (")", stdout);
11744
11745                   if (option->info & OEX_PAGE0)
11746                     fputs (" PAGE0", stdout);
11747                   if (option->info & OEX_SMM)
11748                     fputs (" SMM", stdout);
11749                   if (option->info & OEX_FPDBUG)
11750                     fputs (" FPDBUG", stdout);
11751                   if (option->info & OEX_DISMISS)
11752                     fputs (" DISMISS", stdout);
11753                   break;
11754                 case ODK_PAD:
11755                   fputs (" PAD       ", stdout);
11756                   if (option->info & OPAD_PREFIX)
11757                     fputs (" PREFIX", stdout);
11758                   if (option->info & OPAD_POSTFIX)
11759                     fputs (" POSTFIX", stdout);
11760                   if (option->info & OPAD_SYMBOL)
11761                     fputs (" SYMBOL", stdout);
11762                   break;
11763                 case ODK_HWPATCH:
11764                   fputs (" HWPATCH   ", stdout);
11765                   if (option->info & OHW_R4KEOP)
11766                     fputs (" R4KEOP", stdout);
11767                   if (option->info & OHW_R8KPFETCH)
11768                     fputs (" R8KPFETCH", stdout);
11769                   if (option->info & OHW_R5KEOP)
11770                     fputs (" R5KEOP", stdout);
11771                   if (option->info & OHW_R5KCVTL)
11772                     fputs (" R5KCVTL", stdout);
11773                   break;
11774                 case ODK_FILL:
11775                   fputs (" FILL       ", stdout);
11776                   /* XXX Print content of info word?  */
11777                   break;
11778                 case ODK_TAGS:
11779                   fputs (" TAGS       ", stdout);
11780                   /* XXX Print content of info word?  */
11781                   break;
11782                 case ODK_HWAND:
11783                   fputs (" HWAND     ", stdout);
11784                   if (option->info & OHWA0_R4KEOP_CHECKED)
11785                     fputs (" R4KEOP_CHECKED", stdout);
11786                   if (option->info & OHWA0_R4KEOP_CLEAN)
11787                     fputs (" R4KEOP_CLEAN", stdout);
11788                   break;
11789                 case ODK_HWOR:
11790                   fputs (" HWOR      ", stdout);
11791                   if (option->info & OHWA0_R4KEOP_CHECKED)
11792                     fputs (" R4KEOP_CHECKED", stdout);
11793                   if (option->info & OHWA0_R4KEOP_CLEAN)
11794                     fputs (" R4KEOP_CLEAN", stdout);
11795                   break;
11796                 case ODK_GP_GROUP:
11797                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
11798                           option->info & OGP_GROUP,
11799                           (option->info & OGP_SELF) >> 16);
11800                   break;
11801                 case ODK_IDENT:
11802                   printf (" IDENT     %#06lx  self-contained %#06lx",
11803                           option->info & OGP_GROUP,
11804                           (option->info & OGP_SELF) >> 16);
11805                   break;
11806                 default:
11807                   /* This shouldn't happen.  */
11808                   printf (" %3d ???     %d %lx",
11809                           option->kind, option->section, option->info);
11810                   break;
11811                 }
11812
11813               len = sizeof (* eopt);
11814               while (len < option->size)
11815                 if (((char *) option)[len] >= ' '
11816                     && ((char *) option)[len] < 0x7f)
11817                   printf ("%c", ((char *) option)[len++]);
11818                 else
11819                   printf ("\\%03o", ((char *) option)[len++]);
11820
11821               fputs ("\n", stdout);
11822               ++option;
11823             }
11824
11825           free (eopt);
11826         }
11827     }
11828
11829   if (conflicts_offset != 0 && conflictsno != 0)
11830     {
11831       Elf32_Conflict * iconf;
11832       size_t cnt;
11833
11834       if (dynamic_symbols == NULL)
11835         {
11836           error (_("conflict list found without a dynamic symbol table\n"));
11837           return 0;
11838         }
11839
11840       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
11841       if (iconf == NULL)
11842         {
11843           error (_("Out of memory\n"));
11844           return 0;
11845         }
11846
11847       if (is_32bit_elf)
11848         {
11849           Elf32_External_Conflict * econf32;
11850
11851           econf32 = (Elf32_External_Conflict *)
11852               get_data (NULL, file, conflicts_offset, conflictsno,
11853                         sizeof (* econf32), _("conflict"));
11854           if (!econf32)
11855             return 0;
11856
11857           for (cnt = 0; cnt < conflictsno; ++cnt)
11858             iconf[cnt] = BYTE_GET (econf32[cnt]);
11859
11860           free (econf32);
11861         }
11862       else
11863         {
11864           Elf64_External_Conflict * econf64;
11865
11866           econf64 = (Elf64_External_Conflict *)
11867               get_data (NULL, file, conflicts_offset, conflictsno,
11868                         sizeof (* econf64), _("conflict"));
11869           if (!econf64)
11870             return 0;
11871
11872           for (cnt = 0; cnt < conflictsno; ++cnt)
11873             iconf[cnt] = BYTE_GET (econf64[cnt]);
11874
11875           free (econf64);
11876         }
11877
11878       printf (_("\nSection '.conflict' contains %lu entries:\n"),
11879               (unsigned long) conflictsno);
11880       puts (_("  Num:    Index       Value  Name"));
11881
11882       for (cnt = 0; cnt < conflictsno; ++cnt)
11883         {
11884           Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
11885
11886           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
11887           print_vma (psym->st_value, FULL_HEX);
11888           putchar (' ');
11889           if (VALID_DYNAMIC_NAME (psym->st_name))
11890             print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11891           else
11892             printf (_("<corrupt: %14ld>"), psym->st_name);
11893           putchar ('\n');
11894         }
11895
11896       free (iconf);
11897     }
11898
11899   if (pltgot != 0 && local_gotno != 0)
11900     {
11901       bfd_vma ent, local_end, global_end;
11902       size_t i, offset;
11903       unsigned char * data;
11904       int addr_size;
11905
11906       ent = pltgot;
11907       addr_size = (is_32bit_elf ? 4 : 8);
11908       local_end = pltgot + local_gotno * addr_size;
11909       global_end = local_end + (symtabno - gotsym) * addr_size;
11910
11911       offset = offset_from_vma (file, pltgot, global_end - pltgot);
11912       data = (unsigned char *) get_data (NULL, file, offset,
11913                                          global_end - pltgot, 1, _("GOT"));
11914       printf (_("\nPrimary GOT:\n"));
11915       printf (_(" Canonical gp value: "));
11916       print_vma (pltgot + 0x7ff0, LONG_HEX);
11917       printf ("\n\n");
11918
11919       printf (_(" Reserved entries:\n"));
11920       printf (_("  %*s %10s %*s Purpose\n"),
11921               addr_size * 2, _("Address"), _("Access"),
11922               addr_size * 2, _("Initial"));
11923       ent = print_mips_got_entry (data, pltgot, ent);
11924       printf (_(" Lazy resolver\n"));
11925       if (data
11926           && (byte_get (data + ent - pltgot, addr_size)
11927               >> (addr_size * 8 - 1)) != 0)
11928         {
11929           ent = print_mips_got_entry (data, pltgot, ent);
11930           printf (_(" Module pointer (GNU extension)\n"));
11931         }
11932       printf ("\n");
11933
11934       if (ent < local_end)
11935         {
11936           printf (_(" Local entries:\n"));
11937           printf ("  %*s %10s %*s\n",
11938                   addr_size * 2, _("Address"), _("Access"),
11939                   addr_size * 2, _("Initial"));
11940           while (ent < local_end)
11941             {
11942               ent = print_mips_got_entry (data, pltgot, ent);
11943               printf ("\n");
11944             }
11945           printf ("\n");
11946         }
11947
11948       if (gotsym < symtabno)
11949         {
11950           int sym_width;
11951
11952           printf (_(" Global entries:\n"));
11953           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
11954                   addr_size * 2, _("Address"), _("Access"),
11955                   addr_size * 2, _("Initial"),
11956                   addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11957           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
11958           for (i = gotsym; i < symtabno; i++)
11959             {
11960               Elf_Internal_Sym * psym;
11961
11962               psym = dynamic_symbols + i;
11963               ent = print_mips_got_entry (data, pltgot, ent);
11964               printf (" ");
11965               print_vma (psym->st_value, LONG_HEX);
11966               printf (" %-7s %3s ",
11967                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
11968                       get_symbol_index_type (psym->st_shndx));
11969               if (VALID_DYNAMIC_NAME (psym->st_name))
11970                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
11971               else
11972                 printf (_("<corrupt: %14ld>"), psym->st_name);
11973               printf ("\n");
11974             }
11975           printf ("\n");
11976         }
11977
11978       if (data)
11979         free (data);
11980     }
11981
11982   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
11983     {
11984       bfd_vma ent, end;
11985       size_t offset, rel_offset;
11986       unsigned long count, i;
11987       unsigned char * data;
11988       int addr_size, sym_width;
11989       Elf_Internal_Rela * rels;
11990
11991       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
11992       if (pltrel == DT_RELA)
11993         {
11994           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
11995             return 0;
11996         }
11997       else
11998         {
11999           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12000             return 0;
12001         }
12002
12003       ent = mips_pltgot;
12004       addr_size = (is_32bit_elf ? 4 : 8);
12005       end = mips_pltgot + (2 + count) * addr_size;
12006
12007       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
12008       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
12009                                          1, _("PLT GOT"));
12010       printf (_("\nPLT GOT:\n\n"));
12011       printf (_(" Reserved entries:\n"));
12012       printf (_("  %*s %*s Purpose\n"),
12013               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
12014       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12015       printf (_(" PLT lazy resolver\n"));
12016       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12017       printf (_(" Module pointer\n"));
12018       printf ("\n");
12019
12020       printf (_(" Entries:\n"));
12021       printf ("  %*s %*s %*s %-7s %3s %s\n",
12022               addr_size * 2, _("Address"),
12023               addr_size * 2, _("Initial"),
12024               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12025       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12026       for (i = 0; i < count; i++)
12027         {
12028           Elf_Internal_Sym * psym;
12029
12030           psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
12031           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12032           printf (" ");
12033           print_vma (psym->st_value, LONG_HEX);
12034           printf (" %-7s %3s ",
12035                   get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12036                   get_symbol_index_type (psym->st_shndx));
12037           if (VALID_DYNAMIC_NAME (psym->st_name))
12038             print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12039           else
12040             printf (_("<corrupt: %14ld>"), psym->st_name);
12041           printf ("\n");
12042         }
12043       printf ("\n");
12044
12045       if (data)
12046         free (data);
12047       free (rels);
12048     }
12049
12050   return 1;
12051 }
12052
12053 static int
12054 process_gnu_liblist (FILE * file)
12055 {
12056   Elf_Internal_Shdr * section;
12057   Elf_Internal_Shdr * string_sec;
12058   Elf32_External_Lib * elib;
12059   char * strtab;
12060   size_t strtab_size;
12061   size_t cnt;
12062   unsigned i;
12063
12064   if (! do_arch)
12065     return 0;
12066
12067   for (i = 0, section = section_headers;
12068        i < elf_header.e_shnum;
12069        i++, section++)
12070     {
12071       switch (section->sh_type)
12072         {
12073         case SHT_GNU_LIBLIST:
12074           if (section->sh_link >= elf_header.e_shnum)
12075             break;
12076
12077           elib = (Elf32_External_Lib *)
12078               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
12079                         _("liblist"));
12080
12081           if (elib == NULL)
12082             break;
12083           string_sec = section_headers + section->sh_link;
12084
12085           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12086                                       string_sec->sh_size,
12087                                       _("liblist string table"));
12088           strtab_size = string_sec->sh_size;
12089
12090           if (strtab == NULL
12091               || section->sh_entsize != sizeof (Elf32_External_Lib))
12092             {
12093               free (elib);
12094               free (strtab);
12095               break;
12096             }
12097
12098           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12099                   SECTION_NAME (section),
12100                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
12101
12102           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
12103
12104           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12105                ++cnt)
12106             {
12107               Elf32_Lib liblist;
12108               time_t atime;
12109               char timebuf[20];
12110               struct tm * tmp;
12111
12112               liblist.l_name = BYTE_GET (elib[cnt].l_name);
12113               atime = BYTE_GET (elib[cnt].l_time_stamp);
12114               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12115               liblist.l_version = BYTE_GET (elib[cnt].l_version);
12116               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12117
12118               tmp = gmtime (&atime);
12119               snprintf (timebuf, sizeof (timebuf),
12120                         "%04u-%02u-%02uT%02u:%02u:%02u",
12121                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12122                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12123
12124               printf ("%3lu: ", (unsigned long) cnt);
12125               if (do_wide)
12126                 printf ("%-20s", liblist.l_name < strtab_size
12127                         ? strtab + liblist.l_name : _("<corrupt>"));
12128               else
12129                 printf ("%-20.20s", liblist.l_name < strtab_size
12130                         ? strtab + liblist.l_name : _("<corrupt>"));
12131               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12132                       liblist.l_version, liblist.l_flags);
12133             }
12134
12135           free (elib);
12136           free (strtab);
12137         }
12138     }
12139
12140   return 1;
12141 }
12142
12143 static const char *
12144 get_note_type (unsigned e_type)
12145 {
12146   static char buff[64];
12147
12148   if (elf_header.e_type == ET_CORE)
12149     switch (e_type)
12150       {
12151       case NT_AUXV:
12152         return _("NT_AUXV (auxiliary vector)");
12153       case NT_PRSTATUS:
12154         return _("NT_PRSTATUS (prstatus structure)");
12155       case NT_FPREGSET:
12156         return _("NT_FPREGSET (floating point registers)");
12157       case NT_PRPSINFO:
12158         return _("NT_PRPSINFO (prpsinfo structure)");
12159       case NT_TASKSTRUCT:
12160         return _("NT_TASKSTRUCT (task structure)");
12161       case NT_PRXFPREG:
12162         return _("NT_PRXFPREG (user_xfpregs structure)");
12163       case NT_PPC_VMX:
12164         return _("NT_PPC_VMX (ppc Altivec registers)");
12165       case NT_PPC_VSX:
12166         return _("NT_PPC_VSX (ppc VSX registers)");
12167       case NT_X86_XSTATE:
12168         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
12169       case NT_S390_HIGH_GPRS:
12170         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
12171       case NT_S390_TIMER:
12172         return _("NT_S390_TIMER (s390 timer register)");
12173       case NT_S390_TODCMP:
12174         return _("NT_S390_TODCMP (s390 TOD comparator register)");
12175       case NT_S390_TODPREG:
12176         return _("NT_S390_TODPREG (s390 TOD programmable register)");
12177       case NT_S390_CTRS:
12178         return _("NT_S390_CTRS (s390 control registers)");
12179       case NT_S390_PREFIX:
12180         return _("NT_S390_PREFIX (s390 prefix register)");
12181       case NT_PSTATUS:
12182         return _("NT_PSTATUS (pstatus structure)");
12183       case NT_FPREGS:
12184         return _("NT_FPREGS (floating point registers)");
12185       case NT_PSINFO:
12186         return _("NT_PSINFO (psinfo structure)");
12187       case NT_LWPSTATUS:
12188         return _("NT_LWPSTATUS (lwpstatus_t structure)");
12189       case NT_LWPSINFO:
12190         return _("NT_LWPSINFO (lwpsinfo_t structure)");
12191       case NT_WIN32PSTATUS:
12192         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12193       default:
12194         break;
12195       }
12196   else
12197     switch (e_type)
12198       {
12199       case NT_VERSION:
12200         return _("NT_VERSION (version)");
12201       case NT_ARCH:
12202         return _("NT_ARCH (architecture)");
12203       default:
12204         break;
12205       }
12206
12207   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12208   return buff;
12209 }
12210
12211 static const char *
12212 get_gnu_elf_note_type (unsigned e_type)
12213 {
12214   static char buff[64];
12215
12216   switch (e_type)
12217     {
12218     case NT_GNU_ABI_TAG:
12219       return _("NT_GNU_ABI_TAG (ABI version tag)");
12220     case NT_GNU_HWCAP:
12221       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12222     case NT_GNU_BUILD_ID:
12223       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
12224     case NT_GNU_GOLD_VERSION:
12225       return _("NT_GNU_GOLD_VERSION (gold version)");
12226     default:
12227       break;
12228     }
12229
12230   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12231   return buff;
12232 }
12233
12234 static const char *
12235 get_netbsd_elfcore_note_type (unsigned e_type)
12236 {
12237   static char buff[64];
12238
12239   if (e_type == NT_NETBSDCORE_PROCINFO)
12240     {
12241       /* NetBSD core "procinfo" structure.  */
12242       return _("NetBSD procinfo structure");
12243     }
12244
12245   /* As of Jan 2002 there are no other machine-independent notes
12246      defined for NetBSD core files.  If the note type is less
12247      than the start of the machine-dependent note types, we don't
12248      understand it.  */
12249
12250   if (e_type < NT_NETBSDCORE_FIRSTMACH)
12251     {
12252       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12253       return buff;
12254     }
12255
12256   switch (elf_header.e_machine)
12257     {
12258     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
12259        and PT_GETFPREGS == mach+2.  */
12260
12261     case EM_OLD_ALPHA:
12262     case EM_ALPHA:
12263     case EM_SPARC:
12264     case EM_SPARC32PLUS:
12265     case EM_SPARCV9:
12266       switch (e_type)
12267         {
12268         case NT_NETBSDCORE_FIRSTMACH + 0:
12269           return _("PT_GETREGS (reg structure)");
12270         case NT_NETBSDCORE_FIRSTMACH + 2:
12271           return _("PT_GETFPREGS (fpreg structure)");
12272         default:
12273           break;
12274         }
12275       break;
12276
12277     /* On all other arch's, PT_GETREGS == mach+1 and
12278        PT_GETFPREGS == mach+3.  */
12279     default:
12280       switch (e_type)
12281         {
12282         case NT_NETBSDCORE_FIRSTMACH + 1:
12283           return _("PT_GETREGS (reg structure)");
12284         case NT_NETBSDCORE_FIRSTMACH + 3:
12285           return _("PT_GETFPREGS (fpreg structure)");
12286         default:
12287           break;
12288         }
12289     }
12290
12291   snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
12292             e_type - NT_NETBSDCORE_FIRSTMACH);
12293   return buff;
12294 }
12295
12296 static const char *
12297 get_ia64_vms_note_type (unsigned e_type)
12298 {
12299   static char buff[64];
12300
12301   switch (e_type)
12302     {
12303     case NT_VMS_MHD:
12304       return _("NT_VMS_MHD (module header)");
12305     case NT_VMS_LNM:
12306       return _("NT_VMS_LNM (language name)");
12307     case NT_VMS_SRC:
12308       return _("NT_VMS_SRC (source files)");
12309     case NT_VMS_TITLE:
12310       return _("NT_VMS_TITLE");
12311     case NT_VMS_EIDC:
12312       return _("NT_VMS_EIDC (consistency check)");
12313     case NT_VMS_FPMODE:
12314       return _("NT_VMS_FPMODE (FP mode)");
12315     case NT_VMS_LINKTIME:
12316       return _("NT_VMS_LINKTIME");
12317     case NT_VMS_IMGNAM:
12318       return _("NT_VMS_IMGNAM (image name)");
12319     case NT_VMS_IMGID:
12320       return _("NT_VMS_IMGID (image id)");
12321     case NT_VMS_LINKID:
12322       return _("NT_VMS_LINKID (link id)");
12323     case NT_VMS_IMGBID:
12324       return _("NT_VMS_IMGBID (build id)");
12325     case NT_VMS_GSTNAM:
12326       return _("NT_VMS_GSTNAM (sym table name)");
12327     case NT_VMS_ORIG_DYN:
12328       return _("NT_VMS_ORIG_DYN");
12329     case NT_VMS_PATCHTIME:
12330       return _("NT_VMS_PATCHTIME");
12331     default:
12332       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12333       return buff;
12334     }
12335 }
12336
12337 static int
12338 print_ia64_vms_note (Elf_Internal_Note * pnote)
12339 {
12340   switch (pnote->type)
12341     {
12342     case NT_VMS_MHD:
12343       if (pnote->descsz > 36)
12344         {
12345           size_t l = strlen (pnote->descdata + 34);
12346           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
12347           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
12348           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
12349           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
12350         }
12351       else
12352         printf (_("    Invalid size\n"));
12353       break;
12354     case NT_VMS_LNM:
12355       printf (_("   Language: %s\n"), pnote->descdata);
12356       break;
12357 #ifdef BFD64
12358     case NT_VMS_FPMODE:
12359       printf (_("   FP mode: 0x%016" BFD_VMA_FMT "x\n"),
12360               (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
12361       break;
12362     case NT_VMS_LINKTIME:
12363       printf (_("   Link time: "));
12364       print_vms_time
12365         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12366       printf ("\n");
12367       break;
12368     case NT_VMS_PATCHTIME:
12369       printf (_("   Patch time: "));
12370       print_vms_time
12371         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12372       printf ("\n");
12373       break;
12374     case NT_VMS_ORIG_DYN:
12375       printf (_("   Major id: %u,  minor id: %u\n"),
12376               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
12377               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
12378       printf (_("   Manip date  : "));
12379       print_vms_time
12380         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
12381       printf (_("\n"
12382                 "   Link flags  : 0x%016" BFD_VMA_FMT "x\n"),
12383               (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
12384       printf (_("   Header flags: 0x%08x\n"),
12385               (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
12386       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
12387       break;
12388 #endif
12389     case NT_VMS_IMGNAM:
12390       printf (_("    Image name: %s\n"), pnote->descdata);
12391       break;
12392     case NT_VMS_GSTNAM:
12393       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
12394       break;
12395     case NT_VMS_IMGID:
12396       printf (_("    Image id: %s\n"), pnote->descdata);
12397       break;
12398     case NT_VMS_LINKID:
12399       printf (_("    Linker id: %s\n"), pnote->descdata);
12400       break;
12401     default:
12402       break;
12403     }
12404   return 1;
12405 }
12406
12407 /* Note that by the ELF standard, the name field is already null byte
12408    terminated, and namesz includes the terminating null byte.
12409    I.E. the value of namesz for the name "FSF" is 4.
12410
12411    If the value of namesz is zero, there is no name present.  */
12412 static int
12413 process_note (Elf_Internal_Note * pnote)
12414 {
12415   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
12416   const char * nt;
12417
12418   if (pnote->namesz == 0)
12419     /* If there is no note name, then use the default set of
12420        note type strings.  */
12421     nt = get_note_type (pnote->type);
12422
12423   else if (const_strneq (pnote->namedata, "GNU"))
12424     /* GNU-specific object file notes.  */
12425     nt = get_gnu_elf_note_type (pnote->type);
12426
12427   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
12428     /* NetBSD-specific core file notes.  */
12429     nt = get_netbsd_elfcore_note_type (pnote->type);
12430
12431   else if (strneq (pnote->namedata, "SPU/", 4))
12432     {
12433       /* SPU-specific core file notes.  */
12434       nt = pnote->namedata + 4;
12435       name = "SPU";
12436     }
12437
12438   else if (const_strneq (pnote->namedata, "IPF/VMS"))
12439     /* VMS/ia64-specific file notes.  */
12440     nt = get_ia64_vms_note_type (pnote->type);
12441
12442   else
12443     /* Don't recognize this note name; just use the default set of
12444        note type strings.  */
12445     nt = get_note_type (pnote->type);
12446
12447   printf ("  %-10s\t0x%08lx\t%s\n", name, pnote->descsz, nt);
12448
12449   if (const_strneq (pnote->namedata, "IPF/VMS"))
12450     return print_ia64_vms_note (pnote);
12451   else
12452     return 1;
12453 }
12454
12455
12456 static int
12457 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
12458 {
12459   Elf_External_Note * pnotes;
12460   Elf_External_Note * external;
12461   int res = 1;
12462
12463   if (length <= 0)
12464     return 0;
12465
12466   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
12467                                            _("notes"));
12468   if (pnotes == NULL)
12469     return 0;
12470
12471   external = pnotes;
12472
12473   printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
12474           (unsigned long) offset, (unsigned long) length);
12475   printf (_("  Owner\t\tData size\tDescription\n"));
12476
12477   while (external < (Elf_External_Note *) ((char *) pnotes + length))
12478     {
12479       Elf_External_Note * next;
12480       Elf_Internal_Note inote;
12481       char * temp = NULL;
12482
12483       if (!is_ia64_vms ())
12484         {
12485           inote.type     = BYTE_GET (external->type);
12486           inote.namesz   = BYTE_GET (external->namesz);
12487           inote.namedata = external->name;
12488           inote.descsz   = BYTE_GET (external->descsz);
12489           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
12490           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
12491
12492           next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
12493         }
12494       else
12495         {
12496           Elf64_External_VMS_Note *vms_external;
12497
12498           vms_external = (Elf64_External_VMS_Note *)external;
12499           inote.type     = BYTE_GET (vms_external->type);
12500           inote.namesz   = BYTE_GET (vms_external->namesz);
12501           inote.namedata = vms_external->name;
12502           inote.descsz   = BYTE_GET (vms_external->descsz);
12503           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
12504           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
12505
12506           next = (Elf_External_Note *)
12507             (inote.descdata + align_power (inote.descsz, 3));
12508         }
12509
12510       if (   ((char *) next > ((char *) pnotes) + length)
12511           || ((char *) next <  (char *) pnotes))
12512         {
12513           warn (_("corrupt note found at offset %lx into core notes\n"),
12514                 (unsigned long) ((char *) external - (char *) pnotes));
12515           warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12516                 inote.type, inote.namesz, inote.descsz);
12517           break;
12518         }
12519
12520       external = next;
12521
12522       /* Prevent out-of-bounds indexing.  */
12523       if (inote.namedata + inote.namesz >= (char *) pnotes + length
12524           || inote.namedata + inote.namesz < inote.namedata)
12525         {
12526           warn (_("corrupt note found at offset %lx into core notes\n"),
12527                 (unsigned long) ((char *) external - (char *) pnotes));
12528           warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12529                 inote.type, inote.namesz, inote.descsz);
12530           break;
12531         }
12532
12533       /* Verify that name is null terminated.  It appears that at least
12534          one version of Linux (RedHat 6.0) generates corefiles that don't
12535          comply with the ELF spec by failing to include the null byte in
12536          namesz.  */
12537       if (inote.namedata[inote.namesz] != '\0')
12538         {
12539           temp = (char *) malloc (inote.namesz + 1);
12540
12541           if (temp == NULL)
12542             {
12543               error (_("Out of memory\n"));
12544               res = 0;
12545               break;
12546             }
12547
12548           strncpy (temp, inote.namedata, inote.namesz);
12549           temp[inote.namesz] = 0;
12550
12551           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
12552           inote.namedata = temp;
12553         }
12554
12555       res &= process_note (& inote);
12556
12557       if (temp != NULL)
12558         {
12559           free (temp);
12560           temp = NULL;
12561         }
12562     }
12563
12564   free (pnotes);
12565
12566   return res;
12567 }
12568
12569 static int
12570 process_corefile_note_segments (FILE * file)
12571 {
12572   Elf_Internal_Phdr * segment;
12573   unsigned int i;
12574   int res = 1;
12575
12576   if (! get_program_headers (file))
12577       return 0;
12578
12579   for (i = 0, segment = program_headers;
12580        i < elf_header.e_phnum;
12581        i++, segment++)
12582     {
12583       if (segment->p_type == PT_NOTE)
12584         res &= process_corefile_note_segment (file,
12585                                               (bfd_vma) segment->p_offset,
12586                                               (bfd_vma) segment->p_filesz);
12587     }
12588
12589   return res;
12590 }
12591
12592 static int
12593 process_note_sections (FILE * file)
12594 {
12595   Elf_Internal_Shdr * section;
12596   unsigned long i;
12597   int res = 1;
12598
12599   for (i = 0, section = section_headers;
12600        i < elf_header.e_shnum;
12601        i++, section++)
12602     if (section->sh_type == SHT_NOTE)
12603       res &= process_corefile_note_segment (file,
12604                                             (bfd_vma) section->sh_offset,
12605                                             (bfd_vma) section->sh_size);
12606
12607   return res;
12608 }
12609
12610 static int
12611 process_notes (FILE * file)
12612 {
12613   /* If we have not been asked to display the notes then do nothing.  */
12614   if (! do_notes)
12615     return 1;
12616
12617   if (elf_header.e_type != ET_CORE)
12618     return process_note_sections (file);
12619
12620   /* No program headers means no NOTE segment.  */
12621   if (elf_header.e_phnum > 0)
12622     return process_corefile_note_segments (file);
12623
12624   printf (_("No note segments present in the core file.\n"));
12625   return 1;
12626 }
12627
12628 static int
12629 process_arch_specific (FILE * file)
12630 {
12631   if (! do_arch)
12632     return 1;
12633
12634   switch (elf_header.e_machine)
12635     {
12636     case EM_ARM:
12637       return process_arm_specific (file);
12638     case EM_MIPS:
12639     case EM_MIPS_RS3_LE:
12640       return process_mips_specific (file);
12641       break;
12642     case EM_PPC:
12643       return process_power_specific (file);
12644       break;
12645     case EM_TI_C6000:
12646       return process_tic6x_specific (file);
12647       break;
12648     default:
12649       break;
12650     }
12651   return 1;
12652 }
12653
12654 static int
12655 get_file_header (FILE * file)
12656 {
12657   /* Read in the identity array.  */
12658   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
12659     return 0;
12660
12661   /* Determine how to read the rest of the header.  */
12662   switch (elf_header.e_ident[EI_DATA])
12663     {
12664     default: /* fall through */
12665     case ELFDATANONE: /* fall through */
12666     case ELFDATA2LSB:
12667       byte_get = byte_get_little_endian;
12668       byte_put = byte_put_little_endian;
12669       break;
12670     case ELFDATA2MSB:
12671       byte_get = byte_get_big_endian;
12672       byte_put = byte_put_big_endian;
12673       break;
12674     }
12675
12676   /* For now we only support 32 bit and 64 bit ELF files.  */
12677   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
12678
12679   /* Read in the rest of the header.  */
12680   if (is_32bit_elf)
12681     {
12682       Elf32_External_Ehdr ehdr32;
12683
12684       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
12685         return 0;
12686
12687       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
12688       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
12689       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
12690       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
12691       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
12692       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
12693       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
12694       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
12695       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
12696       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
12697       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
12698       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
12699       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
12700     }
12701   else
12702     {
12703       Elf64_External_Ehdr ehdr64;
12704
12705       /* If we have been compiled with sizeof (bfd_vma) == 4, then
12706          we will not be able to cope with the 64bit data found in
12707          64 ELF files.  Detect this now and abort before we start
12708          overwriting things.  */
12709       if (sizeof (bfd_vma) < 8)
12710         {
12711           error (_("This instance of readelf has been built without support for a\n\
12712 64 bit data type and so it cannot read 64 bit ELF files.\n"));
12713           return 0;
12714         }
12715
12716       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
12717         return 0;
12718
12719       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
12720       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
12721       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
12722       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
12723       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
12724       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
12725       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
12726       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
12727       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
12728       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
12729       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
12730       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
12731       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
12732     }
12733
12734   if (elf_header.e_shoff)
12735     {
12736       /* There may be some extensions in the first section header.  Don't
12737          bomb if we can't read it.  */
12738       if (is_32bit_elf)
12739         get_32bit_section_headers (file, 1);
12740       else
12741         get_64bit_section_headers (file, 1);
12742     }
12743
12744   return 1;
12745 }
12746
12747 /* Process one ELF object file according to the command line options.
12748    This file may actually be stored in an archive.  The file is
12749    positioned at the start of the ELF object.  */
12750
12751 static int
12752 process_object (char * file_name, FILE * file)
12753 {
12754   unsigned int i;
12755
12756   if (! get_file_header (file))
12757     {
12758       error (_("%s: Failed to read file header\n"), file_name);
12759       return 1;
12760     }
12761
12762   /* Initialise per file variables.  */
12763   for (i = ARRAY_SIZE (version_info); i--;)
12764     version_info[i] = 0;
12765
12766   for (i = ARRAY_SIZE (dynamic_info); i--;)
12767     dynamic_info[i] = 0;
12768   dynamic_info_DT_GNU_HASH = 0;
12769
12770   /* Process the file.  */
12771   if (show_name)
12772     printf (_("\nFile: %s\n"), file_name);
12773
12774   /* Initialise the dump_sects array from the cmdline_dump_sects array.
12775      Note we do this even if cmdline_dump_sects is empty because we
12776      must make sure that the dump_sets array is zeroed out before each
12777      object file is processed.  */
12778   if (num_dump_sects > num_cmdline_dump_sects)
12779     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
12780
12781   if (num_cmdline_dump_sects > 0)
12782     {
12783       if (num_dump_sects == 0)
12784         /* A sneaky way of allocating the dump_sects array.  */
12785         request_dump_bynumber (num_cmdline_dump_sects, 0);
12786
12787       assert (num_dump_sects >= num_cmdline_dump_sects);
12788       memcpy (dump_sects, cmdline_dump_sects,
12789               num_cmdline_dump_sects * sizeof (* dump_sects));
12790     }
12791
12792   if (! process_file_header ())
12793     return 1;
12794
12795   if (! process_section_headers (file))
12796     {
12797       /* Without loaded section headers we cannot process lots of
12798          things.  */
12799       do_unwind = do_version = do_dump = do_arch = 0;
12800
12801       if (! do_using_dynamic)
12802         do_syms = do_dyn_syms = do_reloc = 0;
12803     }
12804
12805   if (! process_section_groups (file))
12806     {
12807       /* Without loaded section groups we cannot process unwind.  */
12808       do_unwind = 0;
12809     }
12810
12811   if (process_program_headers (file))
12812     process_dynamic_section (file);
12813
12814   process_relocs (file);
12815
12816   process_unwind (file);
12817
12818   process_symbol_table (file);
12819
12820   process_syminfo (file);
12821
12822   process_version_sections (file);
12823
12824   process_section_contents (file);
12825
12826   process_notes (file);
12827
12828   process_gnu_liblist (file);
12829
12830   process_arch_specific (file);
12831
12832   if (program_headers)
12833     {
12834       free (program_headers);
12835       program_headers = NULL;
12836     }
12837
12838   if (section_headers)
12839     {
12840       free (section_headers);
12841       section_headers = NULL;
12842     }
12843
12844   if (string_table)
12845     {
12846       free (string_table);
12847       string_table = NULL;
12848       string_table_length = 0;
12849     }
12850
12851   if (dynamic_strings)
12852     {
12853       free (dynamic_strings);
12854       dynamic_strings = NULL;
12855       dynamic_strings_length = 0;
12856     }
12857
12858   if (dynamic_symbols)
12859     {
12860       free (dynamic_symbols);
12861       dynamic_symbols = NULL;
12862       num_dynamic_syms = 0;
12863     }
12864
12865   if (dynamic_syminfo)
12866     {
12867       free (dynamic_syminfo);
12868       dynamic_syminfo = NULL;
12869     }
12870
12871   if (dynamic_section)
12872     {
12873       free (dynamic_section);
12874       dynamic_section = NULL;
12875     }
12876
12877   if (section_headers_groups)
12878     {
12879       free (section_headers_groups);
12880       section_headers_groups = NULL;
12881     }
12882
12883   if (section_groups)
12884     {
12885       struct group_list * g;
12886       struct group_list * next;
12887
12888       for (i = 0; i < group_count; i++)
12889         {
12890           for (g = section_groups [i].root; g != NULL; g = next)
12891             {
12892               next = g->next;
12893               free (g);
12894             }
12895         }
12896
12897       free (section_groups);
12898       section_groups = NULL;
12899     }
12900
12901   free_debug_memory ();
12902
12903   return 0;
12904 }
12905
12906 /* Process an ELF archive.
12907    On entry the file is positioned just after the ARMAG string.  */
12908
12909 static int
12910 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
12911 {
12912   struct archive_info arch;
12913   struct archive_info nested_arch;
12914   size_t got;
12915   int ret;
12916
12917   show_name = 1;
12918
12919   /* The ARCH structure is used to hold information about this archive.  */
12920   arch.file_name = NULL;
12921   arch.file = NULL;
12922   arch.index_array = NULL;
12923   arch.sym_table = NULL;
12924   arch.longnames = NULL;
12925
12926   /* The NESTED_ARCH structure is used as a single-item cache of information
12927      about a nested archive (when members of a thin archive reside within
12928      another regular archive file).  */
12929   nested_arch.file_name = NULL;
12930   nested_arch.file = NULL;
12931   nested_arch.index_array = NULL;
12932   nested_arch.sym_table = NULL;
12933   nested_arch.longnames = NULL;
12934
12935   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
12936     {
12937       ret = 1;
12938       goto out;
12939     }
12940
12941   if (do_archive_index)
12942     {
12943       if (arch.sym_table == NULL)
12944         error (_("%s: unable to dump the index as none was found\n"), file_name);
12945       else
12946         {
12947           unsigned int i, l;
12948           unsigned long current_pos;
12949
12950           printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
12951                   file_name, arch.index_num, arch.sym_size);
12952           current_pos = ftell (file);
12953
12954           for (i = l = 0; i < arch.index_num; i++)
12955             {
12956               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
12957                 {
12958                   char * member_name;
12959
12960                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
12961
12962                   if (member_name != NULL)
12963                     {
12964                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
12965
12966                       if (qualified_name != NULL)
12967                         {
12968                           printf (_("Binary %s contains:\n"), qualified_name);
12969                           free (qualified_name);
12970                         }
12971                     }
12972                 }
12973
12974               if (l >= arch.sym_size)
12975                 {
12976                   error (_("%s: end of the symbol table reached before the end of the index\n"),
12977                          file_name);
12978                   break;
12979                 }
12980               printf ("\t%s\n", arch.sym_table + l);
12981               l += strlen (arch.sym_table + l) + 1;
12982             }
12983
12984           if (l & 01)
12985             ++l;
12986           if (l < arch.sym_size)
12987             error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
12988                    file_name);
12989
12990           if (fseek (file, current_pos, SEEK_SET) != 0)
12991             {
12992               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
12993               ret = 1;
12994               goto out;
12995             }
12996         }
12997
12998       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
12999           && !do_segments && !do_header && !do_dump && !do_version
13000           && !do_histogram && !do_debugging && !do_arch && !do_notes
13001           && !do_section_groups && !do_dyn_syms)
13002         {
13003           ret = 0; /* Archive index only.  */
13004           goto out;
13005         }
13006     }
13007
13008   ret = 0;
13009
13010   while (1)
13011     {
13012       char * name;
13013       size_t namelen;
13014       char * qualified_name;
13015
13016       /* Read the next archive header.  */
13017       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13018         {
13019           error (_("%s: failed to seek to next archive header\n"), file_name);
13020           return 1;
13021         }
13022       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13023       if (got != sizeof arch.arhdr)
13024         {
13025           if (got == 0)
13026             break;
13027           error (_("%s: failed to read archive header\n"), file_name);
13028           ret = 1;
13029           break;
13030         }
13031       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13032         {
13033           error (_("%s: did not find a valid archive header\n"), arch.file_name);
13034           ret = 1;
13035           break;
13036         }
13037
13038       arch.next_arhdr_offset += sizeof arch.arhdr;
13039
13040       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13041       if (archive_file_size & 01)
13042         ++archive_file_size;
13043
13044       name = get_archive_member_name (&arch, &nested_arch);
13045       if (name == NULL)
13046         {
13047           error (_("%s: bad archive file name\n"), file_name);
13048           ret = 1;
13049           break;
13050         }
13051       namelen = strlen (name);
13052
13053       qualified_name = make_qualified_name (&arch, &nested_arch, name);
13054       if (qualified_name == NULL)
13055         {
13056           error (_("%s: bad archive file name\n"), file_name);
13057           ret = 1;
13058           break;
13059         }
13060
13061       if (is_thin_archive && arch.nested_member_origin == 0)
13062         {
13063           /* This is a proxy for an external member of a thin archive.  */
13064           FILE * member_file;
13065           char * member_file_name = adjust_relative_path (file_name, name, namelen);
13066           if (member_file_name == NULL)
13067             {
13068               ret = 1;
13069               break;
13070             }
13071
13072           member_file = fopen (member_file_name, "rb");
13073           if (member_file == NULL)
13074             {
13075               error (_("Input file '%s' is not readable.\n"), member_file_name);
13076               free (member_file_name);
13077               ret = 1;
13078               break;
13079             }
13080
13081           archive_file_offset = arch.nested_member_origin;
13082
13083           ret |= process_object (qualified_name, member_file);
13084
13085           fclose (member_file);
13086           free (member_file_name);
13087         }
13088       else if (is_thin_archive)
13089         {
13090           /* This is a proxy for a member of a nested archive.  */
13091           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
13092
13093           /* The nested archive file will have been opened and setup by
13094              get_archive_member_name.  */
13095           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
13096             {
13097               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
13098               ret = 1;
13099               break;
13100             }
13101
13102           ret |= process_object (qualified_name, nested_arch.file);
13103         }
13104       else
13105         {
13106           archive_file_offset = arch.next_arhdr_offset;
13107           arch.next_arhdr_offset += archive_file_size;
13108
13109           ret |= process_object (qualified_name, file);
13110         }
13111
13112       if (dump_sects != NULL)
13113         {
13114           free (dump_sects);
13115           dump_sects = NULL;
13116           num_dump_sects = 0;
13117         }
13118
13119       free (qualified_name);
13120     }
13121
13122  out:
13123   if (nested_arch.file != NULL)
13124     fclose (nested_arch.file);
13125   release_archive (&nested_arch);
13126   release_archive (&arch);
13127
13128   return ret;
13129 }
13130
13131 static int
13132 process_file (char * file_name)
13133 {
13134   FILE * file;
13135   struct stat statbuf;
13136   char armag[SARMAG];
13137   int ret;
13138
13139   if (stat (file_name, &statbuf) < 0)
13140     {
13141       if (errno == ENOENT)
13142         error (_("'%s': No such file\n"), file_name);
13143       else
13144         error (_("Could not locate '%s'.  System error message: %s\n"),
13145                file_name, strerror (errno));
13146       return 1;
13147     }
13148
13149   if (! S_ISREG (statbuf.st_mode))
13150     {
13151       error (_("'%s' is not an ordinary file\n"), file_name);
13152       return 1;
13153     }
13154
13155   file = fopen (file_name, "rb");
13156   if (file == NULL)
13157     {
13158       error (_("Input file '%s' is not readable.\n"), file_name);
13159       return 1;
13160     }
13161
13162   if (fread (armag, SARMAG, 1, file) != 1)
13163     {
13164       error (_("%s: Failed to read file's magic number\n"), file_name);
13165       fclose (file);
13166       return 1;
13167     }
13168
13169   if (memcmp (armag, ARMAG, SARMAG) == 0)
13170     ret = process_archive (file_name, file, FALSE);
13171   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
13172     ret = process_archive (file_name, file, TRUE);
13173   else
13174     {
13175       if (do_archive_index)
13176         error (_("File %s is not an archive so its index cannot be displayed.\n"),
13177                file_name);
13178
13179       rewind (file);
13180       archive_file_size = archive_file_offset = 0;
13181       ret = process_object (file_name, file);
13182     }
13183
13184   fclose (file);
13185
13186   return ret;
13187 }
13188
13189 #ifdef SUPPORT_DISASSEMBLY
13190 /* Needed by the i386 disassembler.  For extra credit, someone could
13191    fix this so that we insert symbolic addresses here, esp for GOT/PLT
13192    symbols.  */
13193
13194 void
13195 print_address (unsigned int addr, FILE * outfile)
13196 {
13197   fprintf (outfile,"0x%8.8x", addr);
13198 }
13199
13200 /* Needed by the i386 disassembler.  */
13201 void
13202 db_task_printsym (unsigned int addr)
13203 {
13204   print_address (addr, stderr);
13205 }
13206 #endif
13207
13208 int
13209 main (int argc, char ** argv)
13210 {
13211   int err;
13212
13213 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
13214   setlocale (LC_MESSAGES, "");
13215 #endif
13216 #if defined (HAVE_SETLOCALE)
13217   setlocale (LC_CTYPE, "");
13218 #endif
13219   bindtextdomain (PACKAGE, LOCALEDIR);
13220   textdomain (PACKAGE);
13221
13222   expandargv (&argc, &argv);
13223
13224   parse_args (argc, argv);
13225
13226   if (num_dump_sects > 0)
13227     {
13228       /* Make a copy of the dump_sects array.  */
13229       cmdline_dump_sects = (dump_type *)
13230           malloc (num_dump_sects * sizeof (* dump_sects));
13231       if (cmdline_dump_sects == NULL)
13232         error (_("Out of memory allocating dump request table.\n"));
13233       else
13234         {
13235           memcpy (cmdline_dump_sects, dump_sects,
13236                   num_dump_sects * sizeof (* dump_sects));
13237           num_cmdline_dump_sects = num_dump_sects;
13238         }
13239     }
13240
13241   if (optind < (argc - 1))
13242     show_name = 1;
13243
13244   err = 0;
13245   while (optind < argc)
13246     err |= process_file (argv[optind++]);
13247
13248   if (dump_sects != NULL)
13249     free (dump_sects);
13250   if (cmdline_dump_sects != NULL)
13251     free (cmdline_dump_sects);
13252
13253   return err;
13254 }