binutils/readelf.c

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