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