binutils/readelf.c

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