binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
   3    Free Software Foundation, Inc.
   4
   5    Originally developed by Eric Youngdale <eric@andante.jic.com>
   6    Modifications by Nick Clifton <nickc@redhat.com>
   7
   8    This file is part of GNU Binutils.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  23    02110-1301, USA.  */
  24 \f
  25 /* The difference between readelf and objdump:
  26
  27   Both programs are capable of displaying the contents of ELF format files,
  28   so why does the binutils project have two file dumpers ?
  29
  30   The reason is that objdump sees an ELF file through a BFD filter of the
  31   world; if BFD has a bug where, say, it disagrees about a machine constant
  32   in e_flags, then the odds are good that it will remain internally
  33   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
  34   GAS sees it the BFD way.  There was need for a tool to go find out what
  35   the file actually says.
  36
  37   This is why the readelf program does not link against the BFD library - it
  38   exists as an independent program to help verify the correct working of BFD.
  39
  40   There is also the case that readelf can provide more information about an
  41   ELF file than is provided by objdump.  In particular it can display DWARF
  42   debugging information which (at the moment) objdump cannot.  */
  43 \f
  44 #include <assert.h>
  45 #include <sys/types.h>
  46 #include <sys/stat.h>
  47 #include <stdio.h>
  48 #include <time.h>
  49
  50 #if __GNUC__ >= 2
  51 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  52    as this will allow us to read in and parse 64bit and 32bit ELF files.
  53    Only do this if we believe that the compiler can support a 64 bit
  54    data type.  For now we only rely on GCC being able to do this.  */
  55 #define BFD64
  56 #endif
  57
  58 #include "dwarf.h"
  59
  60 #include "elf/common.h"
  61 #include "elf/external.h"
  62 #include "elf/internal.h"
  63
  64 /* The following headers use the elf/reloc-macros.h file to
  65    automatically generate relocation recognition functions
  66    such as elf_mips_reloc_type()  */
  67
  68 #define RELOC_MACROS_GEN_FUNC
  69
  70 #include "elf/alpha.h"
  71 #include "elf/arc.h"
  72 #include "elf/arm.h"
  73 #include "elf/avr.h"
  74 #include "elf/bfin.h"
  75 #include "elf/cris.h"
  76 #include "elf/d10v.h"
  77 #include "elf/d30v.h"
  78 #include "elf/dlx.h"
  79 #include "elf/fr30.h"
  80 #include "elf/frv.h"
  81 #include "elf/h8.h"
  82 #include "elf/hppa.h"
  83 #include "elf/i386.h"
  84 #include "elf/i370.h"
  85 #include "elf/i860.h"
  86 #include "elf/i960.h"
  87 #include "elf/ia64.h"
  88 #include "elf/ip2k.h"
  89 #include "elf/m32c.h"
  90 #include "elf/m32r.h"
  91 #include "elf/m68k.h"
  92 #include "elf/m68hc11.h"
  93 #include "elf/mcore.h"
  94 #include "elf/mips.h"
  95 #include "elf/mmix.h"
  96 #include "elf/mn10200.h"
  97 #include "elf/mn10300.h"
  98 #include "elf/ms1.h"
  99 #include "elf/msp430.h"
 100 #include "elf/or32.h"
 101 #include "elf/pj.h"
 102 #include "elf/ppc.h"
 103 #include "elf/ppc64.h"
 104 #include "elf/s390.h"
 105 #include "elf/sh.h"
 106 #include "elf/sparc.h"
 107 #include "elf/v850.h"
 108 #include "elf/vax.h"
 109 #include "elf/x86-64.h"
 110 #include "elf/xstormy16.h"
 111 #include "elf/crx.h"
 112 #include "elf/iq2000.h"
 113 #include "elf/xtensa.h"
 114
 115 #include "aout/ar.h"
 116
 117 #include "bucomm.h"
 118 #include "getopt.h"
 119 #include "libiberty.h"
 120
 121 char *program_name = "readelf";
 122 static long archive_file_offset;
 123 static unsigned long archive_file_size;
 124 static unsigned long dynamic_addr;
 125 static bfd_size_type dynamic_size;
 126 static unsigned int dynamic_nent;
 127 static char *dynamic_strings;
 128 static unsigned long dynamic_strings_length;
 129 static char *string_table;
 130 static unsigned long string_table_length;
 131 static unsigned long num_dynamic_syms;
 132 static Elf_Internal_Sym *dynamic_symbols;
 133 static Elf_Internal_Syminfo *dynamic_syminfo;
 134 static unsigned long dynamic_syminfo_offset;
 135 static unsigned int dynamic_syminfo_nent;
 136 static char program_interpreter[64];
 137 static bfd_vma dynamic_info[DT_JMPREL + 1];
 138 static bfd_vma version_info[16];
 139 static Elf_Internal_Ehdr elf_header;
 140 static Elf_Internal_Shdr *section_headers;
 141 static Elf_Internal_Phdr *program_headers;
 142 static Elf_Internal_Dyn *dynamic_section;
 143 static Elf_Internal_Shdr *symtab_shndx_hdr;
 144 static int show_name;
 145 static int do_dynamic;
 146 static int do_syms;
 147 static int do_reloc;
 148 static int do_sections;
 149 static int do_section_groups;
 150 static int do_section_details;
 151 static int do_segments;
 152 static int do_unwind;
 153 static int do_using_dynamic;
 154 static int do_header;
 155 static int do_dump;
 156 static int do_version;
 157 static int do_wide;
 158 static int do_histogram;
 159 static int do_debugging;
 160 static int do_arch;
 161 static int do_notes;
 162 static int is_32bit_elf;
 163
 164 struct group_list
 165 {
 166   struct group_list *next;
 167   unsigned int section_index;
 168 };
 169
 170 struct group
 171 {
 172   struct group_list *root;
 173   unsigned int group_index;
 174 };
 175
 176 static size_t group_count;
 177 static struct group *section_groups;
 178 static struct group **section_headers_groups;
 179
 180 /* A linked list of the section names for which dumps were requested
 181    by name.  */
 182 struct dump_list_entry
 183 {
 184   char *name;
 185   int type;
 186   struct dump_list_entry *next;
 187 };
 188 static struct dump_list_entry *dump_sects_byname;
 189
 190 /* A dynamic array of flags indicating for which sections a hex dump
 191    has been requested (via the -x switch) and/or a disassembly dump
 192    (via the -i switch).  */
 193 char *cmdline_dump_sects = NULL;
 194 unsigned num_cmdline_dump_sects = 0;
 195
 196 /* A dynamic array of flags indicating for which sections a dump of
 197    some kind has been requested.  It is reset on a per-object file
 198    basis and then initialised from the cmdline_dump_sects array,
 199    the results of interpreting the -w switch, and the
 200    dump_sects_byname list.  */
 201 char *dump_sects = NULL;
 202 unsigned int num_dump_sects = 0;
 203
 204 #define HEX_DUMP        (1 << 0)
 205 #define DISASS_DUMP     (1 << 1)
 206 #define DEBUG_DUMP      (1 << 2)
 207
 208 /* How to print a vma value.  */
 209 typedef enum print_mode
 210 {
 211   HEX,
 212   DEC,
 213   DEC_5,
 214   UNSIGNED,
 215   PREFIX_HEX,
 216   FULL_HEX,
 217   LONG_HEX
 218 }
 219 print_mode;
 220
 221 static void (*byte_put) (unsigned char *, bfd_vma, int);
 222
 223 #define UNKNOWN -1
 224
 225 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
 226                          ((X)->sh_name >= string_table_length \
 227                           ? "<corrupt>" : string_table + (X)->sh_name))
 228
 229 /* Given st_shndx I, map to section_headers index.  */
 230 #define SECTION_HEADER_INDEX(I)                         \
 231   ((I) < SHN_LORESERVE                                  \
 232    ? (I)                                                \
 233    : ((I) <= SHN_HIRESERVE                              \
 234       ? 0                                               \
 235       : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
 236
 237 /* Reverse of the above.  */
 238 #define SECTION_HEADER_NUM(N)                           \
 239   ((N) < SHN_LORESERVE                                  \
 240    ? (N)                                                \
 241    : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
 242
 243 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
 244
 245 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 246
 247 #define BYTE_GET(field) byte_get (field, sizeof (field))
 248
 249 #define NUM_ELEM(array)         (sizeof (array) / sizeof ((array)[0]))
 250
 251 #define GET_ELF_SYMBOLS(file, section)                  \
 252   (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
 253    : get_64bit_elf_symbols (file, section))
 254
 255 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 256 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 257    already been called and verified that the string exists.  */
 258 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 259
 260 /* This is just a bit of syntatic sugar.  */
 261 #define streq(a,b)      (strcmp ((a), (b)) == 0)
 262 #define strneq(a,b,n)   (strncmp ((a), (b), (n)) == 0)
 263 \f
 264 static void *
 265 get_data (void *var, FILE *file, long offset, size_t size, size_t nmemb,
 266           const char *reason)
 267 {
 268   void *mvar;
 269
 270   if (size == 0 || nmemb == 0)
 271     return NULL;
 272
 273   if (fseek (file, archive_file_offset + offset, SEEK_SET))
 274     {
 275       error (_("Unable to seek to 0x%lx for %s\n"),
 276              archive_file_offset + offset, reason);
 277       return NULL;
 278     }
 279
 280   mvar = var;
 281   if (mvar == NULL)
 282     {
 283       /* Check for overflow.  */
 284       if (nmemb < (~(size_t) 0 - 1) / size)
 285         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 286         mvar = malloc (size * nmemb + 1);
 287
 288       if (mvar == NULL)
 289         {
 290           error (_("Out of memory allocating 0x%lx bytes for %s\n"),
 291                  (unsigned long)(size * nmemb), reason);
 292           return NULL;
 293         }
 294
 295       ((char *) mvar)[size * nmemb] = '\0';
 296     }
 297
 298   if (fread (mvar, size, nmemb, file) != nmemb)
 299     {
 300       error (_("Unable to read in 0x%lx bytes of %s\n"),
 301              (unsigned long)(size * nmemb), reason);
 302       if (mvar != var)
 303         free (mvar);
 304       return NULL;
 305     }
 306
 307   return mvar;
 308 }
 309
 310 static void
 311 byte_put_little_endian (unsigned char *field, bfd_vma value, int size)
 312 {
 313   switch (size)
 314     {
 315     case 8:
 316       field[7] = (((value >> 24) >> 24) >> 8) & 0xff;
 317       field[6] = ((value >> 24) >> 24) & 0xff;
 318       field[5] = ((value >> 24) >> 16) & 0xff;
 319       field[4] = ((value >> 24) >> 8) & 0xff;
 320       /* Fall through.  */
 321     case 4:
 322       field[3] = (value >> 24) & 0xff;
 323       field[2] = (value >> 16) & 0xff;
 324       /* Fall through.  */
 325     case 2:
 326       field[1] = (value >> 8) & 0xff;
 327       /* Fall through.  */
 328     case 1:
 329       field[0] = value & 0xff;
 330       break;
 331
 332     default:
 333       error (_("Unhandled data length: %d\n"), size);
 334       abort ();
 335     }
 336 }
 337
 338 #if defined BFD64 && !BFD_HOST_64BIT_LONG
 339 static int
 340 print_dec_vma (bfd_vma vma, int is_signed)
 341 {
 342   char buf[40];
 343   char *bufp = buf;
 344   int nc = 0;
 345
 346   if (is_signed && (bfd_signed_vma) vma < 0)
 347     {
 348       vma = -vma;
 349       putchar ('-');
 350       nc = 1;
 351     }
 352
 353   do
 354     {
 355       *bufp++ = '0' + vma % 10;
 356       vma /= 10;
 357     }
 358   while (vma != 0);
 359   nc += bufp - buf;
 360
 361   while (bufp > buf)
 362     putchar (*--bufp);
 363   return nc;
 364 }
 365
 366 static int
 367 print_hex_vma (bfd_vma vma)
 368 {
 369   char buf[32];
 370   char *bufp = buf;
 371   int nc;
 372
 373   do
 374     {
 375       char digit = '0' + (vma & 0x0f);
 376       if (digit > '9')
 377         digit += 'a' - '0' - 10;
 378       *bufp++ = digit;
 379       vma >>= 4;
 380     }
 381   while (vma != 0);
 382   nc = bufp - buf;
 383
 384   while (bufp > buf)
 385     putchar (*--bufp);
 386   return nc;
 387 }
 388 #endif
 389
 390 /* Print a VMA value.  */
 391 static int
 392 print_vma (bfd_vma vma, print_mode mode)
 393 {
 394 #ifdef BFD64
 395   if (is_32bit_elf)
 396 #endif
 397     {
 398       switch (mode)
 399         {
 400         case FULL_HEX:
 401           return printf ("0x%8.8lx", (unsigned long) vma);
 402
 403         case LONG_HEX:
 404           return printf ("%8.8lx", (unsigned long) vma);
 405
 406         case DEC_5:
 407           if (vma <= 99999)
 408             return printf ("%5ld", (long) vma);
 409           /* Drop through.  */
 410
 411         case PREFIX_HEX:
 412           return printf ("0x%lx", (unsigned long) vma);
 413
 414         case HEX:
 415           return printf ("%lx", (unsigned long) vma);
 416
 417         case DEC:
 418           return printf ("%ld", (unsigned long) vma);
 419
 420         case UNSIGNED:
 421           return printf ("%lu", (unsigned long) vma);
 422         }
 423     }
 424 #ifdef BFD64
 425   else
 426     {
 427       int nc = 0;
 428
 429       switch (mode)
 430         {
 431         case FULL_HEX:
 432           nc = printf ("0x");
 433           /* Drop through.  */
 434
 435         case LONG_HEX:
 436           printf_vma (vma);
 437           return nc + 16;
 438
 439         case PREFIX_HEX:
 440           nc = printf ("0x");
 441           /* Drop through.  */
 442
 443         case HEX:
 444 #if BFD_HOST_64BIT_LONG
 445           return nc + printf ("%lx", vma);
 446 #else
 447           return nc + print_hex_vma (vma);
 448 #endif
 449
 450         case DEC:
 451 #if BFD_HOST_64BIT_LONG
 452           return printf ("%ld", vma);
 453 #else
 454           return print_dec_vma (vma, 1);
 455 #endif
 456
 457         case DEC_5:
 458 #if BFD_HOST_64BIT_LONG
 459           if (vma <= 99999)
 460             return printf ("%5ld", vma);
 461           else
 462             return printf ("%#lx", vma);
 463 #else
 464           if (vma <= 99999)
 465             return printf ("%5ld", _bfd_int64_low (vma));
 466           else
 467             return print_hex_vma (vma);
 468 #endif
 469
 470         case UNSIGNED:
 471 #if BFD_HOST_64BIT_LONG
 472           return printf ("%lu", vma);
 473 #else
 474           return print_dec_vma (vma, 0);
 475 #endif
 476         }
 477     }
 478 #endif
 479   return 0;
 480 }
 481
 482 /* Display a symbol on stdout.  If do_wide is not true then
 483    format the symbol to be at most WIDTH characters,
 484    truncating as necessary.  If WIDTH is negative then
 485    format the string to be exactly - WIDTH characters,
 486    truncating or padding as necessary.  */
 487
 488 static void
 489 print_symbol (int width, const char *symbol)
 490 {
 491   if (do_wide)
 492     printf ("%s", symbol);
 493   else if (width < 0)
 494     printf ("%-*.*s", width, width, symbol);
 495   else
 496     printf ("%-.*s", width, symbol);
 497 }
 498
 499 static void
 500 byte_put_big_endian (unsigned char *field, bfd_vma value, int size)
 501 {
 502   switch (size)
 503     {
 504     case 8:
 505       field[7] = value & 0xff;
 506       field[6] = (value >> 8) & 0xff;
 507       field[5] = (value >> 16) & 0xff;
 508       field[4] = (value >> 24) & 0xff;
 509       value >>= 16;
 510       value >>= 16;
 511       /* Fall through.  */
 512     case 4:
 513       field[3] = value & 0xff;
 514       field[2] = (value >> 8) & 0xff;
 515       value >>= 16;
 516       /* Fall through.  */
 517     case 2:
 518       field[1] = value & 0xff;
 519       value >>= 8;
 520       /* Fall through.  */
 521     case 1:
 522       field[0] = value & 0xff;
 523       break;
 524
 525     default:
 526       error (_("Unhandled data length: %d\n"), size);
 527       abort ();
 528     }
 529 }
 530
 531 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 532
 533 static Elf_Internal_Shdr *
 534 find_section (const char *name)
 535 {
 536   unsigned int i;
 537
 538   for (i = 0; i < elf_header.e_shnum; i++)
 539     if (streq (SECTION_NAME (section_headers + i), name))
 540       return section_headers + i;
 541
 542   return NULL;
 543 }
 544
 545 /* Guess the relocation size commonly used by the specific machines.  */
 546
 547 static int
 548 guess_is_rela (unsigned long e_machine)
 549 {
 550   switch (e_machine)
 551     {
 552       /* Targets that use REL relocations.  */
 553     case EM_ARM:
 554     case EM_386:
 555     case EM_486:
 556     case EM_960:
 557     case EM_DLX:
 558     case EM_OPENRISC:
 559     case EM_OR32:
 560     case EM_CYGNUS_M32R:
 561     case EM_D10V:
 562     case EM_CYGNUS_D10V:
 563     case EM_MIPS:
 564     case EM_MIPS_RS3_LE:
 565       return FALSE;
 566
 567       /* Targets that use RELA relocations.  */
 568     case EM_68K:
 569     case EM_H8_300:
 570     case EM_H8_300H:
 571     case EM_H8S:
 572     case EM_SPARC32PLUS:
 573     case EM_SPARCV9:
 574     case EM_SPARC:
 575     case EM_PPC:
 576     case EM_PPC64:
 577     case EM_V850:
 578     case EM_CYGNUS_V850:
 579     case EM_D30V:
 580     case EM_CYGNUS_D30V:
 581     case EM_MN10200:
 582     case EM_CYGNUS_MN10200:
 583     case EM_MN10300:
 584     case EM_CYGNUS_MN10300:
 585     case EM_FR30:
 586     case EM_CYGNUS_FR30:
 587     case EM_CYGNUS_FRV:
 588     case EM_SH:
 589     case EM_ALPHA:
 590     case EM_MCORE:
 591     case EM_IA_64:
 592     case EM_AVR:
 593     case EM_AVR_OLD:
 594     case EM_CRIS:
 595     case EM_860:
 596     case EM_X86_64:
 597     case EM_S390:
 598     case EM_S390_OLD:
 599     case EM_MMIX:
 600     case EM_MSP430:
 601     case EM_MSP430_OLD:
 602     case EM_XSTORMY16:
 603     case EM_CRX:
 604     case EM_VAX:
 605     case EM_IP2K:
 606     case EM_IP2K_OLD:
 607     case EM_IQ2000:
 608     case EM_XTENSA:
 609     case EM_XTENSA_OLD:
 610     case EM_M32R:
 611     case EM_M32C:
 612     case EM_MS1:
 613     case EM_BLACKFIN:
 614       return TRUE;
 615
 616     case EM_MMA:
 617     case EM_PCP:
 618     case EM_NCPU:
 619     case EM_NDR1:
 620     case EM_STARCORE:
 621     case EM_ME16:
 622     case EM_ST100:
 623     case EM_TINYJ:
 624     case EM_FX66:
 625     case EM_ST9PLUS:
 626     case EM_ST7:
 627     case EM_68HC16:
 628     case EM_68HC11:
 629     case EM_68HC08:
 630     case EM_68HC05:
 631     case EM_SVX:
 632     case EM_ST19:
 633     default:
 634       warn (_("Don't know about relocations on this machine architecture\n"));
 635       return FALSE;
 636     }
 637 }
 638
 639 static int
 640 slurp_rela_relocs (FILE *file,
 641                    unsigned long rel_offset,
 642                    unsigned long rel_size,
 643                    Elf_Internal_Rela **relasp,
 644                    unsigned long *nrelasp)
 645 {
 646   Elf_Internal_Rela *relas;
 647   unsigned long nrelas;
 648   unsigned int i;
 649
 650   if (is_32bit_elf)
 651     {
 652       Elf32_External_Rela *erelas;
 653
 654       erelas = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
 655       if (!erelas)
 656         return 0;
 657
 658       nrelas = rel_size / sizeof (Elf32_External_Rela);
 659
 660       relas = cmalloc (nrelas, sizeof (Elf_Internal_Rela));
 661
 662       if (relas == NULL)
 663         {
 664           free (erelas);
 665           error (_("out of memory parsing relocs"));
 666           return 0;
 667         }
 668
 669       for (i = 0; i < nrelas; i++)
 670         {
 671           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 672           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 673           relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
 674         }
 675
 676       free (erelas);
 677     }
 678   else
 679     {
 680       Elf64_External_Rela *erelas;
 681
 682       erelas = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
 683       if (!erelas)
 684         return 0;
 685
 686       nrelas = rel_size / sizeof (Elf64_External_Rela);
 687
 688       relas = cmalloc (nrelas, sizeof (Elf_Internal_Rela));
 689
 690       if (relas == NULL)
 691         {
 692           free (erelas);
 693           error (_("out of memory parsing relocs"));
 694           return 0;
 695         }
 696
 697       for (i = 0; i < nrelas; i++)
 698         {
 699           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 700           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 701           relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
 702         }
 703
 704       free (erelas);
 705     }
 706   *relasp = relas;
 707   *nrelasp = nrelas;
 708   return 1;
 709 }
 710
 711 static int
 712 slurp_rel_relocs (FILE *file,
 713                   unsigned long rel_offset,
 714                   unsigned long rel_size,
 715                   Elf_Internal_Rela **relsp,
 716                   unsigned long *nrelsp)
 717 {
 718   Elf_Internal_Rela *rels;
 719   unsigned long nrels;
 720   unsigned int i;
 721
 722   if (is_32bit_elf)
 723     {
 724       Elf32_External_Rel *erels;
 725
 726       erels = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
 727       if (!erels)
 728         return 0;
 729
 730       nrels = rel_size / sizeof (Elf32_External_Rel);
 731
 732       rels = cmalloc (nrels, sizeof (Elf_Internal_Rela));
 733
 734       if (rels == NULL)
 735         {
 736           free (erels);
 737           error (_("out of memory parsing relocs"));
 738           return 0;
 739         }
 740
 741       for (i = 0; i < nrels; i++)
 742         {
 743           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 744           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 745           rels[i].r_addend = 0;
 746         }
 747
 748       free (erels);
 749     }
 750   else
 751     {
 752       Elf64_External_Rel *erels;
 753
 754       erels = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
 755       if (!erels)
 756         return 0;
 757
 758       nrels = rel_size / sizeof (Elf64_External_Rel);
 759
 760       rels = cmalloc (nrels, sizeof (Elf_Internal_Rela));
 761
 762       if (rels == NULL)
 763         {
 764           free (erels);
 765           error (_("out of memory parsing relocs"));
 766           return 0;
 767         }
 768
 769       for (i = 0; i < nrels; i++)
 770         {
 771           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 772           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 773           rels[i].r_addend = 0;
 774         }
 775
 776       free (erels);
 777     }
 778   *relsp = rels;
 779   *nrelsp = nrels;
 780   return 1;
 781 }
 782
 783 /* Display the contents of the relocation data found at the specified
 784    offset.  */
 785
 786 static int
 787 dump_relocations (FILE *file,
 788                   unsigned long rel_offset,
 789                   unsigned long rel_size,
 790                   Elf_Internal_Sym *symtab,
 791                   unsigned long nsyms,
 792                   char *strtab,
 793                   unsigned long strtablen,
 794                   int is_rela)
 795 {
 796   unsigned int i;
 797   Elf_Internal_Rela *rels;
 798
 799
 800   if (is_rela == UNKNOWN)
 801     is_rela = guess_is_rela (elf_header.e_machine);
 802
 803   if (is_rela)
 804     {
 805       if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
 806         return 0;
 807     }
 808   else
 809     {
 810       if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
 811         return 0;
 812     }
 813
 814   if (is_32bit_elf)
 815     {
 816       if (is_rela)
 817         {
 818           if (do_wide)
 819             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
 820           else
 821             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
 822         }
 823       else
 824         {
 825           if (do_wide)
 826             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
 827           else
 828             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
 829         }
 830     }
 831   else
 832     {
 833       if (is_rela)
 834         {
 835           if (do_wide)
 836             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
 837           else
 838             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
 839         }
 840       else
 841         {
 842           if (do_wide)
 843             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
 844           else
 845             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
 846         }
 847     }
 848
 849   for (i = 0; i < rel_size; i++)
 850     {
 851       const char *rtype;
 852       const char *rtype2 = NULL;
 853       const char *rtype3 = NULL;
 854       bfd_vma offset;
 855       bfd_vma info;
 856       bfd_vma symtab_index;
 857       bfd_vma type;
 858       bfd_vma type2 = 0;
 859       bfd_vma type3 = 0;
 860
 861       offset = rels[i].r_offset;
 862       info   = rels[i].r_info;
 863
 864       if (is_32bit_elf)
 865         {
 866           type         = ELF32_R_TYPE (info);
 867           symtab_index = ELF32_R_SYM  (info);
 868         }
 869       else
 870         {
 871           /* The #ifdef BFD64 below is to prevent a compile time warning.
 872              We know that if we do not have a 64 bit data type that we
 873              will never execute this code anyway.  */
 874 #ifdef BFD64
 875           if (elf_header.e_machine == EM_MIPS)
 876             {
 877               /* In little-endian objects, r_info isn't really a 64-bit
 878                  little-endian value: it has a 32-bit little-endian
 879                  symbol index followed by four individual byte fields.
 880                  Reorder INFO accordingly.  */
 881               if (elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 882                 info = (((info & 0xffffffff) << 32)
 883                         | ((info >> 56) & 0xff)
 884                         | ((info >> 40) & 0xff00)
 885                         | ((info >> 24) & 0xff0000)
 886                         | ((info >> 8) & 0xff000000));
 887               type  = ELF64_MIPS_R_TYPE (info);
 888               type2 = ELF64_MIPS_R_TYPE2 (info);
 889               type3 = ELF64_MIPS_R_TYPE3 (info);
 890             }
 891           else if (elf_header.e_machine == EM_SPARCV9)
 892             type = ELF64_R_TYPE_ID (info);
 893           else
 894             type = ELF64_R_TYPE (info);
 895
 896           symtab_index = ELF64_R_SYM  (info);
 897 #endif
 898         }
 899
 900       if (is_32bit_elf)
 901         {
 902 #ifdef _bfd_int64_low
 903           printf ("%8.8lx  %8.8lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
 904 #else
 905           printf ("%8.8lx  %8.8lx ", offset, info);
 906 #endif
 907         }
 908       else
 909         {
 910 #ifdef _bfd_int64_low
 911           printf (do_wide
 912                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
 913                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
 914                   _bfd_int64_high (offset),
 915                   _bfd_int64_low (offset),
 916                   _bfd_int64_high (info),
 917                   _bfd_int64_low (info));
 918 #else
 919           printf (do_wide
 920                   ? "%16.16lx  %16.16lx "
 921                   : "%12.12lx  %12.12lx ",
 922                   offset, info);
 923 #endif
 924         }
 925
 926       switch (elf_header.e_machine)
 927         {
 928         default:
 929           rtype = NULL;
 930           break;
 931
 932         case EM_M32R:
 933         case EM_CYGNUS_M32R:
 934           rtype = elf_m32r_reloc_type (type);
 935           break;
 936
 937         case EM_386:
 938         case EM_486:
 939           rtype = elf_i386_reloc_type (type);
 940           break;
 941
 942         case EM_68HC11:
 943         case EM_68HC12:
 944           rtype = elf_m68hc11_reloc_type (type);
 945           break;
 946
 947         case EM_68K:
 948           rtype = elf_m68k_reloc_type (type);
 949           break;
 950
 951         case EM_960:
 952           rtype = elf_i960_reloc_type (type);
 953           break;
 954
 955         case EM_AVR:
 956         case EM_AVR_OLD:
 957           rtype = elf_avr_reloc_type (type);
 958           break;
 959
 960         case EM_OLD_SPARCV9:
 961         case EM_SPARC32PLUS:
 962         case EM_SPARCV9:
 963         case EM_SPARC:
 964           rtype = elf_sparc_reloc_type (type);
 965           break;
 966
 967         case EM_V850:
 968         case EM_CYGNUS_V850:
 969           rtype = v850_reloc_type (type);
 970           break;
 971
 972         case EM_D10V:
 973         case EM_CYGNUS_D10V:
 974           rtype = elf_d10v_reloc_type (type);
 975           break;
 976
 977         case EM_D30V:
 978         case EM_CYGNUS_D30V:
 979           rtype = elf_d30v_reloc_type (type);
 980           break;
 981
 982         case EM_DLX:
 983           rtype = elf_dlx_reloc_type (type);
 984           break;
 985
 986         case EM_SH:
 987           rtype = elf_sh_reloc_type (type);
 988           break;
 989
 990         case EM_MN10300:
 991         case EM_CYGNUS_MN10300:
 992           rtype = elf_mn10300_reloc_type (type);
 993           break;
 994
 995         case EM_MN10200:
 996         case EM_CYGNUS_MN10200:
 997           rtype = elf_mn10200_reloc_type (type);
 998           break;
 999
1000         case EM_FR30:
1001         case EM_CYGNUS_FR30:
1002           rtype = elf_fr30_reloc_type (type);
1003           break;
1004
1005         case EM_CYGNUS_FRV:
1006           rtype = elf_frv_reloc_type (type);
1007           break;
1008
1009         case EM_MCORE:
1010           rtype = elf_mcore_reloc_type (type);
1011           break;
1012
1013         case EM_MMIX:
1014           rtype = elf_mmix_reloc_type (type);
1015           break;
1016
1017         case EM_MSP430:
1018         case EM_MSP430_OLD:
1019           rtype = elf_msp430_reloc_type (type);
1020           break;
1021
1022         case EM_PPC:
1023           rtype = elf_ppc_reloc_type (type);
1024           break;
1025
1026         case EM_PPC64:
1027           rtype = elf_ppc64_reloc_type (type);
1028           break;
1029
1030         case EM_MIPS:
1031         case EM_MIPS_RS3_LE:
1032           rtype = elf_mips_reloc_type (type);
1033           if (!is_32bit_elf)
1034             {
1035               rtype2 = elf_mips_reloc_type (type2);
1036               rtype3 = elf_mips_reloc_type (type3);
1037             }
1038           break;
1039
1040         case EM_ALPHA:
1041           rtype = elf_alpha_reloc_type (type);
1042           break;
1043
1044         case EM_ARM:
1045           rtype = elf_arm_reloc_type (type);
1046           break;
1047
1048         case EM_ARC:
1049           rtype = elf_arc_reloc_type (type);
1050           break;
1051
1052         case EM_PARISC:
1053           rtype = elf_hppa_reloc_type (type);
1054           break;
1055
1056         case EM_H8_300:
1057         case EM_H8_300H:
1058         case EM_H8S:
1059           rtype = elf_h8_reloc_type (type);
1060           break;
1061
1062         case EM_OPENRISC:
1063         case EM_OR32:
1064           rtype = elf_or32_reloc_type (type);
1065           break;
1066
1067         case EM_PJ:
1068         case EM_PJ_OLD:
1069           rtype = elf_pj_reloc_type (type);
1070           break;
1071         case EM_IA_64:
1072           rtype = elf_ia64_reloc_type (type);
1073           break;
1074
1075         case EM_CRIS:
1076           rtype = elf_cris_reloc_type (type);
1077           break;
1078
1079         case EM_860:
1080           rtype = elf_i860_reloc_type (type);
1081           break;
1082
1083         case EM_X86_64:
1084           rtype = elf_x86_64_reloc_type (type);
1085           break;
1086
1087         case EM_S370:
1088           rtype = i370_reloc_type (type);
1089           break;
1090
1091         case EM_S390_OLD:
1092         case EM_S390:
1093           rtype = elf_s390_reloc_type (type);
1094           break;
1095
1096         case EM_XSTORMY16:
1097           rtype = elf_xstormy16_reloc_type (type);
1098           break;
1099
1100         case EM_CRX:
1101           rtype = elf_crx_reloc_type (type);
1102           break;
1103
1104         case EM_VAX:
1105           rtype = elf_vax_reloc_type (type);
1106           break;
1107
1108         case EM_IP2K:
1109         case EM_IP2K_OLD:
1110           rtype = elf_ip2k_reloc_type (type);
1111           break;
1112
1113         case EM_IQ2000:
1114           rtype = elf_iq2000_reloc_type (type);
1115           break;
1116
1117         case EM_XTENSA_OLD:
1118         case EM_XTENSA:
1119           rtype = elf_xtensa_reloc_type (type);
1120           break;
1121
1122         case EM_M32C:
1123           rtype = elf_m32c_reloc_type (type);
1124           break;
1125
1126         case EM_MS1:
1127           rtype = elf_ms1_reloc_type (type);
1128           break;
1129
1130         case EM_BLACKFIN:
1131           rtype = elf_bfin_reloc_type (type);
1132           break;
1133
1134         }
1135
1136       if (rtype == NULL)
1137 #ifdef _bfd_int64_low
1138         printf (_("unrecognized: %-7lx"), _bfd_int64_low (type));
1139 #else
1140         printf (_("unrecognized: %-7lx"), type);
1141 #endif
1142       else
1143         printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1144
1145       if (elf_header.e_machine == EM_ALPHA
1146           && streq (rtype, "R_ALPHA_LITUSE")
1147           && is_rela)
1148         {
1149           switch (rels[i].r_addend)
1150             {
1151             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1152             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1153             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1154             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1155             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1156             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1157             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1158             default: rtype = NULL;
1159             }
1160           if (rtype)
1161             printf (" (%s)", rtype);
1162           else
1163             {
1164               putchar (' ');
1165               printf (_("<unknown addend: %lx>"),
1166                       (unsigned long) rels[i].r_addend);
1167             }
1168         }
1169       else if (symtab_index)
1170         {
1171           if (symtab == NULL || symtab_index >= nsyms)
1172             printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
1173           else
1174             {
1175               Elf_Internal_Sym *psym;
1176
1177               psym = symtab + symtab_index;
1178
1179               printf (" ");
1180               print_vma (psym->st_value, LONG_HEX);
1181               printf (is_32bit_elf ? "   " : " ");
1182
1183               if (psym->st_name == 0)
1184                 {
1185                   const char *sec_name = "<null>";
1186                   char name_buf[40];
1187
1188                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1189                     {
1190                       bfd_vma sec_index = (bfd_vma) -1;
1191
1192                       if (psym->st_shndx < SHN_LORESERVE)
1193                         sec_index = psym->st_shndx;
1194                       else if (psym->st_shndx > SHN_HIRESERVE)
1195                         sec_index = psym->st_shndx - (SHN_HIRESERVE + 1
1196                                                       - SHN_LORESERVE);
1197
1198                       if (sec_index != (bfd_vma) -1)
1199                         sec_name = SECTION_NAME (section_headers + sec_index);
1200                       else if (psym->st_shndx == SHN_ABS)
1201                         sec_name = "ABS";
1202                       else if (psym->st_shndx == SHN_COMMON)
1203                         sec_name = "COMMON";
1204                       else if (elf_header.e_machine == EM_X86_64
1205                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1206                         sec_name = "LARGE_COMMON";
1207                       else if (elf_header.e_machine == EM_IA_64
1208                                && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1209                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1210                         sec_name = "ANSI_COM";
1211                       else
1212                         {
1213                           sprintf (name_buf, "<section 0x%x>",
1214                                    (unsigned int) psym->st_shndx);
1215                           sec_name = name_buf;
1216                         }
1217                     }
1218                   print_symbol (22, sec_name);
1219                 }
1220               else if (strtab == NULL)
1221                 printf (_("<string table index: %3ld>"), psym->st_name);
1222               else if (psym->st_name >= strtablen)
1223                 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1224               else
1225                 print_symbol (22, strtab + psym->st_name);
1226
1227               if (is_rela)
1228                 printf (" + %lx", (unsigned long) rels[i].r_addend);
1229             }
1230         }
1231       else if (is_rela)
1232         {
1233           printf ("%*c", is_32bit_elf ?
1234                   (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
1235           print_vma (rels[i].r_addend, LONG_HEX);
1236         }
1237
1238       if (elf_header.e_machine == EM_SPARCV9 && streq (rtype, "R_SPARC_OLO10"))
1239         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
1240
1241       putchar ('\n');
1242
1243       if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1244         {
1245           printf ("                    Type2: ");
1246
1247           if (rtype2 == NULL)
1248 #ifdef _bfd_int64_low
1249             printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2));
1250 #else
1251             printf (_("unrecognized: %-7lx"), type2);
1252 #endif
1253           else
1254             printf ("%-17.17s", rtype2);
1255
1256           printf ("\n                    Type3: ");
1257
1258           if (rtype3 == NULL)
1259 #ifdef _bfd_int64_low
1260             printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3));
1261 #else
1262             printf (_("unrecognized: %-7lx"), type3);
1263 #endif
1264           else
1265             printf ("%-17.17s", rtype3);
1266
1267           putchar ('\n');
1268         }
1269     }
1270
1271   free (rels);
1272
1273   return 1;
1274 }
1275
1276 static const char *
1277 get_mips_dynamic_type (unsigned long type)
1278 {
1279   switch (type)
1280     {
1281     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1282     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1283     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1284     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1285     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1286     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1287     case DT_MIPS_MSYM: return "MIPS_MSYM";
1288     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1289     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1290     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1291     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1292     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1293     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1294     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1295     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1296     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1297     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1298     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1299     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1300     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1301     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1302     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1303     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1304     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1305     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1306     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1307     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1308     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1309     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1310     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1311     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1312     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1313     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1314     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1315     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1316     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1317     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1318     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1319     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1320     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1321     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1322     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1323     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1324     default:
1325       return NULL;
1326     }
1327 }
1328
1329 static const char *
1330 get_sparc64_dynamic_type (unsigned long type)
1331 {
1332   switch (type)
1333     {
1334     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1335     default:
1336       return NULL;
1337     }
1338 }
1339
1340 static const char *
1341 get_ppc_dynamic_type (unsigned long type)
1342 {
1343   switch (type)
1344     {
1345     case DT_PPC_GOT: return "PPC_GOT";
1346     default:
1347       return NULL;
1348     }
1349 }
1350
1351 static const char *
1352 get_ppc64_dynamic_type (unsigned long type)
1353 {
1354   switch (type)
1355     {
1356     case DT_PPC64_GLINK: return "PPC64_GLINK";
1357     case DT_PPC64_OPD:   return "PPC64_OPD";
1358     case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1359     default:
1360       return NULL;
1361     }
1362 }
1363
1364 static const char *
1365 get_parisc_dynamic_type (unsigned long type)
1366 {
1367   switch (type)
1368     {
1369     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1370     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1371     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1372     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1373     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1374     case DT_HP_PREINIT:         return "HP_PREINIT";
1375     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1376     case DT_HP_NEEDED:          return "HP_NEEDED";
1377     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1378     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1379     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1380     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1381     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1382     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1383     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1384     case DT_HP_FILTERED:        return "HP_FILTERED";
1385     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1386     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1387     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1388     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1389     case DT_PLT:                return "PLT";
1390     case DT_PLT_SIZE:           return "PLT_SIZE";
1391     case DT_DLT:                return "DLT";
1392     case DT_DLT_SIZE:           return "DLT_SIZE";
1393     default:
1394       return NULL;
1395     }
1396 }
1397
1398 static const char *
1399 get_ia64_dynamic_type (unsigned long type)
1400 {
1401   switch (type)
1402     {
1403     case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1404     default:
1405       return NULL;
1406     }
1407 }
1408
1409 static const char *
1410 get_alpha_dynamic_type (unsigned long type)
1411 {
1412   switch (type)
1413     {
1414     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1415     default:
1416       return NULL;
1417     }
1418 }
1419
1420 static const char *
1421 get_dynamic_type (unsigned long type)
1422 {
1423   static char buff[64];
1424
1425   switch (type)
1426     {
1427     case DT_NULL:       return "NULL";
1428     case DT_NEEDED:     return "NEEDED";
1429     case DT_PLTRELSZ:   return "PLTRELSZ";
1430     case DT_PLTGOT:     return "PLTGOT";
1431     case DT_HASH:       return "HASH";
1432     case DT_STRTAB:     return "STRTAB";
1433     case DT_SYMTAB:     return "SYMTAB";
1434     case DT_RELA:       return "RELA";
1435     case DT_RELASZ:     return "RELASZ";
1436     case DT_RELAENT:    return "RELAENT";
1437     case DT_STRSZ:      return "STRSZ";
1438     case DT_SYMENT:     return "SYMENT";
1439     case DT_INIT:       return "INIT";
1440     case DT_FINI:       return "FINI";
1441     case DT_SONAME:     return "SONAME";
1442     case DT_RPATH:      return "RPATH";
1443     case DT_SYMBOLIC:   return "SYMBOLIC";
1444     case DT_REL:        return "REL";
1445     case DT_RELSZ:      return "RELSZ";
1446     case DT_RELENT:     return "RELENT";
1447     case DT_PLTREL:     return "PLTREL";
1448     case DT_DEBUG:      return "DEBUG";
1449     case DT_TEXTREL:    return "TEXTREL";
1450     case DT_JMPREL:     return "JMPREL";
1451     case DT_BIND_NOW:   return "BIND_NOW";
1452     case DT_INIT_ARRAY: return "INIT_ARRAY";
1453     case DT_FINI_ARRAY: return "FINI_ARRAY";
1454     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1455     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1456     case DT_RUNPATH:    return "RUNPATH";
1457     case DT_FLAGS:      return "FLAGS";
1458
1459     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1460     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1461
1462     case DT_CHECKSUM:   return "CHECKSUM";
1463     case DT_PLTPADSZ:   return "PLTPADSZ";
1464     case DT_MOVEENT:    return "MOVEENT";
1465     case DT_MOVESZ:     return "MOVESZ";
1466     case DT_FEATURE:    return "FEATURE";
1467     case DT_POSFLAG_1:  return "POSFLAG_1";
1468     case DT_SYMINSZ:    return "SYMINSZ";
1469     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
1470
1471     case DT_ADDRRNGLO:  return "ADDRRNGLO";
1472     case DT_CONFIG:     return "CONFIG";
1473     case DT_DEPAUDIT:   return "DEPAUDIT";
1474     case DT_AUDIT:      return "AUDIT";
1475     case DT_PLTPAD:     return "PLTPAD";
1476     case DT_MOVETAB:    return "MOVETAB";
1477     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
1478
1479     case DT_VERSYM:     return "VERSYM";
1480
1481     case DT_RELACOUNT:  return "RELACOUNT";
1482     case DT_RELCOUNT:   return "RELCOUNT";
1483     case DT_FLAGS_1:    return "FLAGS_1";
1484     case DT_VERDEF:     return "VERDEF";
1485     case DT_VERDEFNUM:  return "VERDEFNUM";
1486     case DT_VERNEED:    return "VERNEED";
1487     case DT_VERNEEDNUM: return "VERNEEDNUM";
1488
1489     case DT_AUXILIARY:  return "AUXILIARY";
1490     case DT_USED:       return "USED";
1491     case DT_FILTER:     return "FILTER";
1492
1493     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1494     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1495     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1496     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1497     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1498
1499     default:
1500       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1501         {
1502           const char *result;
1503
1504           switch (elf_header.e_machine)
1505             {
1506             case EM_MIPS:
1507             case EM_MIPS_RS3_LE:
1508               result = get_mips_dynamic_type (type);
1509               break;
1510             case EM_SPARCV9:
1511               result = get_sparc64_dynamic_type (type);
1512               break;
1513             case EM_PPC:
1514               result = get_ppc_dynamic_type (type);
1515               break;
1516             case EM_PPC64:
1517               result = get_ppc64_dynamic_type (type);
1518               break;
1519             case EM_IA_64:
1520               result = get_ia64_dynamic_type (type);
1521               break;
1522             case EM_ALPHA:
1523               result = get_alpha_dynamic_type (type);
1524               break;
1525             default:
1526               result = NULL;
1527               break;
1528             }
1529
1530           if (result != NULL)
1531             return result;
1532
1533           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1534         }
1535       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1536                || (elf_header.e_machine == EM_PARISC
1537                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1538         {
1539           const char *result;
1540
1541           switch (elf_header.e_machine)
1542             {
1543             case EM_PARISC:
1544               result = get_parisc_dynamic_type (type);
1545               break;
1546             default:
1547               result = NULL;
1548               break;
1549             }
1550
1551           if (result != NULL)
1552             return result;
1553
1554           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1555                     type);
1556         }
1557       else
1558         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1559
1560       return buff;
1561     }
1562 }
1563
1564 static char *
1565 get_file_type (unsigned e_type)
1566 {
1567   static char buff[32];
1568
1569   switch (e_type)
1570     {
1571     case ET_NONE:       return _("NONE (None)");
1572     case ET_REL:        return _("REL (Relocatable file)");
1573     case ET_EXEC:       return _("EXEC (Executable file)");
1574     case ET_DYN:        return _("DYN (Shared object file)");
1575     case ET_CORE:       return _("CORE (Core file)");
1576
1577     default:
1578       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1579         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1580       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1581         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1582       else
1583         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1584       return buff;
1585     }
1586 }
1587
1588 static char *
1589 get_machine_name (unsigned e_machine)
1590 {
1591   static char buff[64]; /* XXX */
1592
1593   switch (e_machine)
1594     {
1595     case EM_NONE:               return _("None");
1596     case EM_M32:                return "WE32100";
1597     case EM_SPARC:              return "Sparc";
1598     case EM_386:                return "Intel 80386";
1599     case EM_68K:                return "MC68000";
1600     case EM_88K:                return "MC88000";
1601     case EM_486:                return "Intel 80486";
1602     case EM_860:                return "Intel 80860";
1603     case EM_MIPS:               return "MIPS R3000";
1604     case EM_S370:               return "IBM System/370";
1605     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
1606     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
1607     case EM_PARISC:             return "HPPA";
1608     case EM_PPC_OLD:            return "Power PC (old)";
1609     case EM_SPARC32PLUS:        return "Sparc v8+" ;
1610     case EM_960:                return "Intel 90860";
1611     case EM_PPC:                return "PowerPC";
1612     case EM_PPC64:              return "PowerPC64";
1613     case EM_V800:               return "NEC V800";
1614     case EM_FR20:               return "Fujitsu FR20";
1615     case EM_RH32:               return "TRW RH32";
1616     case EM_MCORE:              return "MCORE";
1617     case EM_ARM:                return "ARM";
1618     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
1619     case EM_SH:                 return "Renesas / SuperH SH";
1620     case EM_SPARCV9:            return "Sparc v9";
1621     case EM_TRICORE:            return "Siemens Tricore";
1622     case EM_ARC:                return "ARC";
1623     case EM_H8_300:             return "Renesas H8/300";
1624     case EM_H8_300H:            return "Renesas H8/300H";
1625     case EM_H8S:                return "Renesas H8S";
1626     case EM_H8_500:             return "Renesas H8/500";
1627     case EM_IA_64:              return "Intel IA-64";
1628     case EM_MIPS_X:             return "Stanford MIPS-X";
1629     case EM_COLDFIRE:           return "Motorola Coldfire";
1630     case EM_68HC12:             return "Motorola M68HC12";
1631     case EM_ALPHA:              return "Alpha";
1632     case EM_CYGNUS_D10V:
1633     case EM_D10V:               return "d10v";
1634     case EM_CYGNUS_D30V:
1635     case EM_D30V:               return "d30v";
1636     case EM_CYGNUS_M32R:
1637     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
1638     case EM_CYGNUS_V850:
1639     case EM_V850:               return "NEC v850";
1640     case EM_CYGNUS_MN10300:
1641     case EM_MN10300:            return "mn10300";
1642     case EM_CYGNUS_MN10200:
1643     case EM_MN10200:            return "mn10200";
1644     case EM_CYGNUS_FR30:
1645     case EM_FR30:               return "Fujitsu FR30";
1646     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
1647     case EM_PJ_OLD:
1648     case EM_PJ:                 return "picoJava";
1649     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
1650     case EM_PCP:                return "Siemens PCP";
1651     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
1652     case EM_NDR1:               return "Denso NDR1 microprocesspr";
1653     case EM_STARCORE:           return "Motorola Star*Core processor";
1654     case EM_ME16:               return "Toyota ME16 processor";
1655     case EM_ST100:              return "STMicroelectronics ST100 processor";
1656     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
1657     case EM_FX66:               return "Siemens FX66 microcontroller";
1658     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1659     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
1660     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
1661     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
1662     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
1663     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
1664     case EM_SVX:                return "Silicon Graphics SVx";
1665     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
1666     case EM_VAX:                return "Digital VAX";
1667     case EM_AVR_OLD:
1668     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
1669     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
1670     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
1671     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
1672     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
1673     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
1674     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
1675     case EM_PRISM:              return "Vitesse Prism";
1676     case EM_X86_64:             return "Advanced Micro Devices X86-64";
1677     case EM_S390_OLD:
1678     case EM_S390:               return "IBM S/390";
1679     case EM_XSTORMY16:          return "Sanyo Xstormy16 CPU core";
1680     case EM_OPENRISC:
1681     case EM_OR32:               return "OpenRISC";
1682     case EM_CRX:                return "National Semiconductor CRX microprocessor";
1683     case EM_DLX:                return "OpenDLX";
1684     case EM_IP2K_OLD:
1685     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
1686     case EM_IQ2000:             return "Vitesse IQ2000";
1687     case EM_XTENSA_OLD:
1688     case EM_XTENSA:             return "Tensilica Xtensa Processor";
1689     case EM_M32C:               return "Renesas M32c";
1690     case EM_MS1:                return "Morpho Techologies MS1 processor";
1691     default:
1692       snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_machine);
1693       return buff;
1694     }
1695 }
1696
1697 static void
1698 decode_ARM_machine_flags (unsigned e_flags, char buf[])
1699 {
1700   unsigned eabi;
1701   int unknown = 0;
1702
1703   eabi = EF_ARM_EABI_VERSION (e_flags);
1704   e_flags &= ~ EF_ARM_EABIMASK;
1705
1706   /* Handle "generic" ARM flags.  */
1707   if (e_flags & EF_ARM_RELEXEC)
1708     {
1709       strcat (buf, ", relocatable executable");
1710       e_flags &= ~ EF_ARM_RELEXEC;
1711     }
1712
1713   if (e_flags & EF_ARM_HASENTRY)
1714     {
1715       strcat (buf, ", has entry point");
1716       e_flags &= ~ EF_ARM_HASENTRY;
1717     }
1718
1719   /* Now handle EABI specific flags.  */
1720   switch (eabi)
1721     {
1722     default:
1723       strcat (buf, ", <unrecognized EABI>");
1724       if (e_flags)
1725         unknown = 1;
1726       break;
1727
1728     case EF_ARM_EABI_VER1:
1729       strcat (buf, ", Version1 EABI");
1730       while (e_flags)
1731         {
1732           unsigned flag;
1733
1734           /* Process flags one bit at a time.  */
1735           flag = e_flags & - e_flags;
1736           e_flags &= ~ flag;
1737
1738           switch (flag)
1739             {
1740             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
1741               strcat (buf, ", sorted symbol tables");
1742               break;
1743
1744             default:
1745               unknown = 1;
1746               break;
1747             }
1748         }
1749       break;
1750
1751     case EF_ARM_EABI_VER2:
1752       strcat (buf, ", Version2 EABI");
1753       while (e_flags)
1754         {
1755           unsigned flag;
1756
1757           /* Process flags one bit at a time.  */
1758           flag = e_flags & - e_flags;
1759           e_flags &= ~ flag;
1760
1761           switch (flag)
1762             {
1763             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
1764               strcat (buf, ", sorted symbol tables");
1765               break;
1766
1767             case EF_ARM_DYNSYMSUSESEGIDX:
1768               strcat (buf, ", dynamic symbols use segment index");
1769               break;
1770
1771             case EF_ARM_MAPSYMSFIRST:
1772               strcat (buf, ", mapping symbols precede others");
1773               break;
1774
1775             default:
1776               unknown = 1;
1777               break;
1778             }
1779         }
1780       break;
1781
1782     case EF_ARM_EABI_VER3:
1783       strcat (buf, ", Version3 EABI");
1784       break;
1785
1786     case EF_ARM_EABI_VER4:
1787       strcat (buf, ", Version4 EABI");
1788       while (e_flags)
1789         {
1790           unsigned flag;
1791
1792           /* Process flags one bit at a time.  */
1793           flag = e_flags & - e_flags;
1794           e_flags &= ~ flag;
1795
1796           switch (flag)
1797             {
1798             case EF_ARM_BE8:
1799               strcat (buf, ", BE8");
1800               break;
1801
1802             case EF_ARM_LE8:
1803               strcat (buf, ", LE8");
1804               break;
1805
1806             default:
1807               unknown = 1;
1808               break;
1809             }
1810         }
1811       break;
1812
1813     case EF_ARM_EABI_UNKNOWN:
1814       strcat (buf, ", GNU EABI");
1815       while (e_flags)
1816         {
1817           unsigned flag;
1818
1819           /* Process flags one bit at a time.  */
1820           flag = e_flags & - e_flags;
1821           e_flags &= ~ flag;
1822
1823           switch (flag)
1824             {
1825             case EF_ARM_INTERWORK:
1826               strcat (buf, ", interworking enabled");
1827               break;
1828
1829             case EF_ARM_APCS_26:
1830               strcat (buf, ", uses APCS/26");
1831               break;
1832
1833             case EF_ARM_APCS_FLOAT:
1834               strcat (buf, ", uses APCS/float");
1835               break;
1836
1837             case EF_ARM_PIC:
1838               strcat (buf, ", position independent");
1839               break;
1840
1841             case EF_ARM_ALIGN8:
1842               strcat (buf, ", 8 bit structure alignment");
1843               break;
1844
1845             case EF_ARM_NEW_ABI:
1846               strcat (buf, ", uses new ABI");
1847               break;
1848
1849             case EF_ARM_OLD_ABI:
1850               strcat (buf, ", uses old ABI");
1851               break;
1852
1853             case EF_ARM_SOFT_FLOAT:
1854               strcat (buf, ", software FP");
1855               break;
1856
1857             case EF_ARM_VFP_FLOAT:
1858               strcat (buf, ", VFP");
1859               break;
1860
1861             case EF_ARM_MAVERICK_FLOAT:
1862               strcat (buf, ", Maverick FP");
1863               break;
1864
1865             default:
1866               unknown = 1;
1867               break;
1868             }
1869         }
1870     }
1871
1872   if (unknown)
1873     strcat (buf,", <unknown>");
1874 }
1875
1876 static char *
1877 get_machine_flags (unsigned e_flags, unsigned e_machine)
1878 {
1879   static char buf[1024];
1880
1881   buf[0] = '\0';
1882
1883   if (e_flags)
1884     {
1885       switch (e_machine)
1886         {
1887         default:
1888           break;
1889
1890         case EM_ARM:
1891           decode_ARM_machine_flags (e_flags, buf);
1892           break;
1893
1894         case EM_CYGNUS_FRV:
1895           switch (e_flags & EF_FRV_CPU_MASK)
1896             {
1897             case EF_FRV_CPU_GENERIC:
1898               break;
1899
1900             default:
1901               strcat (buf, ", fr???");
1902               break;
1903
1904             case EF_FRV_CPU_FR300:
1905               strcat (buf, ", fr300");
1906               break;
1907
1908             case EF_FRV_CPU_FR400:
1909               strcat (buf, ", fr400");
1910               break;
1911             case EF_FRV_CPU_FR405:
1912               strcat (buf, ", fr405");
1913               break;
1914
1915             case EF_FRV_CPU_FR450:
1916               strcat (buf, ", fr450");
1917               break;
1918
1919             case EF_FRV_CPU_FR500:
1920               strcat (buf, ", fr500");
1921               break;
1922             case EF_FRV_CPU_FR550:
1923               strcat (buf, ", fr550");
1924               break;
1925
1926             case EF_FRV_CPU_SIMPLE:
1927               strcat (buf, ", simple");
1928               break;
1929             case EF_FRV_CPU_TOMCAT:
1930               strcat (buf, ", tomcat");
1931               break;
1932             }
1933           break;
1934
1935         case EM_68K:
1936           if (e_flags & EF_CPU32)
1937             strcat (buf, ", cpu32");
1938           if (e_flags & EF_M68000)
1939             strcat (buf, ", m68000");
1940           break;
1941
1942         case EM_PPC:
1943           if (e_flags & EF_PPC_EMB)
1944             strcat (buf, ", emb");
1945
1946           if (e_flags & EF_PPC_RELOCATABLE)
1947             strcat (buf, ", relocatable");
1948
1949           if (e_flags & EF_PPC_RELOCATABLE_LIB)
1950             strcat (buf, ", relocatable-lib");
1951           break;
1952
1953         case EM_V850:
1954         case EM_CYGNUS_V850:
1955           switch (e_flags & EF_V850_ARCH)
1956             {
1957             case E_V850E1_ARCH:
1958               strcat (buf, ", v850e1");
1959               break;
1960             case E_V850E_ARCH:
1961               strcat (buf, ", v850e");
1962               break;
1963             case E_V850_ARCH:
1964               strcat (buf, ", v850");
1965               break;
1966             default:
1967               strcat (buf, ", unknown v850 architecture variant");
1968               break;
1969             }
1970           break;
1971
1972         case EM_M32R:
1973         case EM_CYGNUS_M32R:
1974           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
1975             strcat (buf, ", m32r");
1976
1977           break;
1978
1979         case EM_MIPS:
1980         case EM_MIPS_RS3_LE:
1981           if (e_flags & EF_MIPS_NOREORDER)
1982             strcat (buf, ", noreorder");
1983
1984           if (e_flags & EF_MIPS_PIC)
1985             strcat (buf, ", pic");
1986
1987           if (e_flags & EF_MIPS_CPIC)
1988             strcat (buf, ", cpic");
1989
1990           if (e_flags & EF_MIPS_UCODE)
1991             strcat (buf, ", ugen_reserved");
1992
1993           if (e_flags & EF_MIPS_ABI2)
1994             strcat (buf, ", abi2");
1995
1996           if (e_flags & EF_MIPS_OPTIONS_FIRST)
1997             strcat (buf, ", odk first");
1998
1999           if (e_flags & EF_MIPS_32BITMODE)
2000             strcat (buf, ", 32bitmode");
2001
2002           switch ((e_flags & EF_MIPS_MACH))
2003             {
2004             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2005             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2006             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2007             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2008             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2009             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2010             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2011             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2012             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
2013             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2014             case 0:
2015             /* We simply ignore the field in this case to avoid confusion:
2016                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2017                extension.  */
2018               break;
2019             default: strcat (buf, ", unknown CPU"); break;
2020             }
2021
2022           switch ((e_flags & EF_MIPS_ABI))
2023             {
2024             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2025             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2026             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2027             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2028             case 0:
2029             /* We simply ignore the field in this case to avoid confusion:
2030                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2031                This means it is likely to be an o32 file, but not for
2032                sure.  */
2033               break;
2034             default: strcat (buf, ", unknown ABI"); break;
2035             }
2036
2037           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2038             strcat (buf, ", mdmx");
2039
2040           if (e_flags & EF_MIPS_ARCH_ASE_M16)
2041             strcat (buf, ", mips16");
2042
2043           switch ((e_flags & EF_MIPS_ARCH))
2044             {
2045             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2046             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2047             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2048             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2049             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2050             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2051             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2052             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2053             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2054             default: strcat (buf, ", unknown ISA"); break;
2055             }
2056
2057           break;
2058
2059         case EM_SH:
2060           switch ((e_flags & EF_SH_MACH_MASK))
2061             {
2062             case EF_SH1: strcat (buf, ", sh1"); break;
2063             case EF_SH2: strcat (buf, ", sh2"); break;
2064             case EF_SH3: strcat (buf, ", sh3"); break;
2065             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2066             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2067             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2068             case EF_SH3E: strcat (buf, ", sh3e"); break;
2069             case EF_SH4: strcat (buf, ", sh4"); break;
2070             case EF_SH5: strcat (buf, ", sh5"); break;
2071             case EF_SH2E: strcat (buf, ", sh2e"); break;
2072             case EF_SH4A: strcat (buf, ", sh4a"); break;
2073             case EF_SH2A: strcat (buf, ", sh2a"); break;
2074             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2075             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2076             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2077             default: strcat (buf, ", unknown ISA"); break;
2078             }
2079
2080           break;
2081
2082         case EM_SPARCV9:
2083           if (e_flags & EF_SPARC_32PLUS)
2084             strcat (buf, ", v8+");
2085
2086           if (e_flags & EF_SPARC_SUN_US1)
2087             strcat (buf, ", ultrasparcI");
2088
2089           if (e_flags & EF_SPARC_SUN_US3)
2090             strcat (buf, ", ultrasparcIII");
2091
2092           if (e_flags & EF_SPARC_HAL_R1)
2093             strcat (buf, ", halr1");
2094
2095           if (e_flags & EF_SPARC_LEDATA)
2096             strcat (buf, ", ledata");
2097
2098           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2099             strcat (buf, ", tso");
2100
2101           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2102             strcat (buf, ", pso");
2103
2104           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2105             strcat (buf, ", rmo");
2106           break;
2107
2108         case EM_PARISC:
2109           switch (e_flags & EF_PARISC_ARCH)
2110             {
2111             case EFA_PARISC_1_0:
2112               strcpy (buf, ", PA-RISC 1.0");
2113               break;
2114             case EFA_PARISC_1_1:
2115               strcpy (buf, ", PA-RISC 1.1");
2116               break;
2117             case EFA_PARISC_2_0:
2118               strcpy (buf, ", PA-RISC 2.0");
2119               break;
2120             default:
2121               break;
2122             }
2123           if (e_flags & EF_PARISC_TRAPNIL)
2124             strcat (buf, ", trapnil");
2125           if (e_flags & EF_PARISC_EXT)
2126             strcat (buf, ", ext");
2127           if (e_flags & EF_PARISC_LSB)
2128             strcat (buf, ", lsb");
2129           if (e_flags & EF_PARISC_WIDE)
2130             strcat (buf, ", wide");
2131           if (e_flags & EF_PARISC_NO_KABP)
2132             strcat (buf, ", no kabp");
2133           if (e_flags & EF_PARISC_LAZYSWAP)
2134             strcat (buf, ", lazyswap");
2135           break;
2136
2137         case EM_PJ:
2138         case EM_PJ_OLD:
2139           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2140             strcat (buf, ", new calling convention");
2141
2142           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2143             strcat (buf, ", gnu calling convention");
2144           break;
2145
2146         case EM_IA_64:
2147           if ((e_flags & EF_IA_64_ABI64))
2148             strcat (buf, ", 64-bit");
2149           else
2150             strcat (buf, ", 32-bit");
2151           if ((e_flags & EF_IA_64_REDUCEDFP))
2152             strcat (buf, ", reduced fp model");
2153           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2154             strcat (buf, ", no function descriptors, constant gp");
2155           else if ((e_flags & EF_IA_64_CONS_GP))
2156             strcat (buf, ", constant gp");
2157           if ((e_flags & EF_IA_64_ABSOLUTE))
2158             strcat (buf, ", absolute");
2159           break;
2160
2161         case EM_VAX:
2162           if ((e_flags & EF_VAX_NONPIC))
2163             strcat (buf, ", non-PIC");
2164           if ((e_flags & EF_VAX_DFLOAT))
2165             strcat (buf, ", D-Float");
2166           if ((e_flags & EF_VAX_GFLOAT))
2167             strcat (buf, ", G-Float");
2168           break;
2169         }
2170     }
2171
2172   return buf;
2173 }
2174
2175 static const char *
2176 get_osabi_name (unsigned int osabi)
2177 {
2178   static char buff[32];
2179
2180   switch (osabi)
2181     {
2182     case ELFOSABI_NONE:         return "UNIX - System V";
2183     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
2184     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
2185     case ELFOSABI_LINUX:        return "UNIX - Linux";
2186     case ELFOSABI_HURD:         return "GNU/Hurd";
2187     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
2188     case ELFOSABI_AIX:          return "UNIX - AIX";
2189     case ELFOSABI_IRIX:         return "UNIX - IRIX";
2190     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
2191     case ELFOSABI_TRU64:        return "UNIX - TRU64";
2192     case ELFOSABI_MODESTO:      return "Novell - Modesto";
2193     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
2194     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
2195     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
2196     case ELFOSABI_AROS:         return "Amiga Research OS";
2197     case ELFOSABI_STANDALONE:   return _("Standalone App");
2198     case ELFOSABI_ARM:          return "ARM";
2199     default:
2200       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2201       return buff;
2202     }
2203 }
2204
2205 static const char *
2206 get_arm_segment_type (unsigned long type)
2207 {
2208   switch (type)
2209     {
2210     case PT_ARM_EXIDX:
2211       return "EXIDX";
2212     default:
2213       break;
2214     }
2215
2216   return NULL;
2217 }
2218
2219 static const char *
2220 get_mips_segment_type (unsigned long type)
2221 {
2222   switch (type)
2223     {
2224     case PT_MIPS_REGINFO:
2225       return "REGINFO";
2226     case PT_MIPS_RTPROC:
2227       return "RTPROC";
2228     case PT_MIPS_OPTIONS:
2229       return "OPTIONS";
2230     default:
2231       break;
2232     }
2233
2234   return NULL;
2235 }
2236
2237 static const char *
2238 get_parisc_segment_type (unsigned long type)
2239 {
2240   switch (type)
2241     {
2242     case PT_HP_TLS:             return "HP_TLS";
2243     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
2244     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
2245     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
2246     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
2247     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
2248     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
2249     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
2250     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
2251     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
2252     case PT_HP_PARALLEL:        return "HP_PARALLEL";
2253     case PT_HP_FASTBIND:        return "HP_FASTBIND";
2254     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
2255     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
2256     case PT_HP_STACK:           return "HP_STACK";
2257     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
2258     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
2259     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
2260     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
2261     default:
2262       break;
2263     }
2264
2265   return NULL;
2266 }
2267
2268 static const char *
2269 get_ia64_segment_type (unsigned long type)
2270 {
2271   switch (type)
2272     {
2273     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
2274     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
2275     case PT_HP_TLS:             return "HP_TLS";
2276     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
2277     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
2278     case PT_IA_64_HP_STACK:     return "HP_STACK";
2279     default:
2280       break;
2281     }
2282
2283   return NULL;
2284 }
2285
2286 static const char *
2287 get_segment_type (unsigned long p_type)
2288 {
2289   static char buff[32];
2290
2291   switch (p_type)
2292     {
2293     case PT_NULL:       return "NULL";
2294     case PT_LOAD:       return "LOAD";
2295     case PT_DYNAMIC:    return "DYNAMIC";
2296     case PT_INTERP:     return "INTERP";
2297     case PT_NOTE:       return "NOTE";
2298     case PT_SHLIB:      return "SHLIB";
2299     case PT_PHDR:       return "PHDR";
2300     case PT_TLS:        return "TLS";
2301
2302     case PT_GNU_EH_FRAME:
2303                         return "GNU_EH_FRAME";
2304     case PT_GNU_STACK:  return "GNU_STACK";
2305     case PT_GNU_RELRO:  return "GNU_RELRO";
2306
2307     default:
2308       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2309         {
2310           const char *result;
2311
2312           switch (elf_header.e_machine)
2313             {
2314             case EM_ARM:
2315               result = get_arm_segment_type (p_type);
2316               break;
2317             case EM_MIPS:
2318             case EM_MIPS_RS3_LE:
2319               result = get_mips_segment_type (p_type);
2320               break;
2321             case EM_PARISC:
2322               result = get_parisc_segment_type (p_type);
2323               break;
2324             case EM_IA_64:
2325               result = get_ia64_segment_type (p_type);
2326               break;
2327             default:
2328               result = NULL;
2329               break;
2330             }
2331
2332           if (result != NULL)
2333             return result;
2334
2335           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2336         }
2337       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2338         {
2339           const char *result;
2340
2341           switch (elf_header.e_machine)
2342             {
2343             case EM_PARISC:
2344               result = get_parisc_segment_type (p_type);
2345               break;
2346             case EM_IA_64:
2347               result = get_ia64_segment_type (p_type);
2348               break;
2349             default:
2350               result = NULL;
2351               break;
2352             }
2353
2354           if (result != NULL)
2355             return result;
2356
2357           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2358         }
2359       else
2360         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
2361
2362       return buff;
2363     }
2364 }
2365
2366 static const char *
2367 get_mips_section_type_name (unsigned int sh_type)
2368 {
2369   switch (sh_type)
2370     {
2371     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
2372     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
2373     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
2374     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
2375     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
2376     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
2377     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
2378     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
2379     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
2380     case SHT_MIPS_RELD:          return "MIPS_RELD";
2381     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
2382     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
2383     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
2384     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
2385     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
2386     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
2387     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
2388     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
2389     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
2390     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
2391     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
2392     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
2393     case SHT_MIPS_LINE:          return "MIPS_LINE";
2394     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
2395     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
2396     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
2397     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
2398     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
2399     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
2400     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
2401     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
2402     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
2403     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
2404     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
2405     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
2406     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
2407     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
2408     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
2409     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2410     default:
2411       break;
2412     }
2413   return NULL;
2414 }
2415
2416 static const char *
2417 get_parisc_section_type_name (unsigned int sh_type)
2418 {
2419   switch (sh_type)
2420     {
2421     case SHT_PARISC_EXT:        return "PARISC_EXT";
2422     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
2423     case SHT_PARISC_DOC:        return "PARISC_DOC";
2424     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
2425     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
2426     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
2427     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
2428     default:
2429       break;
2430     }
2431   return NULL;
2432 }
2433
2434 static const char *
2435 get_ia64_section_type_name (unsigned int sh_type)
2436 {
2437   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
2438   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2439     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
2440
2441   switch (sh_type)
2442     {
2443     case SHT_IA_64_EXT:           return "IA_64_EXT";
2444     case SHT_IA_64_UNWIND:        return "IA_64_UNWIND";
2445     case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2446     default:
2447       break;
2448     }
2449   return NULL;
2450 }
2451
2452 static const char *
2453 get_x86_64_section_type_name (unsigned int sh_type)
2454 {
2455   switch (sh_type)
2456     {
2457     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
2458     default:
2459       break;
2460     }
2461   return NULL;
2462 }
2463
2464 static const char *
2465 get_arm_section_type_name (unsigned int sh_type)
2466 {
2467   switch (sh_type)
2468     {
2469     case SHT_ARM_EXIDX:
2470       return "ARM_EXIDX";
2471     case SHT_ARM_PREEMPTMAP:
2472       return "ARM_PREEMPTMAP";
2473     case SHT_ARM_ATTRIBUTES:
2474       return "ARM_ATTRIBUTES";
2475     default:
2476       break;
2477     }
2478   return NULL;
2479 }
2480
2481 static const char *
2482 get_section_type_name (unsigned int sh_type)
2483 {
2484   static char buff[32];
2485
2486   switch (sh_type)
2487     {
2488     case SHT_NULL:              return "NULL";
2489     case SHT_PROGBITS:          return "PROGBITS";
2490     case SHT_SYMTAB:            return "SYMTAB";
2491     case SHT_STRTAB:            return "STRTAB";
2492     case SHT_RELA:              return "RELA";
2493     case SHT_HASH:              return "HASH";
2494     case SHT_DYNAMIC:           return "DYNAMIC";
2495     case SHT_NOTE:              return "NOTE";
2496     case SHT_NOBITS:            return "NOBITS";
2497     case SHT_REL:               return "REL";
2498     case SHT_SHLIB:             return "SHLIB";
2499     case SHT_DYNSYM:            return "DYNSYM";
2500     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
2501     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
2502     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
2503     case SHT_GROUP:             return "GROUP";
2504     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
2505     case SHT_GNU_verdef:        return "VERDEF";
2506     case SHT_GNU_verneed:       return "VERNEED";
2507     case SHT_GNU_versym:        return "VERSYM";
2508     case 0x6ffffff0:            return "VERSYM";
2509     case 0x6ffffffc:            return "VERDEF";
2510     case 0x7ffffffd:            return "AUXILIARY";
2511     case 0x7fffffff:            return "FILTER";
2512     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
2513
2514     default:
2515       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
2516         {
2517           const char *result;
2518
2519           switch (elf_header.e_machine)
2520             {
2521             case EM_MIPS:
2522             case EM_MIPS_RS3_LE:
2523               result = get_mips_section_type_name (sh_type);
2524               break;
2525             case EM_PARISC:
2526               result = get_parisc_section_type_name (sh_type);
2527               break;
2528             case EM_IA_64:
2529               result = get_ia64_section_type_name (sh_type);
2530               break;
2531             case EM_X86_64:
2532               result = get_x86_64_section_type_name (sh_type);
2533               break;
2534             case EM_ARM:
2535               result = get_arm_section_type_name (sh_type);
2536               break;
2537             default:
2538               result = NULL;
2539               break;
2540             }
2541
2542           if (result != NULL)
2543             return result;
2544
2545           sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
2546         }
2547       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
2548         sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
2549       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
2550         sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
2551       else
2552         snprintf (buff, sizeof (buff), _("<unknown>: %x"), sh_type);
2553
2554       return buff;
2555     }
2556 }
2557
2558 #define OPTION_DEBUG_DUMP       512
2559
2560 static struct option options[] =
2561 {
2562   {"all",              no_argument, 0, 'a'},
2563   {"file-header",      no_argument, 0, 'h'},
2564   {"program-headers",  no_argument, 0, 'l'},
2565   {"headers",          no_argument, 0, 'e'},
2566   {"histogram",        no_argument, 0, 'I'},
2567   {"segments",         no_argument, 0, 'l'},
2568   {"sections",         no_argument, 0, 'S'},
2569   {"section-headers",  no_argument, 0, 'S'},
2570   {"section-groups",   no_argument, 0, 'g'},
2571   {"section-details",  no_argument, 0, 't'},
2572   {"full-section-name",no_argument, 0, 'N'},
2573   {"symbols",          no_argument, 0, 's'},
2574   {"syms",             no_argument, 0, 's'},
2575   {"relocs",           no_argument, 0, 'r'},
2576   {"notes",            no_argument, 0, 'n'},
2577   {"dynamic",          no_argument, 0, 'd'},
2578   {"arch-specific",    no_argument, 0, 'A'},
2579   {"version-info",     no_argument, 0, 'V'},
2580   {"use-dynamic",      no_argument, 0, 'D'},
2581   {"hex-dump",         required_argument, 0, 'x'},
2582   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
2583   {"unwind",           no_argument, 0, 'u'},
2584 #ifdef SUPPORT_DISASSEMBLY
2585   {"instruction-dump", required_argument, 0, 'i'},
2586 #endif
2587
2588   {"version",          no_argument, 0, 'v'},
2589   {"wide",             no_argument, 0, 'W'},
2590   {"help",             no_argument, 0, 'H'},
2591   {0,                  no_argument, 0, 0}
2592 };
2593
2594 static void
2595 usage (void)
2596 {
2597   fprintf (stdout, _("Usage: readelf <option(s)> elf-file(s)\n"));
2598   fprintf (stdout, _(" Display information about the contents of ELF format files\n"));
2599   fprintf (stdout, _(" Options are:\n\
2600   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2601   -h --file-header       Display the ELF file header\n\
2602   -l --program-headers   Display the program headers\n\
2603      --segments          An alias for --program-headers\n\
2604   -S --section-headers   Display the sections' header\n\
2605      --sections          An alias for --section-headers\n\
2606   -g --section-groups    Display the section groups\n\
2607   -t --section-details   Display the section details\n\
2608   -e --headers           Equivalent to: -h -l -S\n\
2609   -s --syms              Display the symbol table\n\
2610       --symbols          An alias for --syms\n\
2611   -n --notes             Display the core notes (if present)\n\
2612   -r --relocs            Display the relocations (if present)\n\
2613   -u --unwind            Display the unwind info (if present)\n\
2614   -d --dynamic           Display the dynamic section (if present)\n\
2615   -V --version-info      Display the version sections (if present)\n\
2616   -A --arch-specific     Display architecture specific information (if any).\n\
2617   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
2618   -x --hex-dump=<number> Dump the contents of section <number>\n\
2619   -w[liaprmfFsoR] or\n\
2620   --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2621                          Display the contents of DWARF2 debug sections\n"));
2622 #ifdef SUPPORT_DISASSEMBLY
2623   fprintf (stdout, _("\
2624   -i --instruction-dump=<number>\n\
2625                          Disassemble the contents of section <number>\n"));
2626 #endif
2627   fprintf (stdout, _("\
2628   -I --histogram         Display histogram of bucket list lengths\n\
2629   -W --wide              Allow output width to exceed 80 characters\n\
2630   @<file>                Read options from <file>\n\
2631   -H --help              Display this information\n\
2632   -v --version           Display the version number of readelf\n"));
2633   fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
2634
2635   exit (0);
2636 }
2637
2638 /* Record the fact that the user wants the contents of section number
2639    SECTION to be displayed using the method(s) encoded as flags bits
2640    in TYPE.  Note, TYPE can be zero if we are creating the array for
2641    the first time.  */
2642
2643 static void
2644 request_dump (unsigned int section, int type)
2645 {
2646   if (section >= num_dump_sects)
2647     {
2648       char *new_dump_sects;
2649
2650       new_dump_sects = calloc (section + 1, 1);
2651
2652       if (new_dump_sects == NULL)
2653         error (_("Out of memory allocating dump request table."));
2654       else
2655         {
2656           /* Copy current flag settings.  */
2657           memcpy (new_dump_sects, dump_sects, num_dump_sects);
2658
2659           free (dump_sects);
2660
2661           dump_sects = new_dump_sects;
2662           num_dump_sects = section + 1;
2663         }
2664     }
2665
2666   if (dump_sects)
2667     dump_sects[section] |= type;
2668
2669   return;
2670 }
2671
2672 /* Request a dump by section name.  */
2673
2674 static void
2675 request_dump_byname (const char *section, int type)
2676 {
2677   struct dump_list_entry *new_request;
2678
2679   new_request = malloc (sizeof (struct dump_list_entry));
2680   if (!new_request)
2681     error (_("Out of memory allocating dump request table."));
2682
2683   new_request->name = strdup (section);
2684   if (!new_request->name)
2685     error (_("Out of memory allocating dump request table."));
2686
2687   new_request->type = type;
2688
2689   new_request->next = dump_sects_byname;
2690   dump_sects_byname = new_request;
2691 }
2692
2693 static void
2694 parse_args (int argc, char **argv)
2695 {
2696   int c;
2697
2698   if (argc < 2)
2699     usage ();
2700
2701   while ((c = getopt_long
2702           (argc, argv, "ersuahnldSDAINtgw::x:i:vVWH", options, NULL)) != EOF)
2703     {
2704       char *cp;
2705       int section;
2706
2707       switch (c)
2708         {
2709         case 0:
2710           /* Long options.  */
2711           break;
2712         case 'H':
2713           usage ();
2714           break;
2715
2716         case 'a':
2717           do_syms++;
2718           do_reloc++;
2719           do_unwind++;
2720           do_dynamic++;
2721           do_header++;
2722           do_sections++;
2723           do_section_groups++;
2724           do_segments++;
2725           do_version++;
2726           do_histogram++;
2727           do_arch++;
2728           do_notes++;
2729           break;
2730         case 'g':
2731           do_section_groups++;
2732           break;
2733         case 't':
2734         case 'N':
2735           do_sections++;
2736           do_section_details++;
2737           break;
2738         case 'e':
2739           do_header++;
2740           do_sections++;
2741           do_segments++;
2742           break;
2743         case 'A':
2744           do_arch++;
2745           break;
2746         case 'D':
2747           do_using_dynamic++;
2748           break;
2749         case 'r':
2750           do_reloc++;
2751           break;
2752         case 'u':
2753           do_unwind++;
2754           break;
2755         case 'h':
2756           do_header++;
2757           break;
2758         case 'l':
2759           do_segments++;
2760           break;
2761         case 's':
2762           do_syms++;
2763           break;
2764         case 'S':
2765           do_sections++;
2766           break;
2767         case 'd':
2768           do_dynamic++;
2769           break;
2770         case 'I':
2771           do_histogram++;
2772           break;
2773         case 'n':
2774           do_notes++;
2775           break;
2776         case 'x':
2777           do_dump++;
2778           section = strtoul (optarg, & cp, 0);
2779           if (! *cp && section >= 0)
2780             request_dump (section, HEX_DUMP);
2781           else
2782             request_dump_byname (optarg, HEX_DUMP);
2783           break;
2784         case 'w':
2785           do_dump++;
2786           if (optarg == 0)
2787             do_debugging = 1;
2788           else
2789             {
2790               unsigned int index = 0;
2791
2792               do_debugging = 0;
2793
2794               while (optarg[index])
2795                 switch (optarg[index++])
2796                   {
2797                   case 'i':
2798                   case 'I':
2799                     do_debug_info = 1;
2800                     break;
2801
2802                   case 'a':
2803                   case 'A':
2804                     do_debug_abbrevs = 1;
2805                     break;
2806
2807                   case 'l':
2808                   case 'L':
2809                     do_debug_lines = 1;
2810                     break;
2811
2812                   case 'p':
2813                   case 'P':
2814                     do_debug_pubnames = 1;
2815                     break;
2816
2817                   case 'r':
2818                     do_debug_aranges = 1;
2819                     break;
2820
2821                   case 'R':
2822                     do_debug_ranges = 1;
2823                     break;
2824
2825                   case 'F':
2826                     do_debug_frames_interp = 1;
2827                   case 'f':
2828                     do_debug_frames = 1;
2829                     break;
2830
2831                   case 'm':
2832                   case 'M':
2833                     do_debug_macinfo = 1;
2834                     break;
2835
2836                   case 's':
2837                   case 'S':
2838                     do_debug_str = 1;
2839                     break;
2840
2841                   case 'o':
2842                   case 'O':
2843                     do_debug_loc = 1;
2844                     break;
2845
2846                   default:
2847                     warn (_("Unrecognized debug option '%s'\n"), optarg);
2848                     break;
2849                   }
2850             }
2851           break;
2852         case OPTION_DEBUG_DUMP:
2853           do_dump++;
2854           if (optarg == 0)
2855             do_debugging = 1;
2856           else
2857             {
2858               typedef struct
2859               {
2860                 const char * option;
2861                 int *        variable;
2862               }
2863               debug_dump_long_opts;
2864
2865               debug_dump_long_opts opts_table [] =
2866                 {
2867                   /* Please keep this table alpha- sorted.  */
2868                   { "Ranges", & do_debug_ranges },
2869                   { "abbrev", & do_debug_abbrevs },
2870                   { "aranges", & do_debug_aranges },
2871                   { "frames", & do_debug_frames },
2872                   { "frames-interp", & do_debug_frames_interp },
2873                   { "info", & do_debug_info },
2874                   { "line", & do_debug_lines },
2875                   { "loc",  & do_debug_loc },
2876                   { "macro", & do_debug_macinfo },
2877                   { "pubnames", & do_debug_pubnames },
2878                   /* This entry is for compatability
2879                      with earlier versions of readelf.  */
2880                   { "ranges", & do_debug_aranges },
2881                   { "str", & do_debug_str },
2882                   { NULL, NULL }
2883                 };
2884
2885               const char *p;
2886
2887               do_debugging = 0;
2888
2889               p = optarg;
2890               while (*p)
2891                 {
2892                   debug_dump_long_opts * entry;
2893
2894                   for (entry = opts_table; entry->option; entry++)
2895                     {
2896                       size_t len = strlen (entry->option);
2897
2898                       if (strneq (p, entry->option, len)
2899                           && (p[len] == ',' || p[len] == '\0'))
2900                         {
2901                           * entry->variable = 1;
2902
2903                           /* The --debug-dump=frames-interp option also
2904                              enables the --debug-dump=frames option.  */
2905                           if (do_debug_frames_interp)
2906                             do_debug_frames = 1;
2907
2908                           p += len;
2909                           break;
2910                         }
2911                     }
2912
2913                   if (entry->option == NULL)
2914                     {
2915                       warn (_("Unrecognized debug option '%s'\n"), p);
2916                       p = strchr (p, ',');
2917                       if (p == NULL)
2918                         break;
2919                     }
2920
2921                   if (*p == ',')
2922                     p++;
2923                 }
2924             }
2925           break;
2926 #ifdef SUPPORT_DISASSEMBLY
2927         case 'i':
2928           do_dump++;
2929           section = strtoul (optarg, & cp, 0);
2930           if (! *cp && section >= 0)
2931             {
2932               request_dump (section, DISASS_DUMP);
2933               break;
2934             }
2935           goto oops;
2936 #endif
2937         case 'v':
2938           print_version (program_name);
2939           break;
2940         case 'V':
2941           do_version++;
2942           break;
2943         case 'W':
2944           do_wide++;
2945           break;
2946         default:
2947 #ifdef SUPPORT_DISASSEMBLY
2948         oops:
2949 #endif
2950           /* xgettext:c-format */
2951           error (_("Invalid option '-%c'\n"), c);
2952           /* Drop through.  */
2953         case '?':
2954           usage ();
2955         }
2956     }
2957
2958   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
2959       && !do_segments && !do_header && !do_dump && !do_version
2960       && !do_histogram && !do_debugging && !do_arch && !do_notes
2961       && !do_section_groups)
2962     usage ();
2963   else if (argc < 3)
2964     {
2965       warn (_("Nothing to do.\n"));
2966       usage ();
2967     }
2968 }
2969
2970 static const char *
2971 get_elf_class (unsigned int elf_class)
2972 {
2973   static char buff[32];
2974
2975   switch (elf_class)
2976     {
2977     case ELFCLASSNONE: return _("none");
2978     case ELFCLASS32:   return "ELF32";
2979     case ELFCLASS64:   return "ELF64";
2980     default:
2981       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
2982       return buff;
2983     }
2984 }
2985
2986 static const char *
2987 get_data_encoding (unsigned int encoding)
2988 {
2989   static char buff[32];
2990
2991   switch (encoding)
2992     {
2993     case ELFDATANONE: return _("none");
2994     case ELFDATA2LSB: return _("2's complement, little endian");
2995     case ELFDATA2MSB: return _("2's complement, big endian");
2996     default:
2997       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
2998       return buff;
2999     }
3000 }
3001
3002 /* Decode the data held in 'elf_header'.  */
3003
3004 static int
3005 process_file_header (void)
3006 {
3007   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
3008       || elf_header.e_ident[EI_MAG1] != ELFMAG1
3009       || elf_header.e_ident[EI_MAG2] != ELFMAG2
3010       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3011     {
3012       error
3013         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3014       return 0;
3015     }
3016
3017   if (do_header)
3018     {
3019       int i;
3020
3021       printf (_("ELF Header:\n"));
3022       printf (_("  Magic:   "));
3023       for (i = 0; i < EI_NIDENT; i++)
3024         printf ("%2.2x ", elf_header.e_ident[i]);
3025       printf ("\n");
3026       printf (_("  Class:                             %s\n"),
3027               get_elf_class (elf_header.e_ident[EI_CLASS]));
3028       printf (_("  Data:                              %s\n"),
3029               get_data_encoding (elf_header.e_ident[EI_DATA]));
3030       printf (_("  Version:                           %d %s\n"),
3031               elf_header.e_ident[EI_VERSION],
3032               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3033                ? "(current)"
3034                : (elf_header.e_ident[EI_VERSION] != EV_NONE
3035                   ? "<unknown: %lx>"
3036                   : "")));
3037       printf (_("  OS/ABI:                            %s\n"),
3038               get_osabi_name (elf_header.e_ident[EI_OSABI]));
3039       printf (_("  ABI Version:                       %d\n"),
3040               elf_header.e_ident[EI_ABIVERSION]);
3041       printf (_("  Type:                              %s\n"),
3042               get_file_type (elf_header.e_type));
3043       printf (_("  Machine:                           %s\n"),
3044               get_machine_name (elf_header.e_machine));
3045       printf (_("  Version:                           0x%lx\n"),
3046               (unsigned long) elf_header.e_version);
3047
3048       printf (_("  Entry point address:               "));
3049       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3050       printf (_("\n  Start of program headers:          "));
3051       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3052       printf (_(" (bytes into file)\n  Start of section headers:          "));
3053       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3054       printf (_(" (bytes into file)\n"));
3055
3056       printf (_("  Flags:                             0x%lx%s\n"),
3057               (unsigned long) elf_header.e_flags,
3058               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3059       printf (_("  Size of this header:               %ld (bytes)\n"),
3060               (long) elf_header.e_ehsize);
3061       printf (_("  Size of program headers:           %ld (bytes)\n"),
3062               (long) elf_header.e_phentsize);
3063       printf (_("  Number of program headers:         %ld\n"),
3064               (long) elf_header.e_phnum);
3065       printf (_("  Size of section headers:           %ld (bytes)\n"),
3066               (long) elf_header.e_shentsize);
3067       printf (_("  Number of section headers:         %ld"),
3068               (long) elf_header.e_shnum);
3069       if (section_headers != NULL && elf_header.e_shnum == 0)
3070         printf (" (%ld)", (long) section_headers[0].sh_size);
3071       putc ('\n', stdout);
3072       printf (_("  Section header string table index: %ld"),
3073               (long) elf_header.e_shstrndx);
3074       if (section_headers != NULL && elf_header.e_shstrndx == SHN_XINDEX)
3075         printf (" (%ld)", (long) section_headers[0].sh_link);
3076       putc ('\n', stdout);
3077     }
3078
3079   if (section_headers != NULL)
3080     {
3081       if (elf_header.e_shnum == 0)
3082         elf_header.e_shnum = section_headers[0].sh_size;
3083       if (elf_header.e_shstrndx == SHN_XINDEX)
3084         elf_header.e_shstrndx = section_headers[0].sh_link;
3085       free (section_headers);
3086       section_headers = NULL;
3087     }
3088
3089   return 1;
3090 }
3091
3092
3093 static int
3094 get_32bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers)
3095 {
3096   Elf32_External_Phdr *phdrs;
3097   Elf32_External_Phdr *external;
3098   Elf_Internal_Phdr *internal;
3099   unsigned int i;
3100
3101   phdrs = get_data (NULL, file, elf_header.e_phoff,
3102                     elf_header.e_phentsize, elf_header.e_phnum,
3103                     _("program headers"));
3104   if (!phdrs)
3105     return 0;
3106
3107   for (i = 0, internal = program_headers, external = phdrs;
3108        i < elf_header.e_phnum;
3109        i++, internal++, external++)
3110     {
3111       internal->p_type   = BYTE_GET (external->p_type);
3112       internal->p_offset = BYTE_GET (external->p_offset);
3113       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
3114       internal->p_paddr  = BYTE_GET (external->p_paddr);
3115       internal->p_filesz = BYTE_GET (external->p_filesz);
3116       internal->p_memsz  = BYTE_GET (external->p_memsz);
3117       internal->p_flags  = BYTE_GET (external->p_flags);
3118       internal->p_align  = BYTE_GET (external->p_align);
3119     }
3120
3121   free (phdrs);
3122
3123   return 1;
3124 }
3125
3126 static int
3127 get_64bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers)
3128 {
3129   Elf64_External_Phdr *phdrs;
3130   Elf64_External_Phdr *external;
3131   Elf_Internal_Phdr *internal;
3132   unsigned int i;
3133
3134   phdrs = get_data (NULL, file, elf_header.e_phoff,
3135                     elf_header.e_phentsize, elf_header.e_phnum,
3136                     _("program headers"));
3137   if (!phdrs)
3138     return 0;
3139
3140   for (i = 0, internal = program_headers, external = phdrs;
3141        i < elf_header.e_phnum;
3142        i++, internal++, external++)
3143     {
3144       internal->p_type   = BYTE_GET (external->p_type);
3145       internal->p_flags  = BYTE_GET (external->p_flags);
3146       internal->p_offset = BYTE_GET (external->p_offset);
3147       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
3148       internal->p_paddr  = BYTE_GET (external->p_paddr);
3149       internal->p_filesz = BYTE_GET (external->p_filesz);
3150       internal->p_memsz  = BYTE_GET (external->p_memsz);
3151       internal->p_align  = BYTE_GET (external->p_align);
3152     }
3153
3154   free (phdrs);
3155
3156   return 1;
3157 }
3158
3159 /* Returns 1 if the program headers were read into `program_headers'.  */
3160
3161 static int
3162 get_program_headers (FILE *file)
3163 {
3164   Elf_Internal_Phdr *phdrs;
3165
3166   /* Check cache of prior read.  */
3167   if (program_headers != NULL)
3168     return 1;
3169
3170   phdrs = cmalloc (elf_header.e_phnum, sizeof (Elf_Internal_Phdr));
3171
3172   if (phdrs == NULL)
3173     {
3174       error (_("Out of memory\n"));
3175       return 0;
3176     }
3177
3178   if (is_32bit_elf
3179       ? get_32bit_program_headers (file, phdrs)
3180       : get_64bit_program_headers (file, phdrs))
3181     {
3182       program_headers = phdrs;
3183       return 1;
3184     }
3185
3186   free (phdrs);
3187   return 0;
3188 }
3189
3190 /* Returns 1 if the program headers were loaded.  */
3191
3192 static int
3193 process_program_headers (FILE *file)
3194 {
3195   Elf_Internal_Phdr *segment;
3196   unsigned int i;
3197
3198   if (elf_header.e_phnum == 0)
3199     {
3200       if (do_segments)
3201         printf (_("\nThere are no program headers in this file.\n"));
3202       return 0;
3203     }
3204
3205   if (do_segments && !do_header)
3206     {
3207       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3208       printf (_("Entry point "));
3209       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3210       printf (_("\nThere are %d program headers, starting at offset "),
3211               elf_header.e_phnum);
3212       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3213       printf ("\n");
3214     }
3215
3216   if (! get_program_headers (file))
3217       return 0;
3218
3219   if (do_segments)
3220     {
3221       if (elf_header.e_phnum > 1)
3222         printf (_("\nProgram Headers:\n"));
3223       else
3224         printf (_("\nProgram Headers:\n"));
3225
3226       if (is_32bit_elf)
3227         printf
3228           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
3229       else if (do_wide)
3230         printf
3231           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
3232       else
3233         {
3234           printf
3235             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
3236           printf
3237             (_("                 FileSiz            MemSiz              Flags  Align\n"));
3238         }
3239     }
3240
3241   dynamic_addr = 0;
3242   dynamic_size = 0;
3243
3244   for (i = 0, segment = program_headers;
3245        i < elf_header.e_phnum;
3246        i++, segment++)
3247     {
3248       if (do_segments)
3249         {
3250           printf ("  %-14.14s ", get_segment_type (segment->p_type));
3251
3252           if (is_32bit_elf)
3253             {
3254               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3255               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3256               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3257               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3258               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3259               printf ("%c%c%c ",
3260                       (segment->p_flags & PF_R ? 'R' : ' '),
3261                       (segment->p_flags & PF_W ? 'W' : ' '),
3262                       (segment->p_flags & PF_X ? 'E' : ' '));
3263               printf ("%#lx", (unsigned long) segment->p_align);
3264             }
3265           else if (do_wide)
3266             {
3267               if ((unsigned long) segment->p_offset == segment->p_offset)
3268                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3269               else
3270                 {
3271                   print_vma (segment->p_offset, FULL_HEX);
3272                   putchar (' ');
3273                 }
3274
3275               print_vma (segment->p_vaddr, FULL_HEX);
3276               putchar (' ');
3277               print_vma (segment->p_paddr, FULL_HEX);
3278               putchar (' ');
3279
3280               if ((unsigned long) segment->p_filesz == segment->p_filesz)
3281                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3282               else
3283                 {
3284                   print_vma (segment->p_filesz, FULL_HEX);
3285                   putchar (' ');
3286                 }
3287
3288               if ((unsigned long) segment->p_memsz == segment->p_memsz)
3289                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3290               else
3291                 {
3292                   print_vma (segment->p_offset, FULL_HEX);
3293                 }
3294
3295               printf (" %c%c%c ",
3296                       (segment->p_flags & PF_R ? 'R' : ' '),
3297                       (segment->p_flags & PF_W ? 'W' : ' '),
3298                       (segment->p_flags & PF_X ? 'E' : ' '));
3299
3300               if ((unsigned long) segment->p_align == segment->p_align)
3301                 printf ("%#lx", (unsigned long) segment->p_align);
3302               else
3303                 {
3304                   print_vma (segment->p_align, PREFIX_HEX);
3305                 }
3306             }
3307           else
3308             {
3309               print_vma (segment->p_offset, FULL_HEX);
3310               putchar (' ');
3311               print_vma (segment->p_vaddr, FULL_HEX);
3312               putchar (' ');
3313               print_vma (segment->p_paddr, FULL_HEX);
3314               printf ("\n                 ");
3315               print_vma (segment->p_filesz, FULL_HEX);
3316               putchar (' ');
3317               print_vma (segment->p_memsz, FULL_HEX);
3318               printf ("  %c%c%c    ",
3319                       (segment->p_flags & PF_R ? 'R' : ' '),
3320                       (segment->p_flags & PF_W ? 'W' : ' '),
3321                       (segment->p_flags & PF_X ? 'E' : ' '));
3322               print_vma (segment->p_align, HEX);
3323             }
3324         }
3325
3326       switch (segment->p_type)
3327         {
3328         case PT_DYNAMIC:
3329           if (dynamic_addr)
3330             error (_("more than one dynamic segment\n"));
3331
3332           /* Try to locate the .dynamic section. If there is
3333              a section header table, we can easily locate it.  */
3334           if (section_headers != NULL)
3335             {
3336               Elf_Internal_Shdr *sec;
3337
3338               sec = find_section (".dynamic");
3339               if (sec == NULL || sec->sh_size == 0)
3340                 {
3341                   error (_("no .dynamic section in the dynamic segment"));
3342                   break;
3343                 }
3344
3345               dynamic_addr = sec->sh_offset;
3346               dynamic_size = sec->sh_size;
3347
3348               if (dynamic_addr < segment->p_offset
3349                   || dynamic_addr > segment->p_offset + segment->p_filesz)
3350                 warn (_("the .dynamic section is not contained within the dynamic segment"));
3351               else if (dynamic_addr > segment->p_offset)
3352                 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3353             }
3354           else
3355             {
3356               /* Otherwise, we can only assume that the .dynamic
3357                  section is the first section in the DYNAMIC segment.  */
3358               dynamic_addr = segment->p_offset;
3359               dynamic_size = segment->p_filesz;
3360             }
3361           break;
3362
3363         case PT_INTERP:
3364           if (fseek (file, archive_file_offset + (long) segment->p_offset,
3365                      SEEK_SET))
3366             error (_("Unable to find program interpreter name\n"));
3367           else
3368             {
3369               program_interpreter[0] = 0;
3370               fscanf (file, "%63s", program_interpreter);
3371
3372               if (do_segments)
3373                 printf (_("\n      [Requesting program interpreter: %s]"),
3374                     program_interpreter);
3375             }
3376           break;
3377         }
3378
3379       if (do_segments)
3380         putc ('\n', stdout);
3381     }
3382
3383   if (do_segments && section_headers != NULL && string_table != NULL)
3384     {
3385       printf (_("\n Section to Segment mapping:\n"));
3386       printf (_("  Segment Sections...\n"));
3387
3388       for (i = 0; i < elf_header.e_phnum; i++)
3389         {
3390           unsigned int j;
3391           Elf_Internal_Shdr *section;
3392
3393           segment = program_headers + i;
3394           section = section_headers;
3395
3396           printf ("   %2.2d     ", i);
3397
3398           for (j = 1; j < elf_header.e_shnum; j++, section++)
3399             {
3400               if (section->sh_size > 0
3401                   /* Compare allocated sections by VMA, unallocated
3402                      sections by file offset.  */
3403                   && (section->sh_flags & SHF_ALLOC
3404                       ? (section->sh_addr >= segment->p_vaddr
3405                          && section->sh_addr + section->sh_size
3406                          <= segment->p_vaddr + segment->p_memsz)
3407                       : ((bfd_vma) section->sh_offset >= segment->p_offset
3408                          && (section->sh_offset + section->sh_size
3409                              <= segment->p_offset + segment->p_filesz)))
3410                   /* .tbss is special.  It doesn't contribute memory space
3411                      to normal segments.  */
3412                   && (!((section->sh_flags & SHF_TLS) != 0
3413                         && section->sh_type == SHT_NOBITS)
3414                       || segment->p_type == PT_TLS))
3415                 printf ("%s ", SECTION_NAME (section));
3416             }
3417
3418           putc ('\n',stdout);
3419         }
3420     }
3421
3422   return 1;
3423 }
3424
3425
3426 /* Find the file offset corresponding to VMA by using the program headers.  */
3427
3428 static long
3429 offset_from_vma (FILE *file, bfd_vma vma, bfd_size_type size)
3430 {
3431   Elf_Internal_Phdr *seg;
3432
3433   if (! get_program_headers (file))
3434     {
3435       warn (_("Cannot interpret virtual addresses without program headers.\n"));
3436       return (long) vma;
3437     }
3438
3439   for (seg = program_headers;
3440        seg < program_headers + elf_header.e_phnum;
3441        ++seg)
3442     {
3443       if (seg->p_type != PT_LOAD)
3444         continue;
3445
3446       if (vma >= (seg->p_vaddr & -seg->p_align)
3447           && vma + size <= seg->p_vaddr + seg->p_filesz)
3448         return vma - seg->p_vaddr + seg->p_offset;
3449     }
3450
3451   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3452         (long) vma);
3453   return (long) vma;
3454 }
3455
3456
3457 static int
3458 get_32bit_section_headers (FILE *file, unsigned int num)
3459 {
3460   Elf32_External_Shdr *shdrs;
3461   Elf_Internal_Shdr *internal;
3462   unsigned int i;
3463
3464   shdrs = get_data (NULL, file, elf_header.e_shoff,
3465                     elf_header.e_shentsize, num, _("section headers"));
3466   if (!shdrs)
3467     return 0;
3468
3469   section_headers = cmalloc (num, sizeof (Elf_Internal_Shdr));
3470
3471   if (section_headers == NULL)
3472     {
3473       error (_("Out of memory\n"));
3474       return 0;
3475     }
3476
3477   for (i = 0, internal = section_headers;
3478        i < num;
3479        i++, internal++)
3480     {
3481       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
3482       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
3483       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
3484       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
3485       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
3486       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
3487       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
3488       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
3489       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3490       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
3491     }
3492
3493   free (shdrs);
3494
3495   return 1;
3496 }
3497
3498 static int
3499 get_64bit_section_headers (FILE *file, unsigned int num)
3500 {
3501   Elf64_External_Shdr *shdrs;
3502   Elf_Internal_Shdr *internal;
3503   unsigned int i;
3504
3505   shdrs = get_data (NULL, file, elf_header.e_shoff,
3506                     elf_header.e_shentsize, num, _("section headers"));
3507   if (!shdrs)
3508     return 0;
3509
3510   section_headers = cmalloc (num, sizeof (Elf_Internal_Shdr));
3511
3512   if (section_headers == NULL)
3513     {
3514       error (_("Out of memory\n"));
3515       return 0;
3516     }
3517
3518   for (i = 0, internal = section_headers;
3519        i < num;
3520        i++, internal++)
3521     {
3522       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
3523       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
3524       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
3525       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
3526       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
3527       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
3528       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
3529       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
3530       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
3531       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3532     }
3533
3534   free (shdrs);
3535
3536   return 1;
3537 }
3538
3539 static Elf_Internal_Sym *
3540 get_32bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
3541 {
3542   unsigned long number;
3543   Elf32_External_Sym *esyms;
3544   Elf_External_Sym_Shndx *shndx;
3545   Elf_Internal_Sym *isyms;
3546   Elf_Internal_Sym *psym;
3547   unsigned int j;
3548
3549   esyms = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
3550                     _("symbols"));
3551   if (!esyms)
3552     return NULL;
3553
3554   shndx = NULL;
3555   if (symtab_shndx_hdr != NULL
3556       && (symtab_shndx_hdr->sh_link
3557           == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3558     {
3559       shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3560                         1, symtab_shndx_hdr->sh_size, _("symtab shndx"));
3561       if (!shndx)
3562         {
3563           free (esyms);
3564           return NULL;
3565         }
3566     }
3567
3568   number = section->sh_size / section->sh_entsize;
3569   isyms = cmalloc (number, sizeof (Elf_Internal_Sym));
3570
3571   if (isyms == NULL)
3572     {
3573       error (_("Out of memory\n"));
3574       if (shndx)
3575         free (shndx);
3576       free (esyms);
3577       return NULL;
3578     }
3579
3580   for (j = 0, psym = isyms;
3581        j < number;
3582        j++, psym++)
3583     {
3584       psym->st_name  = BYTE_GET (esyms[j].st_name);
3585       psym->st_value = BYTE_GET (esyms[j].st_value);
3586       psym->st_size  = BYTE_GET (esyms[j].st_size);
3587       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3588       if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3589         psym->st_shndx
3590           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3591       psym->st_info  = BYTE_GET (esyms[j].st_info);
3592       psym->st_other = BYTE_GET (esyms[j].st_other);
3593     }
3594
3595   if (shndx)
3596     free (shndx);
3597   free (esyms);
3598
3599   return isyms;
3600 }
3601
3602 static Elf_Internal_Sym *
3603 get_64bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
3604 {
3605   unsigned long number;
3606   Elf64_External_Sym *esyms;
3607   Elf_External_Sym_Shndx *shndx;
3608   Elf_Internal_Sym *isyms;
3609   Elf_Internal_Sym *psym;
3610   unsigned int j;
3611
3612   esyms = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
3613                     _("symbols"));
3614   if (!esyms)
3615     return NULL;
3616
3617   shndx = NULL;
3618   if (symtab_shndx_hdr != NULL
3619       && (symtab_shndx_hdr->sh_link
3620           == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3621     {
3622       shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3623                         1, symtab_shndx_hdr->sh_size, _("symtab shndx"));
3624       if (!shndx)
3625         {
3626           free (esyms);
3627           return NULL;
3628         }
3629     }
3630
3631   number = section->sh_size / section->sh_entsize;
3632   isyms = cmalloc (number, sizeof (Elf_Internal_Sym));
3633
3634   if (isyms == NULL)
3635     {
3636       error (_("Out of memory\n"));
3637       if (shndx)
3638         free (shndx);
3639       free (esyms);
3640       return NULL;
3641     }
3642
3643   for (j = 0, psym = isyms;
3644        j < number;
3645        j++, psym++)
3646     {
3647       psym->st_name  = BYTE_GET (esyms[j].st_name);
3648       psym->st_info  = BYTE_GET (esyms[j].st_info);
3649       psym->st_other = BYTE_GET (esyms[j].st_other);
3650       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3651       if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3652         psym->st_shndx
3653           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3654       psym->st_value = BYTE_GET (esyms[j].st_value);
3655       psym->st_size  = BYTE_GET (esyms[j].st_size);
3656     }
3657
3658   if (shndx)
3659     free (shndx);
3660   free (esyms);
3661
3662   return isyms;
3663 }
3664
3665 static const char *
3666 get_elf_section_flags (bfd_vma sh_flags)
3667 {
3668   static char buff[1024];
3669   char *p = buff;
3670   int field_size = is_32bit_elf ? 8 : 16;
3671   int index, size = sizeof (buff) - (field_size + 4 + 1);
3672   bfd_vma os_flags = 0;
3673   bfd_vma proc_flags = 0;
3674   bfd_vma unknown_flags = 0;
3675   const struct
3676     {
3677       const char *str;
3678       int len;
3679     }
3680   flags [] =
3681     {
3682         { "WRITE", 5 },
3683         { "ALLOC", 5 },
3684         { "EXEC", 4 },
3685         { "MERGE", 5 },
3686         { "STRINGS", 7 },
3687         { "INFO LINK", 9 },
3688         { "LINK ORDER", 10 },
3689         { "OS NONCONF", 10 },
3690         { "GROUP", 5 },
3691         { "TLS", 3 }
3692     };
3693
3694   if (do_section_details)
3695     {
3696       sprintf (buff, "[%*.*lx]: ",
3697                field_size, field_size, (unsigned long) sh_flags);
3698       p += field_size + 4;
3699     }
3700
3701   while (sh_flags)
3702     {
3703       bfd_vma flag;
3704
3705       flag = sh_flags & - sh_flags;
3706       sh_flags &= ~ flag;
3707
3708       if (do_section_details)
3709         {
3710           switch (flag)
3711             {
3712             case SHF_WRITE:             index = 0; break;
3713             case SHF_ALLOC:             index = 1; break;
3714             case SHF_EXECINSTR:         index = 2; break;
3715             case SHF_MERGE:             index = 3; break;
3716             case SHF_STRINGS:           index = 4; break;
3717             case SHF_INFO_LINK:         index = 5; break;
3718             case SHF_LINK_ORDER:        index = 6; break;
3719             case SHF_OS_NONCONFORMING:  index = 7; break;
3720             case SHF_GROUP:             index = 8; break;
3721             case SHF_TLS:               index = 9; break;
3722
3723             default:
3724               index = -1;
3725               break;
3726             }
3727
3728           if (index != -1)
3729             {
3730               if (p != buff + field_size + 4)
3731                 {
3732                   if (size < (10 + 2))
3733                     abort ();
3734                   size -= 2;
3735                   *p++ = ',';
3736                   *p++ = ' ';
3737                 }
3738
3739               size -= flags [index].len;
3740               p = stpcpy (p, flags [index].str);
3741             }
3742           else if (flag & SHF_MASKOS)
3743             os_flags |= flag;
3744           else if (flag & SHF_MASKPROC)
3745             proc_flags |= flag;
3746           else
3747             unknown_flags |= flag;
3748         }
3749       else
3750         {
3751           switch (flag)
3752             {
3753             case SHF_WRITE:             *p = 'W'; break;
3754             case SHF_ALLOC:             *p = 'A'; break;
3755             case SHF_EXECINSTR:         *p = 'X'; break;
3756             case SHF_MERGE:             *p = 'M'; break;
3757             case SHF_STRINGS:           *p = 'S'; break;
3758             case SHF_INFO_LINK:         *p = 'I'; break;
3759             case SHF_LINK_ORDER:        *p = 'L'; break;
3760             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
3761             case SHF_GROUP:             *p = 'G'; break;
3762             case SHF_TLS:               *p = 'T'; break;
3763
3764             default:
3765               if (elf_header.e_machine == EM_X86_64
3766                   && flag == SHF_X86_64_LARGE)
3767                 *p = 'l';
3768               else if (flag & SHF_MASKOS)
3769                 {
3770                   *p = 'o';
3771                   sh_flags &= ~ SHF_MASKOS;
3772                 }
3773               else if (flag & SHF_MASKPROC)
3774                 {
3775                   *p = 'p';
3776                   sh_flags &= ~ SHF_MASKPROC;
3777                 }
3778               else
3779                 *p = 'x';
3780               break;
3781             }
3782           p++;
3783         }
3784     }
3785
3786   if (do_section_details)
3787     {
3788       if (os_flags)
3789         {
3790           size -= 5 + field_size;
3791           if (p != buff + field_size + 4)
3792             {
3793               if (size < (2 + 1))
3794                 abort ();
3795               size -= 2;
3796               *p++ = ',';
3797               *p++ = ' ';
3798             }
3799           sprintf (p, "OS (%*.*lx)", field_size, field_size,
3800                    (unsigned long) os_flags);
3801           p += 5 + field_size;
3802         }
3803       if (proc_flags)
3804         {
3805           size -= 7 + field_size;
3806           if (p != buff + field_size + 4)
3807             {
3808               if (size < (2 + 1))
3809                 abort ();
3810               size -= 2;
3811               *p++ = ',';
3812               *p++ = ' ';
3813             }
3814           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
3815                    (unsigned long) proc_flags);
3816           p += 7 + field_size;
3817         }
3818       if (unknown_flags)
3819         {
3820           size -= 10 + field_size;
3821           if (p != buff + field_size + 4)
3822             {
3823               if (size < (2 + 1))
3824                 abort ();
3825               size -= 2;
3826               *p++ = ',';
3827               *p++ = ' ';
3828             }
3829           sprintf (p, "UNKNOWN (%*.*lx)", field_size, field_size,
3830                    (unsigned long) unknown_flags);
3831           p += 10 + field_size;
3832         }
3833     }
3834
3835   *p = '\0';
3836   return buff;
3837 }
3838
3839 static int
3840 process_section_headers (FILE *file)
3841 {
3842   Elf_Internal_Shdr *section;
3843   unsigned int i;
3844
3845   section_headers = NULL;
3846
3847   if (elf_header.e_shnum == 0)
3848     {
3849       if (do_sections)
3850         printf (_("\nThere are no sections in this file.\n"));
3851
3852       return 1;
3853     }
3854
3855   if (do_sections && !do_header)
3856     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3857             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
3858
3859   if (is_32bit_elf)
3860     {
3861       if (! get_32bit_section_headers (file, elf_header.e_shnum))
3862         return 0;
3863     }
3864   else if (! get_64bit_section_headers (file, elf_header.e_shnum))
3865     return 0;
3866
3867   /* Read in the string table, so that we have names to display.  */
3868   if (SECTION_HEADER_INDEX (elf_header.e_shstrndx) < elf_header.e_shnum)
3869     {
3870       section = SECTION_HEADER (elf_header.e_shstrndx);
3871
3872       if (section->sh_size != 0)
3873         {
3874           string_table = get_data (NULL, file, section->sh_offset,
3875                                    1, section->sh_size, _("string table"));
3876
3877           string_table_length = string_table != NULL ? section->sh_size : 0;
3878         }
3879     }
3880
3881   /* Scan the sections for the dynamic symbol table
3882      and dynamic string table and debug sections.  */
3883   dynamic_symbols = NULL;
3884   dynamic_strings = NULL;
3885   dynamic_syminfo = NULL;
3886   symtab_shndx_hdr = NULL;
3887
3888   eh_addr_size = is_32bit_elf ? 4 : 8;
3889   switch (elf_header.e_machine)
3890     {
3891     case EM_MIPS:
3892     case EM_MIPS_RS3_LE:
3893       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
3894          FDE addresses.  However, the ABI also has a semi-official ILP32
3895          variant for which the normal FDE address size rules apply.
3896
3897          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
3898          section, where XX is the size of longs in bits.  Unfortunately,
3899          earlier compilers provided no way of distinguishing ILP32 objects
3900          from LP64 objects, so if there's any doubt, we should assume that
3901          the official LP64 form is being used.  */
3902       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
3903           && find_section (".gcc_compiled_long32") == NULL)
3904         eh_addr_size = 8;
3905       break;
3906     }
3907
3908 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
3909   do                                                                        \
3910     {                                                                       \
3911       size_t expected_entsize                                               \
3912         = is_32bit_elf ? size32 : size64;                                   \
3913       if (section->sh_entsize != expected_entsize)                          \
3914         error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
3915                i, (unsigned long int) section->sh_entsize,                  \
3916                (unsigned long int) expected_entsize);                       \
3917       section->sh_entsize = expected_entsize;                               \
3918     }                                                                       \
3919   while (0)
3920 #define CHECK_ENTSIZE(section, i, type) \
3921   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
3922                         sizeof (Elf64_External_##type))
3923
3924   for (i = 0, section = section_headers;
3925        i < elf_header.e_shnum;
3926        i++, section++)
3927     {
3928       char *name = SECTION_NAME (section);
3929
3930       if (section->sh_type == SHT_DYNSYM)
3931         {
3932           if (dynamic_symbols != NULL)
3933             {
3934               error (_("File contains multiple dynamic symbol tables\n"));
3935               continue;
3936             }
3937
3938           CHECK_ENTSIZE (section, i, Sym);
3939           num_dynamic_syms = section->sh_size / section->sh_entsize;
3940           dynamic_symbols = GET_ELF_SYMBOLS (file, section);
3941         }
3942       else if (section->sh_type == SHT_STRTAB
3943                && streq (name, ".dynstr"))
3944         {
3945           if (dynamic_strings != NULL)
3946             {
3947               error (_("File contains multiple dynamic string tables\n"));
3948               continue;
3949             }
3950
3951           dynamic_strings = get_data (NULL, file, section->sh_offset,
3952                                       1, section->sh_size, _("dynamic strings"));
3953           dynamic_strings_length = section->sh_size;
3954         }
3955       else if (section->sh_type == SHT_SYMTAB_SHNDX)
3956         {
3957           if (symtab_shndx_hdr != NULL)
3958             {
3959               error (_("File contains multiple symtab shndx tables\n"));
3960               continue;
3961             }
3962           symtab_shndx_hdr = section;
3963         }
3964       else if (section->sh_type == SHT_SYMTAB)
3965         CHECK_ENTSIZE (section, i, Sym);
3966       else if (section->sh_type == SHT_GROUP)
3967         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
3968       else if (section->sh_type == SHT_REL)
3969         CHECK_ENTSIZE (section, i, Rel);
3970       else if (section->sh_type == SHT_RELA)
3971         CHECK_ENTSIZE (section, i, Rela);
3972       else if ((do_debugging || do_debug_info || do_debug_abbrevs
3973                 || do_debug_lines || do_debug_pubnames || do_debug_aranges
3974                 || do_debug_frames || do_debug_macinfo || do_debug_str
3975                 || do_debug_loc || do_debug_ranges)
3976                && strneq (name, ".debug_", 7))
3977         {
3978           name += 7;
3979
3980           if (do_debugging
3981               || (do_debug_info     && streq (name, "info"))
3982               || (do_debug_abbrevs  && streq (name, "abbrev"))
3983               || (do_debug_lines    && streq (name, "line"))
3984               || (do_debug_pubnames && streq (name, "pubnames"))
3985               || (do_debug_aranges  && streq (name, "aranges"))
3986               || (do_debug_ranges   && streq (name, "ranges"))
3987               || (do_debug_frames   && streq (name, "frame"))
3988               || (do_debug_macinfo  && streq (name, "macinfo"))
3989               || (do_debug_str      && streq (name, "str"))
3990               || (do_debug_loc      && streq (name, "loc"))
3991               )
3992             request_dump (i, DEBUG_DUMP);
3993         }
3994       /* linkonce section to be combined with .debug_info at link time.  */
3995       else if ((do_debugging || do_debug_info)
3996                && strneq (name, ".gnu.linkonce.wi.", 17))
3997         request_dump (i, DEBUG_DUMP);
3998       else if (do_debug_frames && streq (name, ".eh_frame"))
3999         request_dump (i, DEBUG_DUMP);
4000     }
4001
4002   if (! do_sections)
4003     return 1;
4004
4005   if (elf_header.e_shnum > 1)
4006     printf (_("\nSection Headers:\n"));
4007   else
4008     printf (_("\nSection Header:\n"));
4009
4010   if (is_32bit_elf)
4011     {
4012       if (do_section_details)
4013         {
4014           printf (_("  [Nr] Name\n"));
4015           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
4016         }
4017       else
4018         printf
4019           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
4020     }
4021   else if (do_wide)
4022     {
4023       if (do_section_details)
4024         {
4025           printf (_("  [Nr] Name\n"));
4026           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
4027         }
4028       else
4029         printf
4030           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
4031     }
4032   else
4033     {
4034       if (do_section_details)
4035         {
4036           printf (_("  [Nr] Name\n"));
4037           printf (_("       Type              Address          Offset            Link\n"));
4038           printf (_("       Size              EntSize          Info              Align\n"));
4039         }
4040       else
4041         {
4042           printf (_("  [Nr] Name              Type             Address           Offset\n"));
4043           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
4044         }
4045     }
4046
4047   if (do_section_details)
4048     printf (_("       Flags\n"));
4049
4050   for (i = 0, section = section_headers;
4051        i < elf_header.e_shnum;
4052        i++, section++)
4053     {
4054       if (do_section_details)
4055         {
4056           printf ("  [%2u] %s\n",
4057                   SECTION_HEADER_NUM (i),
4058                   SECTION_NAME (section));
4059           if (is_32bit_elf || do_wide)
4060             printf ("       %-15.15s ",
4061                     get_section_type_name (section->sh_type));
4062         }
4063       else
4064         printf ("  [%2u] %-17.17s %-15.15s ",
4065                 SECTION_HEADER_NUM (i),
4066                 SECTION_NAME (section),
4067                 get_section_type_name (section->sh_type));
4068
4069       if (is_32bit_elf)
4070         {
4071           print_vma (section->sh_addr, LONG_HEX);
4072
4073           printf ( " %6.6lx %6.6lx %2.2lx",
4074                    (unsigned long) section->sh_offset,
4075                    (unsigned long) section->sh_size,
4076                    (unsigned long) section->sh_entsize);
4077
4078           if (do_section_details)
4079             fputs ("  ", stdout);
4080           else
4081             printf (" %3s ", get_elf_section_flags (section->sh_flags));
4082
4083           printf ("%2ld %3lu %2ld\n",
4084                   (unsigned long) section->sh_link,
4085                   (unsigned long) section->sh_info,
4086                   (unsigned long) section->sh_addralign);
4087         }
4088       else if (do_wide)
4089         {
4090           print_vma (section->sh_addr, LONG_HEX);
4091
4092           if ((long) section->sh_offset == section->sh_offset)
4093             printf (" %6.6lx", (unsigned long) section->sh_offset);
4094           else
4095             {
4096               putchar (' ');
4097               print_vma (section->sh_offset, LONG_HEX);
4098             }
4099
4100           if ((unsigned long) section->sh_size == section->sh_size)
4101             printf (" %6.6lx", (unsigned long) section->sh_size);
4102           else
4103             {
4104               putchar (' ');
4105               print_vma (section->sh_size, LONG_HEX);
4106             }
4107
4108           if ((unsigned long) section->sh_entsize == section->sh_entsize)
4109             printf (" %2.2lx", (unsigned long) section->sh_entsize);
4110           else
4111             {
4112               putchar (' ');
4113               print_vma (section->sh_entsize, LONG_HEX);
4114             }
4115
4116           if (do_section_details)
4117             fputs ("  ", stdout);
4118           else
4119             printf (" %3s ", get_elf_section_flags (section->sh_flags));
4120
4121           printf ("%2ld %3lu ",
4122                   (unsigned long) section->sh_link,
4123                   (unsigned long) section->sh_info);
4124
4125           if ((unsigned long) section->sh_addralign == section->sh_addralign)
4126             printf ("%2ld\n", (unsigned long) section->sh_addralign);
4127           else
4128             {
4129               print_vma (section->sh_addralign, DEC);
4130               putchar ('\n');
4131             }
4132         }
4133       else if (do_section_details)
4134         {
4135           printf ("       %-15.15s  ",
4136                   get_section_type_name (section->sh_type));
4137           print_vma (section->sh_addr, LONG_HEX);
4138           if ((long) section->sh_offset == section->sh_offset)
4139             printf ("  %16.16lx", (unsigned long) section->sh_offset);
4140           else
4141             {
4142               printf ("  ");
4143               print_vma (section->sh_offset, LONG_HEX);
4144             }
4145           printf ("  %ld\n       ", (unsigned long) section->sh_link);
4146           print_vma (section->sh_size, LONG_HEX);
4147           putchar (' ');
4148           print_vma (section->sh_entsize, LONG_HEX);
4149
4150           printf ("  %-16lu  %ld\n",
4151                   (unsigned long) section->sh_info,
4152                   (unsigned long) section->sh_addralign);
4153         }
4154       else
4155         {
4156           putchar (' ');
4157           print_vma (section->sh_addr, LONG_HEX);
4158           if ((long) section->sh_offset == section->sh_offset)
4159             printf ("  %8.8lx", (unsigned long) section->sh_offset);
4160           else
4161             {
4162               printf ("  ");
4163               print_vma (section->sh_offset, LONG_HEX);
4164             }
4165           printf ("\n       ");
4166           print_vma (section->sh_size, LONG_HEX);
4167           printf ("  ");
4168           print_vma (section->sh_entsize, LONG_HEX);
4169
4170           printf (" %3s ", get_elf_section_flags (section->sh_flags));
4171
4172           printf ("     %2ld   %3lu     %ld\n",
4173                   (unsigned long) section->sh_link,
4174                   (unsigned long) section->sh_info,
4175                   (unsigned long) section->sh_addralign);
4176         }
4177
4178       if (do_section_details)
4179         printf ("       %s\n", get_elf_section_flags (section->sh_flags));
4180     }
4181
4182   if (!do_section_details)
4183     printf (_("Key to Flags:\n\
4184   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4185   I (info), L (link order), G (group), x (unknown)\n\
4186   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4187
4188   return 1;
4189 }
4190
4191 static const char *
4192 get_group_flags (unsigned int flags)
4193 {
4194   static char buff[32];
4195   switch (flags)
4196     {
4197     case GRP_COMDAT:
4198       return "COMDAT";
4199
4200    default:
4201       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x]"), flags);
4202       break;
4203     }
4204   return buff;
4205 }
4206
4207 static int
4208 process_section_groups (FILE *file)
4209 {
4210   Elf_Internal_Shdr *section;
4211   unsigned int i;
4212   struct group *group;
4213   Elf_Internal_Shdr *symtab_sec, *strtab_sec;
4214   Elf_Internal_Sym *symtab;
4215   char *strtab;
4216   size_t strtab_size;
4217
4218   /* Don't process section groups unless needed.  */
4219   if (!do_unwind && !do_section_groups)
4220     return 1;
4221
4222   if (elf_header.e_shnum == 0)
4223     {
4224       if (do_section_groups)
4225         printf (_("\nThere are no sections in this file.\n"));
4226
4227       return 1;
4228     }
4229
4230   if (section_headers == NULL)
4231     {
4232       error (_("Section headers are not available!\n"));
4233       abort ();
4234     }
4235
4236   section_headers_groups = calloc (elf_header.e_shnum,
4237                                    sizeof (struct group *));
4238
4239   if (section_headers_groups == NULL)
4240     {
4241       error (_("Out of memory\n"));
4242       return 0;
4243     }
4244
4245   /* Scan the sections for the group section.  */
4246   group_count = 0;
4247   for (i = 0, section = section_headers;
4248        i < elf_header.e_shnum;
4249        i++, section++)
4250     if (section->sh_type == SHT_GROUP)
4251       group_count++;
4252
4253   if (group_count == 0)
4254     {
4255       if (do_section_groups)
4256         printf (_("\nThere are no section groups in this file.\n"));
4257
4258       return 1;
4259     }
4260
4261   section_groups = calloc (group_count, sizeof (struct group));
4262
4263   if (section_groups == NULL)
4264     {
4265       error (_("Out of memory\n"));
4266       return 0;
4267     }
4268
4269   symtab_sec = NULL;
4270   strtab_sec = NULL;
4271   symtab = NULL;
4272   strtab = NULL;
4273   strtab_size = 0;
4274   for (i = 0, section = section_headers, group = section_groups;
4275        i < elf_header.e_shnum;
4276        i++, section++)
4277     {
4278       if (section->sh_type == SHT_GROUP)
4279         {
4280           char *name = SECTION_NAME (section);
4281           char *group_name;
4282           unsigned char *start, *indices;
4283           unsigned int entry, j, size;
4284           Elf_Internal_Shdr *sec;
4285           Elf_Internal_Sym *sym;
4286
4287           /* Get the symbol table.  */
4288           if (SECTION_HEADER_INDEX (section->sh_link) >= elf_header.e_shnum
4289               || ((sec = SECTION_HEADER (section->sh_link))->sh_type
4290                   != SHT_SYMTAB))
4291             {
4292               error (_("Bad sh_link in group section `%s'\n"), name);
4293               continue;
4294             }
4295
4296           if (symtab_sec != sec)
4297             {
4298               symtab_sec = sec;
4299               if (symtab)
4300                 free (symtab);
4301               symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4302             }
4303
4304           sym = symtab + section->sh_info;
4305
4306           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4307             {
4308               bfd_vma sec_index = SECTION_HEADER_INDEX (sym->st_shndx);
4309               if (sec_index == 0)
4310                 {
4311                   error (_("Bad sh_info in group section `%s'\n"), name);
4312                   continue;
4313                 }
4314
4315               group_name = SECTION_NAME (section_headers + sec_index);
4316               strtab_sec = NULL;
4317               if (strtab)
4318                 free (strtab);
4319               strtab = NULL;
4320               strtab_size = 0;
4321             }
4322           else
4323             {
4324               /* Get the string table.  */
4325               if (SECTION_HEADER_INDEX (symtab_sec->sh_link)
4326                   >= elf_header.e_shnum)
4327                 {
4328                   strtab_sec = NULL;
4329                   if (strtab)
4330                     free (strtab);
4331                   strtab = NULL;
4332                   strtab_size = 0;
4333                 }
4334               else if (strtab_sec
4335                        != (sec = SECTION_HEADER (symtab_sec->sh_link)))
4336                 {
4337                   strtab_sec = sec;
4338                   if (strtab)
4339                     free (strtab);
4340                   strtab = get_data (NULL, file, strtab_sec->sh_offset,
4341                                      1, strtab_sec->sh_size,
4342                                      _("string table"));
4343                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
4344                 }
4345               group_name = sym->st_name < strtab_size
4346                            ? strtab + sym->st_name : "<corrupt>";
4347             }
4348
4349           start = get_data (NULL, file, section->sh_offset,
4350                             1, section->sh_size, _("section data"));
4351
4352           indices = start;
4353           size = (section->sh_size / section->sh_entsize) - 1;
4354           entry = byte_get (indices, 4);
4355           indices += 4;
4356
4357           if (do_section_groups)
4358             {
4359               printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4360                       get_group_flags (entry), i, name, group_name, size);
4361
4362               printf (_("   [Index]    Name\n"));
4363             }
4364
4365           group->group_index = i;
4366
4367           for (j = 0; j < size; j++)
4368             {
4369               struct group_list *g;
4370
4371               entry = byte_get (indices, 4);
4372               indices += 4;
4373
4374               if (SECTION_HEADER_INDEX (entry) >= elf_header.e_shnum)
4375                 {
4376                   error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4377                          entry, i, elf_header.e_shnum - 1);
4378                   continue;
4379                 }
4380               else if (entry >= SHN_LORESERVE && entry <= SHN_HIRESERVE)
4381                 {
4382                   error (_("invalid section [%5u] in group section [%5u]\n"),
4383                          entry, i);
4384                   continue;
4385                 }
4386
4387               if (section_headers_groups [SECTION_HEADER_INDEX (entry)]
4388                   != NULL)
4389                 {
4390                   if (entry)
4391                     {
4392                       error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4393                              entry, i,
4394                              section_headers_groups [SECTION_HEADER_INDEX (entry)]->group_index);
4395                       continue;
4396                     }
4397                   else
4398                     {
4399                       /* Intel C/C++ compiler may put section 0 in a
4400                          section group. We just warn it the first time
4401                          and ignore it afterwards.  */
4402                       static int warned = 0;
4403                       if (!warned)
4404                         {
4405                           error (_("section 0 in group section [%5u]\n"),
4406                                  section_headers_groups [SECTION_HEADER_INDEX (entry)]->group_index);
4407                           warned++;
4408                         }
4409                     }
4410                 }
4411
4412               section_headers_groups [SECTION_HEADER_INDEX (entry)]
4413                 = group;
4414
4415               if (do_section_groups)
4416                 {
4417                   sec = SECTION_HEADER (entry);
4418                   printf ("   [%5u]   %s\n", entry, SECTION_NAME (sec));
4419                 }
4420
4421               g = xmalloc (sizeof (struct group_list));
4422               g->section_index = entry;
4423               g->next = group->root;
4424               group->root = g;
4425             }
4426
4427           if (start)
4428             free (start);
4429
4430           group++;
4431         }
4432     }
4433
4434   if (symtab)
4435     free (symtab);
4436   if (strtab)
4437     free (strtab);
4438   return 1;
4439 }
4440
4441 static struct
4442 {
4443   const char *name;
4444   int reloc;
4445   int size;
4446   int rela;
4447 } dynamic_relocations [] =
4448 {
4449     { "REL", DT_REL, DT_RELSZ, FALSE },
4450     { "RELA", DT_RELA, DT_RELASZ, TRUE },
4451     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
4452 };
4453
4454 /* Process the reloc section.  */
4455
4456 static int
4457 process_relocs (FILE *file)
4458 {
4459   unsigned long rel_size;
4460   unsigned long rel_offset;
4461
4462
4463   if (!do_reloc)
4464     return 1;
4465
4466   if (do_using_dynamic)
4467     {
4468       int is_rela;
4469       const char *name;
4470       int has_dynamic_reloc;
4471       unsigned int i;
4472
4473       has_dynamic_reloc = 0;
4474
4475       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
4476         {
4477           is_rela = dynamic_relocations [i].rela;
4478           name = dynamic_relocations [i].name;
4479           rel_size = dynamic_info [dynamic_relocations [i].size];
4480           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
4481
4482           has_dynamic_reloc |= rel_size;
4483
4484           if (is_rela == UNKNOWN)
4485             {
4486               if (dynamic_relocations [i].reloc == DT_JMPREL)
4487                 switch (dynamic_info[DT_PLTREL])
4488                   {
4489                   case DT_REL:
4490                     is_rela = FALSE;
4491                     break;
4492                   case DT_RELA:
4493                     is_rela = TRUE;
4494                     break;
4495                   }
4496             }
4497
4498           if (rel_size)
4499             {
4500               printf
4501                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4502                  name, rel_offset, rel_size);
4503
4504               dump_relocations (file,
4505                                 offset_from_vma (file, rel_offset, rel_size),
4506                                 rel_size,
4507                                 dynamic_symbols, num_dynamic_syms,
4508                                 dynamic_strings, dynamic_strings_length, is_rela);
4509             }
4510         }
4511
4512       if (! has_dynamic_reloc)
4513         printf (_("\nThere are no dynamic relocations in this file.\n"));
4514     }
4515   else
4516     {
4517       Elf_Internal_Shdr *section;
4518       unsigned long i;
4519       int found = 0;
4520
4521       for (i = 0, section = section_headers;
4522            i < elf_header.e_shnum;
4523            i++, section++)
4524         {
4525           if (   section->sh_type != SHT_RELA
4526               && section->sh_type != SHT_REL)
4527             continue;
4528
4529           rel_offset = section->sh_offset;
4530           rel_size   = section->sh_size;
4531
4532           if (rel_size)
4533             {
4534               Elf_Internal_Shdr *strsec;
4535               int is_rela;
4536
4537               printf (_("\nRelocation section "));
4538
4539               if (string_table == NULL)
4540                 printf ("%d", section->sh_name);
4541               else
4542                 printf (_("'%s'"), SECTION_NAME (section));
4543
4544               printf (_(" at offset 0x%lx contains %lu entries:\n"),
4545                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
4546
4547               is_rela = section->sh_type == SHT_RELA;
4548
4549               if (section->sh_link
4550                   && SECTION_HEADER_INDEX (section->sh_link)
4551                      < elf_header.e_shnum)
4552                 {
4553                   Elf_Internal_Shdr *symsec;
4554                   Elf_Internal_Sym *symtab;
4555                   unsigned long nsyms;
4556                   unsigned long strtablen = 0;
4557                   char *strtab = NULL;
4558
4559                   symsec = SECTION_HEADER (section->sh_link);
4560                   if (symsec->sh_type != SHT_SYMTAB
4561                       && symsec->sh_type != SHT_DYNSYM)
4562                     continue;
4563
4564                   nsyms = symsec->sh_size / symsec->sh_entsize;
4565                   symtab = GET_ELF_SYMBOLS (file, symsec);
4566
4567                   if (symtab == NULL)
4568                     continue;
4569
4570                   if (SECTION_HEADER_INDEX (symsec->sh_link)
4571                       < elf_header.e_shnum)
4572                     {
4573                       strsec = SECTION_HEADER (symsec->sh_link);
4574
4575                       strtab = get_data (NULL, file, strsec->sh_offset,
4576                                          1, strsec->sh_size,
4577                                          _("string table"));
4578                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
4579                     }
4580
4581                   dump_relocations (file, rel_offset, rel_size,
4582                                     symtab, nsyms, strtab, strtablen, is_rela);
4583                   if (strtab)
4584                     free (strtab);
4585                   free (symtab);
4586                 }
4587               else
4588                 dump_relocations (file, rel_offset, rel_size,
4589                                   NULL, 0, NULL, 0, is_rela);
4590
4591               found = 1;
4592             }
4593         }
4594
4595       if (! found)
4596         printf (_("\nThere are no relocations in this file.\n"));
4597     }
4598
4599   return 1;
4600 }
4601
4602 /* Process the unwind section.  */
4603
4604 #include "unwind-ia64.h"
4605
4606 /* An absolute address consists of a section and an offset.  If the
4607    section is NULL, the offset itself is the address, otherwise, the
4608    address equals to LOAD_ADDRESS(section) + offset.  */
4609
4610 struct absaddr
4611   {
4612     unsigned short section;
4613     bfd_vma offset;
4614   };
4615
4616 #define ABSADDR(a) \
4617   ((a).section \
4618    ? section_headers [(a).section].sh_addr + (a).offset \
4619    : (a).offset)
4620
4621 struct ia64_unw_aux_info
4622   {
4623     struct ia64_unw_table_entry
4624       {
4625         struct absaddr start;
4626         struct absaddr end;
4627         struct absaddr info;
4628       }
4629     *table;                     /* Unwind table.  */
4630     unsigned long table_len;    /* Length of unwind table.  */
4631     unsigned char *info;        /* Unwind info.  */
4632     unsigned long info_size;    /* Size of unwind info.  */
4633     bfd_vma info_addr;          /* starting address of unwind info.  */
4634     bfd_vma seg_base;           /* Starting address of segment.  */
4635     Elf_Internal_Sym *symtab;   /* The symbol table.  */
4636     unsigned long nsyms;        /* Number of symbols.  */
4637     char *strtab;               /* The string table.  */
4638     unsigned long strtab_size;  /* Size of string table.  */
4639   };
4640
4641 static void
4642 find_symbol_for_address (Elf_Internal_Sym *symtab,
4643                          unsigned long nsyms,
4644                          const char *strtab,
4645                          unsigned long strtab_size,
4646                          struct absaddr addr,
4647                          const char **symname,
4648                          bfd_vma *offset)
4649 {
4650   bfd_vma dist = 0x100000;
4651   Elf_Internal_Sym *sym, *best = NULL;
4652   unsigned long i;
4653
4654   for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4655     {
4656       if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
4657           && sym->st_name != 0
4658           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
4659           && addr.offset >= sym->st_value
4660           && addr.offset - sym->st_value < dist)
4661         {
4662           best = sym;
4663           dist = addr.offset - sym->st_value;
4664           if (!dist)
4665             break;
4666         }
4667     }
4668   if (best)
4669     {
4670       *symname = (best->st_name >= strtab_size
4671                   ? "<corrupt>" : strtab + best->st_name);
4672       *offset = dist;
4673       return;
4674     }
4675   *symname = NULL;
4676   *offset = addr.offset;
4677 }
4678
4679 static void
4680 dump_ia64_unwind (struct ia64_unw_aux_info *aux)
4681 {
4682   struct ia64_unw_table_entry *tp;
4683   int in_body;
4684
4685   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
4686     {
4687       bfd_vma stamp;
4688       bfd_vma offset;
4689       const unsigned char *dp;
4690       const unsigned char *head;
4691       const char *procname;
4692
4693       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
4694                                aux->strtab_size, tp->start, &procname, &offset);
4695
4696       fputs ("\n<", stdout);
4697
4698       if (procname)
4699         {
4700           fputs (procname, stdout);
4701
4702           if (offset)
4703             printf ("+%lx", (unsigned long) offset);
4704         }
4705
4706       fputs (">: [", stdout);
4707       print_vma (tp->start.offset, PREFIX_HEX);
4708       fputc ('-', stdout);
4709       print_vma (tp->end.offset, PREFIX_HEX);
4710       printf ("], info at +0x%lx\n",
4711               (unsigned long) (tp->info.offset - aux->seg_base));
4712
4713       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
4714       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4715
4716       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4717               (unsigned) UNW_VER (stamp),
4718               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
4719               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
4720               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
4721               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4722
4723       if (UNW_VER (stamp) != 1)
4724         {
4725           printf ("\tUnknown version.\n");
4726           continue;
4727         }
4728
4729       in_body = 0;
4730       for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4731         dp = unw_decode (dp, in_body, & in_body);
4732     }
4733 }
4734
4735 static int
4736 slurp_ia64_unwind_table (FILE *file,
4737                          struct ia64_unw_aux_info *aux,
4738                          Elf_Internal_Shdr *sec)
4739 {
4740   unsigned long size, nrelas, i;
4741   Elf_Internal_Phdr *seg;
4742   struct ia64_unw_table_entry *tep;
4743   Elf_Internal_Shdr *relsec;
4744   Elf_Internal_Rela *rela, *rp;
4745   unsigned char *table, *tp;
4746   Elf_Internal_Sym *sym;
4747   const char *relname;
4748
4749   /* First, find the starting address of the segment that includes
4750      this section: */
4751
4752   if (elf_header.e_phnum)
4753     {
4754       if (! get_program_headers (file))
4755           return 0;
4756
4757       for (seg = program_headers;
4758            seg < program_headers + elf_header.e_phnum;
4759            ++seg)
4760         {
4761           if (seg->p_type != PT_LOAD)
4762             continue;
4763
4764           if (sec->sh_addr >= seg->p_vaddr
4765               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
4766             {
4767               aux->seg_base = seg->p_vaddr;
4768               break;
4769             }
4770         }
4771     }
4772
4773   /* Second, build the unwind table from the contents of the unwind section:  */
4774   size = sec->sh_size;
4775   table = get_data (NULL, file, sec->sh_offset, 1, size, _("unwind table"));
4776   if (!table)
4777     return 0;
4778
4779   aux->table = xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
4780   tep = aux->table;
4781   for (tp = table; tp < table + size; tp += 3 * eh_addr_size, ++tep)
4782     {
4783       tep->start.section = SHN_UNDEF;
4784       tep->end.section   = SHN_UNDEF;
4785       tep->info.section  = SHN_UNDEF;
4786       if (is_32bit_elf)
4787         {
4788           tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
4789           tep->end.offset   = byte_get ((unsigned char *) tp + 4, 4);
4790           tep->info.offset  = byte_get ((unsigned char *) tp + 8, 4);
4791         }
4792       else
4793         {
4794           tep->start.offset = BYTE_GET ((unsigned char *) tp +  0);
4795           tep->end.offset   = BYTE_GET ((unsigned char *) tp +  8);
4796           tep->info.offset  = BYTE_GET ((unsigned char *) tp + 16);
4797         }
4798       tep->start.offset += aux->seg_base;
4799       tep->end.offset   += aux->seg_base;
4800       tep->info.offset  += aux->seg_base;
4801     }
4802   free (table);
4803
4804   /* Third, apply any relocations to the unwind table: */
4805
4806   for (relsec = section_headers;
4807        relsec < section_headers + elf_header.e_shnum;
4808        ++relsec)
4809     {
4810       if (relsec->sh_type != SHT_RELA
4811           || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum
4812           || SECTION_HEADER (relsec->sh_info) != sec)
4813         continue;
4814
4815       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
4816                               & rela, & nrelas))
4817         return 0;
4818
4819       for (rp = rela; rp < rela + nrelas; ++rp)
4820         {
4821           if (is_32bit_elf)
4822             {
4823               relname = elf_ia64_reloc_type (ELF32_R_TYPE (rp->r_info));
4824               sym = aux->symtab + ELF32_R_SYM (rp->r_info);
4825             }
4826           else
4827             {
4828               relname = elf_ia64_reloc_type (ELF64_R_TYPE (rp->r_info));
4829               sym = aux->symtab + ELF64_R_SYM (rp->r_info);
4830             }
4831
4832           if (! strneq (relname, "R_IA64_SEGREL", 13))
4833             {
4834               warn (_("Skipping unexpected relocation type %s\n"), relname);
4835               continue;
4836             }
4837
4838           i = rp->r_offset / (3 * eh_addr_size);
4839
4840           switch (rp->r_offset/eh_addr_size % 3)
4841             {
4842             case 0:
4843               aux->table[i].start.section = sym->st_shndx;
4844               aux->table[i].start.offset += rp->r_addend + sym->st_value;
4845               break;
4846             case 1:
4847               aux->table[i].end.section   = sym->st_shndx;
4848               aux->table[i].end.offset   += rp->r_addend + sym->st_value;
4849               break;
4850             case 2:
4851               aux->table[i].info.section  = sym->st_shndx;
4852               aux->table[i].info.offset  += rp->r_addend + sym->st_value;
4853               break;
4854             default:
4855               break;
4856             }
4857         }
4858
4859       free (rela);
4860     }
4861
4862   aux->table_len = size / (3 * eh_addr_size);
4863   return 1;
4864 }
4865
4866 static int
4867 ia64_process_unwind (FILE *file)
4868 {
4869   Elf_Internal_Shdr *sec, *unwsec = NULL, *strsec;
4870   unsigned long i, unwcount = 0, unwstart = 0;
4871   struct ia64_unw_aux_info aux;
4872
4873   memset (& aux, 0, sizeof (aux));
4874
4875   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
4876     {
4877       if (sec->sh_type == SHT_SYMTAB
4878           && SECTION_HEADER_INDEX (sec->sh_link) < elf_header.e_shnum)
4879         {
4880           aux.nsyms = sec->sh_size / sec->sh_entsize;
4881           aux.symtab = GET_ELF_SYMBOLS (file, sec);
4882
4883           strsec = SECTION_HEADER (sec->sh_link);
4884           aux.strtab = get_data (NULL, file, strsec->sh_offset,
4885                                  1, strsec->sh_size, _("string table"));
4886           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
4887         }
4888       else if (sec->sh_type == SHT_IA_64_UNWIND)
4889         unwcount++;
4890     }
4891
4892   if (!unwcount)
4893     printf (_("\nThere are no unwind sections in this file.\n"));
4894
4895   while (unwcount-- > 0)
4896     {
4897       char *suffix;
4898       size_t len, len2;
4899
4900       for (i = unwstart, sec = section_headers + unwstart;
4901            i < elf_header.e_shnum; ++i, ++sec)
4902         if (sec->sh_type == SHT_IA_64_UNWIND)
4903           {
4904             unwsec = sec;
4905             break;
4906           }
4907
4908       unwstart = i + 1;
4909       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
4910
4911       if ((unwsec->sh_flags & SHF_GROUP) != 0)
4912         {
4913           /* We need to find which section group it is in.  */
4914           struct group_list *g = section_headers_groups [i]->root;
4915
4916           for (; g != NULL; g = g->next)
4917             {
4918               sec = SECTION_HEADER (g->section_index);
4919
4920               if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
4921                 break;
4922             }
4923
4924           if (g == NULL)
4925             i = elf_header.e_shnum;
4926         }
4927       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
4928         {
4929           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
4930           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
4931           suffix = SECTION_NAME (unwsec) + len;
4932           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
4933                ++i, ++sec)
4934             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
4935                 && streq (SECTION_NAME (sec) + len2, suffix))
4936               break;
4937         }
4938       else
4939         {
4940           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4941              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
4942           len = sizeof (ELF_STRING_ia64_unwind) - 1;
4943           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
4944           suffix = "";
4945           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
4946             suffix = SECTION_NAME (unwsec) + len;
4947           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
4948                ++i, ++sec)
4949             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
4950                 && streq (SECTION_NAME (sec) + len2, suffix))
4951               break;
4952         }
4953
4954       if (i == elf_header.e_shnum)
4955         {
4956           printf (_("\nCould not find unwind info section for "));
4957
4958           if (string_table == NULL)
4959             printf ("%d", unwsec->sh_name);
4960           else
4961             printf (_("'%s'"), SECTION_NAME (unwsec));
4962         }
4963       else
4964         {
4965           aux.info_size = sec->sh_size;
4966           aux.info_addr = sec->sh_addr;
4967           aux.info = get_data (NULL, file, sec->sh_offset, 1, aux.info_size,
4968                                _("unwind info"));
4969
4970           printf (_("\nUnwind section "));
4971
4972           if (string_table == NULL)
4973             printf ("%d", unwsec->sh_name);
4974           else
4975             printf (_("'%s'"), SECTION_NAME (unwsec));
4976
4977           printf (_(" at offset 0x%lx contains %lu entries:\n"),
4978                   (unsigned long) unwsec->sh_offset,
4979                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
4980
4981           (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4982
4983           if (aux.table_len > 0)
4984             dump_ia64_unwind (& aux);
4985
4986           if (aux.table)
4987             free ((char *) aux.table);
4988           if (aux.info)
4989             free ((char *) aux.info);
4990           aux.table = NULL;
4991           aux.info = NULL;
4992         }
4993     }
4994
4995   if (aux.symtab)
4996     free (aux.symtab);
4997   if (aux.strtab)
4998     free ((char *) aux.strtab);
4999
5000   return 1;
5001 }
5002
5003 struct hppa_unw_aux_info
5004   {
5005     struct hppa_unw_table_entry
5006       {
5007         struct absaddr start;
5008         struct absaddr end;
5009         unsigned int Cannot_unwind:1;                   /* 0 */
5010         unsigned int Millicode:1;                       /* 1 */
5011         unsigned int Millicode_save_sr0:1;              /* 2 */
5012         unsigned int Region_description:2;              /* 3..4 */
5013         unsigned int reserved1:1;                       /* 5 */
5014         unsigned int Entry_SR:1;                        /* 6 */
5015         unsigned int Entry_FR:4;     /* number saved */ /* 7..10 */
5016         unsigned int Entry_GR:5;     /* number saved */ /* 11..15 */
5017         unsigned int Args_stored:1;                     /* 16 */
5018         unsigned int Variable_Frame:1;                  /* 17 */
5019         unsigned int Separate_Package_Body:1;           /* 18 */
5020         unsigned int Frame_Extension_Millicode:1;       /* 19 */
5021         unsigned int Stack_Overflow_Check:1;            /* 20 */
5022         unsigned int Two_Instruction_SP_Increment:1;    /* 21 */
5023         unsigned int Ada_Region:1;                      /* 22 */
5024         unsigned int cxx_info:1;                        /* 23 */
5025         unsigned int cxx_try_catch:1;                   /* 24 */
5026         unsigned int sched_entry_seq:1;                 /* 25 */
5027         unsigned int reserved2:1;                       /* 26 */
5028         unsigned int Save_SP:1;                         /* 27 */
5029         unsigned int Save_RP:1;                         /* 28 */
5030         unsigned int Save_MRP_in_frame:1;               /* 29 */
5031         unsigned int extn_ptr_defined:1;                /* 30 */
5032         unsigned int Cleanup_defined:1;                 /* 31 */
5033
5034         unsigned int MPE_XL_interrupt_marker:1;         /* 0 */
5035         unsigned int HP_UX_interrupt_marker:1;          /* 1 */
5036         unsigned int Large_frame:1;                     /* 2 */
5037         unsigned int Pseudo_SP_Set:1;                   /* 3 */
5038         unsigned int reserved4:1;                       /* 4 */
5039         unsigned int Total_frame_size:27;               /* 5..31 */
5040       }
5041     *table;                     /* Unwind table.  */
5042     unsigned long table_len;    /* Length of unwind table.  */
5043     bfd_vma seg_base;           /* Starting address of segment.  */
5044     Elf_Internal_Sym *symtab;   /* The symbol table.  */
5045     unsigned long nsyms;        /* Number of symbols.  */
5046     char *strtab;               /* The string table.  */
5047     unsigned long strtab_size;  /* Size of string table.  */
5048   };
5049
5050 static void
5051 dump_hppa_unwind (struct hppa_unw_aux_info *aux)
5052 {
5053   struct hppa_unw_table_entry *tp;
5054
5055   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5056     {
5057       bfd_vma offset;
5058       const char *procname;
5059
5060       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5061                                aux->strtab_size, tp->start, &procname,
5062                                &offset);
5063
5064       fputs ("\n<", stdout);
5065
5066       if (procname)
5067         {
5068           fputs (procname, stdout);
5069
5070           if (offset)
5071             printf ("+%lx", (unsigned long) offset);
5072         }
5073
5074       fputs (">: [", stdout);
5075       print_vma (tp->start.offset, PREFIX_HEX);
5076       fputc ('-', stdout);
5077       print_vma (tp->end.offset, PREFIX_HEX);
5078       printf ("]\n\t");
5079
5080 #define PF(_m) if (tp->_m) printf (#_m " ");
5081 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5082       PF(Cannot_unwind);
5083       PF(Millicode);
5084       PF(Millicode_save_sr0);
5085       /* PV(Region_description);  */
5086       PF(Entry_SR);
5087       PV(Entry_FR);
5088       PV(Entry_GR);
5089       PF(Args_stored);
5090       PF(Variable_Frame);
5091       PF(Separate_Package_Body);
5092       PF(Frame_Extension_Millicode);
5093       PF(Stack_Overflow_Check);
5094       PF(Two_Instruction_SP_Increment);
5095       PF(Ada_Region);
5096       PF(cxx_info);
5097       PF(cxx_try_catch);
5098       PF(sched_entry_seq);
5099       PF(Save_SP);
5100       PF(Save_RP);
5101       PF(Save_MRP_in_frame);
5102       PF(extn_ptr_defined);
5103       PF(Cleanup_defined);
5104       PF(MPE_XL_interrupt_marker);
5105       PF(HP_UX_interrupt_marker);
5106       PF(Large_frame);
5107       PF(Pseudo_SP_Set);
5108       PV(Total_frame_size);
5109 #undef PF
5110 #undef PV
5111     }
5112
5113   printf ("\n");
5114 }
5115
5116 static int
5117 slurp_hppa_unwind_table (FILE *file,
5118                          struct hppa_unw_aux_info *aux,
5119                          Elf_Internal_Shdr *sec)
5120 {
5121   unsigned long size, unw_ent_size, nentries, nrelas, i;
5122   Elf_Internal_Phdr *seg;
5123   struct hppa_unw_table_entry *tep;
5124   Elf_Internal_Shdr *relsec;
5125   Elf_Internal_Rela *rela, *rp;
5126   unsigned char *table, *tp;
5127   Elf_Internal_Sym *sym;
5128   const char *relname;
5129
5130   /* First, find the starting address of the segment that includes
5131      this section.  */
5132
5133   if (elf_header.e_phnum)
5134     {
5135       if (! get_program_headers (file))
5136         return 0;
5137
5138       for (seg = program_headers;
5139            seg < program_headers + elf_header.e_phnum;
5140            ++seg)
5141         {
5142           if (seg->p_type != PT_LOAD)
5143             continue;
5144
5145           if (sec->sh_addr >= seg->p_vaddr
5146               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5147             {
5148               aux->seg_base = seg->p_vaddr;
5149               break;
5150             }
5151         }
5152     }
5153
5154   /* Second, build the unwind table from the contents of the unwind
5155      section.  */
5156   size = sec->sh_size;
5157   table = get_data (NULL, file, sec->sh_offset, 1, size, _("unwind table"));
5158   if (!table)
5159     return 0;
5160
5161   unw_ent_size = 16;
5162   nentries = size / unw_ent_size;
5163   size = unw_ent_size * nentries;
5164
5165   tep = aux->table = xcmalloc (nentries, sizeof (aux->table[0]));
5166
5167   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
5168     {
5169       unsigned int tmp1, tmp2;
5170
5171       tep->start.section = SHN_UNDEF;
5172       tep->end.section   = SHN_UNDEF;
5173
5174       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
5175       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
5176       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
5177       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
5178
5179       tep->start.offset += aux->seg_base;
5180       tep->end.offset   += aux->seg_base;
5181
5182       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
5183       tep->Millicode = (tmp1 >> 30) & 0x1;
5184       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
5185       tep->Region_description = (tmp1 >> 27) & 0x3;
5186       tep->reserved1 = (tmp1 >> 26) & 0x1;
5187       tep->Entry_SR = (tmp1 >> 25) & 0x1;
5188       tep->Entry_FR = (tmp1 >> 21) & 0xf;
5189       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
5190       tep->Args_stored = (tmp1 >> 15) & 0x1;
5191       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
5192       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
5193       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
5194       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
5195       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
5196       tep->Ada_Region = (tmp1 >> 9) & 0x1;
5197       tep->cxx_info = (tmp1 >> 8) & 0x1;
5198       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
5199       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
5200       tep->reserved2 = (tmp1 >> 5) & 0x1;
5201       tep->Save_SP = (tmp1 >> 4) & 0x1;
5202       tep->Save_RP = (tmp1 >> 3) & 0x1;
5203       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
5204       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
5205       tep->Cleanup_defined = tmp1 & 0x1;
5206
5207       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
5208       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
5209       tep->Large_frame = (tmp2 >> 29) & 0x1;
5210       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
5211       tep->reserved4 = (tmp2 >> 27) & 0x1;
5212       tep->Total_frame_size = tmp2 & 0x7ffffff;
5213     }
5214   free (table);
5215
5216   /* Third, apply any relocations to the unwind table.  */
5217
5218   for (relsec = section_headers;
5219        relsec < section_headers + elf_header.e_shnum;
5220        ++relsec)
5221     {
5222       if (relsec->sh_type != SHT_RELA
5223           || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum
5224           || SECTION_HEADER (relsec->sh_info) != sec)
5225         continue;
5226
5227       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5228                               & rela, & nrelas))
5229         return 0;
5230
5231       for (rp = rela; rp < rela + nrelas; ++rp)
5232         {
5233           if (is_32bit_elf)
5234             {
5235               relname = elf_hppa_reloc_type (ELF32_R_TYPE (rp->r_info));
5236               sym = aux->symtab + ELF32_R_SYM (rp->r_info);
5237             }
5238           else
5239             {
5240               relname = elf_hppa_reloc_type (ELF64_R_TYPE (rp->r_info));
5241               sym = aux->symtab + ELF64_R_SYM (rp->r_info);
5242             }
5243
5244           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
5245           if (strncmp (relname, "R_PARISC_SEGREL", 15) != 0)
5246             {
5247               warn (_("Skipping unexpected relocation type %s\n"), relname);
5248               continue;
5249             }
5250
5251           i = rp->r_offset / unw_ent_size;
5252
5253           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
5254             {
5255             case 0:
5256               aux->table[i].start.section = sym->st_shndx;
5257               aux->table[i].start.offset += sym->st_value + rp->r_addend;
5258               break;
5259             case 1:
5260               aux->table[i].end.section   = sym->st_shndx;
5261               aux->table[i].end.offset   += sym->st_value + rp->r_addend;
5262               break;
5263             default:
5264               break;
5265             }
5266         }
5267
5268       free (rela);
5269     }
5270
5271   aux->table_len = nentries;
5272
5273   return 1;
5274 }
5275
5276 static int
5277 hppa_process_unwind (FILE *file)
5278 {
5279   struct hppa_unw_aux_info aux;
5280   Elf_Internal_Shdr *unwsec = NULL;
5281   Elf_Internal_Shdr *strsec;
5282   Elf_Internal_Shdr *sec;
5283   unsigned long i;
5284
5285   memset (& aux, 0, sizeof (aux));
5286
5287   if (string_table == NULL)
5288     return 1;
5289
5290   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5291     {
5292       if (sec->sh_type == SHT_SYMTAB
5293           && SECTION_HEADER_INDEX (sec->sh_link) < elf_header.e_shnum)
5294         {
5295           aux.nsyms = sec->sh_size / sec->sh_entsize;
5296           aux.symtab = GET_ELF_SYMBOLS (file, sec);
5297
5298           strsec = SECTION_HEADER (sec->sh_link);
5299           aux.strtab = get_data (NULL, file, strsec->sh_offset,
5300                                  1, strsec->sh_size, _("string table"));
5301           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5302         }
5303       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5304         unwsec = sec;
5305     }
5306
5307   if (!unwsec)
5308     printf (_("\nThere are no unwind sections in this file.\n"));
5309
5310   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5311     {
5312       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5313         {
5314           printf (_("\nUnwind section "));
5315           printf (_("'%s'"), SECTION_NAME (sec));
5316
5317           printf (_(" at offset 0x%lx contains %lu entries:\n"),
5318                   (unsigned long) sec->sh_offset,
5319                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
5320
5321           slurp_hppa_unwind_table (file, &aux, sec);
5322           if (aux.table_len > 0)
5323             dump_hppa_unwind (&aux);
5324
5325           if (aux.table)
5326             free ((char *) aux.table);
5327           aux.table = NULL;
5328         }
5329     }
5330
5331   if (aux.symtab)
5332     free (aux.symtab);
5333   if (aux.strtab)
5334     free ((char *) aux.strtab);
5335
5336   return 1;
5337 }
5338
5339 static int
5340 process_unwind (FILE *file)
5341 {
5342   struct unwind_handler {
5343     int machtype;
5344     int (*handler)(FILE *file);
5345   } handlers[] = {
5346     { EM_IA_64, ia64_process_unwind },
5347     { EM_PARISC, hppa_process_unwind },
5348     { 0, 0 }
5349   };
5350   int i;
5351
5352   if (!do_unwind)
5353     return 1;
5354
5355   for (i = 0; handlers[i].handler != NULL; i++)
5356     if (elf_header.e_machine == handlers[i].machtype)
5357       return handlers[i].handler (file);
5358
5359   printf (_("\nThere are no unwind sections in this file.\n"));
5360   return 1;
5361 }
5362
5363 static void
5364 dynamic_section_mips_val (Elf_Internal_Dyn *entry)
5365 {
5366   switch (entry->d_tag)
5367     {
5368     case DT_MIPS_FLAGS:
5369       if (entry->d_un.d_val == 0)
5370         printf ("NONE\n");
5371       else
5372         {
5373           static const char * opts[] =
5374           {
5375             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5376             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5377             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5378             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5379             "RLD_ORDER_SAFE"
5380           };
5381           unsigned int cnt;
5382           int first = 1;
5383           for (cnt = 0; cnt < NUM_ELEM (opts); ++cnt)
5384             if (entry->d_un.d_val & (1 << cnt))
5385               {
5386                 printf ("%s%s", first ? "" : " ", opts[cnt]);
5387                 first = 0;
5388               }
5389           puts ("");
5390         }
5391       break;
5392
5393     case DT_MIPS_IVERSION:
5394       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
5395         printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
5396       else
5397         printf ("<corrupt: %ld>\n", (long) entry->d_un.d_ptr);
5398       break;
5399
5400     case DT_MIPS_TIME_STAMP:
5401       {
5402         char timebuf[20];
5403         struct tm *tmp;
5404
5405         time_t time = entry->d_un.d_val;
5406         tmp = gmtime (&time);
5407         snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
5408                   tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
5409                   tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
5410         printf ("Time Stamp: %s\n", timebuf);
5411       }
5412       break;
5413
5414     case DT_MIPS_RLD_VERSION:
5415     case DT_MIPS_LOCAL_GOTNO:
5416     case DT_MIPS_CONFLICTNO:
5417     case DT_MIPS_LIBLISTNO:
5418     case DT_MIPS_SYMTABNO:
5419     case DT_MIPS_UNREFEXTNO:
5420     case DT_MIPS_HIPAGENO:
5421     case DT_MIPS_DELTA_CLASS_NO:
5422     case DT_MIPS_DELTA_INSTANCE_NO:
5423     case DT_MIPS_DELTA_RELOC_NO:
5424     case DT_MIPS_DELTA_SYM_NO:
5425     case DT_MIPS_DELTA_CLASSSYM_NO:
5426     case DT_MIPS_COMPACT_SIZE:
5427       printf ("%ld\n", (long) entry->d_un.d_ptr);
5428       break;
5429
5430     default:
5431       printf ("%#lx\n", (long) entry->d_un.d_ptr);
5432     }
5433 }
5434
5435
5436 static void
5437 dynamic_section_parisc_val (Elf_Internal_Dyn *entry)
5438 {
5439   switch (entry->d_tag)
5440     {
5441     case DT_HP_DLD_FLAGS:
5442       {
5443         static struct
5444         {
5445           long int bit;
5446           const char *str;
5447         }
5448         flags[] =
5449         {
5450           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
5451           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
5452           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
5453           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
5454           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
5455           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
5456           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
5457           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
5458           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
5459           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
5460           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
5461           { DT_HP_GST, "HP_GST" },
5462           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
5463           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
5464           { DT_HP_NODELETE, "HP_NODELETE" },
5465           { DT_HP_GROUP, "HP_GROUP" },
5466           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5467         };
5468         int first = 1;
5469         size_t cnt;
5470         bfd_vma val = entry->d_un.d_val;
5471
5472         for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
5473           if (val & flags[cnt].bit)
5474             {
5475               if (! first)
5476                 putchar (' ');
5477               fputs (flags[cnt].str, stdout);
5478               first = 0;
5479               val ^= flags[cnt].bit;
5480             }
5481
5482         if (val != 0 || first)
5483           {
5484             if (! first)
5485               putchar (' ');
5486             print_vma (val, HEX);
5487           }
5488       }
5489       break;
5490
5491     default:
5492       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5493       break;
5494     }
5495   putchar ('\n');
5496 }
5497
5498 static void
5499 dynamic_section_ia64_val (Elf_Internal_Dyn *entry)
5500 {
5501   switch (entry->d_tag)
5502     {
5503     case DT_IA_64_PLT_RESERVE:
5504       /* First 3 slots reserved.  */
5505       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5506       printf (" -- ");
5507       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
5508       break;
5509
5510     default:
5511       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5512       break;
5513     }
5514   putchar ('\n');
5515 }
5516
5517 static int
5518 get_32bit_dynamic_section (FILE *file)
5519 {
5520   Elf32_External_Dyn *edyn, *ext;
5521   Elf_Internal_Dyn *entry;
5522
5523   edyn = get_data (NULL, file, dynamic_addr, 1, dynamic_size,
5524                    _("dynamic section"));
5525   if (!edyn)
5526     return 0;
5527
5528 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5529    might not have the luxury of section headers.  Look for the DT_NULL
5530    terminator to determine the number of entries.  */
5531   for (ext = edyn, dynamic_nent = 0;
5532        (char *) ext < (char *) edyn + dynamic_size;
5533        ext++)
5534     {
5535       dynamic_nent++;
5536       if (BYTE_GET (ext->d_tag) == DT_NULL)
5537         break;
5538     }
5539
5540   dynamic_section = cmalloc (dynamic_nent, sizeof (*entry));
5541   if (dynamic_section == NULL)
5542     {
5543       error (_("Out of memory\n"));
5544       free (edyn);
5545       return 0;
5546     }
5547
5548   for (ext = edyn, entry = dynamic_section;
5549        entry < dynamic_section + dynamic_nent;
5550        ext++, entry++)
5551     {
5552       entry->d_tag      = BYTE_GET (ext->d_tag);
5553       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
5554     }
5555
5556   free (edyn);
5557
5558   return 1;
5559 }
5560
5561 static int
5562 get_64bit_dynamic_section (FILE *file)
5563 {
5564   Elf64_External_Dyn *edyn, *ext;
5565   Elf_Internal_Dyn *entry;
5566
5567   edyn = get_data (NULL, file, dynamic_addr, 1, dynamic_size,
5568                    _("dynamic section"));
5569   if (!edyn)
5570     return 0;
5571
5572 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5573    might not have the luxury of section headers.  Look for the DT_NULL
5574    terminator to determine the number of entries.  */
5575   for (ext = edyn, dynamic_nent = 0;
5576        (char *) ext < (char *) edyn + dynamic_size;
5577        ext++)
5578     {
5579       dynamic_nent++;
5580       if (BYTE_GET (ext->d_tag) == DT_NULL)
5581         break;
5582     }
5583
5584   dynamic_section = cmalloc (dynamic_nent, sizeof (*entry));
5585   if (dynamic_section == NULL)
5586     {
5587       error (_("Out of memory\n"));
5588       free (edyn);
5589       return 0;
5590     }
5591
5592   for (ext = edyn, entry = dynamic_section;
5593        entry < dynamic_section + dynamic_nent;
5594        ext++, entry++)
5595     {
5596       entry->d_tag      = BYTE_GET (ext->d_tag);
5597       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
5598     }
5599
5600   free (edyn);
5601
5602   return 1;
5603 }
5604
5605 static void
5606 print_dynamic_flags (bfd_vma flags)
5607 {
5608   int first = 1;
5609
5610   while (flags)
5611     {
5612       bfd_vma flag;
5613
5614       flag = flags & - flags;
5615       flags &= ~ flag;
5616
5617       if (first)
5618         first = 0;
5619       else
5620         putc (' ', stdout);
5621
5622       switch (flag)
5623         {
5624         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
5625         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
5626         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
5627         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
5628         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
5629         default:                fputs ("unknown", stdout); break;
5630         }
5631     }
5632   puts ("");
5633 }
5634
5635 /* Parse and display the contents of the dynamic section.  */
5636
5637 static int
5638 process_dynamic_section (FILE *file)
5639 {
5640   Elf_Internal_Dyn *entry;
5641
5642   if (dynamic_size == 0)
5643     {
5644       if (do_dynamic)
5645         printf (_("\nThere is no dynamic section in this file.\n"));
5646
5647       return 1;
5648     }
5649
5650   if (is_32bit_elf)
5651     {
5652       if (! get_32bit_dynamic_section (file))
5653         return 0;
5654     }
5655   else if (! get_64bit_dynamic_section (file))
5656     return 0;
5657
5658   /* Find the appropriate symbol table.  */
5659   if (dynamic_symbols == NULL)
5660     {
5661       for (entry = dynamic_section;
5662            entry < dynamic_section + dynamic_nent;
5663            ++entry)
5664         {
5665           Elf_Internal_Shdr section;
5666
5667           if (entry->d_tag != DT_SYMTAB)
5668             continue;
5669
5670           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
5671
5672           /* Since we do not know how big the symbol table is,
5673              we default to reading in the entire file (!) and
5674              processing that.  This is overkill, I know, but it
5675              should work.  */
5676           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
5677
5678           if (archive_file_offset != 0)
5679             section.sh_size = archive_file_size - section.sh_offset;
5680           else
5681             {
5682               if (fseek (file, 0, SEEK_END))
5683                 error (_("Unable to seek to end of file!"));
5684
5685               section.sh_size = ftell (file) - section.sh_offset;
5686             }
5687
5688           if (is_32bit_elf)
5689             section.sh_entsize = sizeof (Elf32_External_Sym);
5690           else
5691             section.sh_entsize = sizeof (Elf64_External_Sym);
5692
5693           num_dynamic_syms = section.sh_size / section.sh_entsize;
5694           if (num_dynamic_syms < 1)
5695             {
5696               error (_("Unable to determine the number of symbols to load\n"));
5697               continue;
5698             }
5699
5700           dynamic_symbols = GET_ELF_SYMBOLS (file, &section);
5701         }
5702     }
5703
5704   /* Similarly find a string table.  */
5705   if (dynamic_strings == NULL)
5706     {
5707       for (entry = dynamic_section;
5708            entry < dynamic_section + dynamic_nent;
5709            ++entry)
5710         {
5711           unsigned long offset;
5712           long str_tab_len;
5713
5714           if (entry->d_tag != DT_STRTAB)
5715             continue;
5716
5717           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
5718
5719           /* Since we do not know how big the string table is,
5720              we default to reading in the entire file (!) and
5721              processing that.  This is overkill, I know, but it
5722              should work.  */
5723
5724           offset = offset_from_vma (file, entry->d_un.d_val, 0);
5725
5726           if (archive_file_offset != 0)
5727             str_tab_len = archive_file_size - offset;
5728           else
5729             {
5730               if (fseek (file, 0, SEEK_END))
5731                 error (_("Unable to seek to end of file\n"));
5732               str_tab_len = ftell (file) - offset;
5733             }
5734
5735           if (str_tab_len < 1)
5736             {
5737               error
5738                 (_("Unable to determine the length of the dynamic string table\n"));
5739               continue;
5740             }
5741
5742           dynamic_strings = get_data (NULL, file, offset, 1, str_tab_len,
5743                                       _("dynamic string table"));
5744           dynamic_strings_length = str_tab_len;
5745           break;
5746         }
5747     }
5748
5749   /* And find the syminfo section if available.  */
5750   if (dynamic_syminfo == NULL)
5751     {
5752       unsigned long syminsz = 0;
5753
5754       for (entry = dynamic_section;
5755            entry < dynamic_section + dynamic_nent;
5756            ++entry)
5757         {
5758           if (entry->d_tag == DT_SYMINENT)
5759             {
5760               /* Note: these braces are necessary to avoid a syntax
5761                  error from the SunOS4 C compiler.  */
5762               assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
5763             }
5764           else if (entry->d_tag == DT_SYMINSZ)
5765             syminsz = entry->d_un.d_val;
5766           else if (entry->d_tag == DT_SYMINFO)
5767             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
5768                                                       syminsz);
5769         }
5770
5771       if (dynamic_syminfo_offset != 0 && syminsz != 0)
5772         {
5773           Elf_External_Syminfo *extsyminfo, *extsym;
5774           Elf_Internal_Syminfo *syminfo;
5775
5776           /* There is a syminfo section.  Read the data.  */
5777           extsyminfo = get_data (NULL, file, dynamic_syminfo_offset, 1,
5778                                  syminsz, _("symbol information"));
5779           if (!extsyminfo)
5780             return 0;
5781
5782           dynamic_syminfo = malloc (syminsz);
5783           if (dynamic_syminfo == NULL)
5784             {
5785               error (_("Out of memory\n"));
5786               return 0;
5787             }
5788
5789           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
5790           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
5791                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
5792                ++syminfo, ++extsym)
5793             {
5794               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
5795               syminfo->si_flags = BYTE_GET (extsym->si_flags);
5796             }
5797
5798           free (extsyminfo);
5799         }
5800     }
5801
5802   if (do_dynamic && dynamic_addr)
5803     printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5804             dynamic_addr, dynamic_nent);
5805   if (do_dynamic)
5806     printf (_("  Tag        Type                         Name/Value\n"));
5807
5808   for (entry = dynamic_section;
5809        entry < dynamic_section + dynamic_nent;
5810        entry++)
5811     {
5812       if (do_dynamic)
5813         {
5814           const char *dtype;
5815
5816           putchar (' ');
5817           print_vma (entry->d_tag, FULL_HEX);
5818           dtype = get_dynamic_type (entry->d_tag);
5819           printf (" (%s)%*s", dtype,
5820                   ((is_32bit_elf ? 27 : 19)
5821                    - (int) strlen (dtype)),
5822                   " ");
5823         }
5824
5825       switch (entry->d_tag)
5826         {
5827         case DT_FLAGS:
5828           if (do_dynamic)
5829             print_dynamic_flags (entry->d_un.d_val);
5830           break;
5831
5832         case DT_AUXILIARY:
5833         case DT_FILTER:
5834         case DT_CONFIG:
5835         case DT_DEPAUDIT:
5836         case DT_AUDIT:
5837           if (do_dynamic)
5838             {
5839               switch (entry->d_tag)
5840                 {
5841                 case DT_AUXILIARY:
5842                   printf (_("Auxiliary library"));
5843                   break;
5844
5845                 case DT_FILTER:
5846                   printf (_("Filter library"));
5847                   break;
5848
5849                 case DT_CONFIG:
5850                   printf (_("Configuration file"));
5851                   break;
5852
5853                 case DT_DEPAUDIT:
5854                   printf (_("Dependency audit library"));
5855                   break;
5856
5857                 case DT_AUDIT:
5858                   printf (_("Audit library"));
5859                   break;
5860                 }
5861
5862               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
5863                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
5864               else
5865                 {
5866                   printf (": ");
5867                   print_vma (entry->d_un.d_val, PREFIX_HEX);
5868                   putchar ('\n');
5869                 }
5870             }
5871           break;
5872
5873         case DT_FEATURE:
5874           if (do_dynamic)
5875             {
5876               printf (_("Flags:"));
5877
5878               if (entry->d_un.d_val == 0)
5879                 printf (_(" None\n"));
5880               else
5881                 {
5882                   unsigned long int val = entry->d_un.d_val;
5883
5884                   if (val & DTF_1_PARINIT)
5885                     {
5886                       printf (" PARINIT");
5887                       val ^= DTF_1_PARINIT;
5888                     }
5889                   if (val & DTF_1_CONFEXP)
5890                     {
5891                       printf (" CONFEXP");
5892                       val ^= DTF_1_CONFEXP;
5893                     }
5894                   if (val != 0)
5895                     printf (" %lx", val);
5896                   puts ("");
5897                 }
5898             }
5899           break;
5900
5901         case DT_POSFLAG_1:
5902           if (do_dynamic)
5903             {
5904               printf (_("Flags:"));
5905
5906               if (entry->d_un.d_val == 0)
5907                 printf (_(" None\n"));
5908               else
5909                 {
5910                   unsigned long int val = entry->d_un.d_val;
5911
5912                   if (val & DF_P1_LAZYLOAD)
5913                     {
5914                       printf (" LAZYLOAD");
5915                       val ^= DF_P1_LAZYLOAD;
5916                     }
5917                   if (val & DF_P1_GROUPPERM)
5918                     {
5919                       printf (" GROUPPERM");
5920                       val ^= DF_P1_GROUPPERM;
5921                     }
5922                   if (val != 0)
5923                     printf (" %lx", val);
5924                   puts ("");
5925                 }
5926             }
5927           break;
5928
5929         case DT_FLAGS_1:
5930           if (do_dynamic)
5931             {
5932               printf (_("Flags:"));
5933               if (entry->d_un.d_val == 0)
5934                 printf (_(" None\n"));
5935               else
5936                 {
5937                   unsigned long int val = entry->d_un.d_val;
5938
5939                   if (val & DF_1_NOW)
5940                     {
5941                       printf (" NOW");
5942                       val ^= DF_1_NOW;
5943                     }
5944                   if (val & DF_1_GLOBAL)
5945                     {
5946                       printf (" GLOBAL");
5947                       val ^= DF_1_GLOBAL;
5948                     }
5949                   if (val & DF_1_GROUP)
5950                     {
5951                       printf (" GROUP");
5952                       val ^= DF_1_GROUP;
5953                     }
5954                   if (val & DF_1_NODELETE)
5955                     {
5956                       printf (" NODELETE");
5957                       val ^= DF_1_NODELETE;
5958                     }
5959                   if (val & DF_1_LOADFLTR)
5960                     {
5961                       printf (" LOADFLTR");
5962                       val ^= DF_1_LOADFLTR;
5963                     }
5964                   if (val & DF_1_INITFIRST)
5965                     {
5966                       printf (" INITFIRST");
5967                       val ^= DF_1_INITFIRST;
5968                     }
5969                   if (val & DF_1_NOOPEN)
5970                     {
5971                       printf (" NOOPEN");
5972                       val ^= DF_1_NOOPEN;
5973                     }
5974                   if (val & DF_1_ORIGIN)
5975                     {
5976                       printf (" ORIGIN");
5977                       val ^= DF_1_ORIGIN;
5978                     }
5979                   if (val & DF_1_DIRECT)
5980                     {
5981                       printf (" DIRECT");
5982                       val ^= DF_1_DIRECT;
5983                     }
5984                   if (val & DF_1_TRANS)
5985                     {
5986                       printf (" TRANS");
5987                       val ^= DF_1_TRANS;
5988                     }
5989                   if (val & DF_1_INTERPOSE)
5990                     {
5991                       printf (" INTERPOSE");
5992                       val ^= DF_1_INTERPOSE;
5993                     }
5994                   if (val & DF_1_NODEFLIB)
5995                     {
5996                       printf (" NODEFLIB");
5997                       val ^= DF_1_NODEFLIB;
5998                     }
5999                   if (val & DF_1_NODUMP)
6000                     {
6001                       printf (" NODUMP");
6002                       val ^= DF_1_NODUMP;
6003                     }
6004                   if (val & DF_1_CONLFAT)
6005                     {
6006                       printf (" CONLFAT");
6007                       val ^= DF_1_CONLFAT;
6008                     }
6009                   if (val != 0)
6010                     printf (" %lx", val);
6011                   puts ("");
6012                 }
6013             }
6014           break;
6015
6016         case DT_PLTREL:
6017           dynamic_info[entry->d_tag] = entry->d_un.d_val;
6018           if (do_dynamic)
6019             puts (get_dynamic_type (entry->d_un.d_val));
6020           break;
6021
6022         case DT_NULL    :
6023         case DT_NEEDED  :
6024         case DT_PLTGOT  :
6025         case DT_HASH    :
6026         case DT_STRTAB  :
6027         case DT_SYMTAB  :
6028         case DT_RELA    :
6029         case DT_INIT    :
6030         case DT_FINI    :
6031         case DT_SONAME  :
6032         case DT_RPATH   :
6033         case DT_SYMBOLIC:
6034         case DT_REL     :
6035         case DT_DEBUG   :
6036         case DT_TEXTREL :
6037         case DT_JMPREL  :
6038         case DT_RUNPATH :
6039           dynamic_info[entry->d_tag] = entry->d_un.d_val;
6040
6041           if (do_dynamic)
6042             {
6043               char *name;
6044
6045               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6046                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
6047               else
6048                 name = NULL;
6049
6050               if (name)
6051                 {
6052                   switch (entry->d_tag)
6053                     {
6054                     case DT_NEEDED:
6055                       printf (_("Shared library: [%s]"), name);
6056
6057                       if (streq (name, program_interpreter))
6058                         printf (_(" program interpreter"));
6059                       break;
6060
6061                     case DT_SONAME:
6062                       printf (_("Library soname: [%s]"), name);
6063                       break;
6064
6065                     case DT_RPATH:
6066                       printf (_("Library rpath: [%s]"), name);
6067                       break;
6068
6069                     case DT_RUNPATH:
6070                       printf (_("Library runpath: [%s]"), name);
6071                       break;
6072
6073                     default:
6074                       print_vma (entry->d_un.d_val, PREFIX_HEX);
6075                       break;
6076                     }
6077                 }
6078               else
6079                 print_vma (entry->d_un.d_val, PREFIX_HEX);
6080
6081               putchar ('\n');
6082             }
6083           break;
6084
6085         case DT_PLTRELSZ:
6086         case DT_RELASZ  :
6087         case DT_STRSZ   :
6088         case DT_RELSZ   :
6089         case DT_RELAENT :
6090         case DT_SYMENT  :
6091         case DT_RELENT  :
6092           dynamic_info[entry->d_tag] = entry->d_un.d_val;
6093         case DT_PLTPADSZ:
6094         case DT_MOVEENT :
6095         case DT_MOVESZ  :
6096         case DT_INIT_ARRAYSZ:
6097         case DT_FINI_ARRAYSZ:
6098         case DT_GNU_CONFLICTSZ:
6099         case DT_GNU_LIBLISTSZ:
6100           if (do_dynamic)
6101             {
6102               print_vma (entry->d_un.d_val, UNSIGNED);
6103               printf (" (bytes)\n");
6104             }
6105           break;
6106
6107         case DT_VERDEFNUM:
6108         case DT_VERNEEDNUM:
6109         case DT_RELACOUNT:
6110         case DT_RELCOUNT:
6111           if (do_dynamic)
6112             {
6113               print_vma (entry->d_un.d_val, UNSIGNED);
6114               putchar ('\n');
6115             }
6116           break;
6117
6118         case DT_SYMINSZ:
6119         case DT_SYMINENT:
6120         case DT_SYMINFO:
6121         case DT_USED:
6122         case DT_INIT_ARRAY:
6123         case DT_FINI_ARRAY:
6124           if (do_dynamic)
6125             {
6126               if (entry->d_tag == DT_USED
6127                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
6128                 {
6129                   char *name = GET_DYNAMIC_NAME (entry->d_un.d_val);
6130
6131                   if (*name)
6132                     {
6133                       printf (_("Not needed object: [%s]\n"), name);
6134                       break;
6135                     }
6136                 }
6137
6138               print_vma (entry->d_un.d_val, PREFIX_HEX);
6139               putchar ('\n');
6140             }
6141           break;
6142
6143         case DT_BIND_NOW:
6144           /* The value of this entry is ignored.  */
6145           if (do_dynamic)
6146             putchar ('\n');
6147           break;
6148
6149         case DT_GNU_PRELINKED:
6150           if (do_dynamic)
6151             {
6152               struct tm *tmp;
6153               time_t time = entry->d_un.d_val;
6154
6155               tmp = gmtime (&time);
6156               printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6157                       tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
6158                       tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
6159
6160             }
6161           break;
6162
6163         default:
6164           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
6165             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
6166               entry->d_un.d_val;
6167
6168           if (do_dynamic)
6169             {
6170               switch (elf_header.e_machine)
6171                 {
6172                 case EM_MIPS:
6173                 case EM_MIPS_RS3_LE:
6174                   dynamic_section_mips_val (entry);
6175                   break;
6176                 case EM_PARISC:
6177                   dynamic_section_parisc_val (entry);
6178                   break;
6179                 case EM_IA_64:
6180                   dynamic_section_ia64_val (entry);
6181                   break;
6182                 default:
6183                   print_vma (entry->d_un.d_val, PREFIX_HEX);
6184                   putchar ('\n');
6185                 }
6186             }
6187           break;
6188         }
6189     }
6190
6191   return 1;
6192 }
6193
6194 static char *
6195 get_ver_flags (unsigned int flags)
6196 {
6197   static char buff[32];
6198
6199   buff[0] = 0;
6200
6201   if (flags == 0)
6202     return _("none");
6203
6204   if (flags & VER_FLG_BASE)
6205     strcat (buff, "BASE ");
6206
6207   if (flags & VER_FLG_WEAK)
6208     {
6209       if (flags & VER_FLG_BASE)
6210         strcat (buff, "| ");
6211
6212       strcat (buff, "WEAK ");
6213     }
6214
6215   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
6216     strcat (buff, "| <unknown>");
6217
6218   return buff;
6219 }
6220
6221 /* Display the contents of the version sections.  */
6222 static int
6223 process_version_sections (FILE *file)
6224 {
6225   Elf_Internal_Shdr *section;
6226   unsigned i;
6227   int found = 0;
6228
6229   if (! do_version)
6230     return 1;
6231
6232   for (i = 0, section = section_headers;
6233        i < elf_header.e_shnum;
6234        i++, section++)
6235     {
6236       switch (section->sh_type)
6237         {
6238         case SHT_GNU_verdef:
6239           {
6240             Elf_External_Verdef *edefs;
6241             unsigned int idx;
6242             unsigned int cnt;
6243
6244             found = 1;
6245
6246             printf
6247               (_("\nVersion definition section '%s' contains %ld entries:\n"),
6248                SECTION_NAME (section), section->sh_info);
6249
6250             printf (_("  Addr: 0x"));
6251             printf_vma (section->sh_addr);
6252             printf (_("  Offset: %#08lx  Link: %lx (%s)\n"),
6253                     (unsigned long) section->sh_offset, section->sh_link,
6254                     SECTION_HEADER_INDEX (section->sh_link)
6255                     < elf_header.e_shnum
6256                     ? SECTION_NAME (SECTION_HEADER (section->sh_link))
6257                     : "<corrupt>");
6258
6259             edefs = get_data (NULL, file, section->sh_offset, 1,
6260                               section->sh_size,
6261                               _("version definition section"));
6262             if (!edefs)
6263               break;
6264
6265             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6266               {
6267                 char *vstart;
6268                 Elf_External_Verdef *edef;
6269                 Elf_Internal_Verdef ent;
6270                 Elf_External_Verdaux *eaux;
6271                 Elf_Internal_Verdaux aux;
6272                 int j;
6273                 int isum;
6274
6275                 vstart = ((char *) edefs) + idx;
6276
6277                 edef = (Elf_External_Verdef *) vstart;
6278
6279                 ent.vd_version = BYTE_GET (edef->vd_version);
6280                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
6281                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
6282                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
6283                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
6284                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
6285                 ent.vd_next    = BYTE_GET (edef->vd_next);
6286
6287                 printf (_("  %#06x: Rev: %d  Flags: %s"),
6288                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
6289
6290                 printf (_("  Index: %d  Cnt: %d  "),
6291                         ent.vd_ndx, ent.vd_cnt);
6292
6293                 vstart += ent.vd_aux;
6294
6295                 eaux = (Elf_External_Verdaux *) vstart;
6296
6297                 aux.vda_name = BYTE_GET (eaux->vda_name);
6298                 aux.vda_next = BYTE_GET (eaux->vda_next);
6299
6300                 if (VALID_DYNAMIC_NAME (aux.vda_name))
6301                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
6302                 else
6303                   printf (_("Name index: %ld\n"), aux.vda_name);
6304
6305                 isum = idx + ent.vd_aux;
6306
6307                 for (j = 1; j < ent.vd_cnt; j++)
6308                   {
6309                     isum   += aux.vda_next;
6310                     vstart += aux.vda_next;
6311
6312                     eaux = (Elf_External_Verdaux *) vstart;
6313
6314                     aux.vda_name = BYTE_GET (eaux->vda_name);
6315                     aux.vda_next = BYTE_GET (eaux->vda_next);
6316
6317                     if (VALID_DYNAMIC_NAME (aux.vda_name))
6318                       printf (_("  %#06x: Parent %d: %s\n"),
6319                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
6320                     else
6321                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
6322                               isum, j, aux.vda_name);
6323                   }
6324
6325                 idx += ent.vd_next;
6326               }
6327
6328             free (edefs);
6329           }
6330           break;
6331
6332         case SHT_GNU_verneed:
6333           {
6334             Elf_External_Verneed *eneed;
6335             unsigned int idx;
6336             unsigned int cnt;
6337
6338             found = 1;
6339
6340             printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6341                     SECTION_NAME (section), section->sh_info);
6342
6343             printf (_(" Addr: 0x"));
6344             printf_vma (section->sh_addr);
6345             printf (_("  Offset: %#08lx  Link to section: %ld (%s)\n"),
6346                     (unsigned long) section->sh_offset, section->sh_link,
6347                     SECTION_HEADER_INDEX (section->sh_link)
6348                     < elf_header.e_shnum
6349                     ? SECTION_NAME (SECTION_HEADER (section->sh_link))
6350                     : "<corrupt>");
6351
6352             eneed = get_data (NULL, file, section->sh_offset, 1,
6353                               section->sh_size,
6354                               _("version need section"));
6355             if (!eneed)
6356               break;
6357
6358             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6359               {
6360                 Elf_External_Verneed *entry;
6361                 Elf_Internal_Verneed ent;
6362                 int j;
6363                 int isum;
6364                 char *vstart;
6365
6366                 vstart = ((char *) eneed) + idx;
6367
6368                 entry = (Elf_External_Verneed *) vstart;
6369
6370                 ent.vn_version = BYTE_GET (entry->vn_version);
6371                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
6372                 ent.vn_file    = BYTE_GET (entry->vn_file);
6373                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
6374                 ent.vn_next    = BYTE_GET (entry->vn_next);
6375
6376                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
6377
6378                 if (VALID_DYNAMIC_NAME (ent.vn_file))
6379                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
6380                 else
6381                   printf (_("  File: %lx"), ent.vn_file);
6382
6383                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
6384
6385                 vstart += ent.vn_aux;
6386
6387                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
6388                   {
6389                     Elf_External_Vernaux *eaux;
6390                     Elf_Internal_Vernaux aux;
6391
6392                     eaux = (Elf_External_Vernaux *) vstart;
6393
6394                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
6395                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
6396                     aux.vna_other = BYTE_GET (eaux->vna_other);
6397                     aux.vna_name  = BYTE_GET (eaux->vna_name);
6398                     aux.vna_next  = BYTE_GET (eaux->vna_next);
6399
6400                     if (VALID_DYNAMIC_NAME (aux.vna_name))
6401                       printf (_("  %#06x:   Name: %s"),
6402                               isum, GET_DYNAMIC_NAME (aux.vna_name));
6403                     else
6404                       printf (_("  %#06x:   Name index: %lx"),
6405                               isum, aux.vna_name);
6406
6407                     printf (_("  Flags: %s  Version: %d\n"),
6408                             get_ver_flags (aux.vna_flags), aux.vna_other);
6409
6410                     isum   += aux.vna_next;
6411                     vstart += aux.vna_next;
6412                   }
6413
6414                 idx += ent.vn_next;
6415               }
6416
6417             free (eneed);
6418           }
6419           break;
6420
6421         case SHT_GNU_versym:
6422           {
6423             Elf_Internal_Shdr *link_section;
6424             int total;
6425             int cnt;
6426             unsigned char *edata;
6427             unsigned short *data;
6428             char *strtab;
6429             Elf_Internal_Sym *symbols;
6430             Elf_Internal_Shdr *string_sec;
6431             long off;
6432
6433             if (SECTION_HEADER_INDEX (section->sh_link) >= elf_header.e_shnum)
6434               break;
6435
6436             link_section = SECTION_HEADER (section->sh_link);
6437             total = section->sh_size / sizeof (Elf_External_Versym);
6438
6439             if (SECTION_HEADER_INDEX (link_section->sh_link)
6440                 >= elf_header.e_shnum)
6441               break;
6442
6443             found = 1;
6444
6445             symbols = GET_ELF_SYMBOLS (file, link_section);
6446
6447             string_sec = SECTION_HEADER (link_section->sh_link);
6448
6449             strtab = get_data (NULL, file, string_sec->sh_offset, 1,
6450                                string_sec->sh_size, _("version string table"));
6451             if (!strtab)
6452               break;
6453
6454             printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6455                     SECTION_NAME (section), total);
6456
6457             printf (_(" Addr: "));
6458             printf_vma (section->sh_addr);
6459             printf (_("  Offset: %#08lx  Link: %lx (%s)\n"),
6460                     (unsigned long) section->sh_offset, section->sh_link,
6461                     SECTION_NAME (link_section));
6462
6463             off = offset_from_vma (file,
6464                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
6465                                    total * sizeof (short));
6466             edata = get_data (NULL, file, off, total, sizeof (short),
6467                               _("version symbol data"));
6468             if (!edata)
6469               {
6470                 free (strtab);
6471                 break;
6472               }
6473
6474             data = cmalloc (total, sizeof (short));
6475
6476             for (cnt = total; cnt --;)
6477               data[cnt] = byte_get (edata + cnt * sizeof (short),
6478                                     sizeof (short));
6479
6480             free (edata);
6481
6482             for (cnt = 0; cnt < total; cnt += 4)
6483               {
6484                 int j, nn;
6485                 int check_def, check_need;
6486                 char *name;
6487
6488                 printf ("  %03x:", cnt);
6489
6490                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
6491                   switch (data[cnt + j])
6492                     {
6493                     case 0:
6494                       fputs (_("   0 (*local*)    "), stdout);
6495                       break;
6496
6497                     case 1:
6498                       fputs (_("   1 (*global*)   "), stdout);
6499                       break;
6500
6501                     default:
6502                       nn = printf ("%4x%c", data[cnt + j] & 0x7fff,
6503                                    data[cnt + j] & 0x8000 ? 'h' : ' ');
6504
6505                       check_def = 1;
6506                       check_need = 1;
6507                       if (SECTION_HEADER_INDEX (symbols[cnt + j].st_shndx)
6508                           >= elf_header.e_shnum
6509                           || SECTION_HEADER (symbols[cnt + j].st_shndx)->sh_type
6510                              != SHT_NOBITS)
6511                         {
6512                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
6513                             check_def = 0;
6514                           else
6515                             check_need = 0;
6516                         }
6517
6518                       if (check_need
6519                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
6520                         {
6521                           Elf_Internal_Verneed ivn;
6522                           unsigned long offset;
6523
6524                           offset = offset_from_vma
6525                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
6526                              sizeof (Elf_External_Verneed));
6527
6528                           do
6529                             {
6530                               Elf_Internal_Vernaux ivna;
6531                               Elf_External_Verneed evn;
6532                               Elf_External_Vernaux evna;
6533                               unsigned long a_off;
6534
6535                               get_data (&evn, file, offset, sizeof (evn), 1,
6536                                         _("version need"));
6537
6538                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
6539                               ivn.vn_next = BYTE_GET (evn.vn_next);
6540
6541                               a_off = offset + ivn.vn_aux;
6542
6543                               do
6544                                 {
6545                                   get_data (&evna, file, a_off, sizeof (evna),
6546                                             1, _("version need aux (2)"));
6547
6548                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
6549                                   ivna.vna_other = BYTE_GET (evna.vna_other);
6550
6551                                   a_off += ivna.vna_next;
6552                                 }
6553                               while (ivna.vna_other != data[cnt + j]
6554                                      && ivna.vna_next != 0);
6555
6556                               if (ivna.vna_other == data[cnt + j])
6557                                 {
6558                                   ivna.vna_name = BYTE_GET (evna.vna_name);
6559
6560                                   name = strtab + ivna.vna_name;
6561                                   nn += printf ("(%s%-*s",
6562                                                 name,
6563                                                 12 - (int) strlen (name),
6564                                                 ")");
6565                                   check_def = 0;
6566                                   break;
6567                                 }
6568
6569                               offset += ivn.vn_next;
6570                             }
6571                           while (ivn.vn_next);
6572                         }
6573
6574                       if (check_def && data[cnt + j] != 0x8001
6575                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
6576                         {
6577                           Elf_Internal_Verdef ivd;
6578                           Elf_External_Verdef evd;
6579                           unsigned long offset;
6580
6581                           offset = offset_from_vma
6582                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
6583                              sizeof evd);
6584
6585                           do
6586                             {
6587                               get_data (&evd, file, offset, sizeof (evd), 1,
6588                                         _("version def"));
6589
6590                               ivd.vd_next = BYTE_GET (evd.vd_next);
6591                               ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
6592
6593                               offset += ivd.vd_next;
6594                             }
6595                           while (ivd.vd_ndx != (data[cnt + j] & 0x7fff)
6596                                  && ivd.vd_next != 0);
6597
6598                           if (ivd.vd_ndx == (data[cnt + j] & 0x7fff))
6599                             {
6600                               Elf_External_Verdaux evda;
6601                               Elf_Internal_Verdaux ivda;
6602
6603                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
6604
6605                               get_data (&evda, file,
6606                                         offset - ivd.vd_next + ivd.vd_aux,
6607                                         sizeof (evda), 1,
6608                                         _("version def aux"));
6609
6610                               ivda.vda_name = BYTE_GET (evda.vda_name);
6611
6612                               name = strtab + ivda.vda_name;
6613                               nn += printf ("(%s%-*s",
6614                                             name,
6615                                             12 - (int) strlen (name),
6616                                             ")");
6617                             }
6618                         }
6619
6620                       if (nn < 18)
6621                         printf ("%*c", 18 - nn, ' ');
6622                     }
6623
6624                 putchar ('\n');
6625               }
6626
6627             free (data);
6628             free (strtab);
6629             free (symbols);
6630           }
6631           break;
6632
6633         default:
6634           break;
6635         }
6636     }
6637
6638   if (! found)
6639     printf (_("\nNo version information found in this file.\n"));
6640
6641   return 1;
6642 }
6643
6644 static const char *
6645 get_symbol_binding (unsigned int binding)
6646 {
6647   static char buff[32];
6648
6649   switch (binding)
6650     {
6651     case STB_LOCAL:     return "LOCAL";
6652     case STB_GLOBAL:    return "GLOBAL";
6653     case STB_WEAK:      return "WEAK";
6654     default:
6655       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
6656         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
6657                   binding);
6658       else if (binding >= STB_LOOS && binding <= STB_HIOS)
6659         snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
6660       else
6661         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
6662       return buff;
6663     }
6664 }
6665
6666 static const char *
6667 get_symbol_type (unsigned int type)
6668 {
6669   static char buff[32];
6670
6671   switch (type)
6672     {
6673     case STT_NOTYPE:    return "NOTYPE";
6674     case STT_OBJECT:    return "OBJECT";
6675     case STT_FUNC:      return "FUNC";
6676     case STT_SECTION:   return "SECTION";
6677     case STT_FILE:      return "FILE";
6678     case STT_COMMON:    return "COMMON";
6679     case STT_TLS:       return "TLS";
6680     default:
6681       if (type >= STT_LOPROC && type <= STT_HIPROC)
6682         {
6683           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
6684             return "THUMB_FUNC";
6685
6686           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
6687             return "REGISTER";
6688
6689           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
6690             return "PARISC_MILLI";
6691
6692           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
6693         }
6694       else if (type >= STT_LOOS && type <= STT_HIOS)
6695         {
6696           if (elf_header.e_machine == EM_PARISC)
6697             {
6698               if (type == STT_HP_OPAQUE)
6699                 return "HP_OPAQUE";
6700               if (type == STT_HP_STUB)
6701                 return "HP_STUB";
6702             }
6703
6704           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
6705         }
6706       else
6707         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
6708       return buff;
6709     }
6710 }
6711
6712 static const char *
6713 get_symbol_visibility (unsigned int visibility)
6714 {
6715   switch (visibility)
6716     {
6717     case STV_DEFAULT:   return "DEFAULT";
6718     case STV_INTERNAL:  return "INTERNAL";
6719     case STV_HIDDEN:    return "HIDDEN";
6720     case STV_PROTECTED: return "PROTECTED";
6721     default: abort ();
6722     }
6723 }
6724
6725 static const char *
6726 get_mips_symbol_other (unsigned int other)
6727 {
6728   switch (other)
6729     {
6730     case STO_OPTIONAL:  return "OPTIONAL";
6731     case STO_MIPS16:    return "MIPS16";
6732     default:            return NULL;
6733     }
6734 }
6735
6736 static const char *
6737 get_symbol_other (unsigned int other)
6738 {
6739   const char * result = NULL;
6740   static char buff [32];
6741
6742   if (other == 0)
6743     return "";
6744
6745   switch (elf_header.e_machine)
6746     {
6747     case EM_MIPS:
6748       result = get_mips_symbol_other (other);
6749     default:
6750       break;
6751     }
6752
6753   if (result)
6754     return result;
6755
6756   snprintf (buff, sizeof buff, _("<other>: %x"), other);
6757   return buff;
6758 }
6759
6760 static const char *
6761 get_symbol_index_type (unsigned int type)
6762 {
6763   static char buff[32];
6764
6765   switch (type)
6766     {
6767     case SHN_UNDEF:     return "UND";
6768     case SHN_ABS:       return "ABS";
6769     case SHN_COMMON:    return "COM";
6770     default:
6771       if (type == SHN_IA_64_ANSI_COMMON
6772           && elf_header.e_machine == EM_IA_64
6773           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
6774         return "ANSI_COM";
6775       else if (elf_header.e_machine == EM_X86_64
6776                && type == SHN_X86_64_LCOMMON)
6777         return "LARGE_COM";
6778       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
6779         sprintf (buff, "PRC[0x%04x]", type);
6780       else if (type >= SHN_LOOS && type <= SHN_HIOS)
6781         sprintf (buff, "OS [0x%04x]", type);
6782       else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
6783         sprintf (buff, "RSV[0x%04x]", type);
6784       else
6785         sprintf (buff, "%3d", type);
6786       break;
6787     }
6788
6789   return buff;
6790 }
6791
6792 static bfd_vma *
6793 get_dynamic_data (FILE *file, unsigned int number, unsigned int ent_size)
6794 {
6795   unsigned char *e_data;
6796   bfd_vma *i_data;
6797
6798   e_data = cmalloc (number, ent_size);
6799
6800   if (e_data == NULL)
6801     {
6802       error (_("Out of memory\n"));
6803       return NULL;
6804     }
6805
6806   if (fread (e_data, ent_size, number, file) != number)
6807     {
6808       error (_("Unable to read in dynamic data\n"));
6809       return NULL;
6810     }
6811
6812   i_data = cmalloc (number, sizeof (*i_data));
6813
6814   if (i_data == NULL)
6815     {
6816       error (_("Out of memory\n"));
6817       free (e_data);
6818       return NULL;
6819     }
6820
6821   while (number--)
6822     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
6823
6824   free (e_data);
6825
6826   return i_data;
6827 }
6828
6829 /* Dump the symbol table.  */
6830 static int
6831 process_symbol_table (FILE *file)
6832 {
6833   Elf_Internal_Shdr *section;
6834   bfd_vma nbuckets = 0;
6835   bfd_vma nchains = 0;
6836   bfd_vma *buckets = NULL;
6837   bfd_vma *chains = NULL;
6838
6839   if (! do_syms && !do_histogram)
6840     return 1;
6841
6842   if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
6843                                 || do_histogram))
6844     {
6845       unsigned char nb[8];
6846       unsigned char nc[8];
6847       int hash_ent_size = 4;
6848
6849       if ((elf_header.e_machine == EM_ALPHA
6850            || elf_header.e_machine == EM_S390
6851            || elf_header.e_machine == EM_S390_OLD)
6852           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
6853         hash_ent_size = 8;
6854
6855       if (fseek (file,
6856                  (archive_file_offset
6857                   + offset_from_vma (file, dynamic_info[DT_HASH],
6858                                      sizeof nb + sizeof nc)),
6859                  SEEK_SET))
6860         {
6861           error (_("Unable to seek to start of dynamic information"));
6862           return 0;
6863         }
6864
6865       if (fread (nb, hash_ent_size, 1, file) != 1)
6866         {
6867           error (_("Failed to read in number of buckets\n"));
6868           return 0;
6869         }
6870
6871       if (fread (nc, hash_ent_size, 1, file) != 1)
6872         {
6873           error (_("Failed to read in number of chains\n"));
6874           return 0;
6875         }
6876
6877       nbuckets = byte_get (nb, hash_ent_size);
6878       nchains  = byte_get (nc, hash_ent_size);
6879
6880       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
6881       chains  = get_dynamic_data (file, nchains, hash_ent_size);
6882
6883       if (buckets == NULL || chains == NULL)
6884         return 0;
6885     }
6886
6887   if (do_syms
6888       && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
6889     {
6890       unsigned long hn;
6891       bfd_vma si;
6892
6893       printf (_("\nSymbol table for image:\n"));
6894       if (is_32bit_elf)
6895         printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
6896       else
6897         printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
6898
6899       for (hn = 0; hn < nbuckets; hn++)
6900         {
6901           if (! buckets[hn])
6902             continue;
6903
6904           for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
6905             {
6906               Elf_Internal_Sym *psym;
6907               int n;
6908
6909               psym = dynamic_symbols + si;
6910
6911               n = print_vma (si, DEC_5);
6912               if (n < 5)
6913                 fputs ("     " + n, stdout);
6914               printf (" %3lu: ", hn);
6915               print_vma (psym->st_value, LONG_HEX);
6916               putchar (' ');
6917               print_vma (psym->st_size, DEC_5);
6918
6919               printf ("  %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
6920               printf (" %6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
6921               printf (" %3s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6922               /* Check to see if any other bits in the st_other field are set.
6923                  Note - displaying this information disrupts the layout of the
6924                  table being generated, but for the moment this case is very rare.  */
6925               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
6926                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
6927               printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
6928               if (VALID_DYNAMIC_NAME (psym->st_name))
6929                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
6930               else
6931                 printf (" <corrupt: %14ld>", psym->st_name);
6932               putchar ('\n');
6933             }
6934         }
6935     }
6936   else if (do_syms && !do_using_dynamic)
6937     {
6938       unsigned int i;
6939
6940       for (i = 0, section = section_headers;
6941            i < elf_header.e_shnum;
6942            i++, section++)
6943         {
6944           unsigned int si;
6945           char *strtab = NULL;
6946           unsigned long int strtab_size = 0;
6947           Elf_Internal_Sym *symtab;
6948           Elf_Internal_Sym *psym;
6949
6950
6951           if (   section->sh_type != SHT_SYMTAB
6952               && section->sh_type != SHT_DYNSYM)
6953             continue;
6954
6955           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6956                   SECTION_NAME (section),
6957                   (unsigned long) (section->sh_size / section->sh_entsize));
6958           if (is_32bit_elf)
6959             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
6960           else
6961             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
6962
6963           symtab = GET_ELF_SYMBOLS (file, section);
6964           if (symtab == NULL)
6965             continue;
6966
6967           if (section->sh_link == elf_header.e_shstrndx)
6968             {
6969               strtab = string_table;
6970               strtab_size = string_table_length;
6971             }
6972           else if (SECTION_HEADER_INDEX (section->sh_link) < elf_header.e_shnum)
6973             {
6974               Elf_Internal_Shdr *string_sec;
6975
6976               string_sec = SECTION_HEADER (section->sh_link);
6977
6978               strtab = get_data (NULL, file, string_sec->sh_offset,
6979                                  1, string_sec->sh_size, _("string table"));
6980               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
6981             }
6982
6983           for (si = 0, psym = symtab;
6984                si < section->sh_size / section->sh_entsize;
6985                si++, psym++)
6986             {
6987               printf ("%6d: ", si);
6988               print_vma (psym->st_value, LONG_HEX);
6989               putchar (' ');
6990               print_vma (psym->st_size, DEC_5);
6991               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
6992               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
6993               printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
6994               /* Check to see if any other bits in the st_other field are set.
6995                  Note - displaying this information disrupts the layout of the
6996                  table being generated, but for the moment this case is very rare.  */
6997               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
6998                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
6999               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
7000               print_symbol (25, psym->st_name < strtab_size
7001                             ? strtab + psym->st_name : "<corrupt>");
7002
7003               if (section->sh_type == SHT_DYNSYM &&
7004                   version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
7005                 {
7006                   unsigned char data[2];
7007                   unsigned short vers_data;
7008                   unsigned long offset;
7009                   int is_nobits;
7010                   int check_def;
7011
7012                   offset = offset_from_vma
7013                     (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
7014                      sizeof data + si * sizeof (vers_data));
7015
7016                   get_data (&data, file, offset + si * sizeof (vers_data),
7017                             sizeof (data), 1, _("version data"));
7018
7019                   vers_data = byte_get (data, 2);
7020
7021                   is_nobits = (SECTION_HEADER_INDEX (psym->st_shndx)
7022                                < elf_header.e_shnum
7023                                && SECTION_HEADER (psym->st_shndx)->sh_type
7024                                   == SHT_NOBITS);
7025
7026                   check_def = (psym->st_shndx != SHN_UNDEF);
7027
7028                   if ((vers_data & 0x8000) || vers_data > 1)
7029                     {
7030                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
7031                           && (is_nobits || ! check_def))
7032                         {
7033                           Elf_External_Verneed evn;
7034                           Elf_Internal_Verneed ivn;
7035                           Elf_Internal_Vernaux ivna;
7036
7037                           /* We must test both.  */
7038                           offset = offset_from_vma
7039                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
7040                              sizeof evn);
7041
7042                           do
7043                             {
7044                               unsigned long vna_off;
7045
7046                               get_data (&evn, file, offset, sizeof (evn), 1,
7047                                         _("version need"));
7048
7049                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
7050                               ivn.vn_next = BYTE_GET (evn.vn_next);
7051
7052                               vna_off = offset + ivn.vn_aux;
7053
7054                               do
7055                                 {
7056                                   Elf_External_Vernaux evna;
7057
7058                                   get_data (&evna, file, vna_off,
7059                                             sizeof (evna), 1,
7060                                             _("version need aux (3)"));
7061
7062                                   ivna.vna_other = BYTE_GET (evna.vna_other);
7063                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
7064                                   ivna.vna_name  = BYTE_GET (evna.vna_name);
7065
7066                                   vna_off += ivna.vna_next;
7067                                 }
7068                               while (ivna.vna_other != vers_data
7069                                      && ivna.vna_next != 0);
7070
7071                               if (ivna.vna_other == vers_data)
7072                                 break;
7073
7074                               offset += ivn.vn_next;
7075                             }
7076                           while (ivn.vn_next != 0);
7077
7078                           if (ivna.vna_other == vers_data)
7079                             {
7080                               printf ("@%s (%d)",
7081                                       ivna.vna_name < strtab_size
7082                                       ? strtab + ivna.vna_name : "<corrupt>",
7083                                       ivna.vna_other);
7084                               check_def = 0;
7085                             }
7086                           else if (! is_nobits)
7087                             error (_("bad dynamic symbol"));
7088                           else
7089                             check_def = 1;
7090                         }
7091
7092                       if (check_def)
7093                         {
7094                           if (vers_data != 0x8001
7095                               && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
7096                             {
7097                               Elf_Internal_Verdef ivd;
7098                               Elf_Internal_Verdaux ivda;
7099                               Elf_External_Verdaux evda;
7100                               unsigned long offset;
7101
7102                               offset = offset_from_vma
7103                                 (file,
7104                                  version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
7105                                  sizeof (Elf_External_Verdef));
7106
7107                               do
7108                                 {
7109                                   Elf_External_Verdef evd;
7110
7111                                   get_data (&evd, file, offset, sizeof (evd),
7112                                             1, _("version def"));
7113
7114                                   ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
7115                                   ivd.vd_aux = BYTE_GET (evd.vd_aux);
7116                                   ivd.vd_next = BYTE_GET (evd.vd_next);
7117
7118                                   offset += ivd.vd_next;
7119                                 }
7120                               while (ivd.vd_ndx != (vers_data & 0x7fff)
7121                                      && ivd.vd_next != 0);
7122
7123                               offset -= ivd.vd_next;
7124                               offset += ivd.vd_aux;
7125
7126                               get_data (&evda, file, offset, sizeof (evda),
7127                                         1, _("version def aux"));
7128
7129                               ivda.vda_name = BYTE_GET (evda.vda_name);
7130
7131                               if (psym->st_name != ivda.vda_name)
7132                                 printf ((vers_data & 0x8000)
7133                                         ? "@%s" : "@@%s",
7134                                         ivda.vda_name < strtab_size
7135                                         ? strtab + ivda.vda_name : "<corrupt>");
7136                             }
7137                         }
7138                     }
7139                 }
7140
7141               putchar ('\n');
7142             }
7143
7144           free (symtab);
7145           if (strtab != string_table)
7146             free (strtab);
7147         }
7148     }
7149   else if (do_syms)
7150     printf
7151       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7152
7153   if (do_histogram && buckets != NULL)
7154     {
7155       unsigned long *lengths;
7156       unsigned long *counts;
7157       unsigned long hn;
7158       bfd_vma si;
7159       unsigned long maxlength = 0;
7160       unsigned long nzero_counts = 0;
7161       unsigned long nsyms = 0;
7162
7163       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7164               (unsigned long) nbuckets);
7165       printf (_(" Length  Number     %% of total  Coverage\n"));
7166
7167       lengths = calloc (nbuckets, sizeof (*lengths));
7168       if (lengths == NULL)
7169         {
7170           error (_("Out of memory"));
7171           return 0;
7172         }
7173       for (hn = 0; hn < nbuckets; ++hn)
7174         {
7175           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
7176             {
7177               ++nsyms;
7178               if (maxlength < ++lengths[hn])
7179                 ++maxlength;
7180             }
7181         }
7182
7183       counts = calloc (maxlength + 1, sizeof (*counts));
7184       if (counts == NULL)
7185         {
7186           error (_("Out of memory"));
7187           return 0;
7188         }
7189
7190       for (hn = 0; hn < nbuckets; ++hn)
7191         ++counts[lengths[hn]];
7192
7193       if (nbuckets > 0)
7194         {
7195           unsigned long i;
7196           printf ("      0  %-10lu (%5.1f%%)\n",
7197                   counts[0], (counts[0] * 100.0) / nbuckets);
7198           for (i = 1; i <= maxlength; ++i)
7199             {
7200               nzero_counts += counts[i] * i;
7201               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
7202                       i, counts[i], (counts[i] * 100.0) / nbuckets,
7203                       (nzero_counts * 100.0) / nsyms);
7204             }
7205         }
7206
7207       free (counts);
7208       free (lengths);
7209     }
7210
7211   if (buckets != NULL)
7212     {
7213       free (buckets);
7214       free (chains);
7215     }
7216
7217   return 1;
7218 }
7219
7220 static int
7221 process_syminfo (FILE *file ATTRIBUTE_UNUSED)
7222 {
7223   unsigned int i;
7224
7225   if (dynamic_syminfo == NULL
7226       || !do_dynamic)
7227     /* No syminfo, this is ok.  */
7228     return 1;
7229
7230   /* There better should be a dynamic symbol section.  */
7231   if (dynamic_symbols == NULL || dynamic_strings == NULL)
7232     return 0;
7233
7234   if (dynamic_addr)
7235     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7236             dynamic_syminfo_offset, dynamic_syminfo_nent);
7237
7238   printf (_(" Num: Name                           BoundTo     Flags\n"));
7239   for (i = 0; i < dynamic_syminfo_nent; ++i)
7240     {
7241       unsigned short int flags = dynamic_syminfo[i].si_flags;
7242
7243       printf ("%4d: ", i);
7244       if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
7245         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
7246       else
7247         printf ("<corrupt: %19ld>", dynamic_symbols[i].st_name);
7248       putchar (' ');
7249
7250       switch (dynamic_syminfo[i].si_boundto)
7251         {
7252         case SYMINFO_BT_SELF:
7253           fputs ("SELF       ", stdout);
7254           break;
7255         case SYMINFO_BT_PARENT:
7256           fputs ("PARENT     ", stdout);
7257           break;
7258         default:
7259           if (dynamic_syminfo[i].si_boundto > 0
7260               && dynamic_syminfo[i].si_boundto < dynamic_nent
7261               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
7262             {
7263               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
7264               putchar (' ' );
7265             }
7266           else
7267             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
7268           break;
7269         }
7270
7271       if (flags & SYMINFO_FLG_DIRECT)
7272         printf (" DIRECT");
7273       if (flags & SYMINFO_FLG_PASSTHRU)
7274         printf (" PASSTHRU");
7275       if (flags & SYMINFO_FLG_COPY)
7276         printf (" COPY");
7277       if (flags & SYMINFO_FLG_LAZYLOAD)
7278         printf (" LAZYLOAD");
7279
7280       puts ("");
7281     }
7282
7283   return 1;
7284 }
7285
7286 #ifdef SUPPORT_DISASSEMBLY
7287 static int
7288 disassemble_section (Elf_Internal_Shdr *section, FILE *file)
7289 {
7290   printf (_("\nAssembly dump of section %s\n"),
7291           SECTION_NAME (section));
7292
7293   /* XXX -- to be done --- XXX */
7294
7295   return 1;
7296 }
7297 #endif
7298
7299 static int
7300 dump_section (Elf_Internal_Shdr *section, FILE *file)
7301 {
7302   bfd_size_type bytes;
7303   bfd_vma addr;
7304   unsigned char *data;
7305   unsigned char *start;
7306
7307   bytes = section->sh_size;
7308
7309   if (bytes == 0 || section->sh_type == SHT_NOBITS)
7310     {
7311       printf (_("\nSection '%s' has no data to dump.\n"),
7312               SECTION_NAME (section));
7313       return 0;
7314     }
7315   else
7316     printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
7317
7318   addr = section->sh_addr;
7319
7320   start = get_data (NULL, file, section->sh_offset, 1, bytes,
7321                     _("section data"));
7322   if (!start)
7323     return 0;
7324
7325   data = start;
7326
7327   while (bytes)
7328     {
7329       int j;
7330       int k;
7331       int lbytes;
7332
7333       lbytes = (bytes > 16 ? 16 : bytes);
7334
7335       printf ("  0x%8.8lx ", (unsigned long) addr);
7336
7337       switch (elf_header.e_ident[EI_DATA])
7338         {
7339         default:
7340         case ELFDATA2LSB:
7341           for (j = 15; j >= 0; j --)
7342             {
7343               if (j < lbytes)
7344                 printf ("%2.2x", data[j]);
7345               else
7346                 printf ("  ");
7347
7348               if (!(j & 0x3))
7349                 printf (" ");
7350             }
7351           break;
7352
7353         case ELFDATA2MSB:
7354           for (j = 0; j < 16; j++)
7355             {
7356               if (j < lbytes)
7357                 printf ("%2.2x", data[j]);
7358               else
7359                 printf ("  ");
7360
7361               if ((j & 3) == 3)
7362                 printf (" ");
7363             }
7364           break;
7365         }
7366
7367       for (j = 0; j < lbytes; j++)
7368         {
7369           k = data[j];
7370           if (k >= ' ' && k < 0x7f)
7371             printf ("%c", k);
7372           else
7373             printf (".");
7374         }
7375
7376       putchar ('\n');
7377
7378       data  += lbytes;
7379       addr  += lbytes;
7380       bytes -= lbytes;
7381     }
7382
7383   free (start);
7384
7385   return 1;
7386 }
7387
7388 /* Apply addends of RELA relocations.  */
7389
7390 static int
7391 debug_apply_rela_addends (void *file,
7392                           Elf_Internal_Shdr *section,
7393                           unsigned char *start)
7394 {
7395   Elf_Internal_Shdr *relsec;
7396   unsigned char *end = start + section->sh_size;
7397   /* FIXME: The relocation field size is relocation type dependent.  */
7398   unsigned int reloc_size = 4;
7399
7400   if (!is_relocatable)
7401     return 1;
7402
7403   if (section->sh_size < reloc_size)
7404     return 1;
7405
7406   for (relsec = section_headers;
7407        relsec < section_headers + elf_header.e_shnum;
7408        ++relsec)
7409     {
7410       unsigned long nrelas;
7411       Elf_Internal_Rela *rela, *rp;
7412       Elf_Internal_Shdr *symsec;
7413       Elf_Internal_Sym *symtab;
7414       Elf_Internal_Sym *sym;
7415
7416       if (relsec->sh_type != SHT_RELA
7417           || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum
7418           || SECTION_HEADER (relsec->sh_info) != section
7419           || relsec->sh_size == 0
7420           || SECTION_HEADER_INDEX (relsec->sh_link) >= elf_header.e_shnum)
7421         continue;
7422
7423       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7424                               &rela, &nrelas))
7425         return 0;
7426
7427       symsec = SECTION_HEADER (relsec->sh_link);
7428       symtab = GET_ELF_SYMBOLS (file, symsec);
7429
7430       for (rp = rela; rp < rela + nrelas; ++rp)
7431         {
7432           unsigned char *loc;
7433
7434           loc = start + rp->r_offset;
7435           if ((loc + reloc_size) > end)
7436             {
7437               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
7438                     (unsigned long) rp->r_offset,
7439                     SECTION_NAME (section));
7440               continue;
7441             }
7442
7443           if (is_32bit_elf)
7444             {
7445               sym = symtab + ELF32_R_SYM (rp->r_info);
7446
7447               if (ELF32_R_SYM (rp->r_info) != 0
7448                   && ELF32_ST_TYPE (sym->st_info) != STT_SECTION
7449                   /* Relocations against object symbols can happen,
7450                      eg when referencing a global array.  For an
7451                      example of this see the _clz.o binary in libgcc.a.  */
7452                   && ELF32_ST_TYPE (sym->st_info) != STT_OBJECT)
7453                 {
7454                   warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7455                         get_symbol_type (ELF32_ST_TYPE (sym->st_info)),
7456                         SECTION_NAME (section));
7457                   continue;
7458                 }
7459             }
7460           else
7461             {
7462               /* In MIPS little-endian objects, r_info isn't really a
7463                  64-bit little-endian value: it has a 32-bit little-endian
7464                  symbol index followed by four individual byte fields.
7465                  Reorder INFO accordingly.  */
7466               if (elf_header.e_machine == EM_MIPS
7467                   && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
7468                 rp->r_info = (((rp->r_info & 0xffffffff) << 32)
7469                               | ((rp->r_info >> 56) & 0xff)
7470                               | ((rp->r_info >> 40) & 0xff00)
7471                               | ((rp->r_info >> 24) & 0xff0000)
7472                               | ((rp->r_info >> 8) & 0xff000000));
7473
7474               sym = symtab + ELF64_R_SYM (rp->r_info);
7475
7476               if (ELF64_R_SYM (rp->r_info) != 0
7477                   && ELF64_ST_TYPE (sym->st_info) != STT_SECTION
7478                   && ELF64_ST_TYPE (sym->st_info) != STT_OBJECT)
7479                 {
7480                   warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7481                         get_symbol_type (ELF64_ST_TYPE (sym->st_info)),
7482                         SECTION_NAME (section));
7483                   continue;
7484                 }
7485             }
7486
7487           byte_put (loc, rp->r_addend, reloc_size);
7488         }
7489
7490       free (symtab);
7491       free (rela);
7492       break;
7493     }
7494   return 1;
7495 }
7496
7497 int
7498 load_debug_section (enum dwarf_section_display_enum debug, void *file)
7499 {
7500   struct dwarf_section *section = &debug_displays [debug].section;
7501   Elf_Internal_Shdr *sec;
7502   char buf [64];
7503
7504   /* If it is already loaded, do nothing.  */
7505   if (section->start != NULL)
7506     return 1;
7507
7508   /* Locate the debug section.  */
7509   sec = find_section (section->name);
7510   if (sec == NULL)
7511     return 0;
7512
7513   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
7514   section->address = sec->sh_addr;
7515   section->size = sec->sh_size;
7516   section->start = get_data (NULL, file, sec->sh_offset, 1,
7517                              sec->sh_size, buf);
7518
7519   if (debug_displays [debug].relocate)
7520     debug_apply_rela_addends (file, sec, section->start);
7521
7522   return section->start != NULL;
7523 }
7524
7525 void
7526 free_debug_section (enum dwarf_section_display_enum debug)
7527 {
7528   struct dwarf_section *section = &debug_displays [debug].section;
7529
7530   if (section->start == NULL)
7531     return;
7532
7533   free ((char *) section->start);
7534   section->start = NULL;
7535   section->address = 0;
7536   section->size = 0;
7537 }
7538
7539 static int
7540 display_debug_section (Elf_Internal_Shdr *section, FILE *file)
7541 {
7542   char *name = SECTION_NAME (section);
7543   bfd_size_type length;
7544   int result = 1;
7545   enum dwarf_section_display_enum i;
7546
7547   length = section->sh_size;
7548   if (length == 0)
7549     {
7550       printf (_("\nSection '%s' has no debugging data.\n"), name);
7551       return 0;
7552     }
7553
7554   if (strneq (name, ".gnu.linkonce.wi.", 17))
7555     name = ".debug_info";
7556
7557   /* See if we know how to display the contents of this section.  */
7558   for (i = 0; i < max; i++)
7559     if (streq (debug_displays[i].section.name, name))
7560       {
7561         struct dwarf_section *sec = &debug_displays [i].section;
7562
7563         if (load_debug_section (i, file))
7564           {
7565             result &= debug_displays[i].display (sec, file);
7566
7567             if (i != info && i != abbrev)
7568               free_debug_section (i);
7569           }
7570
7571         break;
7572       }
7573
7574   if (i == max)
7575     {
7576       printf (_("Unrecognized debug section: %s\n"), name);
7577       result = 0;
7578     }
7579
7580   return result;
7581 }
7582
7583 /* Set DUMP_SECTS for all sections where dumps were requested
7584    based on section name.  */
7585
7586 static void
7587 initialise_dumps_byname (void)
7588 {
7589   struct dump_list_entry *cur;
7590
7591   for (cur = dump_sects_byname; cur; cur = cur->next)
7592     {
7593       unsigned int i;
7594       int any;
7595
7596       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
7597         if (streq (SECTION_NAME (section_headers + i), cur->name))
7598           {
7599             request_dump (i, cur->type);
7600             any = 1;
7601           }
7602
7603       if (!any)
7604         warn (_("Section '%s' was not dumped because it does not exist!\n"),
7605               cur->name);
7606     }
7607 }
7608
7609 static void
7610 process_section_contents (FILE *file)
7611 {
7612   Elf_Internal_Shdr *section;
7613   unsigned int i;
7614
7615   if (! do_dump)
7616     return;
7617
7618   initialise_dumps_byname ();
7619
7620   for (i = 0, section = section_headers;
7621        i < elf_header.e_shnum && i < num_dump_sects;
7622        i++, section++)
7623     {
7624 #ifdef SUPPORT_DISASSEMBLY
7625       if (dump_sects[i] & DISASS_DUMP)
7626         disassemble_section (section, file);
7627 #endif
7628       if (dump_sects[i] & HEX_DUMP)
7629         dump_section (section, file);
7630
7631       if (dump_sects[i] & DEBUG_DUMP)
7632         display_debug_section (section, file);
7633     }
7634
7635   /* Check to see if the user requested a
7636      dump of a section that does not exist.  */
7637   while (i++ < num_dump_sects)
7638     if (dump_sects[i])
7639       warn (_("Section %d was not dumped because it does not exist!\n"), i);
7640 }
7641
7642 static void
7643 process_mips_fpe_exception (int mask)
7644 {
7645   if (mask)
7646     {
7647       int first = 1;
7648       if (mask & OEX_FPU_INEX)
7649         fputs ("INEX", stdout), first = 0;
7650       if (mask & OEX_FPU_UFLO)
7651         printf ("%sUFLO", first ? "" : "|"), first = 0;
7652       if (mask & OEX_FPU_OFLO)
7653         printf ("%sOFLO", first ? "" : "|"), first = 0;
7654       if (mask & OEX_FPU_DIV0)
7655         printf ("%sDIV0", first ? "" : "|"), first = 0;
7656       if (mask & OEX_FPU_INVAL)
7657         printf ("%sINVAL", first ? "" : "|");
7658     }
7659   else
7660     fputs ("0", stdout);
7661 }
7662
7663 /* ARM EABI attributes section.  */
7664 typedef struct
7665 {
7666   int tag;
7667   const char *name;
7668   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
7669   int type;
7670   const char **table;
7671 } arm_attr_public_tag;
7672
7673 static const char *arm_attr_tag_CPU_arch[] =
7674   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
7675    "v6K", "v7"};
7676 static const char *arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
7677 static const char *arm_attr_tag_THUMB_ISA_use[] =
7678   {"No", "Thumb-1", "Thumb-2"};
7679 static const char *arm_attr_tag_VFP_arch[] = {"No", "VFPv1", "VFPv2"};
7680 static const char *arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1"};
7681 static const char *arm_attr_tag_NEON_arch[] = {"No", "NEONv1"};
7682 static const char *arm_attr_tag_ABI_PCS_config[] =
7683   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
7684    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
7685 static const char *arm_attr_tag_ABI_PCS_R9_use[] =
7686   {"V6", "SB", "TLS", "Unused"};
7687 static const char *arm_attr_tag_ABI_PCS_RW_data[] =
7688   {"Absolute", "PC-relative", "SB-relative", "None"};
7689 static const char *arm_attr_tag_ABI_PCS_RO_DATA[] =
7690   {"Absolute", "PC-relative", "None"};
7691 static const char *arm_attr_tag_ABI_PCS_GOT_use[] =
7692   {"None", "direct", "GOT-indirect"};
7693 static const char *arm_attr_tag_ABI_PCS_wchar_t[] =
7694   {"None", "??? 1", "2", "??? 3", "4"};
7695 static const char *arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
7696 static const char *arm_attr_tag_ABI_FP_denormal[] = {"Unused", "Needed"};
7697 static const char *arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
7698 static const char *arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
7699 static const char *arm_attr_tag_ABI_FP_number_model[] =
7700   {"Unused", "Finite", "RTABI", "IEEE 754"};
7701 static const char *arm_attr_tag_ABI_align8_needed[] = {"No", "Yes", "4-byte"};
7702 static const char *arm_attr_tag_ABI_align8_preserved[] =
7703   {"No", "Yes, except leaf SP", "Yes"};
7704 static const char *arm_attr_tag_ABI_enum_size[] =
7705   {"Unused", "small", "int", "forced to int"};
7706 static const char *arm_attr_tag_ABI_HardFP_use[] =
7707   {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
7708 static const char *arm_attr_tag_ABI_VFP_args[] =
7709   {"AAPCS", "VFP registers", "custom"};
7710 static const char *arm_attr_tag_ABI_WMMX_args[] =
7711   {"AAPCS", "WMMX registers", "custom"};
7712 static const char *arm_attr_tag_ABI_optimization_goals[] =
7713   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
7714     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
7715 static const char *arm_attr_tag_ABI_FP_optimization_goals[] =
7716   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
7717     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
7718
7719 #define LOOKUP(id, name) \
7720   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
7721 static arm_attr_public_tag arm_attr_public_tags[] =
7722 {
7723   {4, "CPU_raw_name", 1, NULL},
7724   {5, "CPU_name", 1, NULL},
7725   LOOKUP(6, CPU_arch),
7726   {7, "CPU_arch_profile", 0, NULL},
7727   LOOKUP(8, ARM_ISA_use),
7728   LOOKUP(9, THUMB_ISA_use),
7729   LOOKUP(10, VFP_arch),
7730   LOOKUP(11, WMMX_arch),
7731   LOOKUP(12, NEON_arch),
7732   LOOKUP(13, ABI_PCS_config),
7733   LOOKUP(14, ABI_PCS_R9_use),
7734   LOOKUP(15, ABI_PCS_RW_data),
7735   LOOKUP(16, ABI_PCS_RO_DATA),
7736   LOOKUP(17, ABI_PCS_GOT_use),
7737   LOOKUP(18, ABI_PCS_wchar_t),
7738   LOOKUP(19, ABI_FP_rounding),
7739   LOOKUP(20, ABI_FP_denormal),
7740   LOOKUP(21, ABI_FP_exceptions),
7741   LOOKUP(22, ABI_FP_user_exceptions),
7742   LOOKUP(23, ABI_FP_number_model),
7743   LOOKUP(24, ABI_align8_needed),
7744   LOOKUP(25, ABI_align8_preserved),
7745   LOOKUP(26, ABI_enum_size),
7746   LOOKUP(27, ABI_HardFP_use),
7747   LOOKUP(28, ABI_VFP_args),
7748   LOOKUP(29, ABI_WMMX_args),
7749   LOOKUP(30, ABI_optimization_goals),
7750   LOOKUP(31, ABI_FP_optimization_goals),
7751   {32, "compatibility", 0, NULL}
7752 };
7753 #undef LOOKUP
7754
7755 /* Read an unsigned LEB128 encoded value from p.  Set *PLEN to the number of
7756    bytes read.  */
7757 static unsigned int
7758 read_uleb128 (unsigned char *p, unsigned int *plen)
7759 {
7760   unsigned char c;
7761   unsigned int val;
7762   int shift;
7763   int len;
7764
7765   val = 0;
7766   shift = 0;
7767   len = 0;
7768   do
7769     {
7770       c = *(p++);
7771       len++;
7772       val |= ((unsigned int)c & 0x7f) << shift;
7773       shift += 7;
7774     }
7775   while (c & 0x80);
7776
7777   *plen = len;
7778   return val;
7779 }
7780
7781 static unsigned char *
7782 display_arm_attribute (unsigned char *p)
7783 {
7784   int tag;
7785   unsigned int len;
7786   int val;
7787   arm_attr_public_tag *attr;
7788   unsigned i;
7789   int type;
7790
7791   tag = read_uleb128 (p, &len);
7792   p += len;
7793   attr = NULL;
7794   for (i = 0; i < ARRAY_SIZE(arm_attr_public_tags); i++)
7795     {
7796       if (arm_attr_public_tags[i].tag == tag)
7797         {
7798           attr = &arm_attr_public_tags[i];
7799           break;
7800         }
7801     }
7802
7803   if (attr)
7804     {
7805       printf ("  Tag_%s: ", attr->name);
7806       switch (attr->type)
7807         {
7808         case 0:
7809           switch (tag)
7810             {
7811             case 7: /* Tag_CPU_arch_profile.  */
7812               val = read_uleb128 (p, &len);
7813               p += len;
7814               switch (val)
7815                 {
7816                 case 0: printf ("None\n"); break;
7817                 case 'A': printf ("Application\n"); break;
7818                 case 'R': printf ("Realtime\n"); break;
7819                 case 'M': printf ("Microcontroller\n"); break;
7820                 default: printf ("??? (%d)\n", val); break;
7821                 }
7822               break;
7823
7824             case 32: /* Tag_compatibility.  */
7825               val = read_uleb128 (p, &len);
7826               p += len;
7827               printf ("flag = %d, vendor = %s\n", val, p);
7828               p += strlen((char *)p) + 1;
7829               break;
7830
7831             default:
7832               abort();
7833             }
7834           return p;
7835
7836         case 1:
7837         case 2:
7838           type = attr->type;
7839           break;
7840
7841         default:
7842           assert (attr->type & 0x80);
7843           val = read_uleb128 (p, &len);
7844           p += len;
7845           type = attr->type & 0x7f;
7846           if (val >= type)
7847             printf ("??? (%d)\n", val);
7848           else
7849             printf ("%s\n", attr->table[val]);
7850           return p;
7851         }
7852     }
7853   else
7854     {
7855       if (tag & 1)
7856         type = 1; /* String.  */
7857       else
7858         type = 2; /* uleb128.  */
7859       printf ("  Tag_unknown_%d: ", tag);
7860     }
7861
7862   if (type == 1)
7863     {
7864       printf ("\"%s\"\n", p);
7865       p += strlen((char *)p) + 1;
7866     }
7867   else
7868     {
7869       val = read_uleb128 (p, &len);
7870       p += len;
7871       printf ("%d (0x%x)\n", val, val);
7872     }
7873
7874   return p;
7875 }
7876
7877 static int
7878 process_arm_specific (FILE *file)
7879 {
7880   Elf_Internal_Shdr *sect;
7881   unsigned char *contents;
7882   unsigned char *p;
7883   unsigned char *end;
7884   bfd_vma section_len;
7885   bfd_vma len;
7886   unsigned i;
7887
7888   /* Find the section header so that we get the size.  */
7889   for (i = 0, sect = section_headers;
7890        i < elf_header.e_shnum;
7891        i++, sect++)
7892     {
7893       if (sect->sh_type != SHT_ARM_ATTRIBUTES)
7894         continue;
7895
7896       contents = get_data (NULL, file, sect->sh_offset, 1, sect->sh_size,
7897                            _("attributes"));
7898
7899       if (!contents)
7900         continue;
7901       p = contents;
7902       if (*p == 'A')
7903         {
7904           len = sect->sh_size - 1;
7905           p++;
7906           while (len > 0)
7907             {
7908               int namelen;
7909               bfd_boolean public_section;
7910
7911               section_len = byte_get (p, 4);
7912               p += 4;
7913               if (section_len > len)
7914                 {
7915                   printf (_("ERROR: Bad section length (%d > %d)\n"),
7916                           (int)section_len, (int)len);
7917                   section_len = len;
7918                 }
7919               len -= section_len;
7920               printf ("Attribute Section: %s\n", p);
7921               if (strcmp ((char *)p, "aeabi") == 0)
7922                 public_section = TRUE;
7923               else
7924                 public_section = FALSE;
7925               namelen = strlen ((char *)p) + 1;
7926               p += namelen;
7927               section_len -= namelen + 4;
7928               while (section_len > 0)
7929                 {
7930                   int tag = *(p++);
7931                   int val;
7932                   bfd_vma size;
7933                   size = byte_get (p, 4);
7934                   if (size > section_len)
7935                     {
7936                       printf (_("ERROR: Bad subsection length (%d > %d)\n"),
7937                               (int)size, (int)section_len);
7938                       size = section_len;
7939                     }
7940                   section_len -= size;
7941                   end = p + size - 1;
7942                   p += 4;
7943                   switch (tag)
7944                     {
7945                     case 1:
7946                       printf ("File Attributes\n");
7947                       break;
7948                     case 2:
7949                       printf ("Section Attributes:");
7950                       goto do_numlist;
7951                     case 3:
7952                       printf ("Symbol Attributes:");
7953                     do_numlist:
7954                       for (;;)
7955                         {
7956                           unsigned int i;
7957                           val = read_uleb128 (p, &i);
7958                           p += i;
7959                           if (val == 0)
7960                             break;
7961                           printf (" %d", val);
7962                         }
7963                       printf ("\n");
7964                       break;
7965                     default:
7966                       printf ("Unknown tag: %d\n", tag);
7967                       public_section = FALSE;
7968                       break;
7969                     }
7970                   if (public_section)
7971                     {
7972                       while (p < end)
7973                         p = display_arm_attribute(p);
7974                     }
7975                   else
7976                     {
7977                       /* ??? Do something sensible, like dump hex.  */
7978                       printf ("  Unknown section contexts\n");
7979                       p = end;
7980                     }
7981                 }
7982             }
7983         }
7984       else
7985         {
7986           printf (_("Unknown format '%c'\n"), *p);
7987         }
7988
7989       free(contents);
7990     }
7991   return 1;
7992 }
7993
7994 static int
7995 process_mips_specific (FILE *file)
7996 {
7997   Elf_Internal_Dyn *entry;
7998   size_t liblist_offset = 0;
7999   size_t liblistno = 0;
8000   size_t conflictsno = 0;
8001   size_t options_offset = 0;
8002   size_t conflicts_offset = 0;
8003
8004   /* We have a lot of special sections.  Thanks SGI!  */
8005   if (dynamic_section == NULL)
8006     /* No information available.  */
8007     return 0;
8008
8009   for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
8010     switch (entry->d_tag)
8011       {
8012       case DT_MIPS_LIBLIST:
8013         liblist_offset
8014           = offset_from_vma (file, entry->d_un.d_val,
8015                              liblistno * sizeof (Elf32_External_Lib));
8016         break;
8017       case DT_MIPS_LIBLISTNO:
8018         liblistno = entry->d_un.d_val;
8019         break;
8020       case DT_MIPS_OPTIONS:
8021         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8022         break;
8023       case DT_MIPS_CONFLICT:
8024         conflicts_offset
8025           = offset_from_vma (file, entry->d_un.d_val,
8026                              conflictsno * sizeof (Elf32_External_Conflict));
8027         break;
8028       case DT_MIPS_CONFLICTNO:
8029         conflictsno = entry->d_un.d_val;
8030         break;
8031       default:
8032         break;
8033       }
8034
8035   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
8036     {
8037       Elf32_External_Lib *elib;
8038       size_t cnt;
8039
8040       elib = get_data (NULL, file, liblist_offset,
8041                        liblistno, sizeof (Elf32_External_Lib),
8042                        _("liblist"));
8043       if (elib)
8044         {
8045           printf ("\nSection '.liblist' contains %lu entries:\n",
8046                   (unsigned long) liblistno);
8047           fputs ("     Library              Time Stamp          Checksum   Version Flags\n",
8048                  stdout);
8049
8050           for (cnt = 0; cnt < liblistno; ++cnt)
8051             {
8052               Elf32_Lib liblist;
8053               time_t time;
8054               char timebuf[20];
8055               struct tm *tmp;
8056
8057               liblist.l_name = BYTE_GET (elib[cnt].l_name);
8058               time = BYTE_GET (elib[cnt].l_time_stamp);
8059               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
8060               liblist.l_version = BYTE_GET (elib[cnt].l_version);
8061               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
8062
8063               tmp = gmtime (&time);
8064               snprintf (timebuf, sizeof (timebuf),
8065                         "%04u-%02u-%02uT%02u:%02u:%02u",
8066                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8067                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8068
8069               printf ("%3lu: ", (unsigned long) cnt);
8070               if (VALID_DYNAMIC_NAME (liblist.l_name))
8071                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
8072               else
8073                 printf ("<corrupt: %9ld>", liblist.l_name);
8074               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
8075                       liblist.l_version);
8076
8077               if (liblist.l_flags == 0)
8078                 puts (" NONE");
8079               else
8080                 {
8081                   static const struct
8082                   {
8083                     const char *name;
8084                     int bit;
8085                   }
8086                   l_flags_vals[] =
8087                   {
8088                     { " EXACT_MATCH", LL_EXACT_MATCH },
8089                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
8090                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
8091                     { " EXPORTS", LL_EXPORTS },
8092                     { " DELAY_LOAD", LL_DELAY_LOAD },
8093                     { " DELTA", LL_DELTA }
8094                   };
8095                   int flags = liblist.l_flags;
8096                   size_t fcnt;
8097
8098                   for (fcnt = 0;
8099                        fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
8100                        ++fcnt)
8101                     if ((flags & l_flags_vals[fcnt].bit) != 0)
8102                       {
8103                         fputs (l_flags_vals[fcnt].name, stdout);
8104                         flags ^= l_flags_vals[fcnt].bit;
8105                       }
8106                   if (flags != 0)
8107                     printf (" %#x", (unsigned int) flags);
8108
8109                   puts ("");
8110                 }
8111             }
8112
8113           free (elib);
8114         }
8115     }
8116
8117   if (options_offset != 0)
8118     {
8119       Elf_External_Options *eopt;
8120       Elf_Internal_Shdr *sect = section_headers;
8121       Elf_Internal_Options *iopt;
8122       Elf_Internal_Options *option;
8123       size_t offset;
8124       int cnt;
8125
8126       /* Find the section header so that we get the size.  */
8127       while (sect->sh_type != SHT_MIPS_OPTIONS)
8128         ++sect;
8129
8130       eopt = get_data (NULL, file, options_offset, 1, sect->sh_size,
8131                        _("options"));
8132       if (eopt)
8133         {
8134           iopt = cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (*iopt));
8135           if (iopt == NULL)
8136             {
8137               error (_("Out of memory"));
8138               return 0;
8139             }
8140
8141           offset = cnt = 0;
8142           option = iopt;
8143
8144           while (offset < sect->sh_size)
8145             {
8146               Elf_External_Options *eoption;
8147
8148               eoption = (Elf_External_Options *) ((char *) eopt + offset);
8149
8150               option->kind = BYTE_GET (eoption->kind);
8151               option->size = BYTE_GET (eoption->size);
8152               option->section = BYTE_GET (eoption->section);
8153               option->info = BYTE_GET (eoption->info);
8154
8155               offset += option->size;
8156
8157               ++option;
8158               ++cnt;
8159             }
8160
8161           printf (_("\nSection '%s' contains %d entries:\n"),
8162                   SECTION_NAME (sect), cnt);
8163
8164           option = iopt;
8165
8166           while (cnt-- > 0)
8167             {
8168               size_t len;
8169
8170               switch (option->kind)
8171                 {
8172                 case ODK_NULL:
8173                   /* This shouldn't happen.  */
8174                   printf (" NULL       %d %lx", option->section, option->info);
8175                   break;
8176                 case ODK_REGINFO:
8177                   printf (" REGINFO    ");
8178                   if (elf_header.e_machine == EM_MIPS)
8179                     {
8180                       /* 32bit form.  */
8181                       Elf32_External_RegInfo *ereg;
8182                       Elf32_RegInfo reginfo;
8183
8184                       ereg = (Elf32_External_RegInfo *) (option + 1);
8185                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
8186                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
8187                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
8188                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
8189                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
8190                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
8191
8192                       printf ("GPR %08lx  GP 0x%lx\n",
8193                               reginfo.ri_gprmask,
8194                               (unsigned long) reginfo.ri_gp_value);
8195                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
8196                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
8197                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
8198                     }
8199                   else
8200                     {
8201                       /* 64 bit form.  */
8202                       Elf64_External_RegInfo *ereg;
8203                       Elf64_Internal_RegInfo reginfo;
8204
8205                       ereg = (Elf64_External_RegInfo *) (option + 1);
8206                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
8207                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
8208                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
8209                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
8210                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
8211                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
8212
8213                       printf ("GPR %08lx  GP 0x",
8214                               reginfo.ri_gprmask);
8215                       printf_vma (reginfo.ri_gp_value);
8216                       printf ("\n");
8217
8218                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
8219                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
8220                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
8221                     }
8222                   ++option;
8223                   continue;
8224                 case ODK_EXCEPTIONS:
8225                   fputs (" EXCEPTIONS fpe_min(", stdout);
8226                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
8227                   fputs (") fpe_max(", stdout);
8228                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
8229                   fputs (")", stdout);
8230
8231                   if (option->info & OEX_PAGE0)
8232                     fputs (" PAGE0", stdout);
8233                   if (option->info & OEX_SMM)
8234                     fputs (" SMM", stdout);
8235                   if (option->info & OEX_FPDBUG)
8236                     fputs (" FPDBUG", stdout);
8237                   if (option->info & OEX_DISMISS)
8238                     fputs (" DISMISS", stdout);
8239                   break;
8240                 case ODK_PAD:
8241                   fputs (" PAD       ", stdout);
8242                   if (option->info & OPAD_PREFIX)
8243                     fputs (" PREFIX", stdout);
8244                   if (option->info & OPAD_POSTFIX)
8245                     fputs (" POSTFIX", stdout);
8246                   if (option->info & OPAD_SYMBOL)
8247                     fputs (" SYMBOL", stdout);
8248                   break;
8249                 case ODK_HWPATCH:
8250                   fputs (" HWPATCH   ", stdout);
8251                   if (option->info & OHW_R4KEOP)
8252                     fputs (" R4KEOP", stdout);
8253                   if (option->info & OHW_R8KPFETCH)
8254                     fputs (" R8KPFETCH", stdout);
8255                   if (option->info & OHW_R5KEOP)
8256                     fputs (" R5KEOP", stdout);
8257                   if (option->info & OHW_R5KCVTL)
8258                     fputs (" R5KCVTL", stdout);
8259                   break;
8260                 case ODK_FILL:
8261                   fputs (" FILL       ", stdout);
8262                   /* XXX Print content of info word?  */
8263                   break;
8264                 case ODK_TAGS:
8265                   fputs (" TAGS       ", stdout);
8266                   /* XXX Print content of info word?  */
8267                   break;
8268                 case ODK_HWAND:
8269                   fputs (" HWAND     ", stdout);
8270                   if (option->info & OHWA0_R4KEOP_CHECKED)
8271                     fputs (" R4KEOP_CHECKED", stdout);
8272                   if (option->info & OHWA0_R4KEOP_CLEAN)
8273                     fputs (" R4KEOP_CLEAN", stdout);
8274                   break;
8275                 case ODK_HWOR:
8276                   fputs (" HWOR      ", stdout);
8277                   if (option->info & OHWA0_R4KEOP_CHECKED)
8278                     fputs (" R4KEOP_CHECKED", stdout);
8279                   if (option->info & OHWA0_R4KEOP_CLEAN)
8280                     fputs (" R4KEOP_CLEAN", stdout);
8281                   break;
8282                 case ODK_GP_GROUP:
8283                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
8284                           option->info & OGP_GROUP,
8285                           (option->info & OGP_SELF) >> 16);
8286                   break;
8287                 case ODK_IDENT:
8288                   printf (" IDENT     %#06lx  self-contained %#06lx",
8289                           option->info & OGP_GROUP,
8290                           (option->info & OGP_SELF) >> 16);
8291                   break;
8292                 default:
8293                   /* This shouldn't happen.  */
8294                   printf (" %3d ???     %d %lx",
8295                           option->kind, option->section, option->info);
8296                   break;
8297                 }
8298
8299               len = sizeof (*eopt);
8300               while (len < option->size)
8301                 if (((char *) option)[len] >= ' '
8302                     && ((char *) option)[len] < 0x7f)
8303                   printf ("%c", ((char *) option)[len++]);
8304                 else
8305                   printf ("\\%03o", ((char *) option)[len++]);
8306
8307               fputs ("\n", stdout);
8308               ++option;
8309             }
8310
8311           free (eopt);
8312         }
8313     }
8314
8315   if (conflicts_offset != 0 && conflictsno != 0)
8316     {
8317       Elf32_Conflict *iconf;
8318       size_t cnt;
8319
8320       if (dynamic_symbols == NULL)
8321         {
8322           error (_("conflict list found without a dynamic symbol table"));
8323           return 0;
8324         }
8325
8326       iconf = cmalloc (conflictsno, sizeof (*iconf));
8327       if (iconf == NULL)
8328         {
8329           error (_("Out of memory"));
8330           return 0;
8331         }
8332
8333       if (is_32bit_elf)
8334         {
8335           Elf32_External_Conflict *econf32;
8336
8337           econf32 = get_data (NULL, file, conflicts_offset,
8338                               conflictsno, sizeof (*econf32), _("conflict"));
8339           if (!econf32)
8340             return 0;
8341
8342           for (cnt = 0; cnt < conflictsno; ++cnt)
8343             iconf[cnt] = BYTE_GET (econf32[cnt]);
8344
8345           free (econf32);
8346         }
8347       else
8348         {
8349           Elf64_External_Conflict *econf64;
8350
8351           econf64 = get_data (NULL, file, conflicts_offset,
8352                               conflictsno, sizeof (*econf64), _("conflict"));
8353           if (!econf64)
8354             return 0;
8355
8356           for (cnt = 0; cnt < conflictsno; ++cnt)
8357             iconf[cnt] = BYTE_GET (econf64[cnt]);
8358
8359           free (econf64);
8360         }
8361
8362       printf (_("\nSection '.conflict' contains %lu entries:\n"),
8363               (unsigned long) conflictsno);
8364       puts (_("  Num:    Index       Value  Name"));
8365
8366       for (cnt = 0; cnt < conflictsno; ++cnt)
8367         {
8368           Elf_Internal_Sym *psym = & dynamic_symbols[iconf[cnt]];
8369
8370           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
8371           print_vma (psym->st_value, FULL_HEX);
8372           putchar (' ');
8373           if (VALID_DYNAMIC_NAME (psym->st_name))
8374             print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
8375           else
8376             printf ("<corrupt: %14ld>", psym->st_name);
8377           putchar ('\n');
8378         }
8379
8380       free (iconf);
8381     }
8382
8383   return 1;
8384 }
8385
8386 static int
8387 process_gnu_liblist (FILE *file)
8388 {
8389   Elf_Internal_Shdr *section, *string_sec;
8390   Elf32_External_Lib *elib;
8391   char *strtab;
8392   size_t strtab_size;
8393   size_t cnt;
8394   unsigned i;
8395
8396   if (! do_arch)
8397     return 0;
8398
8399   for (i = 0, section = section_headers;
8400        i < elf_header.e_shnum;
8401        i++, section++)
8402     {
8403       switch (section->sh_type)
8404         {
8405         case SHT_GNU_LIBLIST:
8406           if (SECTION_HEADER_INDEX (section->sh_link) >= elf_header.e_shnum)
8407             break;
8408
8409           elib = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
8410                            _("liblist"));
8411
8412           if (elib == NULL)
8413             break;
8414           string_sec = SECTION_HEADER (section->sh_link);
8415
8416           strtab = get_data (NULL, file, string_sec->sh_offset, 1,
8417                              string_sec->sh_size, _("liblist string table"));
8418           strtab_size = string_sec->sh_size;
8419
8420           if (strtab == NULL
8421               || section->sh_entsize != sizeof (Elf32_External_Lib))
8422             {
8423               free (elib);
8424               break;
8425             }
8426
8427           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
8428                   SECTION_NAME (section),
8429                   (long) (section->sh_size / sizeof (Elf32_External_Lib)));
8430
8431           puts ("     Library              Time Stamp          Checksum   Version Flags");
8432
8433           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
8434                ++cnt)
8435             {
8436               Elf32_Lib liblist;
8437               time_t time;
8438               char timebuf[20];
8439               struct tm *tmp;
8440
8441               liblist.l_name = BYTE_GET (elib[cnt].l_name);
8442               time = BYTE_GET (elib[cnt].l_time_stamp);
8443               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
8444               liblist.l_version = BYTE_GET (elib[cnt].l_version);
8445               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
8446
8447               tmp = gmtime (&time);
8448               snprintf (timebuf, sizeof (timebuf),
8449                         "%04u-%02u-%02uT%02u:%02u:%02u",
8450                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8451                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8452
8453               printf ("%3lu: ", (unsigned long) cnt);
8454               if (do_wide)
8455                 printf ("%-20s", liblist.l_name < strtab_size
8456                                  ? strtab + liblist.l_name : "<corrupt>");
8457               else
8458                 printf ("%-20.20s", liblist.l_name < strtab_size
8459                                     ? strtab + liblist.l_name : "<corrupt>");
8460               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
8461                       liblist.l_version, liblist.l_flags);
8462             }
8463
8464           free (elib);
8465         }
8466     }
8467
8468   return 1;
8469 }
8470
8471 static const char *
8472 get_note_type (unsigned e_type)
8473 {
8474   static char buff[64];
8475
8476   if (elf_header.e_type == ET_CORE)
8477     switch (e_type)
8478       {
8479       case NT_AUXV:
8480         return _("NT_AUXV (auxiliary vector)");
8481       case NT_PRSTATUS:
8482         return _("NT_PRSTATUS (prstatus structure)");
8483       case NT_FPREGSET:
8484         return _("NT_FPREGSET (floating point registers)");
8485       case NT_PRPSINFO:
8486         return _("NT_PRPSINFO (prpsinfo structure)");
8487       case NT_TASKSTRUCT:
8488         return _("NT_TASKSTRUCT (task structure)");
8489       case NT_PRXFPREG:
8490         return _("NT_PRXFPREG (user_xfpregs structure)");
8491       case NT_PSTATUS:
8492         return _("NT_PSTATUS (pstatus structure)");
8493       case NT_FPREGS:
8494         return _("NT_FPREGS (floating point registers)");
8495       case NT_PSINFO:
8496         return _("NT_PSINFO (psinfo structure)");
8497       case NT_LWPSTATUS:
8498         return _("NT_LWPSTATUS (lwpstatus_t structure)");
8499       case NT_LWPSINFO:
8500         return _("NT_LWPSINFO (lwpsinfo_t structure)");
8501       case NT_WIN32PSTATUS:
8502         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
8503       default:
8504         break;
8505       }
8506   else
8507     switch (e_type)
8508       {
8509       case NT_VERSION:
8510         return _("NT_VERSION (version)");
8511       case NT_ARCH:
8512         return _("NT_ARCH (architecture)");
8513       default:
8514         break;
8515       }
8516
8517   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
8518   return buff;
8519 }
8520
8521 static const char *
8522 get_netbsd_elfcore_note_type (unsigned e_type)
8523 {
8524   static char buff[64];
8525
8526   if (e_type == NT_NETBSDCORE_PROCINFO)
8527     {
8528       /* NetBSD core "procinfo" structure.  */
8529       return _("NetBSD procinfo structure");
8530     }
8531
8532   /* As of Jan 2002 there are no other machine-independent notes
8533      defined for NetBSD core files.  If the note type is less
8534      than the start of the machine-dependent note types, we don't
8535      understand it.  */
8536
8537   if (e_type < NT_NETBSDCORE_FIRSTMACH)
8538     {
8539       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
8540       return buff;
8541     }
8542
8543   switch (elf_header.e_machine)
8544     {
8545     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
8546        and PT_GETFPREGS == mach+2.  */
8547
8548     case EM_OLD_ALPHA:
8549     case EM_ALPHA:
8550     case EM_SPARC:
8551     case EM_SPARC32PLUS:
8552     case EM_SPARCV9:
8553       switch (e_type)
8554         {
8555         case NT_NETBSDCORE_FIRSTMACH+0:
8556           return _("PT_GETREGS (reg structure)");
8557         case NT_NETBSDCORE_FIRSTMACH+2:
8558           return _("PT_GETFPREGS (fpreg structure)");
8559         default:
8560           break;
8561         }
8562       break;
8563
8564     /* On all other arch's, PT_GETREGS == mach+1 and
8565        PT_GETFPREGS == mach+3.  */
8566     default:
8567       switch (e_type)
8568         {
8569         case NT_NETBSDCORE_FIRSTMACH+1:
8570           return _("PT_GETREGS (reg structure)");
8571         case NT_NETBSDCORE_FIRSTMACH+3:
8572           return _("PT_GETFPREGS (fpreg structure)");
8573         default:
8574           break;
8575         }
8576     }
8577
8578   snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
8579             e_type - NT_NETBSDCORE_FIRSTMACH);
8580   return buff;
8581 }
8582
8583 /* Note that by the ELF standard, the name field is already null byte
8584    terminated, and namesz includes the terminating null byte.
8585    I.E. the value of namesz for the name "FSF" is 4.
8586
8587    If the value of namesz is zero, there is no name present.  */
8588 static int
8589 process_note (Elf_Internal_Note *pnote)
8590 {
8591   const char *nt;
8592
8593   if (pnote->namesz == 0)
8594     /* If there is no note name, then use the default set of
8595        note type strings.  */
8596     nt = get_note_type (pnote->type);
8597
8598   else if (strneq (pnote->namedata, "NetBSD-CORE", 11))
8599     /* NetBSD-specific core file notes.  */
8600     nt = get_netbsd_elfcore_note_type (pnote->type);
8601
8602   else
8603     /* Don't recognize this note name; just use the default set of
8604        note type strings.  */
8605       nt = get_note_type (pnote->type);
8606
8607   printf ("  %s\t\t0x%08lx\t%s\n",
8608           pnote->namesz ? pnote->namedata : "(NONE)",
8609           pnote->descsz, nt);
8610   return 1;
8611 }
8612
8613
8614 static int
8615 process_corefile_note_segment (FILE *file, bfd_vma offset, bfd_vma length)
8616 {
8617   Elf_External_Note *pnotes;
8618   Elf_External_Note *external;
8619   int res = 1;
8620
8621   if (length <= 0)
8622     return 0;
8623
8624   pnotes = get_data (NULL, file, offset, 1, length, _("notes"));
8625   if (!pnotes)
8626     return 0;
8627
8628   external = pnotes;
8629
8630   printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
8631           (unsigned long) offset, (unsigned long) length);
8632   printf (_("  Owner\t\tData size\tDescription\n"));
8633
8634   while (external < (Elf_External_Note *)((char *) pnotes + length))
8635     {
8636       Elf_External_Note *next;
8637       Elf_Internal_Note inote;
8638       char *temp = NULL;
8639
8640       inote.type     = BYTE_GET (external->type);
8641       inote.namesz   = BYTE_GET (external->namesz);
8642       inote.namedata = external->name;
8643       inote.descsz   = BYTE_GET (external->descsz);
8644       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
8645       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
8646
8647       next = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
8648
8649       if (((char *) next) > (((char *) pnotes) + length))
8650         {
8651           warn (_("corrupt note found at offset %lx into core notes\n"),
8652                 (long)((char *)external - (char *)pnotes));
8653           warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
8654                 inote.type, inote.namesz, inote.descsz);
8655           break;
8656         }
8657
8658       external = next;
8659
8660       /* Verify that name is null terminated.  It appears that at least
8661          one version of Linux (RedHat 6.0) generates corefiles that don't
8662          comply with the ELF spec by failing to include the null byte in
8663          namesz.  */
8664       if (inote.namedata[inote.namesz] != '\0')
8665         {
8666           temp = malloc (inote.namesz + 1);
8667
8668           if (temp == NULL)
8669             {
8670               error (_("Out of memory\n"));
8671               res = 0;
8672               break;
8673             }
8674
8675           strncpy (temp, inote.namedata, inote.namesz);
8676           temp[inote.namesz] = 0;
8677
8678           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
8679           inote.namedata = temp;
8680         }
8681
8682       res &= process_note (& inote);
8683
8684       if (temp != NULL)
8685         {
8686           free (temp);
8687           temp = NULL;
8688         }
8689     }
8690
8691   free (pnotes);
8692
8693   return res;
8694 }
8695
8696 static int
8697 process_corefile_note_segments (FILE *file)
8698 {
8699   Elf_Internal_Phdr *segment;
8700   unsigned int i;
8701   int res = 1;
8702
8703   if (! get_program_headers (file))
8704       return 0;
8705
8706   for (i = 0, segment = program_headers;
8707        i < elf_header.e_phnum;
8708        i++, segment++)
8709     {
8710       if (segment->p_type == PT_NOTE)
8711         res &= process_corefile_note_segment (file,
8712                                               (bfd_vma) segment->p_offset,
8713                                               (bfd_vma) segment->p_filesz);
8714     }
8715
8716   return res;
8717 }
8718
8719 static int
8720 process_note_sections (FILE *file)
8721 {
8722   Elf_Internal_Shdr *section;
8723   unsigned long i;
8724   int res = 1;
8725
8726   for (i = 0, section = section_headers;
8727        i < elf_header.e_shnum;
8728        i++, section++)
8729     if (section->sh_type == SHT_NOTE)
8730       res &= process_corefile_note_segment (file,
8731                                             (bfd_vma) section->sh_offset,
8732                                             (bfd_vma) section->sh_size);
8733
8734   return res;
8735 }
8736
8737 static int
8738 process_notes (FILE *file)
8739 {
8740   /* If we have not been asked to display the notes then do nothing.  */
8741   if (! do_notes)
8742     return 1;
8743
8744   if (elf_header.e_type != ET_CORE)
8745     return process_note_sections (file);
8746
8747   /* No program headers means no NOTE segment.  */
8748   if (elf_header.e_phnum > 0)
8749     return process_corefile_note_segments (file);
8750
8751   printf (_("No note segments present in the core file.\n"));
8752   return 1;
8753 }
8754
8755 static int
8756 process_arch_specific (FILE *file)
8757 {
8758   if (! do_arch)
8759     return 1;
8760
8761   switch (elf_header.e_machine)
8762     {
8763     case EM_ARM:
8764       return process_arm_specific (file);
8765     case EM_MIPS:
8766     case EM_MIPS_RS3_LE:
8767       return process_mips_specific (file);
8768       break;
8769     default:
8770       break;
8771     }
8772   return 1;
8773 }
8774
8775 static int
8776 get_file_header (FILE *file)
8777 {
8778   /* Read in the identity array.  */
8779   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
8780     return 0;
8781
8782   /* Determine how to read the rest of the header.  */
8783   switch (elf_header.e_ident[EI_DATA])
8784     {
8785     default: /* fall through */
8786     case ELFDATANONE: /* fall through */
8787     case ELFDATA2LSB:
8788       byte_get = byte_get_little_endian;
8789       byte_put = byte_put_little_endian;
8790       break;
8791     case ELFDATA2MSB:
8792       byte_get = byte_get_big_endian;
8793       byte_put = byte_put_big_endian;
8794       break;
8795     }
8796
8797   /* For now we only support 32 bit and 64 bit ELF files.  */
8798   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
8799
8800   /* Read in the rest of the header.  */
8801   if (is_32bit_elf)
8802     {
8803       Elf32_External_Ehdr ehdr32;
8804
8805       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
8806         return 0;
8807
8808       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
8809       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
8810       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
8811       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
8812       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
8813       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
8814       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
8815       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
8816       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
8817       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
8818       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
8819       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
8820       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
8821     }
8822   else
8823     {
8824       Elf64_External_Ehdr ehdr64;
8825
8826       /* If we have been compiled with sizeof (bfd_vma) == 4, then
8827          we will not be able to cope with the 64bit data found in
8828          64 ELF files.  Detect this now and abort before we start
8829          overwriting things.  */
8830       if (sizeof (bfd_vma) < 8)
8831         {
8832           error (_("This instance of readelf has been built without support for a\n\
8833 64 bit data type and so it cannot read 64 bit ELF files.\n"));
8834           return 0;
8835         }
8836
8837       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
8838         return 0;
8839
8840       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
8841       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
8842       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
8843       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
8844       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
8845       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
8846       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
8847       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
8848       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
8849       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
8850       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
8851       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
8852       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
8853     }
8854
8855   if (elf_header.e_shoff)
8856     {
8857       /* There may be some extensions in the first section header.  Don't
8858          bomb if we can't read it.  */
8859       if (is_32bit_elf)
8860         get_32bit_section_headers (file, 1);
8861       else
8862         get_64bit_section_headers (file, 1);
8863     }
8864
8865   is_relocatable = elf_header.e_type == ET_REL;
8866
8867   return 1;
8868 }
8869
8870 /* Process one ELF object file according to the command line options.
8871    This file may actually be stored in an archive.  The file is
8872    positioned at the start of the ELF object.  */
8873
8874 static int
8875 process_object (char *file_name, FILE *file)
8876 {
8877   unsigned int i;
8878
8879   if (! get_file_header (file))
8880     {
8881       error (_("%s: Failed to read file header\n"), file_name);
8882       return 1;
8883     }
8884
8885   /* Initialise per file variables.  */
8886   for (i = NUM_ELEM (version_info); i--;)
8887     version_info[i] = 0;
8888
8889   for (i = NUM_ELEM (dynamic_info); i--;)
8890     dynamic_info[i] = 0;
8891
8892   /* Process the file.  */
8893   if (show_name)
8894     printf (_("\nFile: %s\n"), file_name);
8895
8896   /* Initialise the dump_sects array from the cmdline_dump_sects array.
8897      Note we do this even if cmdline_dump_sects is empty because we
8898      must make sure that the dump_sets array is zeroed out before each
8899      object file is processed.  */
8900   if (num_dump_sects > num_cmdline_dump_sects)
8901     memset (dump_sects, 0, num_dump_sects);
8902
8903   if (num_cmdline_dump_sects > 0)
8904     {
8905       if (num_dump_sects == 0)
8906         /* A sneaky way of allocating the dump_sects array.  */
8907         request_dump (num_cmdline_dump_sects, 0);
8908
8909       assert (num_dump_sects >= num_cmdline_dump_sects);
8910       memcpy (dump_sects, cmdline_dump_sects, num_cmdline_dump_sects);
8911     }
8912
8913   if (! process_file_header ())
8914     return 1;
8915
8916   if (! process_section_headers (file))
8917     {
8918       /* Without loaded section headers we cannot process lots of
8919          things.  */
8920       do_unwind = do_version = do_dump = do_arch = 0;
8921
8922       if (! do_using_dynamic)
8923         do_syms = do_reloc = 0;
8924     }
8925
8926   if (! process_section_groups (file))
8927     {
8928       /* Without loaded section groups we cannot process unwind.  */
8929       do_unwind = 0;
8930     }
8931
8932   if (process_program_headers (file))
8933     process_dynamic_section (file);
8934
8935   process_relocs (file);
8936
8937   process_unwind (file);
8938
8939   process_symbol_table (file);
8940
8941   process_syminfo (file);
8942
8943   process_version_sections (file);
8944
8945   process_section_contents (file);
8946
8947   process_notes (file);
8948
8949   process_gnu_liblist (file);
8950
8951   process_arch_specific (file);
8952
8953   if (program_headers)
8954     {
8955       free (program_headers);
8956       program_headers = NULL;
8957     }
8958
8959   if (section_headers)
8960     {
8961       free (section_headers);
8962       section_headers = NULL;
8963     }
8964
8965   if (string_table)
8966     {
8967       free (string_table);
8968       string_table = NULL;
8969       string_table_length = 0;
8970     }
8971
8972   if (dynamic_strings)
8973     {
8974       free (dynamic_strings);
8975       dynamic_strings = NULL;
8976       dynamic_strings_length = 0;
8977     }
8978
8979   if (dynamic_symbols)
8980     {
8981       free (dynamic_symbols);
8982       dynamic_symbols = NULL;
8983       num_dynamic_syms = 0;
8984     }
8985
8986   if (dynamic_syminfo)
8987     {
8988       free (dynamic_syminfo);
8989       dynamic_syminfo = NULL;
8990     }
8991
8992   if (section_headers_groups)
8993     {
8994       free (section_headers_groups);
8995       section_headers_groups = NULL;
8996     }
8997
8998   if (section_groups)
8999     {
9000       struct group_list *g, *next;
9001
9002       for (i = 0; i < group_count; i++)
9003         {
9004           for (g = section_groups [i].root; g != NULL; g = next)
9005             {
9006               next = g->next;
9007               free (g);
9008             }
9009         }
9010
9011       free (section_groups);
9012       section_groups = NULL;
9013     }
9014
9015   free_debug_memory ();
9016
9017   return 0;
9018 }
9019
9020 /* Process an ELF archive.  The file is positioned just after the
9021    ARMAG string.  */
9022
9023 static int
9024 process_archive (char *file_name, FILE *file)
9025 {
9026   struct ar_hdr arhdr;
9027   size_t got;
9028   unsigned long size;
9029   char *longnames = NULL;
9030   unsigned long longnames_size = 0;
9031   size_t file_name_size;
9032   int ret;
9033
9034   show_name = 1;
9035
9036   got = fread (&arhdr, 1, sizeof arhdr, file);
9037   if (got != sizeof arhdr)
9038     {
9039       if (got == 0)
9040         return 0;
9041
9042       error (_("%s: failed to read archive header\n"), file_name);
9043       return 1;
9044     }
9045
9046   if (memcmp (arhdr.ar_name, "/               ", 16) == 0)
9047     {
9048       /* This is the archive symbol table.  Skip it.
9049          FIXME: We should have an option to dump it.  */
9050       size = strtoul (arhdr.ar_size, NULL, 10);
9051       if (fseek (file, size + (size & 1), SEEK_CUR) != 0)
9052         {
9053           error (_("%s: failed to skip archive symbol table\n"), file_name);
9054           return 1;
9055         }
9056
9057       got = fread (&arhdr, 1, sizeof arhdr, file);
9058       if (got != sizeof arhdr)
9059         {
9060           if (got == 0)
9061             return 0;
9062
9063           error (_("%s: failed to read archive header\n"), file_name);
9064           return 1;
9065         }
9066     }
9067
9068   if (memcmp (arhdr.ar_name, "//              ", 16) == 0)
9069     {
9070       /* This is the archive string table holding long member
9071          names.  */
9072
9073       longnames_size = strtoul (arhdr.ar_size, NULL, 10);
9074
9075       longnames = malloc (longnames_size);
9076       if (longnames == NULL)
9077         {
9078           error (_("Out of memory\n"));
9079           return 1;
9080         }
9081
9082       if (fread (longnames, longnames_size, 1, file) != 1)
9083         {
9084           free (longnames);
9085           error (_("%s: failed to read string table\n"), file_name);
9086           return 1;
9087         }
9088
9089       if ((longnames_size & 1) != 0)
9090         getc (file);
9091
9092       got = fread (&arhdr, 1, sizeof arhdr, file);
9093       if (got != sizeof arhdr)
9094         {
9095           free (longnames);
9096
9097           if (got == 0)
9098             return 0;
9099
9100           error (_("%s: failed to read archive header\n"), file_name);
9101           return 1;
9102         }
9103     }
9104
9105   file_name_size = strlen (file_name);
9106   ret = 0;
9107
9108   while (1)
9109     {
9110       char *name;
9111       char *nameend;
9112       char *namealc;
9113
9114       if (arhdr.ar_name[0] == '/')
9115         {
9116           unsigned long off;
9117
9118           off = strtoul (arhdr.ar_name + 1, NULL, 10);
9119           if (off >= longnames_size)
9120             {
9121               error (_("%s: invalid archive string table offset %lu\n"), file_name, off);
9122               ret = 1;
9123               break;
9124             }
9125
9126           name = longnames + off;
9127           nameend = memchr (name, '/', longnames_size - off);
9128         }
9129       else
9130         {
9131           name = arhdr.ar_name;
9132           nameend = memchr (name, '/', 16);
9133         }
9134
9135       if (nameend == NULL)
9136         {
9137           error (_("%s: bad archive file name\n"), file_name);
9138           ret = 1;
9139           break;
9140         }
9141
9142       namealc = malloc (file_name_size + (nameend - name) + 3);
9143       if (namealc == NULL)
9144         {
9145           error (_("Out of memory\n"));
9146           ret = 1;
9147           break;
9148         }
9149
9150       memcpy (namealc, file_name, file_name_size);
9151       namealc[file_name_size] = '(';
9152       memcpy (namealc + file_name_size + 1, name, nameend - name);
9153       namealc[file_name_size + 1 + (nameend - name)] = ')';
9154       namealc[file_name_size + 2 + (nameend - name)] = '\0';
9155
9156       archive_file_offset = ftell (file);
9157       archive_file_size = strtoul (arhdr.ar_size, NULL, 10);
9158
9159       ret |= process_object (namealc, file);
9160
9161       free (namealc);
9162
9163       if (fseek (file,
9164                  (archive_file_offset
9165                   + archive_file_size
9166                   + (archive_file_size & 1)),
9167                  SEEK_SET) != 0)
9168         {
9169           error (_("%s: failed to seek to next archive header\n"), file_name);
9170           ret = 1;
9171           break;
9172         }
9173
9174       got = fread (&arhdr, 1, sizeof arhdr, file);
9175       if (got != sizeof arhdr)
9176         {
9177           if (got == 0)
9178             break;
9179
9180           error (_("%s: failed to read archive header\n"), file_name);
9181           ret = 1;
9182           break;
9183         }
9184     }
9185
9186   if (longnames != 0)
9187     free (longnames);
9188
9189   return ret;
9190 }
9191
9192 static int
9193 process_file (char *file_name)
9194 {
9195   FILE *file;
9196   struct stat statbuf;
9197   char armag[SARMAG];
9198   int ret;
9199
9200   if (stat (file_name, &statbuf) < 0)
9201     {
9202       if (errno == ENOENT)
9203         error (_("'%s': No such file\n"), file_name);
9204       else
9205         error (_("Could not locate '%s'.  System error message: %s\n"),
9206                file_name, strerror (errno));
9207       return 1;
9208     }
9209
9210   if (! S_ISREG (statbuf.st_mode))
9211     {
9212       error (_("'%s' is not an ordinary file\n"), file_name);
9213       return 1;
9214     }
9215
9216   file = fopen (file_name, "rb");
9217   if (file == NULL)
9218     {
9219       error (_("Input file '%s' is not readable.\n"), file_name);
9220       return 1;
9221     }
9222
9223   if (fread (armag, SARMAG, 1, file) != 1)
9224     {
9225       error (_("%s: Failed to read file header\n"), file_name);
9226       fclose (file);
9227       return 1;
9228     }
9229
9230   if (memcmp (armag, ARMAG, SARMAG) == 0)
9231     ret = process_archive (file_name, file);
9232   else
9233     {
9234       rewind (file);
9235       archive_file_size = archive_file_offset = 0;
9236       ret = process_object (file_name, file);
9237     }
9238
9239   fclose (file);
9240
9241   return ret;
9242 }
9243
9244 #ifdef SUPPORT_DISASSEMBLY
9245 /* Needed by the i386 disassembler.  For extra credit, someone could
9246    fix this so that we insert symbolic addresses here, esp for GOT/PLT
9247    symbols.  */
9248
9249 void
9250 print_address (unsigned int addr, FILE *outfile)
9251 {
9252   fprintf (outfile,"0x%8.8x", addr);
9253 }
9254
9255 /* Needed by the i386 disassembler.  */
9256 void
9257 db_task_printsym (unsigned int addr)
9258 {
9259   print_address (addr, stderr);
9260 }
9261 #endif
9262
9263 int
9264 main (int argc, char **argv)
9265 {
9266   int err;
9267
9268 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
9269   setlocale (LC_MESSAGES, "");
9270 #endif
9271 #if defined (HAVE_SETLOCALE)
9272   setlocale (LC_CTYPE, "");
9273 #endif
9274   bindtextdomain (PACKAGE, LOCALEDIR);
9275   textdomain (PACKAGE);
9276
9277   expandargv (&argc, &argv);
9278
9279   parse_args (argc, argv);
9280
9281   if (num_dump_sects > 0)
9282     {
9283       /* Make a copy of the dump_sects array.  */
9284       cmdline_dump_sects = malloc (num_dump_sects);
9285       if (cmdline_dump_sects == NULL)
9286         error (_("Out of memory allocating dump request table."));
9287       else
9288         {
9289           memcpy (cmdline_dump_sects, dump_sects, num_dump_sects);
9290           num_cmdline_dump_sects = num_dump_sects;
9291         }
9292     }
9293
9294   if (optind < (argc - 1))
9295     show_name = 1;
9296
9297   err = 0;
9298   while (optind < argc)
9299     err |= process_file (argv[optind++]);
9300
9301   if (dump_sects != NULL)
9302     free (dump_sects);
9303   if (cmdline_dump_sects != NULL)
9304     free (cmdline_dump_sects);
9305
9306   return err;
9307 }