contrib/binutils-2.17/binutils/readelf.c

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