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