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