binutils/readelf.c

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