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               {
8057                 free (symbols);
8058                 break;
8059               }
8060
8061             printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8062                     SECTION_NAME (section), total);
8063
8064             printf (_(" Addr: "));
8065             printf_vma (section->sh_addr);
8066             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8067                     (unsigned long) section->sh_offset, section->sh_link,
8068                     SECTION_NAME (link_section));
8069
8070             off = offset_from_vma (file,
8071                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8072                                    total * sizeof (short));
8073             edata = (unsigned char *) get_data (NULL, file, off, total,
8074                                                 sizeof (short),
8075                                                 _("version symbol data"));
8076             if (!edata)
8077               {
8078                 free (strtab);
8079                 free (symbols);
8080                 break;
8081               }
8082
8083             data = (short unsigned int *) cmalloc (total, sizeof (short));
8084
8085             for (cnt = total; cnt --;)
8086               data[cnt] = byte_get (edata + cnt * sizeof (short),
8087                                     sizeof (short));
8088
8089             free (edata);
8090
8091             for (cnt = 0; cnt < total; cnt += 4)
8092               {
8093                 int j, nn;
8094                 int check_def, check_need;
8095                 char * name;
8096
8097                 printf ("  %03x:", cnt);
8098
8099                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
8100                   switch (data[cnt + j])
8101                     {
8102                     case 0:
8103                       fputs (_("   0 (*local*)    "), stdout);
8104                       break;
8105
8106                     case 1:
8107                       fputs (_("   1 (*global*)   "), stdout);
8108                       break;
8109
8110                     default:
8111                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8112                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
8113
8114                       /* If this index value is greater than the size of the symbols
8115                          array, break to avoid an out-of-bounds read,  */
8116                       if ((unsigned long)(cnt + j) >=
8117                          ((unsigned long)link_section->sh_size /
8118                           (unsigned long)link_section->sh_entsize))
8119                         {
8120                           warn (_("invalid index into symbol array\n"));
8121                           break;
8122                         }
8123
8124                       check_def = 1;
8125                       check_need = 1;
8126                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8127                           || section_headers[symbols[cnt + j].st_shndx].sh_type
8128                              != SHT_NOBITS)
8129                         {
8130                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
8131                             check_def = 0;
8132                           else
8133                             check_need = 0;
8134                         }
8135
8136                       if (check_need
8137                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
8138                         {
8139                           Elf_Internal_Verneed ivn;
8140                           unsigned long offset;
8141
8142                           offset = offset_from_vma
8143                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8144                              sizeof (Elf_External_Verneed));
8145
8146                           do
8147                             {
8148                               Elf_Internal_Vernaux ivna;
8149                               Elf_External_Verneed evn;
8150                               Elf_External_Vernaux evna;
8151                               unsigned long a_off;
8152
8153                               get_data (&evn, file, offset, sizeof (evn), 1,
8154                                         _("version need"));
8155
8156                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
8157                               ivn.vn_next = BYTE_GET (evn.vn_next);
8158
8159                               a_off = offset + ivn.vn_aux;
8160
8161                               do
8162                                 {
8163                                   get_data (&evna, file, a_off, sizeof (evna),
8164                                             1, _("version need aux (2)"));
8165
8166                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
8167                                   ivna.vna_other = BYTE_GET (evna.vna_other);
8168
8169                                   a_off += ivna.vna_next;
8170                                 }
8171                               while (ivna.vna_other != data[cnt + j]
8172                                      && ivna.vna_next != 0);
8173
8174                               if (ivna.vna_other == data[cnt + j])
8175                                 {
8176                                   ivna.vna_name = BYTE_GET (evna.vna_name);
8177
8178                                   if (ivna.vna_name >= string_sec->sh_size)
8179                                     name = _("*invalid*");
8180                                   else
8181                                     name = strtab + ivna.vna_name;
8182                                   nn += printf ("(%s%-*s",
8183                                                 name,
8184                                                 12 - (int) strlen (name),
8185                                                 ")");
8186                                   check_def = 0;
8187                                   break;
8188                                 }
8189
8190                               offset += ivn.vn_next;
8191                             }
8192                           while (ivn.vn_next);
8193                         }
8194
8195                       if (check_def && data[cnt + j] != 0x8001
8196                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8197                         {
8198                           Elf_Internal_Verdef ivd;
8199                           Elf_External_Verdef evd;
8200                           unsigned long offset;
8201
8202                           offset = offset_from_vma
8203                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8204                              sizeof evd);
8205
8206                           do
8207                             {
8208                               get_data (&evd, file, offset, sizeof (evd), 1,
8209                                         _("version def"));
8210
8211                               ivd.vd_next = BYTE_GET (evd.vd_next);
8212                               ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
8213
8214                               offset += ivd.vd_next;
8215                             }
8216                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
8217                                  && ivd.vd_next != 0);
8218
8219                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
8220                             {
8221                               Elf_External_Verdaux evda;
8222                               Elf_Internal_Verdaux ivda;
8223
8224                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
8225
8226                               get_data (&evda, file,
8227                                         offset - ivd.vd_next + ivd.vd_aux,
8228                                         sizeof (evda), 1,
8229                                         _("version def aux"));
8230
8231                               ivda.vda_name = BYTE_GET (evda.vda_name);
8232
8233                               if (ivda.vda_name >= string_sec->sh_size)
8234                                 name = _("*invalid*");
8235                               else
8236                                 name = strtab + ivda.vda_name;
8237                               nn += printf ("(%s%-*s",
8238                                             name,
8239                                             12 - (int) strlen (name),
8240                                             ")");
8241                             }
8242                         }
8243
8244                       if (nn < 18)
8245                         printf ("%*c", 18 - nn, ' ');
8246                     }
8247
8248                 putchar ('\n');
8249               }
8250
8251             free (data);
8252             free (strtab);
8253             free (symbols);
8254           }
8255           break;
8256
8257         default:
8258           break;
8259         }
8260     }
8261
8262   if (! found)
8263     printf (_("\nNo version information found in this file.\n"));
8264
8265   return 1;
8266 }
8267
8268 static const char *
8269 get_symbol_binding (unsigned int binding)
8270 {
8271   static char buff[32];
8272
8273   switch (binding)
8274     {
8275     case STB_LOCAL:     return "LOCAL";
8276     case STB_GLOBAL:    return "GLOBAL";
8277     case STB_WEAK:      return "WEAK";
8278     default:
8279       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
8280         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8281                   binding);
8282       else if (binding >= STB_LOOS && binding <= STB_HIOS)
8283         {
8284           if (binding == STB_GNU_UNIQUE
8285               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8286                   /* GNU/Linux is still using the default value 0.  */
8287                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8288             return "UNIQUE";
8289           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8290         }
8291       else
8292         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
8293       return buff;
8294     }
8295 }
8296
8297 static const char *
8298 get_symbol_type (unsigned int type)
8299 {
8300   static char buff[32];
8301
8302   switch (type)
8303     {
8304     case STT_NOTYPE:    return "NOTYPE";
8305     case STT_OBJECT:    return "OBJECT";
8306     case STT_FUNC:      return "FUNC";
8307     case STT_SECTION:   return "SECTION";
8308     case STT_FILE:      return "FILE";
8309     case STT_COMMON:    return "COMMON";
8310     case STT_TLS:       return "TLS";
8311     case STT_RELC:      return "RELC";
8312     case STT_SRELC:     return "SRELC";
8313     default:
8314       if (type >= STT_LOPROC && type <= STT_HIPROC)
8315         {
8316           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
8317             return "THUMB_FUNC";
8318
8319           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
8320             return "REGISTER";
8321
8322           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8323             return "PARISC_MILLI";
8324
8325           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
8326         }
8327       else if (type >= STT_LOOS && type <= STT_HIOS)
8328         {
8329           if (elf_header.e_machine == EM_PARISC)
8330             {
8331               if (type == STT_HP_OPAQUE)
8332                 return "HP_OPAQUE";
8333               if (type == STT_HP_STUB)
8334                 return "HP_STUB";
8335             }
8336
8337           if (type == STT_GNU_IFUNC
8338               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8339                   /* GNU/Linux is still using the default value 0.  */
8340                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8341             return "IFUNC";
8342
8343           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
8344         }
8345       else
8346         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
8347       return buff;
8348     }
8349 }
8350
8351 static const char *
8352 get_symbol_visibility (unsigned int visibility)
8353 {
8354   switch (visibility)
8355     {
8356     case STV_DEFAULT:   return "DEFAULT";
8357     case STV_INTERNAL:  return "INTERNAL";
8358     case STV_HIDDEN:    return "HIDDEN";
8359     case STV_PROTECTED: return "PROTECTED";
8360     default: abort ();
8361     }
8362 }
8363
8364 static const char *
8365 get_mips_symbol_other (unsigned int other)
8366 {
8367   switch (other)
8368     {
8369     case STO_OPTIONAL:  return "OPTIONAL";
8370     case STO_MIPS16:    return "MIPS16";
8371     case STO_MIPS_PLT:  return "MIPS PLT";
8372     case STO_MIPS_PIC:  return "MIPS PIC";
8373     default:            return NULL;
8374     }
8375 }
8376
8377 static const char *
8378 get_ia64_symbol_other (unsigned int other)
8379 {
8380   if (is_ia64_vms ())
8381     {
8382       static char res[32];
8383
8384       res[0] = 0;
8385
8386       /* Function types is for images and .STB files only.  */
8387       switch (elf_header.e_type)
8388         {
8389         case ET_DYN:
8390         case ET_EXEC:
8391           switch (VMS_ST_FUNC_TYPE (other))
8392             {
8393             case VMS_SFT_CODE_ADDR:
8394               strcat (res, " CA");
8395               break;
8396             case VMS_SFT_SYMV_IDX:
8397               strcat (res, " VEC");
8398               break;
8399             case VMS_SFT_FD:
8400               strcat (res, " FD");
8401               break;
8402             case VMS_SFT_RESERVE:
8403               strcat (res, " RSV");
8404               break;
8405             default:
8406               abort ();
8407             }
8408           break;
8409         default:
8410           break;
8411         }
8412       switch (VMS_ST_LINKAGE (other))
8413         {
8414         case VMS_STL_IGNORE:
8415           strcat (res, " IGN");
8416           break;
8417         case VMS_STL_RESERVE:
8418           strcat (res, " RSV");
8419           break;
8420         case VMS_STL_STD:
8421           strcat (res, " STD");
8422           break;
8423         case VMS_STL_LNK:
8424           strcat (res, " LNK");
8425           break;
8426         default:
8427           abort ();
8428         }
8429
8430       if (res[0] != 0)
8431         return res + 1;
8432       else
8433         return res;
8434     }
8435   return NULL;
8436 }
8437
8438 static const char *
8439 get_symbol_other (unsigned int other)
8440 {
8441   const char * result = NULL;
8442   static char buff [32];
8443
8444   if (other == 0)
8445     return "";
8446
8447   switch (elf_header.e_machine)
8448     {
8449     case EM_MIPS:
8450       result = get_mips_symbol_other (other);
8451       break;
8452     case EM_IA_64:
8453       result = get_ia64_symbol_other (other);
8454       break;
8455     default:
8456       break;
8457     }
8458
8459   if (result)
8460     return result;
8461
8462   snprintf (buff, sizeof buff, _("<other>: %x"), other);
8463   return buff;
8464 }
8465
8466 static const char *
8467 get_symbol_index_type (unsigned int type)
8468 {
8469   static char buff[32];
8470
8471   switch (type)
8472     {
8473     case SHN_UNDEF:     return "UND";
8474     case SHN_ABS:       return "ABS";
8475     case SHN_COMMON:    return "COM";
8476     default:
8477       if (type == SHN_IA_64_ANSI_COMMON
8478           && elf_header.e_machine == EM_IA_64
8479           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
8480         return "ANSI_COM";
8481       else if ((elf_header.e_machine == EM_X86_64
8482                 || elf_header.e_machine == EM_L1OM)
8483                && type == SHN_X86_64_LCOMMON)
8484         return "LARGE_COM";
8485       else if (type == SHN_MIPS_SCOMMON
8486                && elf_header.e_machine == EM_MIPS)
8487         return "SCOM";
8488       else if (type == SHN_MIPS_SUNDEFINED
8489                && elf_header.e_machine == EM_MIPS)
8490         return "SUND";
8491       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
8492         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
8493       else if (type >= SHN_LOOS && type <= SHN_HIOS)
8494         sprintf (buff, "OS [0x%04x]", type & 0xffff);
8495       else if (type >= SHN_LORESERVE)
8496         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
8497       else
8498         sprintf (buff, "%3d", type);
8499       break;
8500     }
8501
8502   return buff;
8503 }
8504
8505 static bfd_vma *
8506 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
8507 {
8508   unsigned char * e_data;
8509   bfd_vma * i_data;
8510
8511   e_data = (unsigned char *) cmalloc (number, ent_size);
8512
8513   if (e_data == NULL)
8514     {
8515       error (_("Out of memory\n"));
8516       return NULL;
8517     }
8518
8519   if (fread (e_data, ent_size, number, file) != number)
8520     {
8521       error (_("Unable to read in dynamic data\n"));
8522       return NULL;
8523     }
8524
8525   i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
8526
8527   if (i_data == NULL)
8528     {
8529       error (_("Out of memory\n"));
8530       free (e_data);
8531       return NULL;
8532     }
8533
8534   while (number--)
8535     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
8536
8537   free (e_data);
8538
8539   return i_data;
8540 }
8541
8542 static void
8543 print_dynamic_symbol (bfd_vma si, unsigned long hn)
8544 {
8545   Elf_Internal_Sym * psym;
8546   int n;
8547
8548   psym = dynamic_symbols + si;
8549
8550   n = print_vma (si, DEC_5);
8551   if (n < 5)
8552     fputs ("     " + n, stdout);
8553   printf (" %3lu: ", hn);
8554   print_vma (psym->st_value, LONG_HEX);
8555   putchar (' ');
8556   print_vma (psym->st_size, DEC_5);
8557
8558   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8559   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8560   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
8561   /* Check to see if any other bits in the st_other field are set.
8562      Note - displaying this information disrupts the layout of the
8563      table being generated, but for the moment this case is very
8564      rare.  */
8565   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8566     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8567   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
8568   if (VALID_DYNAMIC_NAME (psym->st_name))
8569     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
8570   else
8571     printf (_(" <corrupt: %14ld>"), psym->st_name);
8572   putchar ('\n');
8573 }
8574
8575 /* Dump the symbol table.  */
8576 static int
8577 process_symbol_table (FILE * file)
8578 {
8579   Elf_Internal_Shdr * section;
8580   bfd_vma nbuckets = 0;
8581   bfd_vma nchains = 0;
8582   bfd_vma * buckets = NULL;
8583   bfd_vma * chains = NULL;
8584   bfd_vma ngnubuckets = 0;
8585   bfd_vma * gnubuckets = NULL;
8586   bfd_vma * gnuchains = NULL;
8587   bfd_vma gnusymidx = 0;
8588
8589   if (!do_syms && !do_dyn_syms && !do_histogram)
8590     return 1;
8591
8592   if (dynamic_info[DT_HASH]
8593       && (do_histogram
8594           || (do_using_dynamic
8595               && !do_dyn_syms
8596               && dynamic_strings != NULL)))
8597     {
8598       unsigned char nb[8];
8599       unsigned char nc[8];
8600       int hash_ent_size = 4;
8601
8602       if ((elf_header.e_machine == EM_ALPHA
8603            || elf_header.e_machine == EM_S390
8604            || elf_header.e_machine == EM_S390_OLD)
8605           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
8606         hash_ent_size = 8;
8607
8608       if (fseek (file,
8609                  (archive_file_offset
8610                   + offset_from_vma (file, dynamic_info[DT_HASH],
8611                                      sizeof nb + sizeof nc)),
8612                  SEEK_SET))
8613         {
8614           error (_("Unable to seek to start of dynamic information\n"));
8615           goto no_hash;
8616         }
8617
8618       if (fread (nb, hash_ent_size, 1, file) != 1)
8619         {
8620           error (_("Failed to read in number of buckets\n"));
8621           goto no_hash;
8622         }
8623
8624       if (fread (nc, hash_ent_size, 1, file) != 1)
8625         {
8626           error (_("Failed to read in number of chains\n"));
8627           goto no_hash;
8628         }
8629
8630       nbuckets = byte_get (nb, hash_ent_size);
8631       nchains  = byte_get (nc, hash_ent_size);
8632
8633       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
8634       chains  = get_dynamic_data (file, nchains, hash_ent_size);
8635
8636     no_hash:
8637       if (buckets == NULL || chains == NULL)
8638         {
8639           if (do_using_dynamic)
8640             return 0;
8641           free (buckets);
8642           free (chains);
8643           buckets = NULL;
8644           chains = NULL;
8645           nbuckets = 0;
8646           nchains = 0;
8647         }
8648     }
8649
8650   if (dynamic_info_DT_GNU_HASH
8651       && (do_histogram
8652           || (do_using_dynamic
8653               && !do_dyn_syms
8654               && dynamic_strings != NULL)))
8655     {
8656       unsigned char nb[16];
8657       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
8658       bfd_vma buckets_vma;
8659
8660       if (fseek (file,
8661                  (archive_file_offset
8662                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
8663                                      sizeof nb)),
8664                  SEEK_SET))
8665         {
8666           error (_("Unable to seek to start of dynamic information\n"));
8667           goto no_gnu_hash;
8668         }
8669
8670       if (fread (nb, 16, 1, file) != 1)
8671         {
8672           error (_("Failed to read in number of buckets\n"));
8673           goto no_gnu_hash;
8674         }
8675
8676       ngnubuckets = byte_get (nb, 4);
8677       gnusymidx = byte_get (nb + 4, 4);
8678       bitmaskwords = byte_get (nb + 8, 4);
8679       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
8680       if (is_32bit_elf)
8681         buckets_vma += bitmaskwords * 4;
8682       else
8683         buckets_vma += bitmaskwords * 8;
8684
8685       if (fseek (file,
8686                  (archive_file_offset
8687                   + offset_from_vma (file, buckets_vma, 4)),
8688                  SEEK_SET))
8689         {
8690           error (_("Unable to seek to start of dynamic information\n"));
8691           goto no_gnu_hash;
8692         }
8693
8694       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
8695
8696       if (gnubuckets == NULL)
8697         goto no_gnu_hash;
8698
8699       for (i = 0; i < ngnubuckets; i++)
8700         if (gnubuckets[i] != 0)
8701           {
8702             if (gnubuckets[i] < gnusymidx)
8703               return 0;
8704
8705             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
8706               maxchain = gnubuckets[i];
8707           }
8708
8709       if (maxchain == 0xffffffff)
8710         goto no_gnu_hash;
8711
8712       maxchain -= gnusymidx;
8713
8714       if (fseek (file,
8715                  (archive_file_offset
8716                   + offset_from_vma (file, buckets_vma
8717                                            + 4 * (ngnubuckets + maxchain), 4)),
8718                  SEEK_SET))
8719         {
8720           error (_("Unable to seek to start of dynamic information\n"));
8721           goto no_gnu_hash;
8722         }
8723
8724       do
8725         {
8726           if (fread (nb, 4, 1, file) != 1)
8727             {
8728               error (_("Failed to determine last chain length\n"));
8729               goto no_gnu_hash;
8730             }
8731
8732           if (maxchain + 1 == 0)
8733             goto no_gnu_hash;
8734
8735           ++maxchain;
8736         }
8737       while ((byte_get (nb, 4) & 1) == 0);
8738
8739       if (fseek (file,
8740                  (archive_file_offset
8741                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
8742                  SEEK_SET))
8743         {
8744           error (_("Unable to seek to start of dynamic information\n"));
8745           goto no_gnu_hash;
8746         }
8747
8748       gnuchains = get_dynamic_data (file, maxchain, 4);
8749
8750     no_gnu_hash:
8751       if (gnuchains == NULL)
8752         {
8753           free (gnubuckets);
8754           gnubuckets = NULL;
8755           ngnubuckets = 0;
8756           if (do_using_dynamic)
8757             return 0;
8758         }
8759     }
8760
8761   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
8762       && do_syms
8763       && do_using_dynamic
8764       && dynamic_strings != NULL)
8765     {
8766       unsigned long hn;
8767
8768       if (dynamic_info[DT_HASH])
8769         {
8770           bfd_vma si;
8771
8772           printf (_("\nSymbol table for image:\n"));
8773           if (is_32bit_elf)
8774             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
8775           else
8776             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
8777
8778           for (hn = 0; hn < nbuckets; hn++)
8779             {
8780               if (! buckets[hn])
8781                 continue;
8782
8783               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
8784                 print_dynamic_symbol (si, hn);
8785             }
8786         }
8787
8788       if (dynamic_info_DT_GNU_HASH)
8789         {
8790           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
8791           if (is_32bit_elf)
8792             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
8793           else
8794             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
8795
8796           for (hn = 0; hn < ngnubuckets; ++hn)
8797             if (gnubuckets[hn] != 0)
8798               {
8799                 bfd_vma si = gnubuckets[hn];
8800                 bfd_vma off = si - gnusymidx;
8801
8802                 do
8803                   {
8804                     print_dynamic_symbol (si, hn);
8805                     si++;
8806                   }
8807                 while ((gnuchains[off++] & 1) == 0);
8808               }
8809         }
8810     }
8811   else if (do_dyn_syms || (do_syms && !do_using_dynamic))
8812     {
8813       unsigned int i;
8814
8815       for (i = 0, section = section_headers;
8816            i < elf_header.e_shnum;
8817            i++, section++)
8818         {
8819           unsigned int si;
8820           char * strtab = NULL;
8821           unsigned long int strtab_size = 0;
8822           Elf_Internal_Sym * symtab;
8823           Elf_Internal_Sym * psym;
8824
8825           if ((section->sh_type != SHT_SYMTAB
8826                && section->sh_type != SHT_DYNSYM)
8827               || (!do_syms
8828                   && section->sh_type == SHT_SYMTAB))
8829             continue;
8830
8831           if (section->sh_entsize == 0)
8832             {
8833               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
8834                       SECTION_NAME (section));
8835               continue;
8836             }
8837
8838           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
8839                   SECTION_NAME (section),
8840                   (unsigned long) (section->sh_size / section->sh_entsize));
8841
8842           if (is_32bit_elf)
8843             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
8844           else
8845             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
8846
8847           symtab = GET_ELF_SYMBOLS (file, section);
8848           if (symtab == NULL)
8849             continue;
8850
8851           if (section->sh_link == elf_header.e_shstrndx)
8852             {
8853               strtab = string_table;
8854               strtab_size = string_table_length;
8855             }
8856           else if (section->sh_link < elf_header.e_shnum)
8857             {
8858               Elf_Internal_Shdr * string_sec;
8859
8860               string_sec = section_headers + section->sh_link;
8861
8862               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
8863                                           1, string_sec->sh_size,
8864                                           _("string table"));
8865               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
8866             }
8867
8868           for (si = 0, psym = symtab;
8869                si < section->sh_size / section->sh_entsize;
8870                si++, psym++)
8871             {
8872               printf ("%6d: ", si);
8873               print_vma (psym->st_value, LONG_HEX);
8874               putchar (' ');
8875               print_vma (psym->st_size, DEC_5);
8876               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8877               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8878               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
8879               /* Check to see if any other bits in the st_other field are set.
8880                  Note - displaying this information disrupts the layout of the
8881                  table being generated, but for the moment this case is very rare.  */
8882               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8883                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8884               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
8885               print_symbol (25, psym->st_name < strtab_size
8886                             ? strtab + psym->st_name : _("<corrupt>"));
8887
8888               if (section->sh_type == SHT_DYNSYM &&
8889                   version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
8890                 {
8891                   unsigned char data[2];
8892                   unsigned short vers_data;
8893                   unsigned long offset;
8894                   int is_nobits;
8895                   int check_def;
8896
8897                   offset = offset_from_vma
8898                     (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8899                      sizeof data + si * sizeof (vers_data));
8900
8901                   get_data (&data, file, offset + si * sizeof (vers_data),
8902                             sizeof (data), 1, _("version data"));
8903
8904                   vers_data = byte_get (data, 2);
8905
8906                   is_nobits = (psym->st_shndx < elf_header.e_shnum
8907                                && section_headers[psym->st_shndx].sh_type
8908                                   == SHT_NOBITS);
8909
8910                   check_def = (psym->st_shndx != SHN_UNDEF);
8911
8912                   if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
8913                     {
8914                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
8915                           && (is_nobits || ! check_def))
8916                         {
8917                           Elf_External_Verneed evn;
8918                           Elf_Internal_Verneed ivn;
8919                           Elf_Internal_Vernaux ivna;
8920
8921                           /* We must test both.  */
8922                           offset = offset_from_vma
8923                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8924                              sizeof evn);
8925
8926                           do
8927                             {
8928                               unsigned long vna_off;
8929
8930                               get_data (&evn, file, offset, sizeof (evn), 1,
8931                                         _("version need"));
8932
8933                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
8934                               ivn.vn_next = BYTE_GET (evn.vn_next);
8935
8936                               vna_off = offset + ivn.vn_aux;
8937
8938                               do
8939                                 {
8940                                   Elf_External_Vernaux evna;
8941
8942                                   get_data (&evna, file, vna_off,
8943                                             sizeof (evna), 1,
8944                                             _("version need aux (3)"));
8945
8946                                   ivna.vna_other = BYTE_GET (evna.vna_other);
8947                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
8948                                   ivna.vna_name  = BYTE_GET (evna.vna_name);
8949
8950                                   vna_off += ivna.vna_next;
8951                                 }
8952                               while (ivna.vna_other != vers_data
8953                                      && ivna.vna_next != 0);
8954
8955                               if (ivna.vna_other == vers_data)
8956                                 break;
8957
8958                               offset += ivn.vn_next;
8959                             }
8960                           while (ivn.vn_next != 0);
8961
8962                           if (ivna.vna_other == vers_data)
8963                             {
8964                               printf ("@%s (%d)",
8965                                       ivna.vna_name < strtab_size
8966                                       ? strtab + ivna.vna_name : _("<corrupt>"),
8967                                       ivna.vna_other);
8968                               check_def = 0;
8969                             }
8970                           else if (! is_nobits)
8971                             error (_("bad dynamic symbol\n"));
8972                           else
8973                             check_def = 1;
8974                         }
8975
8976                       if (check_def)
8977                         {
8978                           if (vers_data != 0x8001
8979                               && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8980                             {
8981                               Elf_Internal_Verdef ivd;
8982                               Elf_Internal_Verdaux ivda;
8983                               Elf_External_Verdaux evda;
8984                               unsigned long off;
8985
8986                               off = offset_from_vma
8987                                 (file,
8988                                  version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8989                                  sizeof (Elf_External_Verdef));
8990
8991                               do
8992                                 {
8993                                   Elf_External_Verdef evd;
8994
8995                                   get_data (&evd, file, off, sizeof (evd),
8996                                             1, _("version def"));
8997
8998                                   ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8999                                   ivd.vd_aux = BYTE_GET (evd.vd_aux);
9000                                   ivd.vd_next = BYTE_GET (evd.vd_next);
9001
9002                                   off += ivd.vd_next;
9003                                 }
9004                               while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
9005                                      && ivd.vd_next != 0);
9006
9007                               off -= ivd.vd_next;
9008                               off += ivd.vd_aux;
9009
9010                               get_data (&evda, file, off, sizeof (evda),
9011                                         1, _("version def aux"));
9012
9013                               ivda.vda_name = BYTE_GET (evda.vda_name);
9014
9015                               if (psym->st_name != ivda.vda_name)
9016                                 printf ((vers_data & VERSYM_HIDDEN)
9017                                         ? "@%s" : "@@%s",
9018                                         ivda.vda_name < strtab_size
9019                                         ? strtab + ivda.vda_name : _("<corrupt>"));
9020                             }
9021                         }
9022                     }
9023                 }
9024
9025               putchar ('\n');
9026             }
9027
9028           free (symtab);
9029           if (strtab != string_table)
9030             free (strtab);
9031         }
9032     }
9033   else if (do_syms)
9034     printf
9035       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9036
9037   if (do_histogram && buckets != NULL)
9038     {
9039       unsigned long * lengths;
9040       unsigned long * counts;
9041       unsigned long hn;
9042       bfd_vma si;
9043       unsigned long maxlength = 0;
9044       unsigned long nzero_counts = 0;
9045       unsigned long nsyms = 0;
9046
9047       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9048               (unsigned long) nbuckets);
9049       printf (_(" Length  Number     %% of total  Coverage\n"));
9050
9051       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
9052       if (lengths == NULL)
9053         {
9054           error (_("Out of memory\n"));
9055           return 0;
9056         }
9057       for (hn = 0; hn < nbuckets; ++hn)
9058         {
9059           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
9060             {
9061               ++nsyms;
9062               if (maxlength < ++lengths[hn])
9063                 ++maxlength;
9064             }
9065         }
9066
9067       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9068       if (counts == NULL)
9069         {
9070           error (_("Out of memory\n"));
9071           return 0;
9072         }
9073
9074       for (hn = 0; hn < nbuckets; ++hn)
9075         ++counts[lengths[hn]];
9076
9077       if (nbuckets > 0)
9078         {
9079           unsigned long i;
9080           printf ("      0  %-10lu (%5.1f%%)\n",
9081                   counts[0], (counts[0] * 100.0) / nbuckets);
9082           for (i = 1; i <= maxlength; ++i)
9083             {
9084               nzero_counts += counts[i] * i;
9085               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
9086                       i, counts[i], (counts[i] * 100.0) / nbuckets,
9087                       (nzero_counts * 100.0) / nsyms);
9088             }
9089         }
9090
9091       free (counts);
9092       free (lengths);
9093     }
9094
9095   if (buckets != NULL)
9096     {
9097       free (buckets);
9098       free (chains);
9099     }
9100
9101   if (do_histogram && gnubuckets != NULL)
9102     {
9103       unsigned long * lengths;
9104       unsigned long * counts;
9105       unsigned long hn;
9106       unsigned long maxlength = 0;
9107       unsigned long nzero_counts = 0;
9108       unsigned long nsyms = 0;
9109
9110       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
9111       if (lengths == NULL)
9112         {
9113           error (_("Out of memory\n"));
9114           return 0;
9115         }
9116
9117       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9118               (unsigned long) ngnubuckets);
9119       printf (_(" Length  Number     %% of total  Coverage\n"));
9120
9121       for (hn = 0; hn < ngnubuckets; ++hn)
9122         if (gnubuckets[hn] != 0)
9123           {
9124             bfd_vma off, length = 1;
9125
9126             for (off = gnubuckets[hn] - gnusymidx;
9127                  (gnuchains[off] & 1) == 0; ++off)
9128               ++length;
9129             lengths[hn] = length;
9130             if (length > maxlength)
9131               maxlength = length;
9132             nsyms += length;
9133           }
9134
9135       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9136       if (counts == NULL)
9137         {
9138           error (_("Out of memory\n"));
9139           return 0;
9140         }
9141
9142       for (hn = 0; hn < ngnubuckets; ++hn)
9143         ++counts[lengths[hn]];
9144
9145       if (ngnubuckets > 0)
9146         {
9147           unsigned long j;
9148           printf ("      0  %-10lu (%5.1f%%)\n",
9149                   counts[0], (counts[0] * 100.0) / ngnubuckets);
9150           for (j = 1; j <= maxlength; ++j)
9151             {
9152               nzero_counts += counts[j] * j;
9153               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
9154                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9155                       (nzero_counts * 100.0) / nsyms);
9156             }
9157         }
9158
9159       free (counts);
9160       free (lengths);
9161       free (gnubuckets);
9162       free (gnuchains);
9163     }
9164
9165   return 1;
9166 }
9167
9168 static int
9169 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
9170 {
9171   unsigned int i;
9172
9173   if (dynamic_syminfo == NULL
9174       || !do_dynamic)
9175     /* No syminfo, this is ok.  */
9176     return 1;
9177
9178   /* There better should be a dynamic symbol section.  */
9179   if (dynamic_symbols == NULL || dynamic_strings == NULL)
9180     return 0;
9181
9182   if (dynamic_addr)
9183     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9184             dynamic_syminfo_offset, dynamic_syminfo_nent);
9185
9186   printf (_(" Num: Name                           BoundTo     Flags\n"));
9187   for (i = 0; i < dynamic_syminfo_nent; ++i)
9188     {
9189       unsigned short int flags = dynamic_syminfo[i].si_flags;
9190
9191       printf ("%4d: ", i);
9192       if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9193         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9194       else
9195         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
9196       putchar (' ');
9197
9198       switch (dynamic_syminfo[i].si_boundto)
9199         {
9200         case SYMINFO_BT_SELF:
9201           fputs ("SELF       ", stdout);
9202           break;
9203         case SYMINFO_BT_PARENT:
9204           fputs ("PARENT     ", stdout);
9205           break;
9206         default:
9207           if (dynamic_syminfo[i].si_boundto > 0
9208               && dynamic_syminfo[i].si_boundto < dynamic_nent
9209               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
9210             {
9211               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
9212               putchar (' ' );
9213             }
9214           else
9215             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9216           break;
9217         }
9218
9219       if (flags & SYMINFO_FLG_DIRECT)
9220         printf (" DIRECT");
9221       if (flags & SYMINFO_FLG_PASSTHRU)
9222         printf (" PASSTHRU");
9223       if (flags & SYMINFO_FLG_COPY)
9224         printf (" COPY");
9225       if (flags & SYMINFO_FLG_LAZYLOAD)
9226         printf (" LAZYLOAD");
9227
9228       puts ("");
9229     }
9230
9231   return 1;
9232 }
9233
9234 /* Check to see if the given reloc needs to be handled in a target specific
9235    manner.  If so then process the reloc and return TRUE otherwise return
9236    FALSE.  */
9237
9238 static bfd_boolean
9239 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9240                                 unsigned char *     start,
9241                                 Elf_Internal_Sym *  symtab)
9242 {
9243   unsigned int reloc_type = get_reloc_type (reloc->r_info);
9244
9245   switch (elf_header.e_machine)
9246     {
9247     case EM_MN10300:
9248     case EM_CYGNUS_MN10300:
9249       {
9250         static Elf_Internal_Sym * saved_sym = NULL;
9251
9252         switch (reloc_type)
9253           {
9254           case 34: /* R_MN10300_ALIGN */
9255             return TRUE;
9256           case 33: /* R_MN10300_SYM_DIFF */
9257             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9258             return TRUE;
9259           case 1: /* R_MN10300_32 */
9260           case 2: /* R_MN10300_16 */
9261             if (saved_sym != NULL)
9262               {
9263                 bfd_vma value;
9264
9265                 value = reloc->r_addend
9266                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9267                      - saved_sym->st_value);
9268
9269                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
9270
9271                 saved_sym = NULL;
9272                 return TRUE;
9273               }
9274             break;
9275           default:
9276             if (saved_sym != NULL)
9277               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9278             break;
9279           }
9280         break;
9281       }
9282     }
9283
9284   return FALSE;
9285 }
9286
9287 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9288    DWARF debug sections.  This is a target specific test.  Note - we do not
9289    go through the whole including-target-headers-multiple-times route, (as
9290    we have already done with <elf/h8.h>) because this would become very
9291    messy and even then this function would have to contain target specific
9292    information (the names of the relocs instead of their numeric values).
9293    FIXME: This is not the correct way to solve this problem.  The proper way
9294    is to have target specific reloc sizing and typing functions created by
9295    the reloc-macros.h header, in the same way that it already creates the
9296    reloc naming functions.  */
9297
9298 static bfd_boolean
9299 is_32bit_abs_reloc (unsigned int reloc_type)
9300 {
9301   switch (elf_header.e_machine)
9302     {
9303     case EM_386:
9304     case EM_486:
9305       return reloc_type == 1; /* R_386_32.  */
9306     case EM_68K:
9307       return reloc_type == 1; /* R_68K_32.  */
9308     case EM_860:
9309       return reloc_type == 1; /* R_860_32.  */
9310     case EM_960:
9311       return reloc_type == 2; /* R_960_32.  */
9312     case EM_ALPHA:
9313       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
9314     case EM_ARC:
9315       return reloc_type == 1; /* R_ARC_32.  */
9316     case EM_ARM:
9317       return reloc_type == 2; /* R_ARM_ABS32 */
9318     case EM_AVR_OLD:
9319     case EM_AVR:
9320       return reloc_type == 1;
9321     case EM_BLACKFIN:
9322       return reloc_type == 0x12; /* R_byte4_data.  */
9323     case EM_CRIS:
9324       return reloc_type == 3; /* R_CRIS_32.  */
9325     case EM_CR16:
9326     case EM_CR16_OLD:
9327       return reloc_type == 3; /* R_CR16_NUM32.  */
9328     case EM_CRX:
9329       return reloc_type == 15; /* R_CRX_NUM32.  */
9330     case EM_CYGNUS_FRV:
9331       return reloc_type == 1;
9332     case EM_CYGNUS_D10V:
9333     case EM_D10V:
9334       return reloc_type == 6; /* R_D10V_32.  */
9335     case EM_CYGNUS_D30V:
9336     case EM_D30V:
9337       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
9338     case EM_DLX:
9339       return reloc_type == 3; /* R_DLX_RELOC_32.  */
9340     case EM_CYGNUS_FR30:
9341     case EM_FR30:
9342       return reloc_type == 3; /* R_FR30_32.  */
9343     case EM_H8S:
9344     case EM_H8_300:
9345     case EM_H8_300H:
9346       return reloc_type == 1; /* R_H8_DIR32.  */
9347     case EM_IA_64:
9348       return reloc_type == 0x65; /* R_IA64_SECREL32LSB.  */
9349     case EM_IP2K_OLD:
9350     case EM_IP2K:
9351       return reloc_type == 2; /* R_IP2K_32.  */
9352     case EM_IQ2000:
9353       return reloc_type == 2; /* R_IQ2000_32.  */
9354     case EM_LATTICEMICO32:
9355       return reloc_type == 3; /* R_LM32_32.  */
9356     case EM_M32C_OLD:
9357     case EM_M32C:
9358       return reloc_type == 3; /* R_M32C_32.  */
9359     case EM_M32R:
9360       return reloc_type == 34; /* R_M32R_32_RELA.  */
9361     case EM_MCORE:
9362       return reloc_type == 1; /* R_MCORE_ADDR32.  */
9363     case EM_CYGNUS_MEP:
9364       return reloc_type == 4; /* R_MEP_32.  */
9365     case EM_MICROBLAZE:
9366       return reloc_type == 1; /* R_MICROBLAZE_32.  */
9367     case EM_MIPS:
9368       return reloc_type == 2; /* R_MIPS_32.  */
9369     case EM_MMIX:
9370       return reloc_type == 4; /* R_MMIX_32.  */
9371     case EM_CYGNUS_MN10200:
9372     case EM_MN10200:
9373       return reloc_type == 1; /* R_MN10200_32.  */
9374     case EM_CYGNUS_MN10300:
9375     case EM_MN10300:
9376       return reloc_type == 1; /* R_MN10300_32.  */
9377     case EM_MOXIE:
9378       return reloc_type == 1; /* R_MOXIE_32.  */
9379     case EM_MSP430_OLD:
9380     case EM_MSP430:
9381       return reloc_type == 1; /* R_MSP43_32.  */
9382     case EM_MT:
9383       return reloc_type == 2; /* R_MT_32.  */
9384     case EM_ALTERA_NIOS2:
9385     case EM_NIOS32:
9386       return reloc_type == 1; /* R_NIOS_32.  */
9387     case EM_OPENRISC:
9388     case EM_OR32:
9389       return reloc_type == 1; /* R_OR32_32.  */
9390     case EM_PARISC:
9391       return (reloc_type == 1 /* R_PARISC_DIR32.  */
9392               || reloc_type == 41); /* R_PARISC_SECREL32.  */
9393     case EM_PJ:
9394     case EM_PJ_OLD:
9395       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
9396     case EM_PPC64:
9397       return reloc_type == 1; /* R_PPC64_ADDR32.  */
9398     case EM_PPC:
9399       return reloc_type == 1; /* R_PPC_ADDR32.  */
9400     case EM_RX:
9401       return reloc_type == 1; /* R_RX_DIR32.  */
9402     case EM_S370:
9403       return reloc_type == 1; /* R_I370_ADDR31.  */
9404     case EM_S390_OLD:
9405     case EM_S390:
9406       return reloc_type == 4; /* R_S390_32.  */
9407     case EM_SCORE:
9408       return reloc_type == 8; /* R_SCORE_ABS32.  */
9409     case EM_SH:
9410       return reloc_type == 1; /* R_SH_DIR32.  */
9411     case EM_SPARC32PLUS:
9412     case EM_SPARCV9:
9413     case EM_SPARC:
9414       return reloc_type == 3 /* R_SPARC_32.  */
9415         || reloc_type == 23; /* R_SPARC_UA32.  */
9416     case EM_SPU:
9417       return reloc_type == 6; /* R_SPU_ADDR32 */
9418     case EM_TI_C6000:
9419       return reloc_type == 1; /* R_C6000_ABS32.  */
9420     case EM_CYGNUS_V850:
9421     case EM_V850:
9422       return reloc_type == 6; /* R_V850_ABS32.  */
9423     case EM_VAX:
9424       return reloc_type == 1; /* R_VAX_32.  */
9425     case EM_X86_64:
9426     case EM_L1OM:
9427       return reloc_type == 10; /* R_X86_64_32.  */
9428     case EM_XC16X:
9429     case EM_C166:
9430       return reloc_type == 3; /* R_XC16C_ABS_32.  */
9431     case EM_XSTORMY16:
9432       return reloc_type == 1; /* R_XSTROMY16_32.  */
9433     case EM_XTENSA_OLD:
9434     case EM_XTENSA:
9435       return reloc_type == 1; /* R_XTENSA_32.  */
9436     default:
9437       error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9438              elf_header.e_machine);
9439       abort ();
9440     }
9441 }
9442
9443 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9444    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
9445
9446 static bfd_boolean
9447 is_32bit_pcrel_reloc (unsigned int reloc_type)
9448 {
9449   switch (elf_header.e_machine)
9450     {
9451     case EM_386:
9452     case EM_486:
9453       return reloc_type == 2;  /* R_386_PC32.  */
9454     case EM_68K:
9455       return reloc_type == 4;  /* R_68K_PC32.  */
9456     case EM_ALPHA:
9457       return reloc_type == 10; /* R_ALPHA_SREL32.  */
9458     case EM_ARM:
9459       return reloc_type == 3;  /* R_ARM_REL32 */
9460     case EM_MICROBLAZE:
9461       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
9462     case EM_PARISC:
9463       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
9464     case EM_PPC:
9465       return reloc_type == 26; /* R_PPC_REL32.  */
9466     case EM_PPC64:
9467       return reloc_type == 26; /* R_PPC64_REL32.  */
9468     case EM_S390_OLD:
9469     case EM_S390:
9470       return reloc_type == 5;  /* R_390_PC32.  */
9471     case EM_SH:
9472       return reloc_type == 2;  /* R_SH_REL32.  */
9473     case EM_SPARC32PLUS:
9474     case EM_SPARCV9:
9475     case EM_SPARC:
9476       return reloc_type == 6;  /* R_SPARC_DISP32.  */
9477     case EM_SPU:
9478       return reloc_type == 13; /* R_SPU_REL32.  */
9479     case EM_X86_64:
9480     case EM_L1OM:
9481       return reloc_type == 2;  /* R_X86_64_PC32.  */
9482     case EM_XTENSA_OLD:
9483     case EM_XTENSA:
9484       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
9485     default:
9486       /* Do not abort or issue an error message here.  Not all targets use
9487          pc-relative 32-bit relocs in their DWARF debug information and we
9488          have already tested for target coverage in is_32bit_abs_reloc.  A
9489          more helpful warning message will be generated by apply_relocations
9490          anyway, so just return.  */
9491       return FALSE;
9492     }
9493 }
9494
9495 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9496    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
9497
9498 static bfd_boolean
9499 is_64bit_abs_reloc (unsigned int reloc_type)
9500 {
9501   switch (elf_header.e_machine)
9502     {
9503     case EM_ALPHA:
9504       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
9505     case EM_IA_64:
9506       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
9507     case EM_PARISC:
9508       return reloc_type == 80; /* R_PARISC_DIR64.  */
9509     case EM_PPC64:
9510       return reloc_type == 38; /* R_PPC64_ADDR64.  */
9511     case EM_SPARC32PLUS:
9512     case EM_SPARCV9:
9513     case EM_SPARC:
9514       return reloc_type == 54; /* R_SPARC_UA64.  */
9515     case EM_X86_64:
9516     case EM_L1OM:
9517       return reloc_type == 1; /* R_X86_64_64.  */
9518     case EM_S390_OLD:
9519     case EM_S390:
9520       return reloc_type == 22;  /* R_S390_64 */
9521     case EM_MIPS:
9522       return reloc_type == 18;  /* R_MIPS_64 */
9523     default:
9524       return FALSE;
9525     }
9526 }
9527
9528 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9529    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
9530
9531 static bfd_boolean
9532 is_64bit_pcrel_reloc (unsigned int reloc_type)
9533 {
9534   switch (elf_header.e_machine)
9535     {
9536     case EM_ALPHA:
9537       return reloc_type == 11; /* R_ALPHA_SREL64 */
9538     case EM_IA_64:
9539       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB */
9540     case EM_PARISC:
9541       return reloc_type == 72; /* R_PARISC_PCREL64 */
9542     case EM_PPC64:
9543       return reloc_type == 44; /* R_PPC64_REL64 */
9544     case EM_SPARC32PLUS:
9545     case EM_SPARCV9:
9546     case EM_SPARC:
9547       return reloc_type == 46; /* R_SPARC_DISP64 */
9548     case EM_X86_64:
9549     case EM_L1OM:
9550       return reloc_type == 24; /* R_X86_64_PC64 */
9551     case EM_S390_OLD:
9552     case EM_S390:
9553       return reloc_type == 23;  /* R_S390_PC64 */
9554     default:
9555       return FALSE;
9556     }
9557 }
9558
9559 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9560    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
9561
9562 static bfd_boolean
9563 is_24bit_abs_reloc (unsigned int reloc_type)
9564 {
9565   switch (elf_header.e_machine)
9566     {
9567     case EM_CYGNUS_MN10200:
9568     case EM_MN10200:
9569       return reloc_type == 4; /* R_MN10200_24.  */
9570     default:
9571       return FALSE;
9572     }
9573 }
9574
9575 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9576    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
9577
9578 static bfd_boolean
9579 is_16bit_abs_reloc (unsigned int reloc_type)
9580 {
9581   switch (elf_header.e_machine)
9582     {
9583     case EM_AVR_OLD:
9584     case EM_AVR:
9585       return reloc_type == 4; /* R_AVR_16.  */
9586     case EM_CYGNUS_D10V:
9587     case EM_D10V:
9588       return reloc_type == 3; /* R_D10V_16.  */
9589     case EM_H8S:
9590     case EM_H8_300:
9591     case EM_H8_300H:
9592       return reloc_type == R_H8_DIR16;
9593     case EM_IP2K_OLD:
9594     case EM_IP2K:
9595       return reloc_type == 1; /* R_IP2K_16.  */
9596     case EM_M32C_OLD:
9597     case EM_M32C:
9598       return reloc_type == 1; /* R_M32C_16 */
9599     case EM_MSP430_OLD:
9600     case EM_MSP430:
9601       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
9602     case EM_ALTERA_NIOS2:
9603     case EM_NIOS32:
9604       return reloc_type == 9; /* R_NIOS_16.  */
9605     case EM_TI_C6000:
9606       return reloc_type == 2; /* R_C6000_ABS16.  */
9607     case EM_XC16X:
9608     case EM_C166:
9609       return reloc_type == 2; /* R_XC16C_ABS_16.  */
9610     default:
9611       return FALSE;
9612     }
9613 }
9614
9615 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9616    relocation entries (possibly formerly used for SHT_GROUP sections).  */
9617
9618 static bfd_boolean
9619 is_none_reloc (unsigned int reloc_type)
9620 {
9621   switch (elf_header.e_machine)
9622     {
9623     case EM_68K:     /* R_68K_NONE.  */
9624     case EM_386:     /* R_386_NONE.  */
9625     case EM_SPARC32PLUS:
9626     case EM_SPARCV9:
9627     case EM_SPARC:   /* R_SPARC_NONE.  */
9628     case EM_MIPS:    /* R_MIPS_NONE.  */
9629     case EM_PARISC:  /* R_PARISC_NONE.  */
9630     case EM_ALPHA:   /* R_ALPHA_NONE.  */
9631     case EM_PPC:     /* R_PPC_NONE.  */
9632     case EM_PPC64:   /* R_PPC64_NONE.  */
9633     case EM_ARM:     /* R_ARM_NONE.  */
9634     case EM_IA_64:   /* R_IA64_NONE.  */
9635     case EM_SH:      /* R_SH_NONE.  */
9636     case EM_S390_OLD:
9637     case EM_S390:    /* R_390_NONE.  */
9638     case EM_CRIS:    /* R_CRIS_NONE.  */
9639     case EM_X86_64:  /* R_X86_64_NONE.  */
9640     case EM_L1OM:    /* R_X86_64_NONE.  */
9641     case EM_MN10300: /* R_MN10300_NONE.  */
9642     case EM_MOXIE:   /* R_MOXIE_NONE.  */
9643     case EM_M32R:    /* R_M32R_NONE.  */
9644     case EM_TI_C6000:/* R_C6000_NONE.  */
9645     case EM_XC16X:
9646     case EM_C166:    /* R_XC16X_NONE.  */
9647       return reloc_type == 0;
9648     case EM_XTENSA_OLD:
9649     case EM_XTENSA:
9650       return (reloc_type == 0      /* R_XTENSA_NONE.  */
9651               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
9652               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
9653               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
9654     }
9655   return FALSE;
9656 }
9657
9658 /* Apply relocations to a section.
9659    Note: So far support has been added only for those relocations
9660    which can be found in debug sections.
9661    FIXME: Add support for more relocations ?  */
9662
9663 static void
9664 apply_relocations (void * file,
9665                    Elf_Internal_Shdr * section,
9666                    unsigned char * start)
9667 {
9668   Elf_Internal_Shdr * relsec;
9669   unsigned char * end = start + section->sh_size;
9670
9671   if (elf_header.e_type != ET_REL)
9672     return;
9673
9674   /* Find the reloc section associated with the section.  */
9675   for (relsec = section_headers;
9676        relsec < section_headers + elf_header.e_shnum;
9677        ++relsec)
9678     {
9679       bfd_boolean is_rela;
9680       unsigned long num_relocs;
9681       Elf_Internal_Rela * relocs;
9682       Elf_Internal_Rela * rp;
9683       Elf_Internal_Shdr * symsec;
9684       Elf_Internal_Sym * symtab;
9685       Elf_Internal_Sym * sym;
9686
9687       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9688           || relsec->sh_info >= elf_header.e_shnum
9689           || section_headers + relsec->sh_info != section
9690           || relsec->sh_size == 0
9691           || relsec->sh_link >= elf_header.e_shnum)
9692         continue;
9693
9694       is_rela = relsec->sh_type == SHT_RELA;
9695
9696       if (is_rela)
9697         {
9698           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
9699                                   relsec->sh_size, & relocs, & num_relocs))
9700             return;
9701         }
9702       else
9703         {
9704           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
9705                                  relsec->sh_size, & relocs, & num_relocs))
9706             return;
9707         }
9708
9709       /* SH uses RELA but uses in place value instead of the addend field.  */
9710       if (elf_header.e_machine == EM_SH)
9711         is_rela = FALSE;
9712
9713       symsec = section_headers + relsec->sh_link;
9714       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec);
9715
9716       for (rp = relocs; rp < relocs + num_relocs; ++rp)
9717         {
9718           bfd_vma         addend;
9719           unsigned int    reloc_type;
9720           unsigned int    reloc_size;
9721           unsigned char * rloc;
9722
9723           reloc_type = get_reloc_type (rp->r_info);
9724
9725           if (target_specific_reloc_handling (rp, start, symtab))
9726             continue;
9727           else if (is_none_reloc (reloc_type))
9728             continue;
9729           else if (is_32bit_abs_reloc (reloc_type)
9730                    || is_32bit_pcrel_reloc (reloc_type))
9731             reloc_size = 4;
9732           else if (is_64bit_abs_reloc (reloc_type)
9733                    || is_64bit_pcrel_reloc (reloc_type))
9734             reloc_size = 8;
9735           else if (is_24bit_abs_reloc (reloc_type))
9736             reloc_size = 3;
9737           else if (is_16bit_abs_reloc (reloc_type))
9738             reloc_size = 2;
9739           else
9740             {
9741               warn (_("unable to apply unsupported reloc type %d to section %s\n"),
9742                     reloc_type, SECTION_NAME (section));
9743               continue;
9744             }
9745
9746           rloc = start + rp->r_offset;
9747           if ((rloc + reloc_size) > end)
9748             {
9749               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
9750                     (unsigned long) rp->r_offset,
9751                     SECTION_NAME (section));
9752               continue;
9753             }
9754
9755           sym = symtab + get_reloc_symindex (rp->r_info);
9756
9757           /* If the reloc has a symbol associated with it,
9758              make sure that it is of an appropriate type.
9759
9760              Relocations against symbols without type can happen.
9761              Gcc -feliminate-dwarf2-dups may generate symbols
9762              without type for debug info.
9763
9764              Icc generates relocations against function symbols
9765              instead of local labels.
9766
9767              Relocations against object symbols can happen, eg when
9768              referencing a global array.  For an example of this see
9769              the _clz.o binary in libgcc.a.  */
9770           if (sym != symtab
9771               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
9772             {
9773               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
9774                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
9775                     (long int)(rp - relocs),
9776                     SECTION_NAME (relsec));
9777               continue;
9778             }
9779
9780           addend = 0;
9781           if (is_rela)
9782             addend += rp->r_addend;
9783           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
9784              partial_inplace.  */
9785           if (!is_rela
9786               || (elf_header.e_machine == EM_XTENSA
9787                   && reloc_type == 1)
9788               || ((elf_header.e_machine == EM_PJ
9789                    || elf_header.e_machine == EM_PJ_OLD)
9790                   && reloc_type == 1)
9791               || ((elf_header.e_machine == EM_D30V
9792                    || elf_header.e_machine == EM_CYGNUS_D30V)
9793                   && reloc_type == 12))
9794             addend += byte_get (rloc, reloc_size);
9795
9796           if (is_32bit_pcrel_reloc (reloc_type)
9797               || is_64bit_pcrel_reloc (reloc_type))
9798             {
9799               /* On HPPA, all pc-relative relocations are biased by 8.  */
9800               if (elf_header.e_machine == EM_PARISC)
9801                 addend -= 8;
9802               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
9803                         reloc_size);
9804             }
9805           else
9806             byte_put (rloc, addend + sym->st_value, reloc_size);
9807         }
9808
9809       free (symtab);
9810       free (relocs);
9811       break;
9812     }
9813 }
9814
9815 #ifdef SUPPORT_DISASSEMBLY
9816 static int
9817 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
9818 {
9819   printf (_("\nAssembly dump of section %s\n"),
9820           SECTION_NAME (section));
9821
9822   /* XXX -- to be done --- XXX */
9823
9824   return 1;
9825 }
9826 #endif
9827
9828 /* Reads in the contents of SECTION from FILE, returning a pointer
9829    to a malloc'ed buffer or NULL if something went wrong.  */
9830
9831 static char *
9832 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
9833 {
9834   bfd_size_type num_bytes;
9835
9836   num_bytes = section->sh_size;
9837
9838   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
9839     {
9840       printf (_("\nSection '%s' has no data to dump.\n"),
9841               SECTION_NAME (section));
9842       return NULL;
9843     }
9844
9845   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
9846                              _("section contents"));
9847 }
9848
9849
9850 static void
9851 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
9852 {
9853   Elf_Internal_Shdr * relsec;
9854   bfd_size_type num_bytes;
9855   char * data;
9856   char * end;
9857   char * start;
9858   char * name = SECTION_NAME (section);
9859   bfd_boolean some_strings_shown;
9860
9861   start = get_section_contents (section, file);
9862   if (start == NULL)
9863     return;
9864
9865   printf (_("\nString dump of section '%s':\n"), name);
9866
9867   /* If the section being dumped has relocations against it the user might
9868      be expecting these relocations to have been applied.  Check for this
9869      case and issue a warning message in order to avoid confusion.
9870      FIXME: Maybe we ought to have an option that dumps a section with
9871      relocs applied ?  */
9872   for (relsec = section_headers;
9873        relsec < section_headers + elf_header.e_shnum;
9874        ++relsec)
9875     {
9876       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9877           || relsec->sh_info >= elf_header.e_shnum
9878           || section_headers + relsec->sh_info != section
9879           || relsec->sh_size == 0
9880           || relsec->sh_link >= elf_header.e_shnum)
9881         continue;
9882
9883       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9884       break;
9885     }
9886
9887   num_bytes = section->sh_size;
9888   data = start;
9889   end  = start + num_bytes;
9890   some_strings_shown = FALSE;
9891
9892   while (data < end)
9893     {
9894       while (!ISPRINT (* data))
9895         if (++ data >= end)
9896           break;
9897
9898       if (data < end)
9899         {
9900 #ifndef __MSVCRT__
9901           /* PR 11128: Use two separate invocations in order to work
9902              around bugs in the Solaris 8 implementation of printf.  */
9903           printf ("  [%6tx]  ", data - start);
9904           printf ("%s\n", data);
9905 #else
9906           printf ("  [%6Ix]  %s\n", (size_t) (data - start), data);
9907 #endif
9908           data += strlen (data);
9909           some_strings_shown = TRUE;
9910         }
9911     }
9912
9913   if (! some_strings_shown)
9914     printf (_("  No strings found in this section."));
9915
9916   free (start);
9917
9918   putchar ('\n');
9919 }
9920
9921 static void
9922 dump_section_as_bytes (Elf_Internal_Shdr * section,
9923                        FILE * file,
9924                        bfd_boolean relocate)
9925 {
9926   Elf_Internal_Shdr * relsec;
9927   bfd_size_type bytes;
9928   bfd_vma addr;
9929   unsigned char * data;
9930   unsigned char * start;
9931
9932   start = (unsigned char *) get_section_contents (section, file);
9933   if (start == NULL)
9934     return;
9935
9936   printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
9937
9938   if (relocate)
9939     {
9940       apply_relocations (file, section, start);
9941     }
9942   else
9943     {
9944       /* If the section being dumped has relocations against it the user might
9945          be expecting these relocations to have been applied.  Check for this
9946          case and issue a warning message in order to avoid confusion.
9947          FIXME: Maybe we ought to have an option that dumps a section with
9948          relocs applied ?  */
9949       for (relsec = section_headers;
9950            relsec < section_headers + elf_header.e_shnum;
9951            ++relsec)
9952         {
9953           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9954               || relsec->sh_info >= elf_header.e_shnum
9955               || section_headers + relsec->sh_info != section
9956               || relsec->sh_size == 0
9957               || relsec->sh_link >= elf_header.e_shnum)
9958             continue;
9959
9960           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9961           break;
9962         }
9963     }
9964
9965   addr = section->sh_addr;
9966   bytes = section->sh_size;
9967   data = start;
9968
9969   while (bytes)
9970     {
9971       int j;
9972       int k;
9973       int lbytes;
9974
9975       lbytes = (bytes > 16 ? 16 : bytes);
9976
9977       printf ("  0x%8.8lx ", (unsigned long) addr);
9978
9979       for (j = 0; j < 16; j++)
9980         {
9981           if (j < lbytes)
9982             printf ("%2.2x", data[j]);
9983           else
9984             printf ("  ");
9985
9986           if ((j & 3) == 3)
9987             printf (" ");
9988         }
9989
9990       for (j = 0; j < lbytes; j++)
9991         {
9992           k = data[j];
9993           if (k >= ' ' && k < 0x7f)
9994             printf ("%c", k);
9995           else
9996             printf (".");
9997         }
9998
9999       putchar ('\n');
10000
10001       data  += lbytes;
10002       addr  += lbytes;
10003       bytes -= lbytes;
10004     }
10005
10006   free (start);
10007
10008   putchar ('\n');
10009 }
10010
10011 /* Uncompresses a section that was compressed using zlib, in place.  */
10012
10013 static int
10014 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10015                              dwarf_size_type *size ATTRIBUTE_UNUSED)
10016 {
10017 #ifndef HAVE_ZLIB_H
10018   return FALSE;
10019 #else
10020   dwarf_size_type compressed_size = *size;
10021   unsigned char * compressed_buffer = *buffer;
10022   dwarf_size_type uncompressed_size;
10023   unsigned char * uncompressed_buffer;
10024   z_stream strm;
10025   int rc;
10026   dwarf_size_type header_size = 12;
10027
10028   /* Read the zlib header.  In this case, it should be "ZLIB" followed
10029      by the uncompressed section size, 8 bytes in big-endian order.  */
10030   if (compressed_size < header_size
10031       || ! streq ((char *) compressed_buffer, "ZLIB"))
10032     return 0;
10033
10034   uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10035   uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10036   uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10037   uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10038   uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10039   uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10040   uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10041   uncompressed_size += compressed_buffer[11];
10042
10043   /* It is possible the section consists of several compressed
10044      buffers concatenated together, so we uncompress in a loop.  */
10045   strm.zalloc = NULL;
10046   strm.zfree = NULL;
10047   strm.opaque = NULL;
10048   strm.avail_in = compressed_size - header_size;
10049   strm.next_in = (Bytef *) compressed_buffer + header_size;
10050   strm.avail_out = uncompressed_size;
10051   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
10052
10053   rc = inflateInit (& strm);
10054   while (strm.avail_in > 0)
10055     {
10056       if (rc != Z_OK)
10057         goto fail;
10058       strm.next_out = ((Bytef *) uncompressed_buffer
10059                        + (uncompressed_size - strm.avail_out));
10060       rc = inflate (&strm, Z_FINISH);
10061       if (rc != Z_STREAM_END)
10062         goto fail;
10063       rc = inflateReset (& strm);
10064     }
10065   rc = inflateEnd (& strm);
10066   if (rc != Z_OK
10067       || strm.avail_out != 0)
10068     goto fail;
10069
10070   free (compressed_buffer);
10071   *buffer = uncompressed_buffer;
10072   *size = uncompressed_size;
10073   return 1;
10074
10075  fail:
10076   free (uncompressed_buffer);
10077   /* Indicate decompression failure.  */
10078   *buffer = NULL;
10079   return 0;
10080 #endif  /* HAVE_ZLIB_H */
10081 }
10082
10083 static int
10084 load_specific_debug_section (enum dwarf_section_display_enum debug,
10085                              Elf_Internal_Shdr * sec, void * file)
10086 {
10087   struct dwarf_section * section = &debug_displays [debug].section;
10088   char buf [64];
10089
10090   /* If it is already loaded, do nothing.  */
10091   if (section->start != NULL)
10092     return 1;
10093
10094   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10095   section->address = sec->sh_addr;
10096   section->size = sec->sh_size;
10097   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10098                                                sec->sh_offset, 1,
10099                                                sec->sh_size, buf);
10100   if (uncompress_section_contents (&section->start, &section->size))
10101     sec->sh_size = section->size;
10102
10103   if (section->start == NULL)
10104     return 0;
10105
10106   if (debug_displays [debug].relocate)
10107     apply_relocations ((FILE *) file, sec, section->start);
10108
10109   return 1;
10110 }
10111
10112 int
10113 load_debug_section (enum dwarf_section_display_enum debug, void * file)
10114 {
10115   struct dwarf_section * section = &debug_displays [debug].section;
10116   Elf_Internal_Shdr * sec;
10117
10118   /* Locate the debug section.  */
10119   sec = find_section (section->uncompressed_name);
10120   if (sec != NULL)
10121     section->name = section->uncompressed_name;
10122   else
10123     {
10124       sec = find_section (section->compressed_name);
10125       if (sec != NULL)
10126         section->name = section->compressed_name;
10127     }
10128   if (sec == NULL)
10129     return 0;
10130
10131   return load_specific_debug_section (debug, sec, (FILE *) file);
10132 }
10133
10134 void
10135 free_debug_section (enum dwarf_section_display_enum debug)
10136 {
10137   struct dwarf_section * section = &debug_displays [debug].section;
10138
10139   if (section->start == NULL)
10140     return;
10141
10142   free ((char *) section->start);
10143   section->start = NULL;
10144   section->address = 0;
10145   section->size = 0;
10146 }
10147
10148 static int
10149 display_debug_section (Elf_Internal_Shdr * section, FILE * file)
10150 {
10151   char * name = SECTION_NAME (section);
10152   bfd_size_type length;
10153   int result = 1;
10154   int i;
10155
10156   length = section->sh_size;
10157   if (length == 0)
10158     {
10159       printf (_("\nSection '%s' has no debugging data.\n"), name);
10160       return 0;
10161     }
10162   if (section->sh_type == SHT_NOBITS)
10163     {
10164       /* There is no point in dumping the contents of a debugging section
10165          which has the NOBITS type - the bits in the file will be random.
10166          This can happen when a file containing a .eh_frame section is
10167          stripped with the --only-keep-debug command line option.  */
10168       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10169       return 0;
10170     }
10171
10172   if (const_strneq (name, ".gnu.linkonce.wi."))
10173     name = ".debug_info";
10174
10175   /* See if we know how to display the contents of this section.  */
10176   for (i = 0; i < max; i++)
10177     if (streq (debug_displays[i].section.uncompressed_name, name)
10178         || streq (debug_displays[i].section.compressed_name, name))
10179       {
10180         struct dwarf_section * sec = &debug_displays [i].section;
10181         int secondary = (section != find_section (name));
10182
10183         if (secondary)
10184           free_debug_section ((enum dwarf_section_display_enum) i);
10185
10186         if (streq (sec->uncompressed_name, name))
10187           sec->name = sec->uncompressed_name;
10188         else
10189           sec->name = sec->compressed_name;
10190         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10191                                          section, file))
10192           {
10193             result &= debug_displays[i].display (sec, file);
10194
10195             if (secondary || (i != info && i != abbrev))
10196               free_debug_section ((enum dwarf_section_display_enum) i);
10197           }
10198
10199         break;
10200       }
10201
10202   if (i == max)
10203     {
10204       printf (_("Unrecognized debug section: %s\n"), name);
10205       result = 0;
10206     }
10207
10208   return result;
10209 }
10210
10211 /* Set DUMP_SECTS for all sections where dumps were requested
10212    based on section name.  */
10213
10214 static void
10215 initialise_dumps_byname (void)
10216 {
10217   struct dump_list_entry * cur;
10218
10219   for (cur = dump_sects_byname; cur; cur = cur->next)
10220     {
10221       unsigned int i;
10222       int any;
10223
10224       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10225         if (streq (SECTION_NAME (section_headers + i), cur->name))
10226           {
10227             request_dump_bynumber (i, cur->type);
10228             any = 1;
10229           }
10230
10231       if (!any)
10232         warn (_("Section '%s' was not dumped because it does not exist!\n"),
10233               cur->name);
10234     }
10235 }
10236
10237 static void
10238 process_section_contents (FILE * file)
10239 {
10240   Elf_Internal_Shdr * section;
10241   unsigned int i;
10242
10243   if (! do_dump)
10244     return;
10245
10246   initialise_dumps_byname ();
10247
10248   for (i = 0, section = section_headers;
10249        i < elf_header.e_shnum && i < num_dump_sects;
10250        i++, section++)
10251     {
10252 #ifdef SUPPORT_DISASSEMBLY
10253       if (dump_sects[i] & DISASS_DUMP)
10254         disassemble_section (section, file);
10255 #endif
10256       if (dump_sects[i] & HEX_DUMP)
10257         dump_section_as_bytes (section, file, FALSE);
10258
10259       if (dump_sects[i] & RELOC_DUMP)
10260         dump_section_as_bytes (section, file, TRUE);
10261
10262       if (dump_sects[i] & STRING_DUMP)
10263         dump_section_as_strings (section, file);
10264
10265       if (dump_sects[i] & DEBUG_DUMP)
10266         display_debug_section (section, file);
10267     }
10268
10269   /* Check to see if the user requested a
10270      dump of a section that does not exist.  */
10271   while (i++ < num_dump_sects)
10272     if (dump_sects[i])
10273       warn (_("Section %d was not dumped because it does not exist!\n"), i);
10274 }
10275
10276 static void
10277 process_mips_fpe_exception (int mask)
10278 {
10279   if (mask)
10280     {
10281       int first = 1;
10282       if (mask & OEX_FPU_INEX)
10283         fputs ("INEX", stdout), first = 0;
10284       if (mask & OEX_FPU_UFLO)
10285         printf ("%sUFLO", first ? "" : "|"), first = 0;
10286       if (mask & OEX_FPU_OFLO)
10287         printf ("%sOFLO", first ? "" : "|"), first = 0;
10288       if (mask & OEX_FPU_DIV0)
10289         printf ("%sDIV0", first ? "" : "|"), first = 0;
10290       if (mask & OEX_FPU_INVAL)
10291         printf ("%sINVAL", first ? "" : "|");
10292     }
10293   else
10294     fputs ("0", stdout);
10295 }
10296
10297 /* ARM EABI attributes section.  */
10298 typedef struct
10299 {
10300   int tag;
10301   const char * name;
10302   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
10303   int type;
10304   const char ** table;
10305 } arm_attr_public_tag;
10306
10307 static const char * arm_attr_tag_CPU_arch[] =
10308   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
10309    "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
10310 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
10311 static const char * arm_attr_tag_THUMB_ISA_use[] =
10312   {"No", "Thumb-1", "Thumb-2"};
10313 static const char * arm_attr_tag_FP_arch[] =
10314   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
10315 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
10316 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
10317   {"No", "NEONv1", "NEONv1 with Fused-MAC"};
10318 static const char * arm_attr_tag_PCS_config[] =
10319   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10320    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
10321 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
10322   {"V6", "SB", "TLS", "Unused"};
10323 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
10324   {"Absolute", "PC-relative", "SB-relative", "None"};
10325 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
10326   {"Absolute", "PC-relative", "None"};
10327 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
10328   {"None", "direct", "GOT-indirect"};
10329 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
10330   {"None", "??? 1", "2", "??? 3", "4"};
10331 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
10332 static const char * arm_attr_tag_ABI_FP_denormal[] =
10333   {"Unused", "Needed", "Sign only"};
10334 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
10335 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
10336 static const char * arm_attr_tag_ABI_FP_number_model[] =
10337   {"Unused", "Finite", "RTABI", "IEEE 754"};
10338 static const char * arm_attr_tag_ABI_enum_size[] =
10339   {"Unused", "small", "int", "forced to int"};
10340 static const char * arm_attr_tag_ABI_HardFP_use[] =
10341   {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
10342 static const char * arm_attr_tag_ABI_VFP_args[] =
10343   {"AAPCS", "VFP registers", "custom"};
10344 static const char * arm_attr_tag_ABI_WMMX_args[] =
10345   {"AAPCS", "WMMX registers", "custom"};
10346 static const char * arm_attr_tag_ABI_optimization_goals[] =
10347   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10348     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
10349 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
10350   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10351     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
10352 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
10353 static const char * arm_attr_tag_FP_HP_extension[] =
10354   {"Not Allowed", "Allowed"};
10355 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
10356   {"None", "IEEE 754", "Alternative Format"};
10357 static const char * arm_attr_tag_MPextension_use[] =
10358   {"Not Allowed", "Allowed"};
10359 static const char * arm_attr_tag_DIV_use[] =
10360   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
10361     "Allowed in v7-A with integer division extension"};
10362 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
10363 static const char * arm_attr_tag_Virtualization_use[] =
10364   {"Not Allowed", "TrustZone", "Virtualization Extensions",
10365     "TrustZone and Virtualization Extensions"};
10366 static const char * arm_attr_tag_MPextension_use_legacy[] =
10367   {"Not Allowed", "Allowed"};
10368
10369 #define LOOKUP(id, name) \
10370   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
10371 static arm_attr_public_tag arm_attr_public_tags[] =
10372 {
10373   {4, "CPU_raw_name", 1, NULL},
10374   {5, "CPU_name", 1, NULL},
10375   LOOKUP(6, CPU_arch),
10376   {7, "CPU_arch_profile", 0, NULL},
10377   LOOKUP(8, ARM_ISA_use),
10378   LOOKUP(9, THUMB_ISA_use),
10379   LOOKUP(10, FP_arch),
10380   LOOKUP(11, WMMX_arch),
10381   LOOKUP(12, Advanced_SIMD_arch),
10382   LOOKUP(13, PCS_config),
10383   LOOKUP(14, ABI_PCS_R9_use),
10384   LOOKUP(15, ABI_PCS_RW_data),
10385   LOOKUP(16, ABI_PCS_RO_data),
10386   LOOKUP(17, ABI_PCS_GOT_use),
10387   LOOKUP(18, ABI_PCS_wchar_t),
10388   LOOKUP(19, ABI_FP_rounding),
10389   LOOKUP(20, ABI_FP_denormal),
10390   LOOKUP(21, ABI_FP_exceptions),
10391   LOOKUP(22, ABI_FP_user_exceptions),
10392   LOOKUP(23, ABI_FP_number_model),
10393   {24, "ABI_align_needed", 0, NULL},
10394   {25, "ABI_align_preserved", 0, NULL},
10395   LOOKUP(26, ABI_enum_size),
10396   LOOKUP(27, ABI_HardFP_use),
10397   LOOKUP(28, ABI_VFP_args),
10398   LOOKUP(29, ABI_WMMX_args),
10399   LOOKUP(30, ABI_optimization_goals),
10400   LOOKUP(31, ABI_FP_optimization_goals),
10401   {32, "compatibility", 0, NULL},
10402   LOOKUP(34, CPU_unaligned_access),
10403   LOOKUP(36, FP_HP_extension),
10404   LOOKUP(38, ABI_FP_16bit_format),
10405   LOOKUP(42, MPextension_use),
10406   LOOKUP(44, DIV_use),
10407   {64, "nodefaults", 0, NULL},
10408   {65, "also_compatible_with", 0, NULL},
10409   LOOKUP(66, T2EE_use),
10410   {67, "conformance", 1, NULL},
10411   LOOKUP(68, Virtualization_use),
10412   LOOKUP(70, MPextension_use_legacy)
10413 };
10414 #undef LOOKUP
10415
10416 static unsigned char *
10417 display_arm_attribute (unsigned char * p)
10418 {
10419   int tag;
10420   unsigned int len;
10421   int val;
10422   arm_attr_public_tag * attr;
10423   unsigned i;
10424   int type;
10425
10426   tag = read_uleb128 (p, &len);
10427   p += len;
10428   attr = NULL;
10429   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
10430     {
10431       if (arm_attr_public_tags[i].tag == tag)
10432         {
10433           attr = &arm_attr_public_tags[i];
10434           break;
10435         }
10436     }
10437
10438   if (attr)
10439     {
10440       printf ("  Tag_%s: ", attr->name);
10441       switch (attr->type)
10442         {
10443         case 0:
10444           switch (tag)
10445             {
10446             case 7: /* Tag_CPU_arch_profile.  */
10447               val = read_uleb128 (p, &len);
10448               p += len;
10449               switch (val)
10450                 {
10451                 case 0: printf (_("None\n")); break;
10452                 case 'A': printf (_("Application\n")); break;
10453                 case 'R': printf (_("Realtime\n")); break;
10454                 case 'M': printf (_("Microcontroller\n")); break;
10455                 case 'S': printf (_("Application or Realtime\n")); break;
10456                 default: printf ("??? (%d)\n", val); break;
10457                 }
10458               break;
10459
10460             case 24: /* Tag_align_needed.  */
10461               val = read_uleb128 (p, &len);
10462               p += len;
10463               switch (val)
10464                 {
10465                 case 0: printf (_("None\n")); break;
10466                 case 1: printf (_("8-byte\n")); break;
10467                 case 2: printf (_("4-byte\n")); break;
10468                 case 3: printf ("??? 3\n"); break;
10469                 default:
10470                   if (val <= 12)
10471                     printf (_("8-byte and up to %d-byte extended\n"),
10472                             1 << val);
10473                   else
10474                     printf ("??? (%d)\n", val);
10475                   break;
10476                 }
10477               break;
10478
10479             case 25: /* Tag_align_preserved.  */
10480               val = read_uleb128 (p, &len);
10481               p += len;
10482               switch (val)
10483                 {
10484                 case 0: printf (_("None\n")); break;
10485                 case 1: printf (_("8-byte, except leaf SP\n")); break;
10486                 case 2: printf (_("8-byte\n")); break;
10487                 case 3: printf ("??? 3\n"); break;
10488                 default:
10489                   if (val <= 12)
10490                     printf (_("8-byte and up to %d-byte extended\n"),
10491                             1 << val);
10492                   else
10493                     printf ("??? (%d)\n", val);
10494                   break;
10495                 }
10496               break;
10497
10498             case 32: /* Tag_compatibility.  */
10499               val = read_uleb128 (p, &len);
10500               p += len;
10501               printf (_("flag = %d, vendor = %s\n"), val, p);
10502               p += strlen ((char *) p) + 1;
10503               break;
10504
10505             case 64: /* Tag_nodefaults.  */
10506               p++;
10507               printf (_("True\n"));
10508               break;
10509
10510             case 65: /* Tag_also_compatible_with.  */
10511               val = read_uleb128 (p, &len);
10512               p += len;
10513               if (val == 6 /* Tag_CPU_arch.  */)
10514                 {
10515                   val = read_uleb128 (p, &len);
10516                   p += len;
10517                   if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
10518                     printf ("??? (%d)\n", val);
10519                   else
10520                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
10521                 }
10522               else
10523                 printf ("???\n");
10524               while (*(p++) != '\0' /* NUL terminator.  */);
10525               break;
10526
10527             default:
10528               abort ();
10529             }
10530           return p;
10531
10532         case 1:
10533         case 2:
10534           type = attr->type;
10535           break;
10536
10537         default:
10538           assert (attr->type & 0x80);
10539           val = read_uleb128 (p, &len);
10540           p += len;
10541           type = attr->type & 0x7f;
10542           if (val >= type)
10543             printf ("??? (%d)\n", val);
10544           else
10545             printf ("%s\n", attr->table[val]);
10546           return p;
10547         }
10548     }
10549   else
10550     {
10551       if (tag & 1)
10552         type = 1; /* String.  */
10553       else
10554         type = 2; /* uleb128.  */
10555       printf ("  Tag_unknown_%d: ", tag);
10556     }
10557
10558   if (type == 1)
10559     {
10560       printf ("\"%s\"\n", p);
10561       p += strlen ((char *) p) + 1;
10562     }
10563   else
10564     {
10565       val = read_uleb128 (p, &len);
10566       p += len;
10567       printf ("%d (0x%x)\n", val, val);
10568     }
10569
10570   return p;
10571 }
10572
10573 static unsigned char *
10574 display_gnu_attribute (unsigned char * p,
10575                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
10576 {
10577   int tag;
10578   unsigned int len;
10579   int val;
10580   int type;
10581
10582   tag = read_uleb128 (p, &len);
10583   p += len;
10584
10585   /* Tag_compatibility is the only generic GNU attribute defined at
10586      present.  */
10587   if (tag == 32)
10588     {
10589       val = read_uleb128 (p, &len);
10590       p += len;
10591       printf (_("flag = %d, vendor = %s\n"), val, p);
10592       p += strlen ((char *) p) + 1;
10593       return p;
10594     }
10595
10596   if ((tag & 2) == 0 && display_proc_gnu_attribute)
10597     return display_proc_gnu_attribute (p, tag);
10598
10599   if (tag & 1)
10600     type = 1; /* String.  */
10601   else
10602     type = 2; /* uleb128.  */
10603   printf ("  Tag_unknown_%d: ", tag);
10604
10605   if (type == 1)
10606     {
10607       printf ("\"%s\"\n", p);
10608       p += strlen ((char *) p) + 1;
10609     }
10610   else
10611     {
10612       val = read_uleb128 (p, &len);
10613       p += len;
10614       printf ("%d (0x%x)\n", val, val);
10615     }
10616
10617   return p;
10618 }
10619
10620 static unsigned char *
10621 display_power_gnu_attribute (unsigned char * p, int tag)
10622 {
10623   int type;
10624   unsigned int len;
10625   int val;
10626
10627   if (tag == Tag_GNU_Power_ABI_FP)
10628     {
10629       val = read_uleb128 (p, &len);
10630       p += len;
10631       printf ("  Tag_GNU_Power_ABI_FP: ");
10632
10633       switch (val)
10634         {
10635         case 0:
10636           printf (_("Hard or soft float\n"));
10637           break;
10638         case 1:
10639           printf (_("Hard float\n"));
10640           break;
10641         case 2:
10642           printf (_("Soft float\n"));
10643           break;
10644         case 3:
10645           printf (_("Single-precision hard float\n"));
10646           break;
10647         default:
10648           printf ("??? (%d)\n", val);
10649           break;
10650         }
10651       return p;
10652    }
10653
10654   if (tag == Tag_GNU_Power_ABI_Vector)
10655     {
10656       val = read_uleb128 (p, &len);
10657       p += len;
10658       printf ("  Tag_GNU_Power_ABI_Vector: ");
10659       switch (val)
10660         {
10661         case 0:
10662           printf (_("Any\n"));
10663           break;
10664         case 1:
10665           printf (_("Generic\n"));
10666           break;
10667         case 2:
10668           printf ("AltiVec\n");
10669           break;
10670         case 3:
10671           printf ("SPE\n");
10672           break;
10673         default:
10674           printf ("??? (%d)\n", val);
10675           break;
10676         }
10677       return p;
10678    }
10679
10680   if (tag == Tag_GNU_Power_ABI_Struct_Return)
10681     {
10682       val = read_uleb128 (p, &len);
10683       p += len;
10684       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
10685       switch (val)
10686        {
10687        case 0:
10688          printf (_("Any\n"));
10689          break;
10690        case 1:
10691          printf ("r3/r4\n");
10692          break;
10693        case 2:
10694          printf (_("Memory\n"));
10695          break;
10696        default:
10697          printf ("??? (%d)\n", val);
10698          break;
10699        }
10700       return p;
10701     }
10702
10703   if (tag & 1)
10704     type = 1; /* String.  */
10705   else
10706     type = 2; /* uleb128.  */
10707   printf ("  Tag_unknown_%d: ", tag);
10708
10709   if (type == 1)
10710     {
10711       printf ("\"%s\"\n", p);
10712       p += strlen ((char *) p) + 1;
10713     }
10714   else
10715     {
10716       val = read_uleb128 (p, &len);
10717       p += len;
10718       printf ("%d (0x%x)\n", val, val);
10719     }
10720
10721   return p;
10722 }
10723
10724 static unsigned char *
10725 display_mips_gnu_attribute (unsigned char * p, int tag)
10726 {
10727   int type;
10728   unsigned int len;
10729   int val;
10730
10731   if (tag == Tag_GNU_MIPS_ABI_FP)
10732     {
10733       val = read_uleb128 (p, &len);
10734       p += len;
10735       printf ("  Tag_GNU_MIPS_ABI_FP: ");
10736
10737       switch (val)
10738         {
10739         case 0:
10740           printf (_("Hard or soft float\n"));
10741           break;
10742         case 1:
10743           printf (_("Hard float (double precision)\n"));
10744           break;
10745         case 2:
10746           printf (_("Hard float (single precision)\n"));
10747           break;
10748         case 3:
10749           printf (_("Soft float\n"));
10750           break;
10751         case 4:
10752           printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
10753           break;
10754         default:
10755           printf ("??? (%d)\n", val);
10756           break;
10757         }
10758       return p;
10759    }
10760
10761   if (tag & 1)
10762     type = 1; /* String.  */
10763   else
10764     type = 2; /* uleb128.  */
10765   printf ("  Tag_unknown_%d: ", tag);
10766
10767   if (type == 1)
10768     {
10769       printf ("\"%s\"\n", p);
10770       p += strlen ((char *) p) + 1;
10771     }
10772   else
10773     {
10774       val = read_uleb128 (p, &len);
10775       p += len;
10776       printf ("%d (0x%x)\n", val, val);
10777     }
10778
10779   return p;
10780 }
10781
10782 static unsigned char *
10783 display_tic6x_attribute (unsigned char * p)
10784 {
10785   int tag;
10786   unsigned int len;
10787   int val;
10788
10789   tag = read_uleb128 (p, &len);
10790   p += len;
10791
10792   switch (tag)
10793     {
10794     case Tag_ISA:
10795       val = read_uleb128 (p, &len);
10796       p += len;
10797       printf ("  Tag_ISA: ");
10798
10799       switch (val)
10800         {
10801         case C6XABI_Tag_ISA_none:
10802           printf (_("None\n"));
10803           break;
10804         case C6XABI_Tag_ISA_C62X:
10805           printf ("C62x\n");
10806           break;
10807         case C6XABI_Tag_ISA_C67X:
10808           printf ("C67x\n");
10809           break;
10810         case C6XABI_Tag_ISA_C67XP:
10811           printf ("C67x+\n");
10812           break;
10813         case C6XABI_Tag_ISA_C64X:
10814           printf ("C64x\n");
10815           break;
10816         case C6XABI_Tag_ISA_C64XP:
10817           printf ("C64x+\n");
10818           break;
10819         case C6XABI_Tag_ISA_C674X:
10820           printf ("C674x\n");
10821           break;
10822         default:
10823           printf ("??? (%d)\n", val);
10824           break;
10825         }
10826       return p;
10827
10828     case Tag_ABI_wchar_t:
10829       val = read_uleb128 (p, &len);
10830       p += len;
10831       printf ("  Tag_ABI_wchar_t: ");
10832       switch (val)
10833         {
10834         case 0:
10835           printf (_("Not used\n"));
10836           break;
10837         case 1:
10838           printf (_("2 bytes\n"));
10839           break;
10840         case 2:
10841           printf (_("4 bytes\n"));
10842           break;
10843         default:
10844           printf ("??? (%d)\n", val);
10845           break;
10846         }
10847       return p;
10848
10849     case Tag_ABI_stack_align_needed:
10850       val = read_uleb128 (p, &len);
10851       p += len;
10852       printf ("  Tag_ABI_stack_align_needed: ");
10853       switch (val)
10854         {
10855         case 0:
10856           printf (_("8-byte\n"));
10857           break;
10858         case 1:
10859           printf (_("16-byte\n"));
10860           break;
10861         default:
10862           printf ("??? (%d)\n", val);
10863           break;
10864         }
10865       return p;
10866
10867     case Tag_ABI_stack_align_preserved:
10868       val = read_uleb128 (p, &len);
10869       p += len;
10870       printf ("  Tag_ABI_stack_align_preserved: ");
10871       switch (val)
10872         {
10873         case 0:
10874           printf (_("8-byte\n"));
10875           break;
10876         case 1:
10877           printf (_("16-byte\n"));
10878           break;
10879         default:
10880           printf ("??? (%d)\n", val);
10881           break;
10882         }
10883       return p;
10884
10885     case Tag_ABI_DSBT:
10886       val = read_uleb128 (p, &len);
10887       p += len;
10888       printf ("  Tag_ABI_DSBT: ");
10889       switch (val)
10890         {
10891         case 0:
10892           printf (_("DSBT addressing not used\n"));
10893           break;
10894         case 1:
10895           printf (_("DSBT addressing used\n"));
10896           break;
10897         default:
10898           printf ("??? (%d)\n", val);
10899           break;
10900         }
10901       return p;
10902
10903     case Tag_ABI_PID:
10904       val = read_uleb128 (p, &len);
10905       p += len;
10906       printf ("  Tag_ABI_PID: ");
10907       switch (val)
10908         {
10909         case 0:
10910           printf (_("Data addressing position-dependent\n"));
10911           break;
10912         case 1:
10913           printf (_("Data addressing position-independent, GOT near DP\n"));
10914           break;
10915         case 2:
10916           printf (_("Data addressing position-independent, GOT far from DP\n"));
10917           break;
10918         default:
10919           printf ("??? (%d)\n", val);
10920           break;
10921         }
10922       return p;
10923
10924     case Tag_ABI_PIC:
10925       val = read_uleb128 (p, &len);
10926       p += len;
10927       printf ("  Tag_ABI_PIC: ");
10928       switch (val)
10929         {
10930         case 0:
10931           printf (_("Code addressing position-dependent\n"));
10932           break;
10933         case 1:
10934           printf (_("Code addressing position-independent\n"));
10935           break;
10936         default:
10937           printf ("??? (%d)\n", val);
10938           break;
10939         }
10940       return p;
10941
10942     case Tag_ABI_array_object_alignment:
10943       val = read_uleb128 (p, &len);
10944       p += len;
10945       printf ("  Tag_ABI_array_object_alignment: ");
10946       switch (val)
10947         {
10948         case 0:
10949           printf (_("8-byte\n"));
10950           break;
10951         case 1:
10952           printf (_("4-byte\n"));
10953           break;
10954         case 2:
10955           printf (_("16-byte\n"));
10956           break;
10957         default:
10958           printf ("??? (%d)\n", val);
10959           break;
10960         }
10961       return p;
10962
10963     case Tag_ABI_array_object_align_expected:
10964       val = read_uleb128 (p, &len);
10965       p += len;
10966       printf ("  Tag_ABI_array_object_align_expected: ");
10967       switch (val)
10968         {
10969         case 0:
10970           printf (_("8-byte\n"));
10971           break;
10972         case 1:
10973           printf (_("4-byte\n"));
10974           break;
10975         case 2:
10976           printf (_("16-byte\n"));
10977           break;
10978         default:
10979           printf ("??? (%d)\n", val);
10980           break;
10981         }
10982       return p;
10983
10984     case Tag_ABI_compatibility:
10985       val = read_uleb128 (p, &len);
10986       p += len;
10987       printf ("  Tag_ABI_compatibility: ");
10988       printf (_("flag = %d, vendor = %s\n"), val, p);
10989       p += strlen ((char *) p) + 1;
10990       return p;
10991
10992     case Tag_ABI_conformance:
10993       printf ("  Tag_ABI_conformance: ");
10994       printf ("\"%s\"\n", p);
10995       p += strlen ((char *) p) + 1;
10996       return p;
10997     }
10998
10999   printf ("  Tag_unknown_%d: ", tag);
11000
11001   if (tag & 1)
11002     {
11003       printf ("\"%s\"\n", p);
11004       p += strlen ((char *) p) + 1;
11005     }
11006   else
11007     {
11008       val = read_uleb128 (p, &len);
11009       p += len;
11010       printf ("%d (0x%x)\n", val, val);
11011     }
11012
11013   return p;
11014 }
11015
11016 static int
11017 process_attributes (FILE * file,
11018                     const char * public_name,
11019                     unsigned int proc_type,
11020                     unsigned char * (* display_pub_attribute) (unsigned char *),
11021                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11022 {
11023   Elf_Internal_Shdr * sect;
11024   unsigned char * contents;
11025   unsigned char * p;
11026   unsigned char * end;
11027   bfd_vma section_len;
11028   bfd_vma len;
11029   unsigned i;
11030
11031   /* Find the section header so that we get the size.  */
11032   for (i = 0, sect = section_headers;
11033        i < elf_header.e_shnum;
11034        i++, sect++)
11035     {
11036       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11037         continue;
11038
11039       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11040                                              sect->sh_size, _("attributes"));
11041       if (contents == NULL)
11042         continue;
11043
11044       p = contents;
11045       if (*p == 'A')
11046         {
11047           len = sect->sh_size - 1;
11048           p++;
11049
11050           while (len > 0)
11051             {
11052               int namelen;
11053               bfd_boolean public_section;
11054               bfd_boolean gnu_section;
11055
11056               section_len = byte_get (p, 4);
11057               p += 4;
11058
11059               if (section_len > len)
11060                 {
11061                   printf (_("ERROR: Bad section length (%d > %d)\n"),
11062                           (int) section_len, (int) len);
11063                   section_len = len;
11064                 }
11065
11066               len -= section_len;
11067               printf (_("Attribute Section: %s\n"), p);
11068
11069               if (public_name && streq ((char *) p, public_name))
11070                 public_section = TRUE;
11071               else
11072                 public_section = FALSE;
11073
11074               if (streq ((char *) p, "gnu"))
11075                 gnu_section = TRUE;
11076               else
11077                 gnu_section = FALSE;
11078
11079               namelen = strlen ((char *) p) + 1;
11080               p += namelen;
11081               section_len -= namelen + 4;
11082
11083               while (section_len > 0)
11084                 {
11085                   int tag = *(p++);
11086                   int val;
11087                   bfd_vma size;
11088
11089                   size = byte_get (p, 4);
11090                   if (size > section_len)
11091                     {
11092                       printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11093                               (int) size, (int) section_len);
11094                       size = section_len;
11095                     }
11096
11097                   section_len -= size;
11098                   end = p + size - 1;
11099                   p += 4;
11100
11101                   switch (tag)
11102                     {
11103                     case 1:
11104                       printf (_("File Attributes\n"));
11105                       break;
11106                     case 2:
11107                       printf (_("Section Attributes:"));
11108                       goto do_numlist;
11109                     case 3:
11110                       printf (_("Symbol Attributes:"));
11111                     do_numlist:
11112                       for (;;)
11113                         {
11114                           unsigned int j;
11115
11116                           val = read_uleb128 (p, &j);
11117                           p += j;
11118                           if (val == 0)
11119                             break;
11120                           printf (" %d", val);
11121                         }
11122                       printf ("\n");
11123                       break;
11124                     default:
11125                       printf (_("Unknown tag: %d\n"), tag);
11126                       public_section = FALSE;
11127                       break;
11128                     }
11129
11130                   if (public_section)
11131                     {
11132                       while (p < end)
11133                         p = display_pub_attribute (p);
11134                     }
11135                   else if (gnu_section)
11136                     {
11137                       while (p < end)
11138                         p = display_gnu_attribute (p,
11139                                                    display_proc_gnu_attribute);
11140                     }
11141                   else
11142                     {
11143                       /* ??? Do something sensible, like dump hex.  */
11144                       printf (_("  Unknown section contexts\n"));
11145                       p = end;
11146                     }
11147                 }
11148             }
11149         }
11150       else
11151         printf (_("Unknown format '%c'\n"), *p);
11152
11153       free (contents);
11154     }
11155   return 1;
11156 }
11157
11158 static int
11159 process_arm_specific (FILE * file)
11160 {
11161   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
11162                              display_arm_attribute, NULL);
11163 }
11164
11165 static int
11166 process_power_specific (FILE * file)
11167 {
11168   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11169                              display_power_gnu_attribute);
11170 }
11171
11172 static int
11173 process_tic6x_specific (FILE * file)
11174 {
11175   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
11176                              display_tic6x_attribute, NULL);
11177 }
11178
11179 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11180    Print the Address, Access and Initial fields of an entry at VMA ADDR
11181    and return the VMA of the next entry.  */
11182
11183 static bfd_vma
11184 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
11185 {
11186   printf ("  ");
11187   print_vma (addr, LONG_HEX);
11188   printf (" ");
11189   if (addr < pltgot + 0xfff0)
11190     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
11191   else
11192     printf ("%10s", "");
11193   printf (" ");
11194   if (data == NULL)
11195     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
11196   else
11197     {
11198       bfd_vma entry;
11199
11200       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11201       print_vma (entry, LONG_HEX);
11202     }
11203   return addr + (is_32bit_elf ? 4 : 8);
11204 }
11205
11206 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11207    PLTGOT.  Print the Address and Initial fields of an entry at VMA
11208    ADDR and return the VMA of the next entry.  */
11209
11210 static bfd_vma
11211 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
11212 {
11213   printf ("  ");
11214   print_vma (addr, LONG_HEX);
11215   printf (" ");
11216   if (data == NULL)
11217     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
11218   else
11219     {
11220       bfd_vma entry;
11221
11222       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11223       print_vma (entry, LONG_HEX);
11224     }
11225   return addr + (is_32bit_elf ? 4 : 8);
11226 }
11227
11228 static int
11229 process_mips_specific (FILE * file)
11230 {
11231   Elf_Internal_Dyn * entry;
11232   size_t liblist_offset = 0;
11233   size_t liblistno = 0;
11234   size_t conflictsno = 0;
11235   size_t options_offset = 0;
11236   size_t conflicts_offset = 0;
11237   size_t pltrelsz = 0;
11238   size_t pltrel = 0;
11239   bfd_vma pltgot = 0;
11240   bfd_vma mips_pltgot = 0;
11241   bfd_vma jmprel = 0;
11242   bfd_vma local_gotno = 0;
11243   bfd_vma gotsym = 0;
11244   bfd_vma symtabno = 0;
11245
11246   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11247                       display_mips_gnu_attribute);
11248
11249   /* We have a lot of special sections.  Thanks SGI!  */
11250   if (dynamic_section == NULL)
11251     /* No information available.  */
11252     return 0;
11253
11254   for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
11255     switch (entry->d_tag)
11256       {
11257       case DT_MIPS_LIBLIST:
11258         liblist_offset
11259           = offset_from_vma (file, entry->d_un.d_val,
11260                              liblistno * sizeof (Elf32_External_Lib));
11261         break;
11262       case DT_MIPS_LIBLISTNO:
11263         liblistno = entry->d_un.d_val;
11264         break;
11265       case DT_MIPS_OPTIONS:
11266         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
11267         break;
11268       case DT_MIPS_CONFLICT:
11269         conflicts_offset
11270           = offset_from_vma (file, entry->d_un.d_val,
11271                              conflictsno * sizeof (Elf32_External_Conflict));
11272         break;
11273       case DT_MIPS_CONFLICTNO:
11274         conflictsno = entry->d_un.d_val;
11275         break;
11276       case DT_PLTGOT:
11277         pltgot = entry->d_un.d_ptr;
11278         break;
11279       case DT_MIPS_LOCAL_GOTNO:
11280         local_gotno = entry->d_un.d_val;
11281         break;
11282       case DT_MIPS_GOTSYM:
11283         gotsym = entry->d_un.d_val;
11284         break;
11285       case DT_MIPS_SYMTABNO:
11286         symtabno = entry->d_un.d_val;
11287         break;
11288       case DT_MIPS_PLTGOT:
11289         mips_pltgot = entry->d_un.d_ptr;
11290         break;
11291       case DT_PLTREL:
11292         pltrel = entry->d_un.d_val;
11293         break;
11294       case DT_PLTRELSZ:
11295         pltrelsz = entry->d_un.d_val;
11296         break;
11297       case DT_JMPREL:
11298         jmprel = entry->d_un.d_ptr;
11299         break;
11300       default:
11301         break;
11302       }
11303
11304   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
11305     {
11306       Elf32_External_Lib * elib;
11307       size_t cnt;
11308
11309       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
11310                                               liblistno,
11311                                               sizeof (Elf32_External_Lib),
11312                                               _("liblist"));
11313       if (elib)
11314         {
11315           printf (_("\nSection '.liblist' contains %lu entries:\n"),
11316                   (unsigned long) liblistno);
11317           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
11318                  stdout);
11319
11320           for (cnt = 0; cnt < liblistno; ++cnt)
11321             {
11322               Elf32_Lib liblist;
11323               time_t atime;
11324               char timebuf[20];
11325               struct tm * tmp;
11326
11327               liblist.l_name = BYTE_GET (elib[cnt].l_name);
11328               atime = BYTE_GET (elib[cnt].l_time_stamp);
11329               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11330               liblist.l_version = BYTE_GET (elib[cnt].l_version);
11331               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11332
11333               tmp = gmtime (&atime);
11334               snprintf (timebuf, sizeof (timebuf),
11335                         "%04u-%02u-%02uT%02u:%02u:%02u",
11336                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11337                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
11338
11339               printf ("%3lu: ", (unsigned long) cnt);
11340               if (VALID_DYNAMIC_NAME (liblist.l_name))
11341                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
11342               else
11343                 printf (_("<corrupt: %9ld>"), liblist.l_name);
11344               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
11345                       liblist.l_version);
11346
11347               if (liblist.l_flags == 0)
11348                 puts (_(" NONE"));
11349               else
11350                 {
11351                   static const struct
11352                   {
11353                     const char * name;
11354                     int bit;
11355                   }
11356                   l_flags_vals[] =
11357                   {
11358                     { " EXACT_MATCH", LL_EXACT_MATCH },
11359                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
11360                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
11361                     { " EXPORTS", LL_EXPORTS },
11362                     { " DELAY_LOAD", LL_DELAY_LOAD },
11363                     { " DELTA", LL_DELTA }
11364                   };
11365                   int flags = liblist.l_flags;
11366                   size_t fcnt;
11367
11368                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
11369                     if ((flags & l_flags_vals[fcnt].bit) != 0)
11370                       {
11371                         fputs (l_flags_vals[fcnt].name, stdout);
11372                         flags ^= l_flags_vals[fcnt].bit;
11373                       }
11374                   if (flags != 0)
11375                     printf (" %#x", (unsigned int) flags);
11376
11377                   puts ("");
11378                 }
11379             }
11380
11381           free (elib);
11382         }
11383     }
11384
11385   if (options_offset != 0)
11386     {
11387       Elf_External_Options * eopt;
11388       Elf_Internal_Shdr * sect = section_headers;
11389       Elf_Internal_Options * iopt;
11390       Elf_Internal_Options * option;
11391       size_t offset;
11392       int cnt;
11393
11394       /* Find the section header so that we get the size.  */
11395       while (sect->sh_type != SHT_MIPS_OPTIONS)
11396         ++sect;
11397
11398       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
11399                                                 sect->sh_size, _("options"));
11400       if (eopt)
11401         {
11402           iopt = (Elf_Internal_Options *)
11403               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
11404           if (iopt == NULL)
11405             {
11406               error (_("Out of memory\n"));
11407               return 0;
11408             }
11409
11410           offset = cnt = 0;
11411           option = iopt;
11412
11413           while (offset < sect->sh_size)
11414             {
11415               Elf_External_Options * eoption;
11416
11417               eoption = (Elf_External_Options *) ((char *) eopt + offset);
11418
11419               option->kind = BYTE_GET (eoption->kind);
11420               option->size = BYTE_GET (eoption->size);
11421               option->section = BYTE_GET (eoption->section);
11422               option->info = BYTE_GET (eoption->info);
11423
11424               offset += option->size;
11425
11426               ++option;
11427               ++cnt;
11428             }
11429
11430           printf (_("\nSection '%s' contains %d entries:\n"),
11431                   SECTION_NAME (sect), cnt);
11432
11433           option = iopt;
11434
11435           while (cnt-- > 0)
11436             {
11437               size_t len;
11438
11439               switch (option->kind)
11440                 {
11441                 case ODK_NULL:
11442                   /* This shouldn't happen.  */
11443                   printf (" NULL       %d %lx", option->section, option->info);
11444                   break;
11445                 case ODK_REGINFO:
11446                   printf (" REGINFO    ");
11447                   if (elf_header.e_machine == EM_MIPS)
11448                     {
11449                       /* 32bit form.  */
11450                       Elf32_External_RegInfo * ereg;
11451                       Elf32_RegInfo reginfo;
11452
11453                       ereg = (Elf32_External_RegInfo *) (option + 1);
11454                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11455                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11456                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11457                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11458                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11459                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11460
11461                       printf ("GPR %08lx  GP 0x%lx\n",
11462                               reginfo.ri_gprmask,
11463                               (unsigned long) reginfo.ri_gp_value);
11464                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
11465                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11466                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11467                     }
11468                   else
11469                     {
11470                       /* 64 bit form.  */
11471                       Elf64_External_RegInfo * ereg;
11472                       Elf64_Internal_RegInfo reginfo;
11473
11474                       ereg = (Elf64_External_RegInfo *) (option + 1);
11475                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
11476                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11477                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11478                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11479                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11480                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
11481
11482                       printf ("GPR %08lx  GP 0x",
11483                               reginfo.ri_gprmask);
11484                       printf_vma (reginfo.ri_gp_value);
11485                       printf ("\n");
11486
11487                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
11488                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11489                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11490                     }
11491                   ++option;
11492                   continue;
11493                 case ODK_EXCEPTIONS:
11494                   fputs (" EXCEPTIONS fpe_min(", stdout);
11495                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
11496                   fputs (") fpe_max(", stdout);
11497                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
11498                   fputs (")", stdout);
11499
11500                   if (option->info & OEX_PAGE0)
11501                     fputs (" PAGE0", stdout);
11502                   if (option->info & OEX_SMM)
11503                     fputs (" SMM", stdout);
11504                   if (option->info & OEX_FPDBUG)
11505                     fputs (" FPDBUG", stdout);
11506                   if (option->info & OEX_DISMISS)
11507                     fputs (" DISMISS", stdout);
11508                   break;
11509                 case ODK_PAD:
11510                   fputs (" PAD       ", stdout);
11511                   if (option->info & OPAD_PREFIX)
11512                     fputs (" PREFIX", stdout);
11513                   if (option->info & OPAD_POSTFIX)
11514                     fputs (" POSTFIX", stdout);
11515                   if (option->info & OPAD_SYMBOL)
11516                     fputs (" SYMBOL", stdout);
11517                   break;
11518                 case ODK_HWPATCH:
11519                   fputs (" HWPATCH   ", stdout);
11520                   if (option->info & OHW_R4KEOP)
11521                     fputs (" R4KEOP", stdout);
11522                   if (option->info & OHW_R8KPFETCH)
11523                     fputs (" R8KPFETCH", stdout);
11524                   if (option->info & OHW_R5KEOP)
11525                     fputs (" R5KEOP", stdout);
11526                   if (option->info & OHW_R5KCVTL)
11527                     fputs (" R5KCVTL", stdout);
11528                   break;
11529                 case ODK_FILL:
11530                   fputs (" FILL       ", stdout);
11531                   /* XXX Print content of info word?  */
11532                   break;
11533                 case ODK_TAGS:
11534                   fputs (" TAGS       ", stdout);
11535                   /* XXX Print content of info word?  */
11536                   break;
11537                 case ODK_HWAND:
11538                   fputs (" HWAND     ", stdout);
11539                   if (option->info & OHWA0_R4KEOP_CHECKED)
11540                     fputs (" R4KEOP_CHECKED", stdout);
11541                   if (option->info & OHWA0_R4KEOP_CLEAN)
11542                     fputs (" R4KEOP_CLEAN", stdout);
11543                   break;
11544                 case ODK_HWOR:
11545                   fputs (" HWOR      ", stdout);
11546                   if (option->info & OHWA0_R4KEOP_CHECKED)
11547                     fputs (" R4KEOP_CHECKED", stdout);
11548                   if (option->info & OHWA0_R4KEOP_CLEAN)
11549                     fputs (" R4KEOP_CLEAN", stdout);
11550                   break;
11551                 case ODK_GP_GROUP:
11552                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
11553                           option->info & OGP_GROUP,
11554                           (option->info & OGP_SELF) >> 16);
11555                   break;
11556                 case ODK_IDENT:
11557                   printf (" IDENT     %#06lx  self-contained %#06lx",
11558                           option->info & OGP_GROUP,
11559                           (option->info & OGP_SELF) >> 16);
11560                   break;
11561                 default:
11562                   /* This shouldn't happen.  */
11563                   printf (" %3d ???     %d %lx",
11564                           option->kind, option->section, option->info);
11565                   break;
11566                 }
11567
11568               len = sizeof (* eopt);
11569               while (len < option->size)
11570                 if (((char *) option)[len] >= ' '
11571                     && ((char *) option)[len] < 0x7f)
11572                   printf ("%c", ((char *) option)[len++]);
11573                 else
11574                   printf ("\\%03o", ((char *) option)[len++]);
11575
11576               fputs ("\n", stdout);
11577               ++option;
11578             }
11579
11580           free (eopt);
11581         }
11582     }
11583
11584   if (conflicts_offset != 0 && conflictsno != 0)
11585     {
11586       Elf32_Conflict * iconf;
11587       size_t cnt;
11588
11589       if (dynamic_symbols == NULL)
11590         {
11591           error (_("conflict list found without a dynamic symbol table\n"));
11592           return 0;
11593         }
11594
11595       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
11596       if (iconf == NULL)
11597         {
11598           error (_("Out of memory\n"));
11599           return 0;
11600         }
11601
11602       if (is_32bit_elf)
11603         {
11604           Elf32_External_Conflict * econf32;
11605
11606           econf32 = (Elf32_External_Conflict *)
11607               get_data (NULL, file, conflicts_offset, conflictsno,
11608                         sizeof (* econf32), _("conflict"));
11609           if (!econf32)
11610             return 0;
11611
11612           for (cnt = 0; cnt < conflictsno; ++cnt)
11613             iconf[cnt] = BYTE_GET (econf32[cnt]);
11614
11615           free (econf32);
11616         }
11617       else
11618         {
11619           Elf64_External_Conflict * econf64;
11620
11621           econf64 = (Elf64_External_Conflict *)
11622               get_data (NULL, file, conflicts_offset, conflictsno,
11623                         sizeof (* econf64), _("conflict"));
11624           if (!econf64)
11625             return 0;
11626
11627           for (cnt = 0; cnt < conflictsno; ++cnt)
11628             iconf[cnt] = BYTE_GET (econf64[cnt]);
11629
11630           free (econf64);
11631         }
11632
11633       printf (_("\nSection '.conflict' contains %lu entries:\n"),
11634               (unsigned long) conflictsno);
11635       puts (_("  Num:    Index       Value  Name"));
11636
11637       for (cnt = 0; cnt < conflictsno; ++cnt)
11638         {
11639           Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
11640
11641           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
11642           print_vma (psym->st_value, FULL_HEX);
11643           putchar (' ');
11644           if (VALID_DYNAMIC_NAME (psym->st_name))
11645             print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11646           else
11647             printf (_("<corrupt: %14ld>"), psym->st_name);
11648           putchar ('\n');
11649         }
11650
11651       free (iconf);
11652     }
11653
11654   if (pltgot != 0 && local_gotno != 0)
11655     {
11656       bfd_vma ent, local_end, global_end;
11657       size_t i, offset;
11658       unsigned char * data;
11659       int addr_size;
11660
11661       ent = pltgot;
11662       addr_size = (is_32bit_elf ? 4 : 8);
11663       local_end = pltgot + local_gotno * addr_size;
11664       global_end = local_end + (symtabno - gotsym) * addr_size;
11665
11666       offset = offset_from_vma (file, pltgot, global_end - pltgot);
11667       data = (unsigned char *) get_data (NULL, file, offset,
11668                                          global_end - pltgot, 1, _("GOT"));
11669       printf (_("\nPrimary GOT:\n"));
11670       printf (_(" Canonical gp value: "));
11671       print_vma (pltgot + 0x7ff0, LONG_HEX);
11672       printf ("\n\n");
11673
11674       printf (_(" Reserved entries:\n"));
11675       printf (_("  %*s %10s %*s Purpose\n"),
11676               addr_size * 2, _("Address"), _("Access"),
11677               addr_size * 2, _("Initial"));
11678       ent = print_mips_got_entry (data, pltgot, ent);
11679       printf (_(" Lazy resolver\n"));
11680       if (data
11681           && (byte_get (data + ent - pltgot, addr_size)
11682               >> (addr_size * 8 - 1)) != 0)
11683         {
11684           ent = print_mips_got_entry (data, pltgot, ent);
11685           printf (_(" Module pointer (GNU extension)\n"));
11686         }
11687       printf ("\n");
11688
11689       if (ent < local_end)
11690         {
11691           printf (_(" Local entries:\n"));
11692           printf ("  %*s %10s %*s\n",
11693                   addr_size * 2, _("Address"), _("Access"),
11694                   addr_size * 2, _("Initial"));
11695           while (ent < local_end)
11696             {
11697               ent = print_mips_got_entry (data, pltgot, ent);
11698               printf ("\n");
11699             }
11700           printf ("\n");
11701         }
11702
11703       if (gotsym < symtabno)
11704         {
11705           int sym_width;
11706
11707           printf (_(" Global entries:\n"));
11708           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
11709                   addr_size * 2, _("Address"), _("Access"),
11710                   addr_size * 2, _("Initial"),
11711                   addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11712           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
11713           for (i = gotsym; i < symtabno; i++)
11714             {
11715               Elf_Internal_Sym * psym;
11716
11717               psym = dynamic_symbols + i;
11718               ent = print_mips_got_entry (data, pltgot, ent);
11719               printf (" ");
11720               print_vma (psym->st_value, LONG_HEX);
11721               printf (" %-7s %3s ",
11722                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
11723                       get_symbol_index_type (psym->st_shndx));
11724               if (VALID_DYNAMIC_NAME (psym->st_name))
11725                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
11726               else
11727                 printf (_("<corrupt: %14ld>"), psym->st_name);
11728               printf ("\n");
11729             }
11730           printf ("\n");
11731         }
11732
11733       if (data)
11734         free (data);
11735     }
11736
11737   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
11738     {
11739       bfd_vma ent, end;
11740       size_t offset, rel_offset;
11741       unsigned long count, i;
11742       unsigned char * data;
11743       int addr_size, sym_width;
11744       Elf_Internal_Rela * rels;
11745
11746       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
11747       if (pltrel == DT_RELA)
11748         {
11749           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
11750             return 0;
11751         }
11752       else
11753         {
11754           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
11755             return 0;
11756         }
11757
11758       ent = mips_pltgot;
11759       addr_size = (is_32bit_elf ? 4 : 8);
11760       end = mips_pltgot + (2 + count) * addr_size;
11761
11762       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
11763       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
11764                                          1, _("PLT GOT"));
11765       printf (_("\nPLT GOT:\n\n"));
11766       printf (_(" Reserved entries:\n"));
11767       printf (_("  %*s %*s Purpose\n"),
11768               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
11769       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
11770       printf (_(" PLT lazy resolver\n"));
11771       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
11772       printf (_(" Module pointer\n"));
11773       printf ("\n");
11774
11775       printf (_(" Entries:\n"));
11776       printf ("  %*s %*s %*s %-7s %3s %s\n",
11777               addr_size * 2, _("Address"),
11778               addr_size * 2, _("Initial"),
11779               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11780       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
11781       for (i = 0; i < count; i++)
11782         {
11783           Elf_Internal_Sym * psym;
11784
11785           psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
11786           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
11787           printf (" ");
11788           print_vma (psym->st_value, LONG_HEX);
11789           printf (" %-7s %3s ",
11790                   get_symbol_type (ELF_ST_TYPE (psym->st_info)),
11791                   get_symbol_index_type (psym->st_shndx));
11792           if (VALID_DYNAMIC_NAME (psym->st_name))
11793             print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
11794           else
11795             printf (_("<corrupt: %14ld>"), psym->st_name);
11796           printf ("\n");
11797         }
11798       printf ("\n");
11799
11800       if (data)
11801         free (data);
11802       free (rels);
11803     }
11804
11805   return 1;
11806 }
11807
11808 static int
11809 process_gnu_liblist (FILE * file)
11810 {
11811   Elf_Internal_Shdr * section;
11812   Elf_Internal_Shdr * string_sec;
11813   Elf32_External_Lib * elib;
11814   char * strtab;
11815   size_t strtab_size;
11816   size_t cnt;
11817   unsigned i;
11818
11819   if (! do_arch)
11820     return 0;
11821
11822   for (i = 0, section = section_headers;
11823        i < elf_header.e_shnum;
11824        i++, section++)
11825     {
11826       switch (section->sh_type)
11827         {
11828         case SHT_GNU_LIBLIST:
11829           if (section->sh_link >= elf_header.e_shnum)
11830             break;
11831
11832           elib = (Elf32_External_Lib *)
11833               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
11834                         _("liblist"));
11835
11836           if (elib == NULL)
11837             break;
11838           string_sec = section_headers + section->sh_link;
11839
11840           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
11841                                       string_sec->sh_size,
11842                                       _("liblist string table"));
11843           strtab_size = string_sec->sh_size;
11844
11845           if (strtab == NULL
11846               || section->sh_entsize != sizeof (Elf32_External_Lib))
11847             {
11848               free (elib);
11849               free (strtab);
11850               break;
11851             }
11852
11853           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11854                   SECTION_NAME (section),
11855                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
11856
11857           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
11858
11859           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
11860                ++cnt)
11861             {
11862               Elf32_Lib liblist;
11863               time_t atime;
11864               char timebuf[20];
11865               struct tm * tmp;
11866
11867               liblist.l_name = BYTE_GET (elib[cnt].l_name);
11868               atime = BYTE_GET (elib[cnt].l_time_stamp);
11869               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11870               liblist.l_version = BYTE_GET (elib[cnt].l_version);
11871               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11872
11873               tmp = gmtime (&atime);
11874               snprintf (timebuf, sizeof (timebuf),
11875                         "%04u-%02u-%02uT%02u:%02u:%02u",
11876                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11877                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
11878
11879               printf ("%3lu: ", (unsigned long) cnt);
11880               if (do_wide)
11881                 printf ("%-20s", liblist.l_name < strtab_size
11882                         ? strtab + liblist.l_name : _("<corrupt>"));
11883               else
11884                 printf ("%-20.20s", liblist.l_name < strtab_size
11885                         ? strtab + liblist.l_name : _("<corrupt>"));
11886               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
11887                       liblist.l_version, liblist.l_flags);
11888             }
11889
11890           free (elib);
11891           free (strtab);
11892         }
11893     }
11894
11895   return 1;
11896 }
11897
11898 static const char *
11899 get_note_type (unsigned e_type)
11900 {
11901   static char buff[64];
11902
11903   if (elf_header.e_type == ET_CORE)
11904     switch (e_type)
11905       {
11906       case NT_AUXV:
11907         return _("NT_AUXV (auxiliary vector)");
11908       case NT_PRSTATUS:
11909         return _("NT_PRSTATUS (prstatus structure)");
11910       case NT_FPREGSET:
11911         return _("NT_FPREGSET (floating point registers)");
11912       case NT_PRPSINFO:
11913         return _("NT_PRPSINFO (prpsinfo structure)");
11914       case NT_TASKSTRUCT:
11915         return _("NT_TASKSTRUCT (task structure)");
11916       case NT_PRXFPREG:
11917         return _("NT_PRXFPREG (user_xfpregs structure)");
11918       case NT_PPC_VMX:
11919         return _("NT_PPC_VMX (ppc Altivec registers)");
11920       case NT_PPC_VSX:
11921         return _("NT_PPC_VSX (ppc VSX registers)");
11922       case NT_X86_XSTATE:
11923         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
11924       case NT_S390_HIGH_GPRS:
11925         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
11926       case NT_S390_TIMER:
11927         return _("NT_S390_TIMER (s390 timer register)");
11928       case NT_S390_TODCMP:
11929         return _("NT_S390_TODCMP (s390 TOD comparator register)");
11930       case NT_S390_TODPREG:
11931         return _("NT_S390_TODPREG (s390 TOD programmable register)");
11932       case NT_S390_CTRS:
11933         return _("NT_S390_CTRS (s390 control registers)");
11934       case NT_S390_PREFIX:
11935         return _("NT_S390_PREFIX (s390 prefix register)");
11936       case NT_PSTATUS:
11937         return _("NT_PSTATUS (pstatus structure)");
11938       case NT_FPREGS:
11939         return _("NT_FPREGS (floating point registers)");
11940       case NT_PSINFO:
11941         return _("NT_PSINFO (psinfo structure)");
11942       case NT_LWPSTATUS:
11943         return _("NT_LWPSTATUS (lwpstatus_t structure)");
11944       case NT_LWPSINFO:
11945         return _("NT_LWPSINFO (lwpsinfo_t structure)");
11946       case NT_WIN32PSTATUS:
11947         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11948       default:
11949         break;
11950       }
11951   else
11952     switch (e_type)
11953       {
11954       case NT_VERSION:
11955         return _("NT_VERSION (version)");
11956       case NT_ARCH:
11957         return _("NT_ARCH (architecture)");
11958       default:
11959         break;
11960       }
11961
11962   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11963   return buff;
11964 }
11965
11966 static const char *
11967 get_gnu_elf_note_type (unsigned e_type)
11968 {
11969   static char buff[64];
11970
11971   switch (e_type)
11972     {
11973     case NT_GNU_ABI_TAG:
11974       return _("NT_GNU_ABI_TAG (ABI version tag)");
11975     case NT_GNU_HWCAP:
11976       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
11977     case NT_GNU_BUILD_ID:
11978       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
11979     case NT_GNU_GOLD_VERSION:
11980       return _("NT_GNU_GOLD_VERSION (gold version)");
11981     default:
11982       break;
11983     }
11984
11985   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11986   return buff;
11987 }
11988
11989 static const char *
11990 get_netbsd_elfcore_note_type (unsigned e_type)
11991 {
11992   static char buff[64];
11993
11994   if (e_type == NT_NETBSDCORE_PROCINFO)
11995     {
11996       /* NetBSD core "procinfo" structure.  */
11997       return _("NetBSD procinfo structure");
11998     }
11999
12000   /* As of Jan 2002 there are no other machine-independent notes
12001      defined for NetBSD core files.  If the note type is less
12002      than the start of the machine-dependent note types, we don't
12003      understand it.  */
12004
12005   if (e_type < NT_NETBSDCORE_FIRSTMACH)
12006     {
12007       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12008       return buff;
12009     }
12010
12011   switch (elf_header.e_machine)
12012     {
12013     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
12014        and PT_GETFPREGS == mach+2.  */
12015
12016     case EM_OLD_ALPHA:
12017     case EM_ALPHA:
12018     case EM_SPARC:
12019     case EM_SPARC32PLUS:
12020     case EM_SPARCV9:
12021       switch (e_type)
12022         {
12023         case NT_NETBSDCORE_FIRSTMACH + 0:
12024           return _("PT_GETREGS (reg structure)");
12025         case NT_NETBSDCORE_FIRSTMACH + 2:
12026           return _("PT_GETFPREGS (fpreg structure)");
12027         default:
12028           break;
12029         }
12030       break;
12031
12032     /* On all other arch's, PT_GETREGS == mach+1 and
12033        PT_GETFPREGS == mach+3.  */
12034     default:
12035       switch (e_type)
12036         {
12037         case NT_NETBSDCORE_FIRSTMACH + 1:
12038           return _("PT_GETREGS (reg structure)");
12039         case NT_NETBSDCORE_FIRSTMACH + 3:
12040           return _("PT_GETFPREGS (fpreg structure)");
12041         default:
12042           break;
12043         }
12044     }
12045
12046   snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
12047             e_type - NT_NETBSDCORE_FIRSTMACH);
12048   return buff;
12049 }
12050
12051 /* Note that by the ELF standard, the name field is already null byte
12052    terminated, and namesz includes the terminating null byte.
12053    I.E. the value of namesz for the name "FSF" is 4.
12054
12055    If the value of namesz is zero, there is no name present.  */
12056 static int
12057 process_note (Elf_Internal_Note * pnote)
12058 {
12059   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
12060   const char * nt;
12061
12062   if (pnote->namesz == 0)
12063     /* If there is no note name, then use the default set of
12064        note type strings.  */
12065     nt = get_note_type (pnote->type);
12066
12067   else if (const_strneq (pnote->namedata, "GNU"))
12068     /* GNU-specific object file notes.  */
12069     nt = get_gnu_elf_note_type (pnote->type);
12070
12071   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
12072     /* NetBSD-specific core file notes.  */
12073     nt = get_netbsd_elfcore_note_type (pnote->type);
12074
12075   else if (strneq (pnote->namedata, "SPU/", 4))
12076     {
12077       /* SPU-specific core file notes.  */
12078       nt = pnote->namedata + 4;
12079       name = "SPU";
12080     }
12081
12082   else
12083     /* Don't recognize this note name; just use the default set of
12084        note type strings.  */
12085       nt = get_note_type (pnote->type);
12086
12087   printf ("  %s\t\t0x%08lx\t%s\n", name, pnote->descsz, nt);
12088   return 1;
12089 }
12090
12091
12092 static int
12093 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
12094 {
12095   Elf_External_Note * pnotes;
12096   Elf_External_Note * external;
12097   int res = 1;
12098
12099   if (length <= 0)
12100     return 0;
12101
12102   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
12103                                            _("notes"));
12104   if (pnotes == NULL)
12105     return 0;
12106
12107   external = pnotes;
12108
12109   printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
12110           (unsigned long) offset, (unsigned long) length);
12111   printf (_("  Owner\t\tData size\tDescription\n"));
12112
12113   while (external < (Elf_External_Note *) ((char *) pnotes + length))
12114     {
12115       Elf_External_Note * next;
12116       Elf_Internal_Note inote;
12117       char * temp = NULL;
12118
12119       inote.type     = BYTE_GET (external->type);
12120       inote.namesz   = BYTE_GET (external->namesz);
12121       inote.namedata = external->name;
12122       inote.descsz   = BYTE_GET (external->descsz);
12123       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
12124       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
12125
12126       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
12127
12128       if (   ((char *) next > ((char *) pnotes) + length)
12129           || ((char *) next <  (char *) pnotes))
12130         {
12131           warn (_("corrupt note found at offset %lx into core notes\n"),
12132                 (unsigned long) ((char *) external - (char *) pnotes));
12133           warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12134                 inote.type, inote.namesz, inote.descsz);
12135           break;
12136         }
12137
12138       external = next;
12139
12140       /* Prevent out-of-bounds indexing.  */
12141       if (inote.namedata + inote.namesz >= (char *) pnotes + length
12142           || inote.namedata + inote.namesz < inote.namedata)
12143         {
12144           warn (_("corrupt note found at offset %lx into core notes\n"),
12145                 (unsigned long) ((char *) external - (char *) pnotes));
12146           warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12147                 inote.type, inote.namesz, inote.descsz);
12148           break;
12149         }
12150
12151       /* Verify that name is null terminated.  It appears that at least
12152          one version of Linux (RedHat 6.0) generates corefiles that don't
12153          comply with the ELF spec by failing to include the null byte in
12154          namesz.  */
12155       if (inote.namedata[inote.namesz] != '\0')
12156         {
12157           temp = (char *) malloc (inote.namesz + 1);
12158
12159           if (temp == NULL)
12160             {
12161               error (_("Out of memory\n"));
12162               res = 0;
12163               break;
12164             }
12165
12166           strncpy (temp, inote.namedata, inote.namesz);
12167           temp[inote.namesz] = 0;
12168
12169           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
12170           inote.namedata = temp;
12171         }
12172
12173       res &= process_note (& inote);
12174
12175       if (temp != NULL)
12176         {
12177           free (temp);
12178           temp = NULL;
12179         }
12180     }
12181
12182   free (pnotes);
12183
12184   return res;
12185 }
12186
12187 static int
12188 process_corefile_note_segments (FILE * file)
12189 {
12190   Elf_Internal_Phdr * segment;
12191   unsigned int i;
12192   int res = 1;
12193
12194   if (! get_program_headers (file))
12195       return 0;
12196
12197   for (i = 0, segment = program_headers;
12198        i < elf_header.e_phnum;
12199        i++, segment++)
12200     {
12201       if (segment->p_type == PT_NOTE)
12202         res &= process_corefile_note_segment (file,
12203                                               (bfd_vma) segment->p_offset,
12204                                               (bfd_vma) segment->p_filesz);
12205     }
12206
12207   return res;
12208 }
12209
12210 static int
12211 process_note_sections (FILE * file)
12212 {
12213   Elf_Internal_Shdr * section;
12214   unsigned long i;
12215   int res = 1;
12216
12217   for (i = 0, section = section_headers;
12218        i < elf_header.e_shnum;
12219        i++, section++)
12220     if (section->sh_type == SHT_NOTE)
12221       res &= process_corefile_note_segment (file,
12222                                             (bfd_vma) section->sh_offset,
12223                                             (bfd_vma) section->sh_size);
12224
12225   return res;
12226 }
12227
12228 static int
12229 process_notes (FILE * file)
12230 {
12231   /* If we have not been asked to display the notes then do nothing.  */
12232   if (! do_notes)
12233     return 1;
12234
12235   if (elf_header.e_type != ET_CORE)
12236     return process_note_sections (file);
12237
12238   /* No program headers means no NOTE segment.  */
12239   if (elf_header.e_phnum > 0)
12240     return process_corefile_note_segments (file);
12241
12242   printf (_("No note segments present in the core file.\n"));
12243   return 1;
12244 }
12245
12246 static int
12247 process_arch_specific (FILE * file)
12248 {
12249   if (! do_arch)
12250     return 1;
12251
12252   switch (elf_header.e_machine)
12253     {
12254     case EM_ARM:
12255       return process_arm_specific (file);
12256     case EM_MIPS:
12257     case EM_MIPS_RS3_LE:
12258       return process_mips_specific (file);
12259       break;
12260     case EM_PPC:
12261       return process_power_specific (file);
12262       break;
12263     case EM_TI_C6000:
12264       return process_tic6x_specific (file);
12265       break;
12266     default:
12267       break;
12268     }
12269   return 1;
12270 }
12271
12272 static int
12273 get_file_header (FILE * file)
12274 {
12275   /* Read in the identity array.  */
12276   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
12277     return 0;
12278
12279   /* Determine how to read the rest of the header.  */
12280   switch (elf_header.e_ident[EI_DATA])
12281     {
12282     default: /* fall through */
12283     case ELFDATANONE: /* fall through */
12284     case ELFDATA2LSB:
12285       byte_get = byte_get_little_endian;
12286       byte_put = byte_put_little_endian;
12287       break;
12288     case ELFDATA2MSB:
12289       byte_get = byte_get_big_endian;
12290       byte_put = byte_put_big_endian;
12291       break;
12292     }
12293
12294   /* For now we only support 32 bit and 64 bit ELF files.  */
12295   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
12296
12297   /* Read in the rest of the header.  */
12298   if (is_32bit_elf)
12299     {
12300       Elf32_External_Ehdr ehdr32;
12301
12302       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
12303         return 0;
12304
12305       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
12306       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
12307       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
12308       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
12309       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
12310       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
12311       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
12312       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
12313       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
12314       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
12315       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
12316       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
12317       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
12318     }
12319   else
12320     {
12321       Elf64_External_Ehdr ehdr64;
12322
12323       /* If we have been compiled with sizeof (bfd_vma) == 4, then
12324          we will not be able to cope with the 64bit data found in
12325          64 ELF files.  Detect this now and abort before we start
12326          overwriting things.  */
12327       if (sizeof (bfd_vma) < 8)
12328         {
12329           error (_("This instance of readelf has been built without support for a\n\
12330 64 bit data type and so it cannot read 64 bit ELF files.\n"));
12331           return 0;
12332         }
12333
12334       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
12335         return 0;
12336
12337       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
12338       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
12339       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
12340       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
12341       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
12342       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
12343       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
12344       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
12345       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
12346       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
12347       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
12348       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
12349       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
12350     }
12351
12352   if (elf_header.e_shoff)
12353     {
12354       /* There may be some extensions in the first section header.  Don't
12355          bomb if we can't read it.  */
12356       if (is_32bit_elf)
12357         get_32bit_section_headers (file, 1);
12358       else
12359         get_64bit_section_headers (file, 1);
12360     }
12361
12362   return 1;
12363 }
12364
12365 /* Process one ELF object file according to the command line options.
12366    This file may actually be stored in an archive.  The file is
12367    positioned at the start of the ELF object.  */
12368
12369 static int
12370 process_object (char * file_name, FILE * file)
12371 {
12372   unsigned int i;
12373
12374   if (! get_file_header (file))
12375     {
12376       error (_("%s: Failed to read file header\n"), file_name);
12377       return 1;
12378     }
12379
12380   /* Initialise per file variables.  */
12381   for (i = ARRAY_SIZE (version_info); i--;)
12382     version_info[i] = 0;
12383
12384   for (i = ARRAY_SIZE (dynamic_info); i--;)
12385     dynamic_info[i] = 0;
12386   dynamic_info_DT_GNU_HASH = 0;
12387
12388   /* Process the file.  */
12389   if (show_name)
12390     printf (_("\nFile: %s\n"), file_name);
12391
12392   /* Initialise the dump_sects array from the cmdline_dump_sects array.
12393      Note we do this even if cmdline_dump_sects is empty because we
12394      must make sure that the dump_sets array is zeroed out before each
12395      object file is processed.  */
12396   if (num_dump_sects > num_cmdline_dump_sects)
12397     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
12398
12399   if (num_cmdline_dump_sects > 0)
12400     {
12401       if (num_dump_sects == 0)
12402         /* A sneaky way of allocating the dump_sects array.  */
12403         request_dump_bynumber (num_cmdline_dump_sects, 0);
12404
12405       assert (num_dump_sects >= num_cmdline_dump_sects);
12406       memcpy (dump_sects, cmdline_dump_sects,
12407               num_cmdline_dump_sects * sizeof (* dump_sects));
12408     }
12409
12410   if (! process_file_header ())
12411     return 1;
12412
12413   if (! process_section_headers (file))
12414     {
12415       /* Without loaded section headers we cannot process lots of
12416          things.  */
12417       do_unwind = do_version = do_dump = do_arch = 0;
12418
12419       if (! do_using_dynamic)
12420         do_syms = do_dyn_syms = do_reloc = 0;
12421     }
12422
12423   if (! process_section_groups (file))
12424     {
12425       /* Without loaded section groups we cannot process unwind.  */
12426       do_unwind = 0;
12427     }
12428
12429   if (process_program_headers (file))
12430     process_dynamic_section (file);
12431
12432   process_relocs (file);
12433
12434   process_unwind (file);
12435
12436   process_symbol_table (file);
12437
12438   process_syminfo (file);
12439
12440   process_version_sections (file);
12441
12442   process_section_contents (file);
12443
12444   process_notes (file);
12445
12446   process_gnu_liblist (file);
12447
12448   process_arch_specific (file);
12449
12450   if (program_headers)
12451     {
12452       free (program_headers);
12453       program_headers = NULL;
12454     }
12455
12456   if (section_headers)
12457     {
12458       free (section_headers);
12459       section_headers = NULL;
12460     }
12461
12462   if (string_table)
12463     {
12464       free (string_table);
12465       string_table = NULL;
12466       string_table_length = 0;
12467     }
12468
12469   if (dynamic_strings)
12470     {
12471       free (dynamic_strings);
12472       dynamic_strings = NULL;
12473       dynamic_strings_length = 0;
12474     }
12475
12476   if (dynamic_symbols)
12477     {
12478       free (dynamic_symbols);
12479       dynamic_symbols = NULL;
12480       num_dynamic_syms = 0;
12481     }
12482
12483   if (dynamic_syminfo)
12484     {
12485       free (dynamic_syminfo);
12486       dynamic_syminfo = NULL;
12487     }
12488
12489   if (dynamic_section)
12490     {
12491       free (dynamic_section);
12492       dynamic_section = NULL;
12493     }
12494
12495   if (section_headers_groups)
12496     {
12497       free (section_headers_groups);
12498       section_headers_groups = NULL;
12499     }
12500
12501   if (section_groups)
12502     {
12503       struct group_list * g;
12504       struct group_list * next;
12505
12506       for (i = 0; i < group_count; i++)
12507         {
12508           for (g = section_groups [i].root; g != NULL; g = next)
12509             {
12510               next = g->next;
12511               free (g);
12512             }
12513         }
12514
12515       free (section_groups);
12516       section_groups = NULL;
12517     }
12518
12519   free_debug_memory ();
12520
12521   return 0;
12522 }
12523
12524 /* Process an ELF archive.
12525    On entry the file is positioned just after the ARMAG string.  */
12526
12527 static int
12528 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
12529 {
12530   struct archive_info arch;
12531   struct archive_info nested_arch;
12532   size_t got;
12533   int ret;
12534
12535   show_name = 1;
12536
12537   /* The ARCH structure is used to hold information about this archive.  */
12538   arch.file_name = NULL;
12539   arch.file = NULL;
12540   arch.index_array = NULL;
12541   arch.sym_table = NULL;
12542   arch.longnames = NULL;
12543
12544   /* The NESTED_ARCH structure is used as a single-item cache of information
12545      about a nested archive (when members of a thin archive reside within
12546      another regular archive file).  */
12547   nested_arch.file_name = NULL;
12548   nested_arch.file = NULL;
12549   nested_arch.index_array = NULL;
12550   nested_arch.sym_table = NULL;
12551   nested_arch.longnames = NULL;
12552
12553   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
12554     {
12555       ret = 1;
12556       goto out;
12557     }
12558
12559   if (do_archive_index)
12560     {
12561       if (arch.sym_table == NULL)
12562         error (_("%s: unable to dump the index as none was found\n"), file_name);
12563       else
12564         {
12565           unsigned int i, l;
12566           unsigned long current_pos;
12567
12568           printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
12569                   file_name, arch.index_num, arch.sym_size);
12570           current_pos = ftell (file);
12571
12572           for (i = l = 0; i < arch.index_num; i++)
12573             {
12574               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
12575                 {
12576                   char * member_name;
12577
12578                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
12579
12580                   if (member_name != NULL)
12581                     {
12582                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
12583
12584                       if (qualified_name != NULL)
12585                         {
12586                           printf (_("Binary %s contains:\n"), qualified_name);
12587                           free (qualified_name);
12588                         }
12589                     }
12590                 }
12591
12592               if (l >= arch.sym_size)
12593                 {
12594                   error (_("%s: end of the symbol table reached before the end of the index\n"),
12595                          file_name);
12596                   break;
12597                 }
12598               printf ("\t%s\n", arch.sym_table + l);
12599               l += strlen (arch.sym_table + l) + 1;
12600             }
12601
12602           if (l & 01)
12603             ++l;
12604           if (l < arch.sym_size)
12605             error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
12606                    file_name);
12607
12608           if (fseek (file, current_pos, SEEK_SET) != 0)
12609             {
12610               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
12611               ret = 1;
12612               goto out;
12613             }
12614         }
12615
12616       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
12617           && !do_segments && !do_header && !do_dump && !do_version
12618           && !do_histogram && !do_debugging && !do_arch && !do_notes
12619           && !do_section_groups && !do_dyn_syms)
12620         {
12621           ret = 0; /* Archive index only.  */
12622           goto out;
12623         }
12624     }
12625
12626   ret = 0;
12627
12628   while (1)
12629     {
12630       char * name;
12631       size_t namelen;
12632       char * qualified_name;
12633
12634       /* Read the next archive header.  */
12635       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
12636         {
12637           error (_("%s: failed to seek to next archive header\n"), file_name);
12638           return 1;
12639         }
12640       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
12641       if (got != sizeof arch.arhdr)
12642         {
12643           if (got == 0)
12644             break;
12645           error (_("%s: failed to read archive header\n"), file_name);
12646           ret = 1;
12647           break;
12648         }
12649       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
12650         {
12651           error (_("%s: did not find a valid archive header\n"), arch.file_name);
12652           ret = 1;
12653           break;
12654         }
12655
12656       arch.next_arhdr_offset += sizeof arch.arhdr;
12657
12658       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
12659       if (archive_file_size & 01)
12660         ++archive_file_size;
12661
12662       name = get_archive_member_name (&arch, &nested_arch);
12663       if (name == NULL)
12664         {
12665           error (_("%s: bad archive file name\n"), file_name);
12666           ret = 1;
12667           break;
12668         }
12669       namelen = strlen (name);
12670
12671       qualified_name = make_qualified_name (&arch, &nested_arch, name);
12672       if (qualified_name == NULL)
12673         {
12674           error (_("%s: bad archive file name\n"), file_name);
12675           ret = 1;
12676           break;
12677         }
12678
12679       if (is_thin_archive && arch.nested_member_origin == 0)
12680         {
12681           /* This is a proxy for an external member of a thin archive.  */
12682           FILE * member_file;
12683           char * member_file_name = adjust_relative_path (file_name, name, namelen);
12684           if (member_file_name == NULL)
12685             {
12686               ret = 1;
12687               break;
12688             }
12689
12690           member_file = fopen (member_file_name, "rb");
12691           if (member_file == NULL)
12692             {
12693               error (_("Input file '%s' is not readable.\n"), member_file_name);
12694               free (member_file_name);
12695               ret = 1;
12696               break;
12697             }
12698
12699           archive_file_offset = arch.nested_member_origin;
12700
12701           ret |= process_object (qualified_name, member_file);
12702
12703           fclose (member_file);
12704           free (member_file_name);
12705         }
12706       else if (is_thin_archive)
12707         {
12708           /* This is a proxy for a member of a nested archive.  */
12709           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
12710
12711           /* The nested archive file will have been opened and setup by
12712              get_archive_member_name.  */
12713           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
12714             {
12715               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
12716               ret = 1;
12717               break;
12718             }
12719
12720           ret |= process_object (qualified_name, nested_arch.file);
12721         }
12722       else
12723         {
12724           archive_file_offset = arch.next_arhdr_offset;
12725           arch.next_arhdr_offset += archive_file_size;
12726
12727           ret |= process_object (qualified_name, file);
12728         }
12729
12730       if (dump_sects != NULL)
12731         {
12732           free (dump_sects);
12733           dump_sects = NULL;
12734           num_dump_sects = 0;
12735         }
12736
12737       free (qualified_name);
12738     }
12739
12740  out:
12741   if (nested_arch.file != NULL)
12742     fclose (nested_arch.file);
12743   release_archive (&nested_arch);
12744   release_archive (&arch);
12745
12746   return ret;
12747 }
12748
12749 static int
12750 process_file (char * file_name)
12751 {
12752   FILE * file;
12753   struct stat statbuf;
12754   char armag[SARMAG];
12755   int ret;
12756
12757   if (stat (file_name, &statbuf) < 0)
12758     {
12759       if (errno == ENOENT)
12760         error (_("'%s': No such file\n"), file_name);
12761       else
12762         error (_("Could not locate '%s'.  System error message: %s\n"),
12763                file_name, strerror (errno));
12764       return 1;
12765     }
12766
12767   if (! S_ISREG (statbuf.st_mode))
12768     {
12769       error (_("'%s' is not an ordinary file\n"), file_name);
12770       return 1;
12771     }
12772
12773   file = fopen (file_name, "rb");
12774   if (file == NULL)
12775     {
12776       error (_("Input file '%s' is not readable.\n"), file_name);
12777       return 1;
12778     }
12779
12780   if (fread (armag, SARMAG, 1, file) != 1)
12781     {
12782       error (_("%s: Failed to read file's magic number\n"), file_name);
12783       fclose (file);
12784       return 1;
12785     }
12786
12787   if (memcmp (armag, ARMAG, SARMAG) == 0)
12788     ret = process_archive (file_name, file, FALSE);
12789   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
12790     ret = process_archive (file_name, file, TRUE);
12791   else
12792     {
12793       if (do_archive_index)
12794         error (_("File %s is not an archive so its index cannot be displayed.\n"),
12795                file_name);
12796
12797       rewind (file);
12798       archive_file_size = archive_file_offset = 0;
12799       ret = process_object (file_name, file);
12800     }
12801
12802   fclose (file);
12803
12804   return ret;
12805 }
12806
12807 #ifdef SUPPORT_DISASSEMBLY
12808 /* Needed by the i386 disassembler.  For extra credit, someone could
12809    fix this so that we insert symbolic addresses here, esp for GOT/PLT
12810    symbols.  */
12811
12812 void
12813 print_address (unsigned int addr, FILE * outfile)
12814 {
12815   fprintf (outfile,"0x%8.8x", addr);
12816 }
12817
12818 /* Needed by the i386 disassembler.  */
12819 void
12820 db_task_printsym (unsigned int addr)
12821 {
12822   print_address (addr, stderr);
12823 }
12824 #endif
12825
12826 int
12827 main (int argc, char ** argv)
12828 {
12829   int err;
12830
12831 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12832   setlocale (LC_MESSAGES, "");
12833 #endif
12834 #if defined (HAVE_SETLOCALE)
12835   setlocale (LC_CTYPE, "");
12836 #endif
12837   bindtextdomain (PACKAGE, LOCALEDIR);
12838   textdomain (PACKAGE);
12839
12840   expandargv (&argc, &argv);
12841
12842   parse_args (argc, argv);
12843
12844   if (num_dump_sects > 0)
12845     {
12846       /* Make a copy of the dump_sects array.  */
12847       cmdline_dump_sects = (dump_type *)
12848           malloc (num_dump_sects * sizeof (* dump_sects));
12849       if (cmdline_dump_sects == NULL)
12850         error (_("Out of memory allocating dump request table.\n"));
12851       else
12852         {
12853           memcpy (cmdline_dump_sects, dump_sects,
12854                   num_dump_sects * sizeof (* dump_sects));
12855           num_cmdline_dump_sects = num_dump_sects;
12856         }
12857     }
12858
12859   if (optind < (argc - 1))
12860     show_name = 1;
12861
12862   err = 0;
12863   while (optind < argc)
12864     err |= process_file (argv[optind++]);
12865
12866   if (dump_sects != NULL)
12867     free (dump_sects);
12868   if (cmdline_dump_sects != NULL)
12869     free (cmdline_dump_sects);
12870
12871   return err;
12872 }