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 static long archive_file_offset;
 165 static unsigned long archive_file_size;
 166 static unsigned long dynamic_addr;
 167 static bfd_size_type dynamic_size;
 168 static unsigned int dynamic_nent;
 169 static char *dynamic_strings;
 170 static unsigned long dynamic_strings_length;
 171 static char *string_table;
 172 static unsigned long string_table_length;
 173 static unsigned long num_dynamic_syms;
 174 static Elf_Internal_Sym *dynamic_symbols;
 175 static Elf_Internal_Syminfo *dynamic_syminfo;
 176 static unsigned long dynamic_syminfo_offset;
 177 static unsigned int dynamic_syminfo_nent;
 178 static char program_interpreter[PATH_MAX];
 179 static bfd_vma dynamic_info[DT_JMPREL + 1];
 180 static bfd_vma dynamic_info_DT_GNU_HASH;
 181 static bfd_vma version_info[16];
 182 static Elf_Internal_Ehdr elf_header;
 183 static Elf_Internal_Shdr *section_headers;
 184 static Elf_Internal_Phdr *program_headers;
 185 static Elf_Internal_Dyn *dynamic_section;
 186 static Elf_Internal_Shdr *symtab_shndx_hdr;
 187 static int show_name;
 188 static int do_dynamic;
 189 static int do_syms;
 190 static int do_reloc;
 191 static int do_sections;
 192 static int do_section_groups;
 193 static int do_section_details;
 194 static int do_segments;
 195 static int do_unwind;
 196 static int do_using_dynamic;
 197 static int do_header;
 198 static int do_dump;
 199 static int do_version;
 200 static int do_wide;
 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[liaprmfFsoR] or\n\
2884   --debug-dump[=line,=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 'p':
3087                     do_debug_pubnames = 1;
3088                     break;
3089
3090                   case 'r':
3091                     do_debug_aranges = 1;
3092                     break;
3093
3094                   case 'R':
3095                     do_debug_ranges = 1;
3096                     break;
3097
3098                   case 'F':
3099                     do_debug_frames_interp = 1;
3100                   case 'f':
3101                     do_debug_frames = 1;
3102                     break;
3103
3104                   case 'm':
3105                     do_debug_macinfo = 1;
3106                     break;
3107
3108                   case 's':
3109                     do_debug_str = 1;
3110                     break;
3111
3112                   case 'o':
3113                     do_debug_loc = 1;
3114                     break;
3115
3116                   default:
3117                     warn (_("Unrecognized debug option '%s'\n"), optarg);
3118                     break;
3119                   }
3120             }
3121           break;
3122         case OPTION_DEBUG_DUMP:
3123           do_dump++;
3124           if (optarg == 0)
3125             do_debugging = 1;
3126           else
3127             {
3128               typedef struct
3129               {
3130                 const char * option;
3131                 int *        variable;
3132               }
3133               debug_dump_long_opts;
3134
3135               debug_dump_long_opts opts_table [] =
3136                 {
3137                   /* Please keep this table alpha- sorted.  */
3138                   { "Ranges", & do_debug_ranges },
3139                   { "abbrev", & do_debug_abbrevs },
3140                   { "aranges", & do_debug_aranges },
3141                   { "frames", & do_debug_frames },
3142                   { "frames-interp", & do_debug_frames_interp },
3143                   { "info", & do_debug_info },
3144                   { "line", & do_debug_lines },
3145                   { "loc",  & do_debug_loc },
3146                   { "macro", & do_debug_macinfo },
3147                   { "pubnames", & do_debug_pubnames },
3148                   /* This entry is for compatability
3149                      with earlier versions of readelf.  */
3150                   { "ranges", & do_debug_aranges },
3151                   { "str", & do_debug_str },
3152                   { NULL, NULL }
3153                 };
3154
3155               const char *p;
3156
3157               do_debugging = 0;
3158
3159               p = optarg;
3160               while (*p)
3161                 {
3162                   debug_dump_long_opts * entry;
3163
3164                   for (entry = opts_table; entry->option; entry++)
3165                     {
3166                       size_t len = strlen (entry->option);
3167
3168                       if (strneq (p, entry->option, len)
3169                           && (p[len] == ',' || p[len] == '\0'))
3170                         {
3171                           * entry->variable = 1;
3172
3173                           /* The --debug-dump=frames-interp option also
3174                              enables the --debug-dump=frames option.  */
3175                           if (do_debug_frames_interp)
3176                             do_debug_frames = 1;
3177
3178                           p += len;
3179                           break;
3180                         }
3181                     }
3182
3183                   if (entry->option == NULL)
3184                     {
3185                       warn (_("Unrecognized debug option '%s'\n"), p);
3186                       p = strchr (p, ',');
3187                       if (p == NULL)
3188                         break;
3189                     }
3190
3191                   if (*p == ',')
3192                     p++;
3193                 }
3194             }
3195           break;
3196 #ifdef SUPPORT_DISASSEMBLY
3197         case 'i':
3198           do_dump++;
3199           section = strtoul (optarg, & cp, 0);
3200           if (! *cp && section >= 0)
3201             request_dump_bynumber (section, DISASS_DUMP);
3202           else
3203             request_dump_byname (optarg, DISASS_DUMP);
3204 #endif
3205         case 'v':
3206           print_version (program_name);
3207           break;
3208         case 'V':
3209           do_version++;
3210           break;
3211         case 'W':
3212           do_wide++;
3213           break;
3214         default:
3215           /* xgettext:c-format */
3216           error (_("Invalid option '-%c'\n"), c);
3217           /* Drop through.  */
3218         case '?':
3219           usage (stderr);
3220         }
3221     }
3222
3223   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3224       && !do_segments && !do_header && !do_dump && !do_version
3225       && !do_histogram && !do_debugging && !do_arch && !do_notes
3226       && !do_section_groups && !do_archive_index)
3227     usage (stderr);
3228   else if (argc < 3)
3229     {
3230       warn (_("Nothing to do.\n"));
3231       usage (stderr);
3232     }
3233 }
3234
3235 static const char *
3236 get_elf_class (unsigned int elf_class)
3237 {
3238   static char buff[32];
3239
3240   switch (elf_class)
3241     {
3242     case ELFCLASSNONE: return _("none");
3243     case ELFCLASS32:   return "ELF32";
3244     case ELFCLASS64:   return "ELF64";
3245     default:
3246       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3247       return buff;
3248     }
3249 }
3250
3251 static const char *
3252 get_data_encoding (unsigned int encoding)
3253 {
3254   static char buff[32];
3255
3256   switch (encoding)
3257     {
3258     case ELFDATANONE: return _("none");
3259     case ELFDATA2LSB: return _("2's complement, little endian");
3260     case ELFDATA2MSB: return _("2's complement, big endian");
3261     default:
3262       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3263       return buff;
3264     }
3265 }
3266
3267 /* Decode the data held in 'elf_header'.  */
3268
3269 static int
3270 process_file_header (void)
3271 {
3272   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
3273       || elf_header.e_ident[EI_MAG1] != ELFMAG1
3274       || elf_header.e_ident[EI_MAG2] != ELFMAG2
3275       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3276     {
3277       error
3278         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3279       return 0;
3280     }
3281
3282   init_dwarf_regnames (elf_header.e_machine);
3283
3284   if (do_header)
3285     {
3286       int i;
3287
3288       printf (_("ELF Header:\n"));
3289       printf (_("  Magic:   "));
3290       for (i = 0; i < EI_NIDENT; i++)
3291         printf ("%2.2x ", elf_header.e_ident[i]);
3292       printf ("\n");
3293       printf (_("  Class:                             %s\n"),
3294               get_elf_class (elf_header.e_ident[EI_CLASS]));
3295       printf (_("  Data:                              %s\n"),
3296               get_data_encoding (elf_header.e_ident[EI_DATA]));
3297       printf (_("  Version:                           %d %s\n"),
3298               elf_header.e_ident[EI_VERSION],
3299               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3300                ? "(current)"
3301                : (elf_header.e_ident[EI_VERSION] != EV_NONE
3302                   ? "<unknown: %lx>"
3303                   : "")));
3304       printf (_("  OS/ABI:                            %s\n"),
3305               get_osabi_name (elf_header.e_ident[EI_OSABI]));
3306       printf (_("  ABI Version:                       %d\n"),
3307               elf_header.e_ident[EI_ABIVERSION]);
3308       printf (_("  Type:                              %s\n"),
3309               get_file_type (elf_header.e_type));
3310       printf (_("  Machine:                           %s\n"),
3311               get_machine_name (elf_header.e_machine));
3312       printf (_("  Version:                           0x%lx\n"),
3313               (unsigned long) elf_header.e_version);
3314
3315       printf (_("  Entry point address:               "));
3316       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3317       printf (_("\n  Start of program headers:          "));
3318       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3319       printf (_(" (bytes into file)\n  Start of section headers:          "));
3320       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3321       printf (_(" (bytes into file)\n"));
3322
3323       printf (_("  Flags:                             0x%lx%s\n"),
3324               (unsigned long) elf_header.e_flags,
3325               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3326       printf (_("  Size of this header:               %ld (bytes)\n"),
3327               (long) elf_header.e_ehsize);
3328       printf (_("  Size of program headers:           %ld (bytes)\n"),
3329               (long) elf_header.e_phentsize);
3330       printf (_("  Number of program headers:         %ld\n"),
3331               (long) elf_header.e_phnum);
3332       printf (_("  Size of section headers:           %ld (bytes)\n"),
3333               (long) elf_header.e_shentsize);
3334       printf (_("  Number of section headers:         %ld"),
3335               (long) elf_header.e_shnum);
3336       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
3337         printf (" (%ld)", (long) section_headers[0].sh_size);
3338       putc ('\n', stdout);
3339       printf (_("  Section header string table index: %ld"),
3340               (long) elf_header.e_shstrndx);
3341       if (section_headers != NULL
3342           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3343         printf (" (%ld)", (long) section_headers[0].sh_link);
3344       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3345         printf (" <corrupt: out of range>");
3346       putc ('\n', stdout);
3347     }
3348
3349   if (section_headers != NULL)
3350     {
3351       if (elf_header.e_shnum == SHN_UNDEF)
3352         elf_header.e_shnum = section_headers[0].sh_size;
3353       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3354         elf_header.e_shstrndx = section_headers[0].sh_link;
3355       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3356         elf_header.e_shstrndx = SHN_UNDEF;
3357       free (section_headers);
3358       section_headers = NULL;
3359     }
3360
3361   return 1;
3362 }
3363
3364
3365 static int
3366 get_32bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers)
3367 {
3368   Elf32_External_Phdr *phdrs;
3369   Elf32_External_Phdr *external;
3370   Elf_Internal_Phdr *internal;
3371   unsigned int i;
3372
3373   phdrs = get_data (NULL, file, elf_header.e_phoff,
3374                     elf_header.e_phentsize, elf_header.e_phnum,
3375                     _("program headers"));
3376   if (!phdrs)
3377     return 0;
3378
3379   for (i = 0, internal = program_headers, external = phdrs;
3380        i < elf_header.e_phnum;
3381        i++, internal++, external++)
3382     {
3383       internal->p_type   = BYTE_GET (external->p_type);
3384       internal->p_offset = BYTE_GET (external->p_offset);
3385       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
3386       internal->p_paddr  = BYTE_GET (external->p_paddr);
3387       internal->p_filesz = BYTE_GET (external->p_filesz);
3388       internal->p_memsz  = BYTE_GET (external->p_memsz);
3389       internal->p_flags  = BYTE_GET (external->p_flags);
3390       internal->p_align  = BYTE_GET (external->p_align);
3391     }
3392
3393   free (phdrs);
3394
3395   return 1;
3396 }
3397
3398 static int
3399 get_64bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers)
3400 {
3401   Elf64_External_Phdr *phdrs;
3402   Elf64_External_Phdr *external;
3403   Elf_Internal_Phdr *internal;
3404   unsigned int i;
3405
3406   phdrs = get_data (NULL, file, elf_header.e_phoff,
3407                     elf_header.e_phentsize, elf_header.e_phnum,
3408                     _("program headers"));
3409   if (!phdrs)
3410     return 0;
3411
3412   for (i = 0, internal = program_headers, external = phdrs;
3413        i < elf_header.e_phnum;
3414        i++, internal++, external++)
3415     {
3416       internal->p_type   = BYTE_GET (external->p_type);
3417       internal->p_flags  = BYTE_GET (external->p_flags);
3418       internal->p_offset = BYTE_GET (external->p_offset);
3419       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
3420       internal->p_paddr  = BYTE_GET (external->p_paddr);
3421       internal->p_filesz = BYTE_GET (external->p_filesz);
3422       internal->p_memsz  = BYTE_GET (external->p_memsz);
3423       internal->p_align  = BYTE_GET (external->p_align);
3424     }
3425
3426   free (phdrs);
3427
3428   return 1;
3429 }
3430
3431 /* Returns 1 if the program headers were read into `program_headers'.  */
3432
3433 static int
3434 get_program_headers (FILE *file)
3435 {
3436   Elf_Internal_Phdr *phdrs;
3437
3438   /* Check cache of prior read.  */
3439   if (program_headers != NULL)
3440     return 1;
3441
3442   phdrs = cmalloc (elf_header.e_phnum, sizeof (Elf_Internal_Phdr));
3443
3444   if (phdrs == NULL)
3445     {
3446       error (_("Out of memory\n"));
3447       return 0;
3448     }
3449
3450   if (is_32bit_elf
3451       ? get_32bit_program_headers (file, phdrs)
3452       : get_64bit_program_headers (file, phdrs))
3453     {
3454       program_headers = phdrs;
3455       return 1;
3456     }
3457
3458   free (phdrs);
3459   return 0;
3460 }
3461
3462 /* Returns 1 if the program headers were loaded.  */
3463
3464 static int
3465 process_program_headers (FILE *file)
3466 {
3467   Elf_Internal_Phdr *segment;
3468   unsigned int i;
3469
3470   if (elf_header.e_phnum == 0)
3471     {
3472       if (do_segments)
3473         printf (_("\nThere are no program headers in this file.\n"));
3474       return 0;
3475     }
3476
3477   if (do_segments && !do_header)
3478     {
3479       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3480       printf (_("Entry point "));
3481       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3482       printf (_("\nThere are %d program headers, starting at offset "),
3483               elf_header.e_phnum);
3484       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3485       printf ("\n");
3486     }
3487
3488   if (! get_program_headers (file))
3489       return 0;
3490
3491   if (do_segments)
3492     {
3493       if (elf_header.e_phnum > 1)
3494         printf (_("\nProgram Headers:\n"));
3495       else
3496         printf (_("\nProgram Headers:\n"));
3497
3498       if (is_32bit_elf)
3499         printf
3500           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
3501       else if (do_wide)
3502         printf
3503           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
3504       else
3505         {
3506           printf
3507             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
3508           printf
3509             (_("                 FileSiz            MemSiz              Flags  Align\n"));
3510         }
3511     }
3512
3513   dynamic_addr = 0;
3514   dynamic_size = 0;
3515
3516   for (i = 0, segment = program_headers;
3517        i < elf_header.e_phnum;
3518        i++, segment++)
3519     {
3520       if (do_segments)
3521         {
3522           printf ("  %-14.14s ", get_segment_type (segment->p_type));
3523
3524           if (is_32bit_elf)
3525             {
3526               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3527               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3528               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3529               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3530               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3531               printf ("%c%c%c ",
3532                       (segment->p_flags & PF_R ? 'R' : ' '),
3533                       (segment->p_flags & PF_W ? 'W' : ' '),
3534                       (segment->p_flags & PF_X ? 'E' : ' '));
3535               printf ("%#lx", (unsigned long) segment->p_align);
3536             }
3537           else if (do_wide)
3538             {
3539               if ((unsigned long) segment->p_offset == segment->p_offset)
3540                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3541               else
3542                 {
3543                   print_vma (segment->p_offset, FULL_HEX);
3544                   putchar (' ');
3545                 }
3546
3547               print_vma (segment->p_vaddr, FULL_HEX);
3548               putchar (' ');
3549               print_vma (segment->p_paddr, FULL_HEX);
3550               putchar (' ');
3551
3552               if ((unsigned long) segment->p_filesz == segment->p_filesz)
3553                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3554               else
3555                 {
3556                   print_vma (segment->p_filesz, FULL_HEX);
3557                   putchar (' ');
3558                 }
3559
3560               if ((unsigned long) segment->p_memsz == segment->p_memsz)
3561                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3562               else
3563                 {
3564                   print_vma (segment->p_offset, FULL_HEX);
3565                 }
3566
3567               printf (" %c%c%c ",
3568                       (segment->p_flags & PF_R ? 'R' : ' '),
3569                       (segment->p_flags & PF_W ? 'W' : ' '),
3570                       (segment->p_flags & PF_X ? 'E' : ' '));
3571
3572               if ((unsigned long) segment->p_align == segment->p_align)
3573                 printf ("%#lx", (unsigned long) segment->p_align);
3574               else
3575                 {
3576                   print_vma (segment->p_align, PREFIX_HEX);
3577                 }
3578             }
3579           else
3580             {
3581               print_vma (segment->p_offset, FULL_HEX);
3582               putchar (' ');
3583               print_vma (segment->p_vaddr, FULL_HEX);
3584               putchar (' ');
3585               print_vma (segment->p_paddr, FULL_HEX);
3586               printf ("\n                 ");
3587               print_vma (segment->p_filesz, FULL_HEX);
3588               putchar (' ');
3589               print_vma (segment->p_memsz, FULL_HEX);
3590               printf ("  %c%c%c    ",
3591                       (segment->p_flags & PF_R ? 'R' : ' '),
3592                       (segment->p_flags & PF_W ? 'W' : ' '),
3593                       (segment->p_flags & PF_X ? 'E' : ' '));
3594               print_vma (segment->p_align, HEX);
3595             }
3596         }
3597
3598       switch (segment->p_type)
3599         {
3600         case PT_DYNAMIC:
3601           if (dynamic_addr)
3602             error (_("more than one dynamic segment\n"));
3603
3604           /* By default, assume that the .dynamic section is the first
3605              section in the DYNAMIC segment.  */
3606           dynamic_addr = segment->p_offset;
3607           dynamic_size = segment->p_filesz;
3608
3609           /* Try to locate the .dynamic section. If there is
3610              a section header table, we can easily locate it.  */
3611           if (section_headers != NULL)
3612             {
3613               Elf_Internal_Shdr *sec;
3614
3615               sec = find_section (".dynamic");
3616               if (sec == NULL || sec->sh_size == 0)
3617                 {
3618                   error (_("no .dynamic section in the dynamic segment\n"));
3619                   break;
3620                 }
3621
3622               if (sec->sh_type == SHT_NOBITS)
3623                 {
3624                   dynamic_size = 0;
3625                   break;
3626                 }
3627
3628               dynamic_addr = sec->sh_offset;
3629               dynamic_size = sec->sh_size;
3630
3631               if (dynamic_addr < segment->p_offset
3632                   || dynamic_addr > segment->p_offset + segment->p_filesz)
3633                 warn (_("the .dynamic section is not contained"
3634                         " within the dynamic segment\n"));
3635               else if (dynamic_addr > segment->p_offset)
3636                 warn (_("the .dynamic section is not the first section"
3637                         " in the dynamic segment.\n"));
3638             }
3639           break;
3640
3641         case PT_INTERP:
3642           if (fseek (file, archive_file_offset + (long) segment->p_offset,
3643                      SEEK_SET))
3644             error (_("Unable to find program interpreter name\n"));
3645           else
3646             {
3647               char fmt [32];
3648               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3649
3650               if (ret >= (int) sizeof (fmt) || ret < 0)
3651                 error (_("Internal error: failed to create format string to display program interpreter\n"));
3652
3653               program_interpreter[0] = 0;
3654               if (fscanf (file, fmt, program_interpreter) <= 0)
3655                 error (_("Unable to read program interpreter name\n"));
3656
3657               if (do_segments)
3658                 printf (_("\n      [Requesting program interpreter: %s]"),
3659                     program_interpreter);
3660             }
3661           break;
3662         }
3663
3664       if (do_segments)
3665         putc ('\n', stdout);
3666     }
3667
3668   if (do_segments && section_headers != NULL && string_table != NULL)
3669     {
3670       printf (_("\n Section to Segment mapping:\n"));
3671       printf (_("  Segment Sections...\n"));
3672
3673       for (i = 0; i < elf_header.e_phnum; i++)
3674         {
3675           unsigned int j;
3676           Elf_Internal_Shdr *section;
3677
3678           segment = program_headers + i;
3679           section = section_headers;
3680
3681           printf ("   %2.2d     ", i);
3682
3683           for (j = 1; j < elf_header.e_shnum; j++, section++)
3684             {
3685               if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section, segment))
3686                 printf ("%s ", SECTION_NAME (section));
3687             }
3688
3689           putc ('\n',stdout);
3690         }
3691     }
3692
3693   return 1;
3694 }
3695
3696
3697 /* Find the file offset corresponding to VMA by using the program headers.  */
3698
3699 static long
3700 offset_from_vma (FILE *file, bfd_vma vma, bfd_size_type size)
3701 {
3702   Elf_Internal_Phdr *seg;
3703
3704   if (! get_program_headers (file))
3705     {
3706       warn (_("Cannot interpret virtual addresses without program headers.\n"));
3707       return (long) vma;
3708     }
3709
3710   for (seg = program_headers;
3711        seg < program_headers + elf_header.e_phnum;
3712        ++seg)
3713     {
3714       if (seg->p_type != PT_LOAD)
3715         continue;
3716
3717       if (vma >= (seg->p_vaddr & -seg->p_align)
3718           && vma + size <= seg->p_vaddr + seg->p_filesz)
3719         return vma - seg->p_vaddr + seg->p_offset;
3720     }
3721
3722   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3723         (long) vma);
3724   return (long) vma;
3725 }
3726
3727
3728 static int
3729 get_32bit_section_headers (FILE *file, unsigned int num)
3730 {
3731   Elf32_External_Shdr *shdrs;
3732   Elf_Internal_Shdr *internal;
3733   unsigned int i;
3734
3735   shdrs = get_data (NULL, file, elf_header.e_shoff,
3736                     elf_header.e_shentsize, num, _("section headers"));
3737   if (!shdrs)
3738     return 0;
3739
3740   section_headers = cmalloc (num, sizeof (Elf_Internal_Shdr));
3741
3742   if (section_headers == NULL)
3743     {
3744       error (_("Out of memory\n"));
3745       return 0;
3746     }
3747
3748   for (i = 0, internal = section_headers;
3749        i < num;
3750        i++, internal++)
3751     {
3752       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
3753       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
3754       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
3755       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
3756       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
3757       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
3758       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
3759       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
3760       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3761       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
3762     }
3763
3764   free (shdrs);
3765
3766   return 1;
3767 }
3768
3769 static int
3770 get_64bit_section_headers (FILE *file, unsigned int num)
3771 {
3772   Elf64_External_Shdr *shdrs;
3773   Elf_Internal_Shdr *internal;
3774   unsigned int i;
3775
3776   shdrs = get_data (NULL, file, elf_header.e_shoff,
3777                     elf_header.e_shentsize, num, _("section headers"));
3778   if (!shdrs)
3779     return 0;
3780
3781   section_headers = cmalloc (num, sizeof (Elf_Internal_Shdr));
3782
3783   if (section_headers == NULL)
3784     {
3785       error (_("Out of memory\n"));
3786       return 0;
3787     }
3788
3789   for (i = 0, internal = section_headers;
3790        i < num;
3791        i++, internal++)
3792     {
3793       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
3794       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
3795       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
3796       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
3797       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
3798       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
3799       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
3800       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
3801       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
3802       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3803     }
3804
3805   free (shdrs);
3806
3807   return 1;
3808 }
3809
3810 static Elf_Internal_Sym *
3811 get_32bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
3812 {
3813   unsigned long number;
3814   Elf32_External_Sym *esyms;
3815   Elf_External_Sym_Shndx *shndx;
3816   Elf_Internal_Sym *isyms;
3817   Elf_Internal_Sym *psym;
3818   unsigned int j;
3819
3820   esyms = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
3821                     _("symbols"));
3822   if (!esyms)
3823     return NULL;
3824
3825   shndx = NULL;
3826   if (symtab_shndx_hdr != NULL
3827       && (symtab_shndx_hdr->sh_link
3828           == (unsigned long) (section - section_headers)))
3829     {
3830       shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3831                         1, symtab_shndx_hdr->sh_size, _("symtab shndx"));
3832       if (!shndx)
3833         {
3834           free (esyms);
3835           return NULL;
3836         }
3837     }
3838
3839   number = section->sh_size / section->sh_entsize;
3840   isyms = cmalloc (number, sizeof (Elf_Internal_Sym));
3841
3842   if (isyms == NULL)
3843     {
3844       error (_("Out of memory\n"));
3845       if (shndx)
3846         free (shndx);
3847       free (esyms);
3848       return NULL;
3849     }
3850
3851   for (j = 0, psym = isyms;
3852        j < number;
3853        j++, psym++)
3854     {
3855       psym->st_name  = BYTE_GET (esyms[j].st_name);
3856       psym->st_value = BYTE_GET (esyms[j].st_value);
3857       psym->st_size  = BYTE_GET (esyms[j].st_size);
3858       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3859       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
3860         psym->st_shndx
3861           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3862       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
3863         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
3864       psym->st_info  = BYTE_GET (esyms[j].st_info);
3865       psym->st_other = BYTE_GET (esyms[j].st_other);
3866     }
3867
3868   if (shndx)
3869     free (shndx);
3870   free (esyms);
3871
3872   return isyms;
3873 }
3874
3875 static Elf_Internal_Sym *
3876 get_64bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
3877 {
3878   unsigned long number;
3879   Elf64_External_Sym *esyms;
3880   Elf_External_Sym_Shndx *shndx;
3881   Elf_Internal_Sym *isyms;
3882   Elf_Internal_Sym *psym;
3883   unsigned int j;
3884
3885   esyms = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
3886                     _("symbols"));
3887   if (!esyms)
3888     return NULL;
3889
3890   shndx = NULL;
3891   if (symtab_shndx_hdr != NULL
3892       && (symtab_shndx_hdr->sh_link
3893           == (unsigned long) (section - section_headers)))
3894     {
3895       shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3896                         1, symtab_shndx_hdr->sh_size, _("symtab shndx"));
3897       if (!shndx)
3898         {
3899           free (esyms);
3900           return NULL;
3901         }
3902     }
3903
3904   number = section->sh_size / section->sh_entsize;
3905   isyms = cmalloc (number, sizeof (Elf_Internal_Sym));
3906
3907   if (isyms == NULL)
3908     {
3909       error (_("Out of memory\n"));
3910       if (shndx)
3911         free (shndx);
3912       free (esyms);
3913       return NULL;
3914     }
3915
3916   for (j = 0, psym = isyms;
3917        j < number;
3918        j++, psym++)
3919     {
3920       psym->st_name  = BYTE_GET (esyms[j].st_name);
3921       psym->st_info  = BYTE_GET (esyms[j].st_info);
3922       psym->st_other = BYTE_GET (esyms[j].st_other);
3923       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3924       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
3925         psym->st_shndx
3926           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3927       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
3928         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
3929       psym->st_value = BYTE_GET (esyms[j].st_value);
3930       psym->st_size  = BYTE_GET (esyms[j].st_size);
3931     }
3932
3933   if (shndx)
3934     free (shndx);
3935   free (esyms);
3936
3937   return isyms;
3938 }
3939
3940 static const char *
3941 get_elf_section_flags (bfd_vma sh_flags)
3942 {
3943   static char buff[1024];
3944   char *p = buff;
3945   int field_size = is_32bit_elf ? 8 : 16;
3946   int index, size = sizeof (buff) - (field_size + 4 + 1);
3947   bfd_vma os_flags = 0;
3948   bfd_vma proc_flags = 0;
3949   bfd_vma unknown_flags = 0;
3950   static const struct
3951     {
3952       const char *str;
3953       int len;
3954     }
3955   flags [] =
3956     {
3957         { "WRITE", 5 },
3958         { "ALLOC", 5 },
3959         { "EXEC", 4 },
3960         { "MERGE", 5 },
3961         { "STRINGS", 7 },
3962         { "INFO LINK", 9 },
3963         { "LINK ORDER", 10 },
3964         { "OS NONCONF", 10 },
3965         { "GROUP", 5 },
3966         { "TLS", 3 },
3967         /* IA-64 specific.  */
3968         { "SHORT", 5 },
3969         { "NORECOV", 7 },
3970         /* IA-64 OpenVMS specific.  */
3971         { "VMS_GLOBAL", 10 },
3972         { "VMS_OVERLAID", 12 },
3973         { "VMS_SHARED", 10 },
3974         { "VMS_VECTOR", 10 },
3975         { "VMS_ALLOC_64BIT", 15 },
3976         { "VMS_PROTECTED", 13}
3977     };
3978
3979   if (do_section_details)
3980     {
3981       sprintf (buff, "[%*.*lx]: ",
3982                field_size, field_size, (unsigned long) sh_flags);
3983       p += field_size + 4;
3984     }
3985
3986   while (sh_flags)
3987     {
3988       bfd_vma flag;
3989
3990       flag = sh_flags & - sh_flags;
3991       sh_flags &= ~ flag;
3992
3993       if (do_section_details)
3994         {
3995           switch (flag)
3996             {
3997             case SHF_WRITE:             index = 0; break;
3998             case SHF_ALLOC:             index = 1; break;
3999             case SHF_EXECINSTR:         index = 2; break;
4000             case SHF_MERGE:             index = 3; break;
4001             case SHF_STRINGS:           index = 4; break;
4002             case SHF_INFO_LINK:         index = 5; break;
4003             case SHF_LINK_ORDER:        index = 6; break;
4004             case SHF_OS_NONCONFORMING:  index = 7; break;
4005             case SHF_GROUP:             index = 8; break;
4006             case SHF_TLS:               index = 9; break;
4007
4008             default:
4009               index = -1;
4010               if (elf_header.e_machine == EM_IA_64)
4011                 {
4012                   if (flag == SHF_IA_64_SHORT)
4013                     index = 10;
4014                   else if (flag == SHF_IA_64_NORECOV)
4015                     index = 11;
4016 #ifdef BFD64
4017                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4018                     switch (flag)
4019                       {
4020                       case SHF_IA_64_VMS_GLOBAL:      index = 12; break;
4021                       case SHF_IA_64_VMS_OVERLAID:    index = 13; break;
4022                       case SHF_IA_64_VMS_SHARED:      index = 14; break;
4023                       case SHF_IA_64_VMS_VECTOR:      index = 15; break;
4024                       case SHF_IA_64_VMS_ALLOC_64BIT: index = 16; break;
4025                       case SHF_IA_64_VMS_PROTECTED:   index = 17; break;
4026                       default:                        break;
4027                       }
4028 #endif
4029                 }
4030               break;
4031             }
4032
4033           if (index != -1)
4034             {
4035               if (p != buff + field_size + 4)
4036                 {
4037                   if (size < (10 + 2))
4038                     abort ();
4039                   size -= 2;
4040                   *p++ = ',';
4041                   *p++ = ' ';
4042                 }
4043
4044               size -= flags [index].len;
4045               p = stpcpy (p, flags [index].str);
4046             }
4047           else if (flag & SHF_MASKOS)
4048             os_flags |= flag;
4049           else if (flag & SHF_MASKPROC)
4050             proc_flags |= flag;
4051           else
4052             unknown_flags |= flag;
4053         }
4054       else
4055         {
4056           switch (flag)
4057             {
4058             case SHF_WRITE:             *p = 'W'; break;
4059             case SHF_ALLOC:             *p = 'A'; break;
4060             case SHF_EXECINSTR:         *p = 'X'; break;
4061             case SHF_MERGE:             *p = 'M'; break;
4062             case SHF_STRINGS:           *p = 'S'; break;
4063             case SHF_INFO_LINK:         *p = 'I'; break;
4064             case SHF_LINK_ORDER:        *p = 'L'; break;
4065             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
4066             case SHF_GROUP:             *p = 'G'; break;
4067             case SHF_TLS:               *p = 'T'; break;
4068
4069             default:
4070               if (elf_header.e_machine == EM_X86_64
4071                   && flag == SHF_X86_64_LARGE)
4072                 *p = 'l';
4073               else if (flag & SHF_MASKOS)
4074                 {
4075                   *p = 'o';
4076                   sh_flags &= ~ SHF_MASKOS;
4077                 }
4078               else if (flag & SHF_MASKPROC)
4079                 {
4080                   *p = 'p';
4081                   sh_flags &= ~ SHF_MASKPROC;
4082                 }
4083               else
4084                 *p = 'x';
4085               break;
4086             }
4087           p++;
4088         }
4089     }
4090
4091   if (do_section_details)
4092     {
4093       if (os_flags)
4094         {
4095           size -= 5 + field_size;
4096           if (p != buff + field_size + 4)
4097             {
4098               if (size < (2 + 1))
4099                 abort ();
4100               size -= 2;
4101               *p++ = ',';
4102               *p++ = ' ';
4103             }
4104           sprintf (p, "OS (%*.*lx)", field_size, field_size,
4105                    (unsigned long) os_flags);
4106           p += 5 + field_size;
4107         }
4108       if (proc_flags)
4109         {
4110           size -= 7 + field_size;
4111           if (p != buff + field_size + 4)
4112             {
4113               if (size < (2 + 1))
4114                 abort ();
4115               size -= 2;
4116               *p++ = ',';
4117               *p++ = ' ';
4118             }
4119           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4120                    (unsigned long) proc_flags);
4121           p += 7 + field_size;
4122         }
4123       if (unknown_flags)
4124         {
4125           size -= 10 + field_size;
4126           if (p != buff + field_size + 4)
4127             {
4128               if (size < (2 + 1))
4129                 abort ();
4130               size -= 2;
4131               *p++ = ',';
4132               *p++ = ' ';
4133             }
4134           sprintf (p, "UNKNOWN (%*.*lx)", field_size, field_size,
4135                    (unsigned long) unknown_flags);
4136           p += 10 + field_size;
4137         }
4138     }
4139
4140   *p = '\0';
4141   return buff;
4142 }
4143
4144 static int
4145 process_section_headers (FILE *file)
4146 {
4147   Elf_Internal_Shdr *section;
4148   unsigned int i;
4149
4150   section_headers = NULL;
4151
4152   if (elf_header.e_shnum == 0)
4153     {
4154       if (do_sections)
4155         printf (_("\nThere are no sections in this file.\n"));
4156
4157       return 1;
4158     }
4159
4160   if (do_sections && !do_header)
4161     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4162             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4163
4164   if (is_32bit_elf)
4165     {
4166       if (! get_32bit_section_headers (file, elf_header.e_shnum))
4167         return 0;
4168     }
4169   else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4170     return 0;
4171
4172   /* Read in the string table, so that we have names to display.  */
4173   if (elf_header.e_shstrndx != SHN_UNDEF
4174        && elf_header.e_shstrndx < elf_header.e_shnum)
4175     {
4176       section = section_headers + elf_header.e_shstrndx;
4177
4178       if (section->sh_size != 0)
4179         {
4180           string_table = get_data (NULL, file, section->sh_offset,
4181                                    1, section->sh_size, _("string table"));
4182
4183           string_table_length = string_table != NULL ? section->sh_size : 0;
4184         }
4185     }
4186
4187   /* Scan the sections for the dynamic symbol table
4188      and dynamic string table and debug sections.  */
4189   dynamic_symbols = NULL;
4190   dynamic_strings = NULL;
4191   dynamic_syminfo = NULL;
4192   symtab_shndx_hdr = NULL;
4193
4194   eh_addr_size = is_32bit_elf ? 4 : 8;
4195   switch (elf_header.e_machine)
4196     {
4197     case EM_MIPS:
4198     case EM_MIPS_RS3_LE:
4199       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4200          FDE addresses.  However, the ABI also has a semi-official ILP32
4201          variant for which the normal FDE address size rules apply.
4202
4203          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4204          section, where XX is the size of longs in bits.  Unfortunately,
4205          earlier compilers provided no way of distinguishing ILP32 objects
4206          from LP64 objects, so if there's any doubt, we should assume that
4207          the official LP64 form is being used.  */
4208       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4209           && find_section (".gcc_compiled_long32") == NULL)
4210         eh_addr_size = 8;
4211       break;
4212
4213     case EM_H8_300:
4214     case EM_H8_300H:
4215       switch (elf_header.e_flags & EF_H8_MACH)
4216         {
4217         case E_H8_MACH_H8300:
4218         case E_H8_MACH_H8300HN:
4219         case E_H8_MACH_H8300SN:
4220         case E_H8_MACH_H8300SXN:
4221           eh_addr_size = 2;
4222           break;
4223         case E_H8_MACH_H8300H:
4224         case E_H8_MACH_H8300S:
4225         case E_H8_MACH_H8300SX:
4226           eh_addr_size = 4;
4227           break;
4228         }
4229       break;
4230
4231     case EM_M32C:
4232       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4233         {
4234         case EF_M32C_CPU_M16C:
4235           eh_addr_size = 2;
4236           break;
4237         }
4238       break;
4239     }
4240
4241 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4242   do                                                                        \
4243     {                                                                       \
4244       size_t expected_entsize                                               \
4245         = is_32bit_elf ? size32 : size64;                                   \
4246       if (section->sh_entsize != expected_entsize)                          \
4247         error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4248                i, (unsigned long int) section->sh_entsize,                  \
4249                (unsigned long int) expected_entsize);                       \
4250       section->sh_entsize = expected_entsize;                               \
4251     }                                                                       \
4252   while (0)
4253 #define CHECK_ENTSIZE(section, i, type) \
4254   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
4255                         sizeof (Elf64_External_##type))
4256
4257   for (i = 0, section = section_headers;
4258        i < elf_header.e_shnum;
4259        i++, section++)
4260     {
4261       char *name = SECTION_NAME (section);
4262
4263       if (section->sh_type == SHT_DYNSYM)
4264         {
4265           if (dynamic_symbols != NULL)
4266             {
4267               error (_("File contains multiple dynamic symbol tables\n"));
4268               continue;
4269             }
4270
4271           CHECK_ENTSIZE (section, i, Sym);
4272           num_dynamic_syms = section->sh_size / section->sh_entsize;
4273           dynamic_symbols = GET_ELF_SYMBOLS (file, section);
4274         }
4275       else if (section->sh_type == SHT_STRTAB
4276                && streq (name, ".dynstr"))
4277         {
4278           if (dynamic_strings != NULL)
4279             {
4280               error (_("File contains multiple dynamic string tables\n"));
4281               continue;
4282             }
4283
4284           dynamic_strings = get_data (NULL, file, section->sh_offset,
4285                                       1, section->sh_size, _("dynamic strings"));
4286           dynamic_strings_length = section->sh_size;
4287         }
4288       else if (section->sh_type == SHT_SYMTAB_SHNDX)
4289         {
4290           if (symtab_shndx_hdr != NULL)
4291             {
4292               error (_("File contains multiple symtab shndx tables\n"));
4293               continue;
4294             }
4295           symtab_shndx_hdr = section;
4296         }
4297       else if (section->sh_type == SHT_SYMTAB)
4298         CHECK_ENTSIZE (section, i, Sym);
4299       else if (section->sh_type == SHT_GROUP)
4300         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4301       else if (section->sh_type == SHT_REL)
4302         CHECK_ENTSIZE (section, i, Rel);
4303       else if (section->sh_type == SHT_RELA)
4304         CHECK_ENTSIZE (section, i, Rela);
4305       else if ((do_debugging || do_debug_info || do_debug_abbrevs
4306                 || do_debug_lines || do_debug_pubnames || do_debug_aranges
4307                 || do_debug_frames || do_debug_macinfo || do_debug_str
4308                 || do_debug_loc || do_debug_ranges)
4309                && const_strneq (name, ".debug_"))
4310         {
4311           name += 7;
4312
4313           if (do_debugging
4314               || (do_debug_info     && streq (name, "info"))
4315               || (do_debug_abbrevs  && streq (name, "abbrev"))
4316               || (do_debug_lines    && streq (name, "line"))
4317               || (do_debug_pubnames && streq (name, "pubnames"))
4318               || (do_debug_aranges  && streq (name, "aranges"))
4319               || (do_debug_ranges   && streq (name, "ranges"))
4320               || (do_debug_frames   && streq (name, "frame"))
4321               || (do_debug_macinfo  && streq (name, "macinfo"))
4322               || (do_debug_str      && streq (name, "str"))
4323               || (do_debug_loc      && streq (name, "loc"))
4324               )
4325             request_dump_bynumber (i, DEBUG_DUMP);
4326         }
4327       /* linkonce section to be combined with .debug_info at link time.  */
4328       else if ((do_debugging || do_debug_info)
4329                && const_strneq (name, ".gnu.linkonce.wi."))
4330         request_dump_bynumber (i, DEBUG_DUMP);
4331       else if (do_debug_frames && streq (name, ".eh_frame"))
4332         request_dump_bynumber (i, DEBUG_DUMP);
4333     }
4334
4335   if (! do_sections)
4336     return 1;
4337
4338   if (elf_header.e_shnum > 1)
4339     printf (_("\nSection Headers:\n"));
4340   else
4341     printf (_("\nSection Header:\n"));
4342
4343   if (is_32bit_elf)
4344     {
4345       if (do_section_details)
4346         {
4347           printf (_("  [Nr] Name\n"));
4348           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
4349         }
4350       else
4351         printf
4352           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
4353     }
4354   else if (do_wide)
4355     {
4356       if (do_section_details)
4357         {
4358           printf (_("  [Nr] Name\n"));
4359           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
4360         }
4361       else
4362         printf
4363           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
4364     }
4365   else
4366     {
4367       if (do_section_details)
4368         {
4369           printf (_("  [Nr] Name\n"));
4370           printf (_("       Type              Address          Offset            Link\n"));
4371           printf (_("       Size              EntSize          Info              Align\n"));
4372         }
4373       else
4374         {
4375           printf (_("  [Nr] Name              Type             Address           Offset\n"));
4376           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
4377         }
4378     }
4379
4380   if (do_section_details)
4381     printf (_("       Flags\n"));
4382
4383   for (i = 0, section = section_headers;
4384        i < elf_header.e_shnum;
4385        i++, section++)
4386     {
4387       if (do_section_details)
4388         {
4389           printf ("  [%2u] %s\n",
4390                   i,
4391                   SECTION_NAME (section));
4392           if (is_32bit_elf || do_wide)
4393             printf ("       %-15.15s ",
4394                     get_section_type_name (section->sh_type));
4395         }
4396       else
4397         printf ("  [%2u] %-17.17s %-15.15s ",
4398                 i,
4399                 SECTION_NAME (section),
4400                 get_section_type_name (section->sh_type));
4401
4402       if (is_32bit_elf)
4403         {
4404           print_vma (section->sh_addr, LONG_HEX);
4405
4406           printf ( " %6.6lx %6.6lx %2.2lx",
4407                    (unsigned long) section->sh_offset,
4408                    (unsigned long) section->sh_size,
4409                    (unsigned long) section->sh_entsize);
4410
4411           if (do_section_details)
4412             fputs ("  ", stdout);
4413           else
4414             printf (" %3s ", get_elf_section_flags (section->sh_flags));
4415
4416           printf ("%2ld %3lu %2ld\n",
4417                   (unsigned long) section->sh_link,
4418                   (unsigned long) section->sh_info,
4419                   (unsigned long) section->sh_addralign);
4420         }
4421       else if (do_wide)
4422         {
4423           print_vma (section->sh_addr, LONG_HEX);
4424
4425           if ((long) section->sh_offset == section->sh_offset)
4426             printf (" %6.6lx", (unsigned long) section->sh_offset);
4427           else
4428             {
4429               putchar (' ');
4430               print_vma (section->sh_offset, LONG_HEX);
4431             }
4432
4433           if ((unsigned long) section->sh_size == section->sh_size)
4434             printf (" %6.6lx", (unsigned long) section->sh_size);
4435           else
4436             {
4437               putchar (' ');
4438               print_vma (section->sh_size, LONG_HEX);
4439             }
4440
4441           if ((unsigned long) section->sh_entsize == section->sh_entsize)
4442             printf (" %2.2lx", (unsigned long) section->sh_entsize);
4443           else
4444             {
4445               putchar (' ');
4446               print_vma (section->sh_entsize, LONG_HEX);
4447             }
4448
4449           if (do_section_details)
4450             fputs ("  ", stdout);
4451           else
4452             printf (" %3s ", get_elf_section_flags (section->sh_flags));
4453
4454           printf ("%2ld %3lu ",
4455                   (unsigned long) section->sh_link,
4456                   (unsigned long) section->sh_info);
4457
4458           if ((unsigned long) section->sh_addralign == section->sh_addralign)
4459             printf ("%2ld\n", (unsigned long) section->sh_addralign);
4460           else
4461             {
4462               print_vma (section->sh_addralign, DEC);
4463               putchar ('\n');
4464             }
4465         }
4466       else if (do_section_details)
4467         {
4468           printf ("       %-15.15s  ",
4469                   get_section_type_name (section->sh_type));
4470           print_vma (section->sh_addr, LONG_HEX);
4471           if ((long) section->sh_offset == section->sh_offset)
4472             printf ("  %16.16lx", (unsigned long) section->sh_offset);
4473           else
4474             {
4475               printf ("  ");
4476               print_vma (section->sh_offset, LONG_HEX);
4477             }
4478           printf ("  %ld\n       ", (unsigned long) section->sh_link);
4479           print_vma (section->sh_size, LONG_HEX);
4480           putchar (' ');
4481           print_vma (section->sh_entsize, LONG_HEX);
4482
4483           printf ("  %-16lu  %ld\n",
4484                   (unsigned long) section->sh_info,
4485                   (unsigned long) section->sh_addralign);
4486         }
4487       else
4488         {
4489           putchar (' ');
4490           print_vma (section->sh_addr, LONG_HEX);
4491           if ((long) section->sh_offset == section->sh_offset)
4492             printf ("  %8.8lx", (unsigned long) section->sh_offset);
4493           else
4494             {
4495               printf ("  ");
4496               print_vma (section->sh_offset, LONG_HEX);
4497             }
4498           printf ("\n       ");
4499           print_vma (section->sh_size, LONG_HEX);
4500           printf ("  ");
4501           print_vma (section->sh_entsize, LONG_HEX);
4502
4503           printf (" %3s ", get_elf_section_flags (section->sh_flags));
4504
4505           printf ("     %2ld   %3lu     %ld\n",
4506                   (unsigned long) section->sh_link,
4507                   (unsigned long) section->sh_info,
4508                   (unsigned long) section->sh_addralign);
4509         }
4510
4511       if (do_section_details)
4512         printf ("       %s\n", get_elf_section_flags (section->sh_flags));
4513     }
4514
4515   if (!do_section_details)
4516     printf (_("Key to Flags:\n\
4517   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4518   I (info), L (link order), G (group), x (unknown)\n\
4519   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4520
4521   return 1;
4522 }
4523
4524 static const char *
4525 get_group_flags (unsigned int flags)
4526 {
4527   static char buff[32];
4528   switch (flags)
4529     {
4530     case GRP_COMDAT:
4531       return "COMDAT";
4532
4533    default:
4534       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x]"), flags);
4535       break;
4536     }
4537   return buff;
4538 }
4539
4540 static int
4541 process_section_groups (FILE *file)
4542 {
4543   Elf_Internal_Shdr *section;
4544   unsigned int i;
4545   struct group *group;
4546   Elf_Internal_Shdr *symtab_sec, *strtab_sec;
4547   Elf_Internal_Sym *symtab;
4548   char *strtab;
4549   size_t strtab_size;
4550
4551   /* Don't process section groups unless needed.  */
4552   if (!do_unwind && !do_section_groups)
4553     return 1;
4554
4555   if (elf_header.e_shnum == 0)
4556     {
4557       if (do_section_groups)
4558         printf (_("\nThere are no sections in this file.\n"));
4559
4560       return 1;
4561     }
4562
4563   if (section_headers == NULL)
4564     {
4565       error (_("Section headers are not available!\n"));
4566       abort ();
4567     }
4568
4569   section_headers_groups = calloc (elf_header.e_shnum,
4570                                    sizeof (struct group *));
4571
4572   if (section_headers_groups == NULL)
4573     {
4574       error (_("Out of memory\n"));
4575       return 0;
4576     }
4577
4578   /* Scan the sections for the group section.  */
4579   group_count = 0;
4580   for (i = 0, section = section_headers;
4581        i < elf_header.e_shnum;
4582        i++, section++)
4583     if (section->sh_type == SHT_GROUP)
4584       group_count++;
4585
4586   if (group_count == 0)
4587     {
4588       if (do_section_groups)
4589         printf (_("\nThere are no section groups in this file.\n"));
4590
4591       return 1;
4592     }
4593
4594   section_groups = calloc (group_count, sizeof (struct group));
4595
4596   if (section_groups == NULL)
4597     {
4598       error (_("Out of memory\n"));
4599       return 0;
4600     }
4601
4602   symtab_sec = NULL;
4603   strtab_sec = NULL;
4604   symtab = NULL;
4605   strtab = NULL;
4606   strtab_size = 0;
4607   for (i = 0, section = section_headers, group = section_groups;
4608        i < elf_header.e_shnum;
4609        i++, section++)
4610     {
4611       if (section->sh_type == SHT_GROUP)
4612         {
4613           char *name = SECTION_NAME (section);
4614           char *group_name;
4615           unsigned char *start, *indices;
4616           unsigned int entry, j, size;
4617           Elf_Internal_Shdr *sec;
4618           Elf_Internal_Sym *sym;
4619
4620           /* Get the symbol table.  */
4621           if (section->sh_link >= elf_header.e_shnum
4622               || ((sec = section_headers + section->sh_link)->sh_type
4623                   != SHT_SYMTAB))
4624             {
4625               error (_("Bad sh_link in group section `%s'\n"), name);
4626               continue;
4627             }
4628
4629           if (symtab_sec != sec)
4630             {
4631               symtab_sec = sec;
4632               if (symtab)
4633                 free (symtab);
4634               symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4635             }
4636
4637           sym = symtab + section->sh_info;
4638
4639           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4640             {
4641               if (sym->st_shndx == 0
4642                   || sym->st_shndx >= elf_header.e_shnum)
4643                 {
4644                   error (_("Bad sh_info in group section `%s'\n"), name);
4645                   continue;
4646                 }
4647
4648               group_name = SECTION_NAME (section_headers + sym->st_shndx);
4649               strtab_sec = NULL;
4650               if (strtab)
4651                 free (strtab);
4652               strtab = NULL;
4653               strtab_size = 0;
4654             }
4655           else
4656             {
4657               /* Get the string table.  */
4658               if (symtab_sec->sh_link >= elf_header.e_shnum)
4659                 {
4660                   strtab_sec = NULL;
4661                   if (strtab)
4662                     free (strtab);
4663                   strtab = NULL;
4664                   strtab_size = 0;
4665                 }
4666               else if (strtab_sec
4667                        != (sec = section_headers + symtab_sec->sh_link))
4668                 {
4669                   strtab_sec = sec;
4670                   if (strtab)
4671                     free (strtab);
4672                   strtab = get_data (NULL, file, strtab_sec->sh_offset,
4673                                      1, strtab_sec->sh_size,
4674                                      _("string table"));
4675                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
4676                 }
4677               group_name = sym->st_name < strtab_size
4678                            ? strtab + sym->st_name : "<corrupt>";
4679             }
4680
4681           start = get_data (NULL, file, section->sh_offset,
4682                             1, section->sh_size, _("section data"));
4683
4684           indices = start;
4685           size = (section->sh_size / section->sh_entsize) - 1;
4686           entry = byte_get (indices, 4);
4687           indices += 4;
4688
4689           if (do_section_groups)
4690             {
4691               printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4692                       get_group_flags (entry), i, name, group_name, size);
4693
4694               printf (_("   [Index]    Name\n"));
4695             }
4696
4697           group->group_index = i;
4698
4699           for (j = 0; j < size; j++)
4700             {
4701               struct group_list *g;
4702
4703               entry = byte_get (indices, 4);
4704               indices += 4;
4705
4706               if (entry >= elf_header.e_shnum)
4707                 {
4708                   error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4709                          entry, i, elf_header.e_shnum - 1);
4710                   continue;
4711                 }
4712
4713               if (section_headers_groups [entry] != NULL)
4714                 {
4715                   if (entry)
4716                     {
4717                       error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4718                              entry, i,
4719                              section_headers_groups [entry]->group_index);
4720                       continue;
4721                     }
4722                   else
4723                     {
4724                       /* Intel C/C++ compiler may put section 0 in a
4725                          section group. We just warn it the first time
4726                          and ignore it afterwards.  */
4727                       static int warned = 0;
4728                       if (!warned)
4729                         {
4730                           error (_("section 0 in group section [%5u]\n"),
4731                                  section_headers_groups [entry]->group_index);
4732                           warned++;
4733                         }
4734                     }
4735                 }
4736
4737               section_headers_groups [entry] = group;
4738
4739               if (do_section_groups)
4740                 {
4741                   sec = section_headers + entry;
4742                   printf ("   [%5u]   %s\n", entry, SECTION_NAME (sec));
4743                 }
4744
4745               g = xmalloc (sizeof (struct group_list));
4746               g->section_index = entry;
4747               g->next = group->root;
4748               group->root = g;
4749             }
4750
4751           if (start)
4752             free (start);
4753
4754           group++;
4755         }
4756     }
4757
4758   if (symtab)
4759     free (symtab);
4760   if (strtab)
4761     free (strtab);
4762   return 1;
4763 }
4764
4765 static struct
4766 {
4767   const char *name;
4768   int reloc;
4769   int size;
4770   int rela;
4771 } dynamic_relocations [] =
4772 {
4773     { "REL", DT_REL, DT_RELSZ, FALSE },
4774     { "RELA", DT_RELA, DT_RELASZ, TRUE },
4775     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
4776 };
4777
4778 /* Process the reloc section.  */
4779
4780 static int
4781 process_relocs (FILE *file)
4782 {
4783   unsigned long rel_size;
4784   unsigned long rel_offset;
4785
4786
4787   if (!do_reloc)
4788     return 1;
4789
4790   if (do_using_dynamic)
4791     {
4792       int is_rela;
4793       const char *name;
4794       int has_dynamic_reloc;
4795       unsigned int i;
4796
4797       has_dynamic_reloc = 0;
4798
4799       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
4800         {
4801           is_rela = dynamic_relocations [i].rela;
4802           name = dynamic_relocations [i].name;
4803           rel_size = dynamic_info [dynamic_relocations [i].size];
4804           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
4805
4806           has_dynamic_reloc |= rel_size;
4807
4808           if (is_rela == UNKNOWN)
4809             {
4810               if (dynamic_relocations [i].reloc == DT_JMPREL)
4811                 switch (dynamic_info[DT_PLTREL])
4812                   {
4813                   case DT_REL:
4814                     is_rela = FALSE;
4815                     break;
4816                   case DT_RELA:
4817                     is_rela = TRUE;
4818                     break;
4819                   }
4820             }
4821
4822           if (rel_size)
4823             {
4824               printf
4825                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4826                  name, rel_offset, rel_size);
4827
4828               dump_relocations (file,
4829                                 offset_from_vma (file, rel_offset, rel_size),
4830                                 rel_size,
4831                                 dynamic_symbols, num_dynamic_syms,
4832                                 dynamic_strings, dynamic_strings_length, is_rela);
4833             }
4834         }
4835
4836       if (! has_dynamic_reloc)
4837         printf (_("\nThere are no dynamic relocations in this file.\n"));
4838     }
4839   else
4840     {
4841       Elf_Internal_Shdr *section;
4842       unsigned long i;
4843       int found = 0;
4844
4845       for (i = 0, section = section_headers;
4846            i < elf_header.e_shnum;
4847            i++, section++)
4848         {
4849           if (   section->sh_type != SHT_RELA
4850               && section->sh_type != SHT_REL)
4851             continue;
4852
4853           rel_offset = section->sh_offset;
4854           rel_size   = section->sh_size;
4855
4856           if (rel_size)
4857             {
4858               Elf_Internal_Shdr *strsec;
4859               int is_rela;
4860
4861               printf (_("\nRelocation section "));
4862
4863               if (string_table == NULL)
4864                 printf ("%d", section->sh_name);
4865               else
4866                 printf (_("'%s'"), SECTION_NAME (section));
4867
4868               printf (_(" at offset 0x%lx contains %lu entries:\n"),
4869                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
4870
4871               is_rela = section->sh_type == SHT_RELA;
4872
4873               if (section->sh_link != 0
4874                   && section->sh_link < elf_header.e_shnum)
4875                 {
4876                   Elf_Internal_Shdr *symsec;
4877                   Elf_Internal_Sym *symtab;
4878                   unsigned long nsyms;
4879                   unsigned long strtablen = 0;
4880                   char *strtab = NULL;
4881
4882                   symsec = section_headers + section->sh_link;
4883                   if (symsec->sh_type != SHT_SYMTAB
4884                       && symsec->sh_type != SHT_DYNSYM)
4885                     continue;
4886
4887                   nsyms = symsec->sh_size / symsec->sh_entsize;
4888                   symtab = GET_ELF_SYMBOLS (file, symsec);
4889
4890                   if (symtab == NULL)
4891                     continue;
4892
4893                   if (symsec->sh_link != 0
4894                       && symsec->sh_link < elf_header.e_shnum)
4895                     {
4896                       strsec = section_headers + symsec->sh_link;
4897
4898                       strtab = get_data (NULL, file, strsec->sh_offset,
4899                                          1, strsec->sh_size,
4900                                          _("string table"));
4901                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
4902                     }
4903
4904                   dump_relocations (file, rel_offset, rel_size,
4905                                     symtab, nsyms, strtab, strtablen, is_rela);
4906                   if (strtab)
4907                     free (strtab);
4908                   free (symtab);
4909                 }
4910               else
4911                 dump_relocations (file, rel_offset, rel_size,
4912                                   NULL, 0, NULL, 0, is_rela);
4913
4914               found = 1;
4915             }
4916         }
4917
4918       if (! found)
4919         printf (_("\nThere are no relocations in this file.\n"));
4920     }
4921
4922   return 1;
4923 }
4924
4925 /* Process the unwind section.  */
4926
4927 #include "unwind-ia64.h"
4928
4929 /* An absolute address consists of a section and an offset.  If the
4930    section is NULL, the offset itself is the address, otherwise, the
4931    address equals to LOAD_ADDRESS(section) + offset.  */
4932
4933 struct absaddr
4934   {
4935     unsigned short section;
4936     bfd_vma offset;
4937   };
4938
4939 #define ABSADDR(a) \
4940   ((a).section \
4941    ? section_headers [(a).section].sh_addr + (a).offset \
4942    : (a).offset)
4943
4944 struct ia64_unw_aux_info
4945   {
4946     struct ia64_unw_table_entry
4947       {
4948         struct absaddr start;
4949         struct absaddr end;
4950         struct absaddr info;
4951       }
4952     *table;                     /* Unwind table.  */
4953     unsigned long table_len;    /* Length of unwind table.  */
4954     unsigned char *info;        /* Unwind info.  */
4955     unsigned long info_size;    /* Size of unwind info.  */
4956     bfd_vma info_addr;          /* starting address of unwind info.  */
4957     bfd_vma seg_base;           /* Starting address of segment.  */
4958     Elf_Internal_Sym *symtab;   /* The symbol table.  */
4959     unsigned long nsyms;        /* Number of symbols.  */
4960     char *strtab;               /* The string table.  */
4961     unsigned long strtab_size;  /* Size of string table.  */
4962   };
4963
4964 static void
4965 find_symbol_for_address (Elf_Internal_Sym *symtab,
4966                          unsigned long nsyms,
4967                          const char *strtab,
4968                          unsigned long strtab_size,
4969                          struct absaddr addr,
4970                          const char **symname,
4971                          bfd_vma *offset)
4972 {
4973   bfd_vma dist = 0x100000;
4974   Elf_Internal_Sym *sym, *best = NULL;
4975   unsigned long i;
4976
4977   for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4978     {
4979       if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
4980           && sym->st_name != 0
4981           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
4982           && addr.offset >= sym->st_value
4983           && addr.offset - sym->st_value < dist)
4984         {
4985           best = sym;
4986           dist = addr.offset - sym->st_value;
4987           if (!dist)
4988             break;
4989         }
4990     }
4991   if (best)
4992     {
4993       *symname = (best->st_name >= strtab_size
4994                   ? "<corrupt>" : strtab + best->st_name);
4995       *offset = dist;
4996       return;
4997     }
4998   *symname = NULL;
4999   *offset = addr.offset;
5000 }
5001
5002 static void
5003 dump_ia64_unwind (struct ia64_unw_aux_info *aux)
5004 {
5005   struct ia64_unw_table_entry *tp;
5006   int in_body;
5007
5008   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5009     {
5010       bfd_vma stamp;
5011       bfd_vma offset;
5012       const unsigned char *dp;
5013       const unsigned char *head;
5014       const char *procname;
5015
5016       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5017                                aux->strtab_size, tp->start, &procname, &offset);
5018
5019       fputs ("\n<", stdout);
5020
5021       if (procname)
5022         {
5023           fputs (procname, stdout);
5024
5025           if (offset)
5026             printf ("+%lx", (unsigned long) offset);
5027         }
5028
5029       fputs (">: [", stdout);
5030       print_vma (tp->start.offset, PREFIX_HEX);
5031       fputc ('-', stdout);
5032       print_vma (tp->end.offset, PREFIX_HEX);
5033       printf ("], info at +0x%lx\n",
5034               (unsigned long) (tp->info.offset - aux->seg_base));
5035
5036       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5037       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5038
5039       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5040               (unsigned) UNW_VER (stamp),
5041               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5042               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5043               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5044               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5045
5046       if (UNW_VER (stamp) != 1)
5047         {
5048           printf ("\tUnknown version.\n");
5049           continue;
5050         }
5051
5052       in_body = 0;
5053       for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5054         dp = unw_decode (dp, in_body, & in_body);
5055     }
5056 }
5057
5058 static int
5059 slurp_ia64_unwind_table (FILE *file,
5060                          struct ia64_unw_aux_info *aux,
5061                          Elf_Internal_Shdr *sec)
5062 {
5063   unsigned long size, nrelas, i;
5064   Elf_Internal_Phdr *seg;
5065   struct ia64_unw_table_entry *tep;
5066   Elf_Internal_Shdr *relsec;
5067   Elf_Internal_Rela *rela, *rp;
5068   unsigned char *table, *tp;
5069   Elf_Internal_Sym *sym;
5070   const char *relname;
5071
5072   /* First, find the starting address of the segment that includes
5073      this section: */
5074
5075   if (elf_header.e_phnum)
5076     {
5077       if (! get_program_headers (file))
5078           return 0;
5079
5080       for (seg = program_headers;
5081            seg < program_headers + elf_header.e_phnum;
5082            ++seg)
5083         {
5084           if (seg->p_type != PT_LOAD)
5085             continue;
5086
5087           if (sec->sh_addr >= seg->p_vaddr
5088               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5089             {
5090               aux->seg_base = seg->p_vaddr;
5091               break;
5092             }
5093         }
5094     }
5095
5096   /* Second, build the unwind table from the contents of the unwind section:  */
5097   size = sec->sh_size;
5098   table = get_data (NULL, file, sec->sh_offset, 1, size, _("unwind table"));
5099   if (!table)
5100     return 0;
5101
5102   aux->table = xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5103   tep = aux->table;
5104   for (tp = table; tp < table + size; tp += 3 * eh_addr_size, ++tep)
5105     {
5106       tep->start.section = SHN_UNDEF;
5107       tep->end.section   = SHN_UNDEF;
5108       tep->info.section  = SHN_UNDEF;
5109       if (is_32bit_elf)
5110         {
5111           tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
5112           tep->end.offset   = byte_get ((unsigned char *) tp + 4, 4);
5113           tep->info.offset  = byte_get ((unsigned char *) tp + 8, 4);
5114         }
5115       else
5116         {
5117           tep->start.offset = BYTE_GET ((unsigned char *) tp +  0);
5118           tep->end.offset   = BYTE_GET ((unsigned char *) tp +  8);
5119           tep->info.offset  = BYTE_GET ((unsigned char *) tp + 16);
5120         }
5121       tep->start.offset += aux->seg_base;
5122       tep->end.offset   += aux->seg_base;
5123       tep->info.offset  += aux->seg_base;
5124     }
5125   free (table);
5126
5127   /* Third, apply any relocations to the unwind table:  */
5128   for (relsec = section_headers;
5129        relsec < section_headers + elf_header.e_shnum;
5130        ++relsec)
5131     {
5132       if (relsec->sh_type != SHT_RELA
5133           || relsec->sh_info >= elf_header.e_shnum
5134           || section_headers + relsec->sh_info != sec)
5135         continue;
5136
5137       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5138                               & rela, & nrelas))
5139         return 0;
5140
5141       for (rp = rela; rp < rela + nrelas; ++rp)
5142         {
5143           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5144           sym = aux->symtab + get_reloc_symindex (rp->r_info);
5145
5146           if (! const_strneq (relname, "R_IA64_SEGREL"))
5147             {
5148               warn (_("Skipping unexpected relocation type %s\n"), relname);
5149               continue;
5150             }
5151
5152           i = rp->r_offset / (3 * eh_addr_size);
5153
5154           switch (rp->r_offset/eh_addr_size % 3)
5155             {
5156             case 0:
5157               aux->table[i].start.section = sym->st_shndx;
5158               aux->table[i].start.offset += rp->r_addend + sym->st_value;
5159               break;
5160             case 1:
5161               aux->table[i].end.section   = sym->st_shndx;
5162               aux->table[i].end.offset   += rp->r_addend + sym->st_value;
5163               break;
5164             case 2:
5165               aux->table[i].info.section  = sym->st_shndx;
5166               aux->table[i].info.offset  += rp->r_addend + sym->st_value;
5167               break;
5168             default:
5169               break;
5170             }
5171         }
5172
5173       free (rela);
5174     }
5175
5176   aux->table_len = size / (3 * eh_addr_size);
5177   return 1;
5178 }
5179
5180 static int
5181 ia64_process_unwind (FILE *file)
5182 {
5183   Elf_Internal_Shdr *sec, *unwsec = NULL, *strsec;
5184   unsigned long i, unwcount = 0, unwstart = 0;
5185   struct ia64_unw_aux_info aux;
5186
5187   memset (& aux, 0, sizeof (aux));
5188
5189   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5190     {
5191       if (sec->sh_type == SHT_SYMTAB
5192           && sec->sh_link < elf_header.e_shnum)
5193         {
5194           aux.nsyms = sec->sh_size / sec->sh_entsize;
5195           aux.symtab = GET_ELF_SYMBOLS (file, sec);
5196
5197           strsec = section_headers + sec->sh_link;
5198           aux.strtab = get_data (NULL, file, strsec->sh_offset,
5199                                  1, strsec->sh_size, _("string table"));
5200           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5201         }
5202       else if (sec->sh_type == SHT_IA_64_UNWIND)
5203         unwcount++;
5204     }
5205
5206   if (!unwcount)
5207     printf (_("\nThere are no unwind sections in this file.\n"));
5208
5209   while (unwcount-- > 0)
5210     {
5211       char *suffix;
5212       size_t len, len2;
5213
5214       for (i = unwstart, sec = section_headers + unwstart;
5215            i < elf_header.e_shnum; ++i, ++sec)
5216         if (sec->sh_type == SHT_IA_64_UNWIND)
5217           {
5218             unwsec = sec;
5219             break;
5220           }
5221
5222       unwstart = i + 1;
5223       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5224
5225       if ((unwsec->sh_flags & SHF_GROUP) != 0)
5226         {
5227           /* We need to find which section group it is in.  */
5228           struct group_list *g = section_headers_groups [i]->root;
5229
5230           for (; g != NULL; g = g->next)
5231             {
5232               sec = section_headers + g->section_index;
5233
5234               if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
5235                 break;
5236             }
5237
5238           if (g == NULL)
5239             i = elf_header.e_shnum;
5240         }
5241       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
5242         {
5243           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
5244           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5245           suffix = SECTION_NAME (unwsec) + len;
5246           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5247                ++i, ++sec)
5248             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5249                 && streq (SECTION_NAME (sec) + len2, suffix))
5250               break;
5251         }
5252       else
5253         {
5254           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5255              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
5256           len = sizeof (ELF_STRING_ia64_unwind) - 1;
5257           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5258           suffix = "";
5259           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
5260             suffix = SECTION_NAME (unwsec) + len;
5261           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5262                ++i, ++sec)
5263             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5264                 && streq (SECTION_NAME (sec) + len2, suffix))
5265               break;
5266         }
5267
5268       if (i == elf_header.e_shnum)
5269         {
5270           printf (_("\nCould not find unwind info section for "));
5271
5272           if (string_table == NULL)
5273             printf ("%d", unwsec->sh_name);
5274           else
5275             printf (_("'%s'"), SECTION_NAME (unwsec));
5276         }
5277       else
5278         {
5279           aux.info_size = sec->sh_size;
5280           aux.info_addr = sec->sh_addr;
5281           aux.info = get_data (NULL, file, sec->sh_offset, 1, aux.info_size,
5282                                _("unwind info"));
5283
5284           printf (_("\nUnwind section "));
5285
5286           if (string_table == NULL)
5287             printf ("%d", unwsec->sh_name);
5288           else
5289             printf (_("'%s'"), SECTION_NAME (unwsec));
5290
5291           printf (_(" at offset 0x%lx contains %lu entries:\n"),
5292                   (unsigned long) unwsec->sh_offset,
5293                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
5294
5295           (void) slurp_ia64_unwind_table (file, & aux, unwsec);
5296
5297           if (aux.table_len > 0)
5298             dump_ia64_unwind (& aux);
5299
5300           if (aux.table)
5301             free ((char *) aux.table);
5302           if (aux.info)
5303             free ((char *) aux.info);
5304           aux.table = NULL;
5305           aux.info = NULL;
5306         }
5307     }
5308
5309   if (aux.symtab)
5310     free (aux.symtab);
5311   if (aux.strtab)
5312     free ((char *) aux.strtab);
5313
5314   return 1;
5315 }
5316
5317 struct hppa_unw_aux_info
5318   {
5319     struct hppa_unw_table_entry
5320       {
5321         struct absaddr start;
5322         struct absaddr end;
5323         unsigned int Cannot_unwind:1;                   /* 0 */
5324         unsigned int Millicode:1;                       /* 1 */
5325         unsigned int Millicode_save_sr0:1;              /* 2 */
5326         unsigned int Region_description:2;              /* 3..4 */
5327         unsigned int reserved1:1;                       /* 5 */
5328         unsigned int Entry_SR:1;                        /* 6 */
5329         unsigned int Entry_FR:4;     /* number saved */ /* 7..10 */
5330         unsigned int Entry_GR:5;     /* number saved */ /* 11..15 */
5331         unsigned int Args_stored:1;                     /* 16 */
5332         unsigned int Variable_Frame:1;                  /* 17 */
5333         unsigned int Separate_Package_Body:1;           /* 18 */
5334         unsigned int Frame_Extension_Millicode:1;       /* 19 */
5335         unsigned int Stack_Overflow_Check:1;            /* 20 */
5336         unsigned int Two_Instruction_SP_Increment:1;    /* 21 */
5337         unsigned int Ada_Region:1;                      /* 22 */
5338         unsigned int cxx_info:1;                        /* 23 */
5339         unsigned int cxx_try_catch:1;                   /* 24 */
5340         unsigned int sched_entry_seq:1;                 /* 25 */
5341         unsigned int reserved2:1;                       /* 26 */
5342         unsigned int Save_SP:1;                         /* 27 */
5343         unsigned int Save_RP:1;                         /* 28 */
5344         unsigned int Save_MRP_in_frame:1;               /* 29 */
5345         unsigned int extn_ptr_defined:1;                /* 30 */
5346         unsigned int Cleanup_defined:1;                 /* 31 */
5347
5348         unsigned int MPE_XL_interrupt_marker:1;         /* 0 */
5349         unsigned int HP_UX_interrupt_marker:1;          /* 1 */
5350         unsigned int Large_frame:1;                     /* 2 */
5351         unsigned int Pseudo_SP_Set:1;                   /* 3 */
5352         unsigned int reserved4:1;                       /* 4 */
5353         unsigned int Total_frame_size:27;               /* 5..31 */
5354       }
5355     *table;                     /* Unwind table.  */
5356     unsigned long table_len;    /* Length of unwind table.  */
5357     bfd_vma seg_base;           /* Starting address of segment.  */
5358     Elf_Internal_Sym *symtab;   /* The symbol table.  */
5359     unsigned long nsyms;        /* Number of symbols.  */
5360     char *strtab;               /* The string table.  */
5361     unsigned long strtab_size;  /* Size of string table.  */
5362   };
5363
5364 static void
5365 dump_hppa_unwind (struct hppa_unw_aux_info *aux)
5366 {
5367   struct hppa_unw_table_entry *tp;
5368
5369   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5370     {
5371       bfd_vma offset;
5372       const char *procname;
5373
5374       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5375                                aux->strtab_size, tp->start, &procname,
5376                                &offset);
5377
5378       fputs ("\n<", stdout);
5379
5380       if (procname)
5381         {
5382           fputs (procname, stdout);
5383
5384           if (offset)
5385             printf ("+%lx", (unsigned long) offset);
5386         }
5387
5388       fputs (">: [", stdout);
5389       print_vma (tp->start.offset, PREFIX_HEX);
5390       fputc ('-', stdout);
5391       print_vma (tp->end.offset, PREFIX_HEX);
5392       printf ("]\n\t");
5393
5394 #define PF(_m) if (tp->_m) printf (#_m " ");
5395 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5396       PF(Cannot_unwind);
5397       PF(Millicode);
5398       PF(Millicode_save_sr0);
5399       /* PV(Region_description);  */
5400       PF(Entry_SR);
5401       PV(Entry_FR);
5402       PV(Entry_GR);
5403       PF(Args_stored);
5404       PF(Variable_Frame);
5405       PF(Separate_Package_Body);
5406       PF(Frame_Extension_Millicode);
5407       PF(Stack_Overflow_Check);
5408       PF(Two_Instruction_SP_Increment);
5409       PF(Ada_Region);
5410       PF(cxx_info);
5411       PF(cxx_try_catch);
5412       PF(sched_entry_seq);
5413       PF(Save_SP);
5414       PF(Save_RP);
5415       PF(Save_MRP_in_frame);
5416       PF(extn_ptr_defined);
5417       PF(Cleanup_defined);
5418       PF(MPE_XL_interrupt_marker);
5419       PF(HP_UX_interrupt_marker);
5420       PF(Large_frame);
5421       PF(Pseudo_SP_Set);
5422       PV(Total_frame_size);
5423 #undef PF
5424 #undef PV
5425     }
5426
5427   printf ("\n");
5428 }
5429
5430 static int
5431 slurp_hppa_unwind_table (FILE *file,
5432                          struct hppa_unw_aux_info *aux,
5433                          Elf_Internal_Shdr *sec)
5434 {
5435   unsigned long size, unw_ent_size, nentries, nrelas, i;
5436   Elf_Internal_Phdr *seg;
5437   struct hppa_unw_table_entry *tep;
5438   Elf_Internal_Shdr *relsec;
5439   Elf_Internal_Rela *rela, *rp;
5440   unsigned char *table, *tp;
5441   Elf_Internal_Sym *sym;
5442   const char *relname;
5443
5444   /* First, find the starting address of the segment that includes
5445      this section.  */
5446
5447   if (elf_header.e_phnum)
5448     {
5449       if (! get_program_headers (file))
5450         return 0;
5451
5452       for (seg = program_headers;
5453            seg < program_headers + elf_header.e_phnum;
5454            ++seg)
5455         {
5456           if (seg->p_type != PT_LOAD)
5457             continue;
5458
5459           if (sec->sh_addr >= seg->p_vaddr
5460               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5461             {
5462               aux->seg_base = seg->p_vaddr;
5463               break;
5464             }
5465         }
5466     }
5467
5468   /* Second, build the unwind table from the contents of the unwind
5469      section.  */
5470   size = sec->sh_size;
5471   table = get_data (NULL, file, sec->sh_offset, 1, size, _("unwind table"));
5472   if (!table)
5473     return 0;
5474
5475   unw_ent_size = 16;
5476   nentries = size / unw_ent_size;
5477   size = unw_ent_size * nentries;
5478
5479   tep = aux->table = xcmalloc (nentries, sizeof (aux->table[0]));
5480
5481   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
5482     {
5483       unsigned int tmp1, tmp2;
5484
5485       tep->start.section = SHN_UNDEF;
5486       tep->end.section   = SHN_UNDEF;
5487
5488       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
5489       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
5490       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
5491       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
5492
5493       tep->start.offset += aux->seg_base;
5494       tep->end.offset   += aux->seg_base;
5495
5496       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
5497       tep->Millicode = (tmp1 >> 30) & 0x1;
5498       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
5499       tep->Region_description = (tmp1 >> 27) & 0x3;
5500       tep->reserved1 = (tmp1 >> 26) & 0x1;
5501       tep->Entry_SR = (tmp1 >> 25) & 0x1;
5502       tep->Entry_FR = (tmp1 >> 21) & 0xf;
5503       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
5504       tep->Args_stored = (tmp1 >> 15) & 0x1;
5505       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
5506       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
5507       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
5508       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
5509       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
5510       tep->Ada_Region = (tmp1 >> 9) & 0x1;
5511       tep->cxx_info = (tmp1 >> 8) & 0x1;
5512       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
5513       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
5514       tep->reserved2 = (tmp1 >> 5) & 0x1;
5515       tep->Save_SP = (tmp1 >> 4) & 0x1;
5516       tep->Save_RP = (tmp1 >> 3) & 0x1;
5517       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
5518       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
5519       tep->Cleanup_defined = tmp1 & 0x1;
5520
5521       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
5522       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
5523       tep->Large_frame = (tmp2 >> 29) & 0x1;
5524       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
5525       tep->reserved4 = (tmp2 >> 27) & 0x1;
5526       tep->Total_frame_size = tmp2 & 0x7ffffff;
5527     }
5528   free (table);
5529
5530   /* Third, apply any relocations to the unwind table.  */
5531   for (relsec = section_headers;
5532        relsec < section_headers + elf_header.e_shnum;
5533        ++relsec)
5534     {
5535       if (relsec->sh_type != SHT_RELA
5536           || relsec->sh_info >= elf_header.e_shnum
5537           || section_headers + relsec->sh_info != sec)
5538         continue;
5539
5540       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5541                               & rela, & nrelas))
5542         return 0;
5543
5544       for (rp = rela; rp < rela + nrelas; ++rp)
5545         {
5546           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
5547           sym = aux->symtab + get_reloc_symindex (rp->r_info);
5548
5549           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
5550           if (! const_strneq (relname, "R_PARISC_SEGREL"))
5551             {
5552               warn (_("Skipping unexpected relocation type %s\n"), relname);
5553               continue;
5554             }
5555
5556           i = rp->r_offset / unw_ent_size;
5557
5558           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
5559             {
5560             case 0:
5561               aux->table[i].start.section = sym->st_shndx;
5562               aux->table[i].start.offset += sym->st_value + rp->r_addend;
5563               break;
5564             case 1:
5565               aux->table[i].end.section   = sym->st_shndx;
5566               aux->table[i].end.offset   += sym->st_value + rp->r_addend;
5567               break;
5568             default:
5569               break;
5570             }
5571         }
5572
5573       free (rela);
5574     }
5575
5576   aux->table_len = nentries;
5577
5578   return 1;
5579 }
5580
5581 static int
5582 hppa_process_unwind (FILE *file)
5583 {
5584   struct hppa_unw_aux_info aux;
5585   Elf_Internal_Shdr *unwsec = NULL;
5586   Elf_Internal_Shdr *strsec;
5587   Elf_Internal_Shdr *sec;
5588   unsigned long i;
5589
5590   memset (& aux, 0, sizeof (aux));
5591
5592   if (string_table == NULL)
5593     return 1;
5594
5595   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5596     {
5597       if (sec->sh_type == SHT_SYMTAB
5598           && sec->sh_link < elf_header.e_shnum)
5599         {
5600           aux.nsyms = sec->sh_size / sec->sh_entsize;
5601           aux.symtab = GET_ELF_SYMBOLS (file, sec);
5602
5603           strsec = section_headers + sec->sh_link;
5604           aux.strtab = get_data (NULL, file, strsec->sh_offset,
5605                                  1, strsec->sh_size, _("string table"));
5606           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5607         }
5608       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5609         unwsec = sec;
5610     }
5611
5612   if (!unwsec)
5613     printf (_("\nThere are no unwind sections in this file.\n"));
5614
5615   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5616     {
5617       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5618         {
5619           printf (_("\nUnwind section "));
5620           printf (_("'%s'"), SECTION_NAME (sec));
5621
5622           printf (_(" at offset 0x%lx contains %lu entries:\n"),
5623                   (unsigned long) sec->sh_offset,
5624                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
5625
5626           slurp_hppa_unwind_table (file, &aux, sec);
5627           if (aux.table_len > 0)
5628             dump_hppa_unwind (&aux);
5629
5630           if (aux.table)
5631             free ((char *) aux.table);
5632           aux.table = NULL;
5633         }
5634     }
5635
5636   if (aux.symtab)
5637     free (aux.symtab);
5638   if (aux.strtab)
5639     free ((char *) aux.strtab);
5640
5641   return 1;
5642 }
5643
5644 static int
5645 process_unwind (FILE *file)
5646 {
5647   struct unwind_handler {
5648     int machtype;
5649     int (*handler)(FILE *file);
5650   } handlers[] = {
5651     { EM_IA_64, ia64_process_unwind },
5652     { EM_PARISC, hppa_process_unwind },
5653     { 0, 0 }
5654   };
5655   int i;
5656
5657   if (!do_unwind)
5658     return 1;
5659
5660   for (i = 0; handlers[i].handler != NULL; i++)
5661     if (elf_header.e_machine == handlers[i].machtype)
5662       return handlers[i].handler (file);
5663
5664   printf (_("\nThere are no unwind sections in this file.\n"));
5665   return 1;
5666 }
5667
5668 static void
5669 dynamic_section_mips_val (Elf_Internal_Dyn *entry)
5670 {
5671   switch (entry->d_tag)
5672     {
5673     case DT_MIPS_FLAGS:
5674       if (entry->d_un.d_val == 0)
5675         printf ("NONE\n");
5676       else
5677         {
5678           static const char * opts[] =
5679           {
5680             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5681             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5682             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5683             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5684             "RLD_ORDER_SAFE"
5685           };
5686           unsigned int cnt;
5687           int first = 1;
5688           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
5689             if (entry->d_un.d_val & (1 << cnt))
5690               {
5691                 printf ("%s%s", first ? "" : " ", opts[cnt]);
5692                 first = 0;
5693               }
5694           puts ("");
5695         }
5696       break;
5697
5698     case DT_MIPS_IVERSION:
5699       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
5700         printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
5701       else
5702         printf ("<corrupt: %ld>\n", (long) entry->d_un.d_ptr);
5703       break;
5704
5705     case DT_MIPS_TIME_STAMP:
5706       {
5707         char timebuf[20];
5708         struct tm *tmp;
5709
5710         time_t time = entry->d_un.d_val;
5711         tmp = gmtime (&time);
5712         snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
5713                   tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
5714                   tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
5715         printf ("Time Stamp: %s\n", timebuf);
5716       }
5717       break;
5718
5719     case DT_MIPS_RLD_VERSION:
5720     case DT_MIPS_LOCAL_GOTNO:
5721     case DT_MIPS_CONFLICTNO:
5722     case DT_MIPS_LIBLISTNO:
5723     case DT_MIPS_SYMTABNO:
5724     case DT_MIPS_UNREFEXTNO:
5725     case DT_MIPS_HIPAGENO:
5726     case DT_MIPS_DELTA_CLASS_NO:
5727     case DT_MIPS_DELTA_INSTANCE_NO:
5728     case DT_MIPS_DELTA_RELOC_NO:
5729     case DT_MIPS_DELTA_SYM_NO:
5730     case DT_MIPS_DELTA_CLASSSYM_NO:
5731     case DT_MIPS_COMPACT_SIZE:
5732       printf ("%ld\n", (long) entry->d_un.d_ptr);
5733       break;
5734
5735     default:
5736       printf ("%#lx\n", (long) entry->d_un.d_ptr);
5737     }
5738 }
5739
5740
5741 static void
5742 dynamic_section_parisc_val (Elf_Internal_Dyn *entry)
5743 {
5744   switch (entry->d_tag)
5745     {
5746     case DT_HP_DLD_FLAGS:
5747       {
5748         static struct
5749         {
5750           long int bit;
5751           const char *str;
5752         }
5753         flags[] =
5754         {
5755           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
5756           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
5757           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
5758           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
5759           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
5760           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
5761           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
5762           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
5763           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
5764           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
5765           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
5766           { DT_HP_GST, "HP_GST" },
5767           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
5768           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
5769           { DT_HP_NODELETE, "HP_NODELETE" },
5770           { DT_HP_GROUP, "HP_GROUP" },
5771           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5772         };
5773         int first = 1;
5774         size_t cnt;
5775         bfd_vma val = entry->d_un.d_val;
5776
5777         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
5778           if (val & flags[cnt].bit)
5779             {
5780               if (! first)
5781                 putchar (' ');
5782               fputs (flags[cnt].str, stdout);
5783               first = 0;
5784               val ^= flags[cnt].bit;
5785             }
5786
5787         if (val != 0 || first)
5788           {
5789             if (! first)
5790               putchar (' ');
5791             print_vma (val, HEX);
5792           }
5793       }
5794       break;
5795
5796     default:
5797       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5798       break;
5799     }
5800   putchar ('\n');
5801 }
5802
5803 static void
5804 dynamic_section_ia64_val (Elf_Internal_Dyn *entry)
5805 {
5806   switch (entry->d_tag)
5807     {
5808     case DT_IA_64_PLT_RESERVE:
5809       /* First 3 slots reserved.  */
5810       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5811       printf (" -- ");
5812       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
5813       break;
5814
5815     default:
5816       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5817       break;
5818     }
5819   putchar ('\n');
5820 }
5821
5822 static int
5823 get_32bit_dynamic_section (FILE *file)
5824 {
5825   Elf32_External_Dyn *edyn, *ext;
5826   Elf_Internal_Dyn *entry;
5827
5828   edyn = get_data (NULL, file, dynamic_addr, 1, dynamic_size,
5829                    _("dynamic section"));
5830   if (!edyn)
5831     return 0;
5832
5833 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5834    might not have the luxury of section headers.  Look for the DT_NULL
5835    terminator to determine the number of entries.  */
5836   for (ext = edyn, dynamic_nent = 0;
5837        (char *) ext < (char *) edyn + dynamic_size;
5838        ext++)
5839     {
5840       dynamic_nent++;
5841       if (BYTE_GET (ext->d_tag) == DT_NULL)
5842         break;
5843     }
5844
5845   dynamic_section = cmalloc (dynamic_nent, sizeof (*entry));
5846   if (dynamic_section == NULL)
5847     {
5848       error (_("Out of memory\n"));
5849       free (edyn);
5850       return 0;
5851     }
5852
5853   for (ext = edyn, entry = dynamic_section;
5854        entry < dynamic_section + dynamic_nent;
5855        ext++, entry++)
5856     {
5857       entry->d_tag      = BYTE_GET (ext->d_tag);
5858       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
5859     }
5860
5861   free (edyn);
5862
5863   return 1;
5864 }
5865
5866 static int
5867 get_64bit_dynamic_section (FILE *file)
5868 {
5869   Elf64_External_Dyn *edyn, *ext;
5870   Elf_Internal_Dyn *entry;
5871
5872   edyn = get_data (NULL, file, dynamic_addr, 1, dynamic_size,
5873                    _("dynamic section"));
5874   if (!edyn)
5875     return 0;
5876
5877 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5878    might not have the luxury of section headers.  Look for the DT_NULL
5879    terminator to determine the number of entries.  */
5880   for (ext = edyn, dynamic_nent = 0;
5881        (char *) ext < (char *) edyn + dynamic_size;
5882        ext++)
5883     {
5884       dynamic_nent++;
5885       if (BYTE_GET (ext->d_tag) == DT_NULL)
5886         break;
5887     }
5888
5889   dynamic_section = cmalloc (dynamic_nent, sizeof (*entry));
5890   if (dynamic_section == NULL)
5891     {
5892       error (_("Out of memory\n"));
5893       free (edyn);
5894       return 0;
5895     }
5896
5897   for (ext = edyn, entry = dynamic_section;
5898        entry < dynamic_section + dynamic_nent;
5899        ext++, entry++)
5900     {
5901       entry->d_tag      = BYTE_GET (ext->d_tag);
5902       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
5903     }
5904
5905   free (edyn);
5906
5907   return 1;
5908 }
5909
5910 static void
5911 print_dynamic_flags (bfd_vma flags)
5912 {
5913   int first = 1;
5914
5915   while (flags)
5916     {
5917       bfd_vma flag;
5918
5919       flag = flags & - flags;
5920       flags &= ~ flag;
5921
5922       if (first)
5923         first = 0;
5924       else
5925         putc (' ', stdout);
5926
5927       switch (flag)
5928         {
5929         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
5930         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
5931         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
5932         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
5933         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
5934         default:                fputs ("unknown", stdout); break;
5935         }
5936     }
5937   puts ("");
5938 }
5939
5940 /* Parse and display the contents of the dynamic section.  */
5941
5942 static int
5943 process_dynamic_section (FILE *file)
5944 {
5945   Elf_Internal_Dyn *entry;
5946
5947   if (dynamic_size == 0)
5948     {
5949       if (do_dynamic)
5950         printf (_("\nThere is no dynamic section in this file.\n"));
5951
5952       return 1;
5953     }
5954
5955   if (is_32bit_elf)
5956     {
5957       if (! get_32bit_dynamic_section (file))
5958         return 0;
5959     }
5960   else if (! get_64bit_dynamic_section (file))
5961     return 0;
5962
5963   /* Find the appropriate symbol table.  */
5964   if (dynamic_symbols == NULL)
5965     {
5966       for (entry = dynamic_section;
5967            entry < dynamic_section + dynamic_nent;
5968            ++entry)
5969         {
5970           Elf_Internal_Shdr section;
5971
5972           if (entry->d_tag != DT_SYMTAB)
5973             continue;
5974
5975           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
5976
5977           /* Since we do not know how big the symbol table is,
5978              we default to reading in the entire file (!) and
5979              processing that.  This is overkill, I know, but it
5980              should work.  */
5981           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
5982
5983           if (archive_file_offset != 0)
5984             section.sh_size = archive_file_size - section.sh_offset;
5985           else
5986             {
5987               if (fseek (file, 0, SEEK_END))
5988                 error (_("Unable to seek to end of file!\n"));
5989
5990               section.sh_size = ftell (file) - section.sh_offset;
5991             }
5992
5993           if (is_32bit_elf)
5994             section.sh_entsize = sizeof (Elf32_External_Sym);
5995           else
5996             section.sh_entsize = sizeof (Elf64_External_Sym);
5997
5998           num_dynamic_syms = section.sh_size / section.sh_entsize;
5999           if (num_dynamic_syms < 1)
6000             {
6001               error (_("Unable to determine the number of symbols to load\n"));
6002               continue;
6003             }
6004
6005           dynamic_symbols = GET_ELF_SYMBOLS (file, &section);
6006         }
6007     }
6008
6009   /* Similarly find a string table.  */
6010   if (dynamic_strings == NULL)
6011     {
6012       for (entry = dynamic_section;
6013            entry < dynamic_section + dynamic_nent;
6014            ++entry)
6015         {
6016           unsigned long offset;
6017           long str_tab_len;
6018
6019           if (entry->d_tag != DT_STRTAB)
6020             continue;
6021
6022           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
6023
6024           /* Since we do not know how big the string table is,
6025              we default to reading in the entire file (!) and
6026              processing that.  This is overkill, I know, but it
6027              should work.  */
6028
6029           offset = offset_from_vma (file, entry->d_un.d_val, 0);
6030
6031           if (archive_file_offset != 0)
6032             str_tab_len = archive_file_size - offset;
6033           else
6034             {
6035               if (fseek (file, 0, SEEK_END))
6036                 error (_("Unable to seek to end of file\n"));
6037               str_tab_len = ftell (file) - offset;
6038             }
6039
6040           if (str_tab_len < 1)
6041             {
6042               error
6043                 (_("Unable to determine the length of the dynamic string table\n"));
6044               continue;
6045             }
6046
6047           dynamic_strings = get_data (NULL, file, offset, 1, str_tab_len,
6048                                       _("dynamic string table"));
6049           dynamic_strings_length = str_tab_len;
6050           break;
6051         }
6052     }
6053
6054   /* And find the syminfo section if available.  */
6055   if (dynamic_syminfo == NULL)
6056     {
6057       unsigned long syminsz = 0;
6058
6059       for (entry = dynamic_section;
6060            entry < dynamic_section + dynamic_nent;
6061            ++entry)
6062         {
6063           if (entry->d_tag == DT_SYMINENT)
6064             {
6065               /* Note: these braces are necessary to avoid a syntax
6066                  error from the SunOS4 C compiler.  */
6067               assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
6068             }
6069           else if (entry->d_tag == DT_SYMINSZ)
6070             syminsz = entry->d_un.d_val;
6071           else if (entry->d_tag == DT_SYMINFO)
6072             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
6073                                                       syminsz);
6074         }
6075
6076       if (dynamic_syminfo_offset != 0 && syminsz != 0)
6077         {
6078           Elf_External_Syminfo *extsyminfo, *extsym;
6079           Elf_Internal_Syminfo *syminfo;
6080
6081           /* There is a syminfo section.  Read the data.  */
6082           extsyminfo = get_data (NULL, file, dynamic_syminfo_offset, 1,
6083                                  syminsz, _("symbol information"));
6084           if (!extsyminfo)
6085             return 0;
6086
6087           dynamic_syminfo = malloc (syminsz);
6088           if (dynamic_syminfo == NULL)
6089             {
6090               error (_("Out of memory\n"));
6091               return 0;
6092             }
6093
6094           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
6095           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
6096                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
6097                ++syminfo, ++extsym)
6098             {
6099               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
6100               syminfo->si_flags = BYTE_GET (extsym->si_flags);
6101             }
6102
6103           free (extsyminfo);
6104         }
6105     }
6106
6107   if (do_dynamic && dynamic_addr)
6108     printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6109             dynamic_addr, dynamic_nent);
6110   if (do_dynamic)
6111     printf (_("  Tag        Type                         Name/Value\n"));
6112
6113   for (entry = dynamic_section;
6114        entry < dynamic_section + dynamic_nent;
6115        entry++)
6116     {
6117       if (do_dynamic)
6118         {
6119           const char *dtype;
6120
6121           putchar (' ');
6122           print_vma (entry->d_tag, FULL_HEX);
6123           dtype = get_dynamic_type (entry->d_tag);
6124           printf (" (%s)%*s", dtype,
6125                   ((is_32bit_elf ? 27 : 19)
6126                    - (int) strlen (dtype)),
6127                   " ");
6128         }
6129
6130       switch (entry->d_tag)
6131         {
6132         case DT_FLAGS:
6133           if (do_dynamic)
6134             print_dynamic_flags (entry->d_un.d_val);
6135           break;
6136
6137         case DT_AUXILIARY:
6138         case DT_FILTER:
6139         case DT_CONFIG:
6140         case DT_DEPAUDIT:
6141         case DT_AUDIT:
6142           if (do_dynamic)
6143             {
6144               switch (entry->d_tag)
6145                 {
6146                 case DT_AUXILIARY:
6147                   printf (_("Auxiliary library"));
6148                   break;
6149
6150                 case DT_FILTER:
6151                   printf (_("Filter library"));
6152                   break;
6153
6154                 case DT_CONFIG:
6155                   printf (_("Configuration file"));
6156                   break;
6157
6158                 case DT_DEPAUDIT:
6159                   printf (_("Dependency audit library"));
6160                   break;
6161
6162                 case DT_AUDIT:
6163                   printf (_("Audit library"));
6164                   break;
6165                 }
6166
6167               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6168                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
6169               else
6170                 {
6171                   printf (": ");
6172                   print_vma (entry->d_un.d_val, PREFIX_HEX);
6173                   putchar ('\n');
6174                 }
6175             }
6176           break;
6177
6178         case DT_FEATURE:
6179           if (do_dynamic)
6180             {
6181               printf (_("Flags:"));
6182
6183               if (entry->d_un.d_val == 0)
6184                 printf (_(" None\n"));
6185               else
6186                 {
6187                   unsigned long int val = entry->d_un.d_val;
6188
6189                   if (val & DTF_1_PARINIT)
6190                     {
6191                       printf (" PARINIT");
6192                       val ^= DTF_1_PARINIT;
6193                     }
6194                   if (val & DTF_1_CONFEXP)
6195                     {
6196                       printf (" CONFEXP");
6197                       val ^= DTF_1_CONFEXP;
6198                     }
6199                   if (val != 0)
6200                     printf (" %lx", val);
6201                   puts ("");
6202                 }
6203             }
6204           break;
6205
6206         case DT_POSFLAG_1:
6207           if (do_dynamic)
6208             {
6209               printf (_("Flags:"));
6210
6211               if (entry->d_un.d_val == 0)
6212                 printf (_(" None\n"));
6213               else
6214                 {
6215                   unsigned long int val = entry->d_un.d_val;
6216
6217                   if (val & DF_P1_LAZYLOAD)
6218                     {
6219                       printf (" LAZYLOAD");
6220                       val ^= DF_P1_LAZYLOAD;
6221                     }
6222                   if (val & DF_P1_GROUPPERM)
6223                     {
6224                       printf (" GROUPPERM");
6225                       val ^= DF_P1_GROUPPERM;
6226                     }
6227                   if (val != 0)
6228                     printf (" %lx", val);
6229                   puts ("");
6230                 }
6231             }
6232           break;
6233
6234         case DT_FLAGS_1:
6235           if (do_dynamic)
6236             {
6237               printf (_("Flags:"));
6238               if (entry->d_un.d_val == 0)
6239                 printf (_(" None\n"));
6240               else
6241                 {
6242                   unsigned long int val = entry->d_un.d_val;
6243
6244                   if (val & DF_1_NOW)
6245                     {
6246                       printf (" NOW");
6247                       val ^= DF_1_NOW;
6248                     }
6249                   if (val & DF_1_GLOBAL)
6250                     {
6251                       printf (" GLOBAL");
6252                       val ^= DF_1_GLOBAL;
6253                     }
6254                   if (val & DF_1_GROUP)
6255                     {
6256                       printf (" GROUP");
6257                       val ^= DF_1_GROUP;
6258                     }
6259                   if (val & DF_1_NODELETE)
6260                     {
6261                       printf (" NODELETE");
6262                       val ^= DF_1_NODELETE;
6263                     }
6264                   if (val & DF_1_LOADFLTR)
6265                     {
6266                       printf (" LOADFLTR");
6267                       val ^= DF_1_LOADFLTR;
6268                     }
6269                   if (val & DF_1_INITFIRST)
6270                     {
6271                       printf (" INITFIRST");
6272                       val ^= DF_1_INITFIRST;
6273                     }
6274                   if (val & DF_1_NOOPEN)
6275                     {
6276                       printf (" NOOPEN");
6277                       val ^= DF_1_NOOPEN;
6278                     }
6279                   if (val & DF_1_ORIGIN)
6280                     {
6281                       printf (" ORIGIN");
6282                       val ^= DF_1_ORIGIN;
6283                     }
6284                   if (val & DF_1_DIRECT)
6285                     {
6286                       printf (" DIRECT");
6287                       val ^= DF_1_DIRECT;
6288                     }
6289                   if (val & DF_1_TRANS)
6290                     {
6291                       printf (" TRANS");
6292                       val ^= DF_1_TRANS;
6293                     }
6294                   if (val & DF_1_INTERPOSE)
6295                     {
6296                       printf (" INTERPOSE");
6297                       val ^= DF_1_INTERPOSE;
6298                     }
6299                   if (val & DF_1_NODEFLIB)
6300                     {
6301                       printf (" NODEFLIB");
6302                       val ^= DF_1_NODEFLIB;
6303                     }
6304                   if (val & DF_1_NODUMP)
6305                     {
6306                       printf (" NODUMP");
6307                       val ^= DF_1_NODUMP;
6308                     }
6309                   if (val & DF_1_CONLFAT)
6310                     {
6311                       printf (" CONLFAT");
6312                       val ^= DF_1_CONLFAT;
6313                     }
6314                   if (val != 0)
6315                     printf (" %lx", val);
6316                   puts ("");
6317                 }
6318             }
6319           break;
6320
6321         case DT_PLTREL:
6322           dynamic_info[entry->d_tag] = entry->d_un.d_val;
6323           if (do_dynamic)
6324             puts (get_dynamic_type (entry->d_un.d_val));
6325           break;
6326
6327         case DT_NULL    :
6328         case DT_NEEDED  :
6329         case DT_PLTGOT  :
6330         case DT_HASH    :
6331         case DT_STRTAB  :
6332         case DT_SYMTAB  :
6333         case DT_RELA    :
6334         case DT_INIT    :
6335         case DT_FINI    :
6336         case DT_SONAME  :
6337         case DT_RPATH   :
6338         case DT_SYMBOLIC:
6339         case DT_REL     :
6340         case DT_DEBUG   :
6341         case DT_TEXTREL :
6342         case DT_JMPREL  :
6343         case DT_RUNPATH :
6344           dynamic_info[entry->d_tag] = entry->d_un.d_val;
6345
6346           if (do_dynamic)
6347             {
6348               char *name;
6349
6350               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6351                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
6352               else
6353                 name = NULL;
6354
6355               if (name)
6356                 {
6357                   switch (entry->d_tag)
6358                     {
6359                     case DT_NEEDED:
6360                       printf (_("Shared library: [%s]"), name);
6361
6362                       if (streq (name, program_interpreter))
6363                         printf (_(" program interpreter"));
6364                       break;
6365
6366                     case DT_SONAME:
6367                       printf (_("Library soname: [%s]"), name);
6368                       break;
6369
6370                     case DT_RPATH:
6371                       printf (_("Library rpath: [%s]"), name);
6372                       break;
6373
6374                     case DT_RUNPATH:
6375                       printf (_("Library runpath: [%s]"), name);
6376                       break;
6377
6378                     default:
6379                       print_vma (entry->d_un.d_val, PREFIX_HEX);
6380                       break;
6381                     }
6382                 }
6383               else
6384                 print_vma (entry->d_un.d_val, PREFIX_HEX);
6385
6386               putchar ('\n');
6387             }
6388           break;
6389
6390         case DT_PLTRELSZ:
6391         case DT_RELASZ  :
6392         case DT_STRSZ   :
6393         case DT_RELSZ   :
6394         case DT_RELAENT :
6395         case DT_SYMENT  :
6396         case DT_RELENT  :
6397           dynamic_info[entry->d_tag] = entry->d_un.d_val;
6398         case DT_PLTPADSZ:
6399         case DT_MOVEENT :
6400         case DT_MOVESZ  :
6401         case DT_INIT_ARRAYSZ:
6402         case DT_FINI_ARRAYSZ:
6403         case DT_GNU_CONFLICTSZ:
6404         case DT_GNU_LIBLISTSZ:
6405           if (do_dynamic)
6406             {
6407               print_vma (entry->d_un.d_val, UNSIGNED);
6408               printf (" (bytes)\n");
6409             }
6410           break;
6411
6412         case DT_VERDEFNUM:
6413         case DT_VERNEEDNUM:
6414         case DT_RELACOUNT:
6415         case DT_RELCOUNT:
6416           if (do_dynamic)
6417             {
6418               print_vma (entry->d_un.d_val, UNSIGNED);
6419               putchar ('\n');
6420             }
6421           break;
6422
6423         case DT_SYMINSZ:
6424         case DT_SYMINENT:
6425         case DT_SYMINFO:
6426         case DT_USED:
6427         case DT_INIT_ARRAY:
6428         case DT_FINI_ARRAY:
6429           if (do_dynamic)
6430             {
6431               if (entry->d_tag == DT_USED
6432                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
6433                 {
6434                   char *name = GET_DYNAMIC_NAME (entry->d_un.d_val);
6435
6436                   if (*name)
6437                     {
6438                       printf (_("Not needed object: [%s]\n"), name);
6439                       break;
6440                     }
6441                 }
6442
6443               print_vma (entry->d_un.d_val, PREFIX_HEX);
6444               putchar ('\n');
6445             }
6446           break;
6447
6448         case DT_BIND_NOW:
6449           /* The value of this entry is ignored.  */
6450           if (do_dynamic)
6451             putchar ('\n');
6452           break;
6453
6454         case DT_GNU_PRELINKED:
6455           if (do_dynamic)
6456             {
6457               struct tm *tmp;
6458               time_t time = entry->d_un.d_val;
6459
6460               tmp = gmtime (&time);
6461               printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6462                       tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
6463                       tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
6464
6465             }
6466           break;
6467
6468         case DT_GNU_HASH:
6469           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
6470           if (do_dynamic)
6471             {
6472               print_vma (entry->d_un.d_val, PREFIX_HEX);
6473               putchar ('\n');
6474             }
6475           break;
6476
6477         default:
6478           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
6479             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
6480               entry->d_un.d_val;
6481
6482           if (do_dynamic)
6483             {
6484               switch (elf_header.e_machine)
6485                 {
6486                 case EM_MIPS:
6487                 case EM_MIPS_RS3_LE:
6488                   dynamic_section_mips_val (entry);
6489                   break;
6490                 case EM_PARISC:
6491                   dynamic_section_parisc_val (entry);
6492                   break;
6493                 case EM_IA_64:
6494                   dynamic_section_ia64_val (entry);
6495                   break;
6496                 default:
6497                   print_vma (entry->d_un.d_val, PREFIX_HEX);
6498                   putchar ('\n');
6499                 }
6500             }
6501           break;
6502         }
6503     }
6504
6505   return 1;
6506 }
6507
6508 static char *
6509 get_ver_flags (unsigned int flags)
6510 {
6511   static char buff[32];
6512
6513   buff[0] = 0;
6514
6515   if (flags == 0)
6516     return _("none");
6517
6518   if (flags & VER_FLG_BASE)
6519     strcat (buff, "BASE ");
6520
6521   if (flags & VER_FLG_WEAK)
6522     {
6523       if (flags & VER_FLG_BASE)
6524         strcat (buff, "| ");
6525
6526       strcat (buff, "WEAK ");
6527     }
6528
6529   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
6530     strcat (buff, "| <unknown>");
6531
6532   return buff;
6533 }
6534
6535 /* Display the contents of the version sections.  */
6536 static int
6537 process_version_sections (FILE *file)
6538 {
6539   Elf_Internal_Shdr *section;
6540   unsigned i;
6541   int found = 0;
6542
6543   if (! do_version)
6544     return 1;
6545
6546   for (i = 0, section = section_headers;
6547        i < elf_header.e_shnum;
6548        i++, section++)
6549     {
6550       switch (section->sh_type)
6551         {
6552         case SHT_GNU_verdef:
6553           {
6554             Elf_External_Verdef *edefs;
6555             unsigned int idx;
6556             unsigned int cnt;
6557             char *endbuf;
6558
6559             found = 1;
6560
6561             printf
6562               (_("\nVersion definition section '%s' contains %ld entries:\n"),
6563                SECTION_NAME (section), section->sh_info);
6564
6565             printf (_("  Addr: 0x"));
6566             printf_vma (section->sh_addr);
6567             printf (_("  Offset: %#08lx  Link: %lx (%s)\n"),
6568                     (unsigned long) section->sh_offset, section->sh_link,
6569                     section->sh_link < elf_header.e_shnum
6570                     ? SECTION_NAME (section_headers + section->sh_link)
6571                     : "<corrupt>");
6572
6573             edefs = get_data (NULL, file, section->sh_offset, 1,
6574                               section->sh_size,
6575                               _("version definition section"));
6576             endbuf = (char *) edefs + section->sh_size;
6577             if (!edefs)
6578               break;
6579
6580             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6581               {
6582                 char *vstart;
6583                 Elf_External_Verdef *edef;
6584                 Elf_Internal_Verdef ent;
6585                 Elf_External_Verdaux *eaux;
6586                 Elf_Internal_Verdaux aux;
6587                 int j;
6588                 int isum;
6589
6590                 vstart = ((char *) edefs) + idx;
6591                 if (vstart + sizeof (*edef) > endbuf)
6592                   break;
6593
6594                 edef = (Elf_External_Verdef *) vstart;
6595
6596                 ent.vd_version = BYTE_GET (edef->vd_version);
6597                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
6598                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
6599                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
6600                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
6601                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
6602                 ent.vd_next    = BYTE_GET (edef->vd_next);
6603
6604                 printf (_("  %#06x: Rev: %d  Flags: %s"),
6605                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
6606
6607                 printf (_("  Index: %d  Cnt: %d  "),
6608                         ent.vd_ndx, ent.vd_cnt);
6609
6610                 vstart += ent.vd_aux;
6611
6612                 eaux = (Elf_External_Verdaux *) vstart;
6613
6614                 aux.vda_name = BYTE_GET (eaux->vda_name);
6615                 aux.vda_next = BYTE_GET (eaux->vda_next);
6616
6617                 if (VALID_DYNAMIC_NAME (aux.vda_name))
6618                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
6619                 else
6620                   printf (_("Name index: %ld\n"), aux.vda_name);
6621
6622                 isum = idx + ent.vd_aux;
6623
6624                 for (j = 1; j < ent.vd_cnt; j++)
6625                   {
6626                     isum   += aux.vda_next;
6627                     vstart += aux.vda_next;
6628
6629                     eaux = (Elf_External_Verdaux *) vstart;
6630                     if (vstart + sizeof (*eaux) > endbuf)
6631                       break;
6632
6633                     aux.vda_name = BYTE_GET (eaux->vda_name);
6634                     aux.vda_next = BYTE_GET (eaux->vda_next);
6635
6636                     if (VALID_DYNAMIC_NAME (aux.vda_name))
6637                       printf (_("  %#06x: Parent %d: %s\n"),
6638                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
6639                     else
6640                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
6641                               isum, j, aux.vda_name);
6642                   }
6643                 if (j < ent.vd_cnt)
6644                   printf (_("  Version def aux past end of section\n"));
6645
6646                 idx += ent.vd_next;
6647               }
6648             if (cnt < section->sh_info)
6649               printf (_("  Version definition past end of section\n"));
6650
6651             free (edefs);
6652           }
6653           break;
6654
6655         case SHT_GNU_verneed:
6656           {
6657             Elf_External_Verneed *eneed;
6658             unsigned int idx;
6659             unsigned int cnt;
6660             char *endbuf;
6661
6662             found = 1;
6663
6664             printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6665                     SECTION_NAME (section), section->sh_info);
6666
6667             printf (_(" Addr: 0x"));
6668             printf_vma (section->sh_addr);
6669             printf (_("  Offset: %#08lx  Link to section: %ld (%s)\n"),
6670                     (unsigned long) section->sh_offset, section->sh_link,
6671                     section->sh_link < elf_header.e_shnum
6672                     ? SECTION_NAME (section_headers + section->sh_link)
6673                     : "<corrupt>");
6674
6675             eneed = get_data (NULL, file, section->sh_offset, 1,
6676                               section->sh_size,
6677                               _("version need section"));
6678             endbuf = (char *) eneed + section->sh_size;
6679             if (!eneed)
6680               break;
6681
6682             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6683               {
6684                 Elf_External_Verneed *entry;
6685                 Elf_Internal_Verneed ent;
6686                 int j;
6687                 int isum;
6688                 char *vstart;
6689
6690                 vstart = ((char *) eneed) + idx;
6691                 if (vstart + sizeof (*entry) > endbuf)
6692                   break;
6693
6694                 entry = (Elf_External_Verneed *) vstart;
6695
6696                 ent.vn_version = BYTE_GET (entry->vn_version);
6697                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
6698                 ent.vn_file    = BYTE_GET (entry->vn_file);
6699                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
6700                 ent.vn_next    = BYTE_GET (entry->vn_next);
6701
6702                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
6703
6704                 if (VALID_DYNAMIC_NAME (ent.vn_file))
6705                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
6706                 else
6707                   printf (_("  File: %lx"), ent.vn_file);
6708
6709                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
6710
6711                 vstart += ent.vn_aux;
6712
6713                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
6714                   {
6715                     Elf_External_Vernaux *eaux;
6716                     Elf_Internal_Vernaux aux;
6717
6718                     if (vstart + sizeof (*eaux) > endbuf)
6719                       break;
6720                     eaux = (Elf_External_Vernaux *) vstart;
6721
6722                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
6723                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
6724                     aux.vna_other = BYTE_GET (eaux->vna_other);
6725                     aux.vna_name  = BYTE_GET (eaux->vna_name);
6726                     aux.vna_next  = BYTE_GET (eaux->vna_next);
6727
6728                     if (VALID_DYNAMIC_NAME (aux.vna_name))
6729                       printf (_("  %#06x:   Name: %s"),
6730                               isum, GET_DYNAMIC_NAME (aux.vna_name));
6731                     else
6732                       printf (_("  %#06x:   Name index: %lx"),
6733                               isum, aux.vna_name);
6734
6735                     printf (_("  Flags: %s  Version: %d\n"),
6736                             get_ver_flags (aux.vna_flags), aux.vna_other);
6737
6738                     isum   += aux.vna_next;
6739                     vstart += aux.vna_next;
6740                   }
6741                 if (j < ent.vn_cnt)
6742                   printf (_("  Version need aux past end of section\n"));
6743
6744                 idx += ent.vn_next;
6745               }
6746             if (cnt < section->sh_info)
6747               printf (_("  Version need past end of section\n"));
6748
6749             free (eneed);
6750           }
6751           break;
6752
6753         case SHT_GNU_versym:
6754           {
6755             Elf_Internal_Shdr *link_section;
6756             int total;
6757             int cnt;
6758             unsigned char *edata;
6759             unsigned short *data;
6760             char *strtab;
6761             Elf_Internal_Sym *symbols;
6762             Elf_Internal_Shdr *string_sec;
6763             long off;
6764
6765             if (section->sh_link >= elf_header.e_shnum)
6766               break;
6767
6768             link_section = section_headers + section->sh_link;
6769             total = section->sh_size / sizeof (Elf_External_Versym);
6770
6771             if (link_section->sh_link >= elf_header.e_shnum)
6772               break;
6773
6774             found = 1;
6775
6776             symbols = GET_ELF_SYMBOLS (file, link_section);
6777
6778             string_sec = section_headers + link_section->sh_link;
6779
6780             strtab = get_data (NULL, file, string_sec->sh_offset, 1,
6781                                string_sec->sh_size, _("version string table"));
6782             if (!strtab)
6783               break;
6784
6785             printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6786                     SECTION_NAME (section), total);
6787
6788             printf (_(" Addr: "));
6789             printf_vma (section->sh_addr);
6790             printf (_("  Offset: %#08lx  Link: %lx (%s)\n"),
6791                     (unsigned long) section->sh_offset, section->sh_link,
6792                     SECTION_NAME (link_section));
6793
6794             off = offset_from_vma (file,
6795                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
6796                                    total * sizeof (short));
6797             edata = get_data (NULL, file, off, total, sizeof (short),
6798                               _("version symbol data"));
6799             if (!edata)
6800               {
6801                 free (strtab);
6802                 break;
6803               }
6804
6805             data = cmalloc (total, sizeof (short));
6806
6807             for (cnt = total; cnt --;)
6808               data[cnt] = byte_get (edata + cnt * sizeof (short),
6809                                     sizeof (short));
6810
6811             free (edata);
6812
6813             for (cnt = 0; cnt < total; cnt += 4)
6814               {
6815                 int j, nn;
6816                 int check_def, check_need;
6817                 char *name;
6818
6819                 printf ("  %03x:", cnt);
6820
6821                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
6822                   switch (data[cnt + j])
6823                     {
6824                     case 0:
6825                       fputs (_("   0 (*local*)    "), stdout);
6826                       break;
6827
6828                     case 1:
6829                       fputs (_("   1 (*global*)   "), stdout);
6830                       break;
6831
6832                     default:
6833                       nn = printf ("%4x%c", data[cnt + j] & 0x7fff,
6834                                    data[cnt + j] & 0x8000 ? 'h' : ' ');
6835
6836                       check_def = 1;
6837                       check_need = 1;
6838                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
6839                           || section_headers[symbols[cnt + j].st_shndx].sh_type
6840                              != SHT_NOBITS)
6841                         {
6842                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
6843                             check_def = 0;
6844                           else
6845                             check_need = 0;
6846                         }
6847
6848                       if (check_need
6849                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
6850                         {
6851                           Elf_Internal_Verneed ivn;
6852                           unsigned long offset;
6853
6854                           offset = offset_from_vma
6855                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
6856                              sizeof (Elf_External_Verneed));
6857
6858                           do
6859                             {
6860                               Elf_Internal_Vernaux ivna;
6861                               Elf_External_Verneed evn;
6862                               Elf_External_Vernaux evna;
6863                               unsigned long a_off;
6864
6865                               get_data (&evn, file, offset, sizeof (evn), 1,
6866                                         _("version need"));
6867
6868                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
6869                               ivn.vn_next = BYTE_GET (evn.vn_next);
6870
6871                               a_off = offset + ivn.vn_aux;
6872
6873                               do
6874                                 {
6875                                   get_data (&evna, file, a_off, sizeof (evna),
6876                                             1, _("version need aux (2)"));
6877
6878                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
6879                                   ivna.vna_other = BYTE_GET (evna.vna_other);
6880
6881                                   a_off += ivna.vna_next;
6882                                 }
6883                               while (ivna.vna_other != data[cnt + j]
6884                                      && ivna.vna_next != 0);
6885
6886                               if (ivna.vna_other == data[cnt + j])
6887                                 {
6888                                   ivna.vna_name = BYTE_GET (evna.vna_name);
6889
6890                                   if (ivna.vna_name >= string_sec->sh_size)
6891                                     name = _("*invalid*");
6892                                   else
6893                                     name = strtab + ivna.vna_name;
6894                                   nn += printf ("(%s%-*s",
6895                                                 name,
6896                                                 12 - (int) strlen (name),
6897                                                 ")");
6898                                   check_def = 0;
6899                                   break;
6900                                 }
6901
6902                               offset += ivn.vn_next;
6903                             }
6904                           while (ivn.vn_next);
6905                         }
6906
6907                       if (check_def && data[cnt + j] != 0x8001
6908                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
6909                         {
6910                           Elf_Internal_Verdef ivd;
6911                           Elf_External_Verdef evd;
6912                           unsigned long offset;
6913
6914                           offset = offset_from_vma
6915                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
6916                              sizeof evd);
6917
6918                           do
6919                             {
6920                               get_data (&evd, file, offset, sizeof (evd), 1,
6921                                         _("version def"));
6922
6923                               ivd.vd_next = BYTE_GET (evd.vd_next);
6924                               ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
6925
6926                               offset += ivd.vd_next;
6927                             }
6928                           while (ivd.vd_ndx != (data[cnt + j] & 0x7fff)
6929                                  && ivd.vd_next != 0);
6930
6931                           if (ivd.vd_ndx == (data[cnt + j] & 0x7fff))
6932                             {
6933                               Elf_External_Verdaux evda;
6934                               Elf_Internal_Verdaux ivda;
6935
6936                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
6937
6938                               get_data (&evda, file,
6939                                         offset - ivd.vd_next + ivd.vd_aux,
6940                                         sizeof (evda), 1,
6941                                         _("version def aux"));
6942
6943                               ivda.vda_name = BYTE_GET (evda.vda_name);
6944
6945                               if (ivda.vda_name >= string_sec->sh_size)
6946                                 name = _("*invalid*");
6947                               else
6948                                 name = strtab + ivda.vda_name;
6949                               nn += printf ("(%s%-*s",
6950                                             name,
6951                                             12 - (int) strlen (name),
6952                                             ")");
6953                             }
6954                         }
6955
6956                       if (nn < 18)
6957                         printf ("%*c", 18 - nn, ' ');
6958                     }
6959
6960                 putchar ('\n');
6961               }
6962
6963             free (data);
6964             free (strtab);
6965             free (symbols);
6966           }
6967           break;
6968
6969         default:
6970           break;
6971         }
6972     }
6973
6974   if (! found)
6975     printf (_("\nNo version information found in this file.\n"));
6976
6977   return 1;
6978 }
6979
6980 static const char *
6981 get_symbol_binding (unsigned int binding)
6982 {
6983   static char buff[32];
6984
6985   switch (binding)
6986     {
6987     case STB_LOCAL:     return "LOCAL";
6988     case STB_GLOBAL:    return "GLOBAL";
6989     case STB_WEAK:      return "WEAK";
6990     default:
6991       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
6992         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
6993                   binding);
6994       else if (binding >= STB_LOOS && binding <= STB_HIOS)
6995         snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
6996       else
6997         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
6998       return buff;
6999     }
7000 }
7001
7002 static const char *
7003 get_symbol_type (unsigned int type)
7004 {
7005   static char buff[32];
7006
7007   switch (type)
7008     {
7009     case STT_NOTYPE:    return "NOTYPE";
7010     case STT_OBJECT:    return "OBJECT";
7011     case STT_FUNC:      return "FUNC";
7012     case STT_SECTION:   return "SECTION";
7013     case STT_FILE:      return "FILE";
7014     case STT_COMMON:    return "COMMON";
7015     case STT_TLS:       return "TLS";
7016     case STT_RELC:      return "RELC";
7017     case STT_SRELC:     return "SRELC";
7018     default:
7019       if (type >= STT_LOPROC && type <= STT_HIPROC)
7020         {
7021           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
7022             return "THUMB_FUNC";
7023
7024           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
7025             return "REGISTER";
7026
7027           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
7028             return "PARISC_MILLI";
7029
7030           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
7031         }
7032       else if (type >= STT_LOOS && type <= STT_HIOS)
7033         {
7034           if (elf_header.e_machine == EM_PARISC)
7035             {
7036               if (type == STT_HP_OPAQUE)
7037                 return "HP_OPAQUE";
7038               if (type == STT_HP_STUB)
7039                 return "HP_STUB";
7040             }
7041
7042           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
7043         }
7044       else
7045         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
7046       return buff;
7047     }
7048 }
7049
7050 static const char *
7051 get_symbol_visibility (unsigned int visibility)
7052 {
7053   switch (visibility)
7054     {
7055     case STV_DEFAULT:   return "DEFAULT";
7056     case STV_INTERNAL:  return "INTERNAL";
7057     case STV_HIDDEN:    return "HIDDEN";
7058     case STV_PROTECTED: return "PROTECTED";
7059     default: abort ();
7060     }
7061 }
7062
7063 static const char *
7064 get_mips_symbol_other (unsigned int other)
7065 {
7066   switch (other)
7067     {
7068     case STO_OPTIONAL:  return "OPTIONAL";
7069     case STO_MIPS16:    return "MIPS16";
7070     default:            return NULL;
7071     }
7072 }
7073
7074 static const char *
7075 get_symbol_other (unsigned int other)
7076 {
7077   const char * result = NULL;
7078   static char buff [32];
7079
7080   if (other == 0)
7081     return "";
7082
7083   switch (elf_header.e_machine)
7084     {
7085     case EM_MIPS:
7086       result = get_mips_symbol_other (other);
7087     default:
7088       break;
7089     }
7090
7091   if (result)
7092     return result;
7093
7094   snprintf (buff, sizeof buff, _("<other>: %x"), other);
7095   return buff;
7096 }
7097
7098 static const char *
7099 get_symbol_index_type (unsigned int type)
7100 {
7101   static char buff[32];
7102
7103   switch (type)
7104     {
7105     case SHN_UNDEF:     return "UND";
7106     case SHN_ABS:       return "ABS";
7107     case SHN_COMMON:    return "COM";
7108     default:
7109       if (type == SHN_IA_64_ANSI_COMMON
7110           && elf_header.e_machine == EM_IA_64
7111           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
7112         return "ANSI_COM";
7113       else if (elf_header.e_machine == EM_X86_64
7114                && type == SHN_X86_64_LCOMMON)
7115         return "LARGE_COM";
7116       else if (type == SHN_MIPS_SCOMMON
7117                && elf_header.e_machine == EM_MIPS)
7118         return "SCOM";
7119       else if (type == SHN_MIPS_SUNDEFINED
7120                && elf_header.e_machine == EM_MIPS)
7121         return "SUND";
7122       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
7123         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
7124       else if (type >= SHN_LOOS && type <= SHN_HIOS)
7125         sprintf (buff, "OS [0x%04x]", type & 0xffff);
7126       else if (type >= SHN_LORESERVE)
7127         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
7128       else
7129         sprintf (buff, "%3d", type);
7130       break;
7131     }
7132
7133   return buff;
7134 }
7135
7136 static bfd_vma *
7137 get_dynamic_data (FILE *file, unsigned int number, unsigned int ent_size)
7138 {
7139   unsigned char *e_data;
7140   bfd_vma *i_data;
7141
7142   e_data = cmalloc (number, ent_size);
7143
7144   if (e_data == NULL)
7145     {
7146       error (_("Out of memory\n"));
7147       return NULL;
7148     }
7149
7150   if (fread (e_data, ent_size, number, file) != number)
7151     {
7152       error (_("Unable to read in dynamic data\n"));
7153       return NULL;
7154     }
7155
7156   i_data = cmalloc (number, sizeof (*i_data));
7157
7158   if (i_data == NULL)
7159     {
7160       error (_("Out of memory\n"));
7161       free (e_data);
7162       return NULL;
7163     }
7164
7165   while (number--)
7166     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
7167
7168   free (e_data);
7169
7170   return i_data;
7171 }
7172
7173 static void
7174 print_dynamic_symbol (bfd_vma si, unsigned long hn)
7175 {
7176   Elf_Internal_Sym *psym;
7177   int n;
7178
7179   psym = dynamic_symbols + si;
7180
7181   n = print_vma (si, DEC_5);
7182   if (n < 5)
7183     fputs ("     " + n, stdout);
7184   printf (" %3lu: ", hn);
7185   print_vma (psym->st_value, LONG_HEX);
7186   putchar (' ');
7187   print_vma (psym->st_size, DEC_5);
7188
7189   printf ("  %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
7190   printf (" %6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
7191   printf (" %3s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
7192   /* Check to see if any other bits in the st_other field are set.
7193      Note - displaying this information disrupts the layout of the
7194      table being generated, but for the moment this case is very
7195      rare.  */
7196   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
7197     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
7198   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
7199   if (VALID_DYNAMIC_NAME (psym->st_name))
7200     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
7201   else
7202     printf (" <corrupt: %14ld>", psym->st_name);
7203   putchar ('\n');
7204 }
7205
7206 /* Dump the symbol table.  */
7207 static int
7208 process_symbol_table (FILE *file)
7209 {
7210   Elf_Internal_Shdr *section;
7211   bfd_vma nbuckets = 0;
7212   bfd_vma nchains = 0;
7213   bfd_vma *buckets = NULL;
7214   bfd_vma *chains = NULL;
7215   bfd_vma ngnubuckets = 0;
7216   bfd_vma *gnubuckets = NULL;
7217   bfd_vma *gnuchains = NULL;
7218   bfd_vma gnusymidx = 0;
7219
7220   if (! do_syms && !do_histogram)
7221     return 1;
7222
7223   if (dynamic_info[DT_HASH]
7224       && (do_histogram
7225           || (do_using_dynamic && dynamic_strings != NULL)))
7226     {
7227       unsigned char nb[8];
7228       unsigned char nc[8];
7229       int hash_ent_size = 4;
7230
7231       if ((elf_header.e_machine == EM_ALPHA
7232            || elf_header.e_machine == EM_S390
7233            || elf_header.e_machine == EM_S390_OLD)
7234           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
7235         hash_ent_size = 8;
7236
7237       if (fseek (file,
7238                  (archive_file_offset
7239                   + offset_from_vma (file, dynamic_info[DT_HASH],
7240                                      sizeof nb + sizeof nc)),
7241                  SEEK_SET))
7242         {
7243           error (_("Unable to seek to start of dynamic information\n"));
7244           return 0;
7245         }
7246
7247       if (fread (nb, hash_ent_size, 1, file) != 1)
7248         {
7249           error (_("Failed to read in number of buckets\n"));
7250           return 0;
7251         }
7252
7253       if (fread (nc, hash_ent_size, 1, file) != 1)
7254         {
7255           error (_("Failed to read in number of chains\n"));
7256           return 0;
7257         }
7258
7259       nbuckets = byte_get (nb, hash_ent_size);
7260       nchains  = byte_get (nc, hash_ent_size);
7261
7262       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
7263       chains  = get_dynamic_data (file, nchains, hash_ent_size);
7264
7265       if (buckets == NULL || chains == NULL)
7266         return 0;
7267     }
7268
7269   if (dynamic_info_DT_GNU_HASH
7270       && (do_histogram
7271           || (do_using_dynamic && dynamic_strings != NULL)))
7272     {
7273       unsigned char nb[16];
7274       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
7275       bfd_vma buckets_vma;
7276
7277       if (fseek (file,
7278                  (archive_file_offset
7279                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
7280                                      sizeof nb)),
7281                  SEEK_SET))
7282         {
7283           error (_("Unable to seek to start of dynamic information\n"));
7284           return 0;
7285         }
7286
7287       if (fread (nb, 16, 1, file) != 1)
7288         {
7289           error (_("Failed to read in number of buckets\n"));
7290           return 0;
7291         }
7292
7293       ngnubuckets = byte_get (nb, 4);
7294       gnusymidx = byte_get (nb + 4, 4);
7295       bitmaskwords = byte_get (nb + 8, 4);
7296       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
7297       if (is_32bit_elf)
7298         buckets_vma += bitmaskwords * 4;
7299       else
7300         buckets_vma += bitmaskwords * 8;
7301
7302       if (fseek (file,
7303                  (archive_file_offset
7304                   + offset_from_vma (file, buckets_vma, 4)),
7305                  SEEK_SET))
7306         {
7307           error (_("Unable to seek to start of dynamic information\n"));
7308           return 0;
7309         }
7310
7311       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
7312
7313       if (gnubuckets == NULL)
7314         return 0;
7315
7316       for (i = 0; i < ngnubuckets; i++)
7317         if (gnubuckets[i] != 0)
7318           {
7319             if (gnubuckets[i] < gnusymidx)
7320               return 0;
7321
7322             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
7323               maxchain = gnubuckets[i];
7324           }
7325
7326       if (maxchain == 0xffffffff)
7327         return 0;
7328
7329       maxchain -= gnusymidx;
7330
7331       if (fseek (file,
7332                  (archive_file_offset
7333                   + offset_from_vma (file, buckets_vma
7334                                            + 4 * (ngnubuckets + maxchain), 4)),
7335                  SEEK_SET))
7336         {
7337           error (_("Unable to seek to start of dynamic information\n"));
7338           return 0;
7339         }
7340
7341       do
7342         {
7343           if (fread (nb, 4, 1, file) != 1)
7344             {
7345               error (_("Failed to determine last chain length\n"));
7346               return 0;
7347             }
7348
7349           if (maxchain + 1 == 0)
7350             return 0;
7351
7352           ++maxchain;
7353         }
7354       while ((byte_get (nb, 4) & 1) == 0);
7355
7356       if (fseek (file,
7357                  (archive_file_offset
7358                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
7359                  SEEK_SET))
7360         {
7361           error (_("Unable to seek to start of dynamic information\n"));
7362           return 0;
7363         }
7364
7365       gnuchains = get_dynamic_data (file, maxchain, 4);
7366
7367       if (gnuchains == NULL)
7368         return 0;
7369     }
7370
7371   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
7372       && do_syms
7373       && do_using_dynamic
7374       && dynamic_strings != NULL)
7375     {
7376       unsigned long hn;
7377
7378       if (dynamic_info[DT_HASH])
7379         {
7380           bfd_vma si;
7381
7382           printf (_("\nSymbol table for image:\n"));
7383           if (is_32bit_elf)
7384             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
7385           else
7386             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
7387
7388           for (hn = 0; hn < nbuckets; hn++)
7389             {
7390               if (! buckets[hn])
7391                 continue;
7392
7393               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
7394                 print_dynamic_symbol (si, hn);
7395             }
7396         }
7397
7398       if (dynamic_info_DT_GNU_HASH)
7399         {
7400           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7401           if (is_32bit_elf)
7402             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
7403           else
7404             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
7405
7406           for (hn = 0; hn < ngnubuckets; ++hn)
7407             if (gnubuckets[hn] != 0)
7408               {
7409                 bfd_vma si = gnubuckets[hn];
7410                 bfd_vma off = si - gnusymidx;
7411
7412                 do
7413                   {
7414                     print_dynamic_symbol (si, hn);
7415                     si++;
7416                   }
7417                 while ((gnuchains[off++] & 1) == 0);
7418               }
7419         }
7420     }
7421   else if (do_syms && !do_using_dynamic)
7422     {
7423       unsigned int i;
7424
7425       for (i = 0, section = section_headers;
7426            i < elf_header.e_shnum;
7427            i++, section++)
7428         {
7429           unsigned int si;
7430           char *strtab = NULL;
7431           unsigned long int strtab_size = 0;
7432           Elf_Internal_Sym *symtab;
7433           Elf_Internal_Sym *psym;
7434
7435
7436           if (   section->sh_type != SHT_SYMTAB
7437               && section->sh_type != SHT_DYNSYM)
7438             continue;
7439
7440           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7441                   SECTION_NAME (section),
7442                   (unsigned long) (section->sh_size / section->sh_entsize));
7443           if (is_32bit_elf)
7444             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
7445           else
7446             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
7447
7448           symtab = GET_ELF_SYMBOLS (file, section);
7449           if (symtab == NULL)
7450             continue;
7451
7452           if (section->sh_link == elf_header.e_shstrndx)
7453             {
7454               strtab = string_table;
7455               strtab_size = string_table_length;
7456             }
7457           else if (section->sh_link < elf_header.e_shnum)
7458             {
7459               Elf_Internal_Shdr *string_sec;
7460
7461               string_sec = section_headers + section->sh_link;
7462
7463               strtab = get_data (NULL, file, string_sec->sh_offset,
7464                                  1, string_sec->sh_size, _("string table"));
7465               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
7466             }
7467
7468           for (si = 0, psym = symtab;
7469                si < section->sh_size / section->sh_entsize;
7470                si++, psym++)
7471             {
7472               printf ("%6d: ", si);
7473               print_vma (psym->st_value, LONG_HEX);
7474               putchar (' ');
7475               print_vma (psym->st_size, DEC_5);
7476               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
7477               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
7478               printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
7479               /* Check to see if any other bits in the st_other field are set.
7480                  Note - displaying this information disrupts the layout of the
7481                  table being generated, but for the moment this case is very rare.  */
7482               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
7483                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
7484               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
7485               print_symbol (25, psym->st_name < strtab_size
7486                             ? strtab + psym->st_name : "<corrupt>");
7487
7488               if (section->sh_type == SHT_DYNSYM &&
7489                   version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
7490                 {
7491                   unsigned char data[2];
7492                   unsigned short vers_data;
7493                   unsigned long offset;
7494                   int is_nobits;
7495                   int check_def;
7496
7497                   offset = offset_from_vma
7498                     (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
7499                      sizeof data + si * sizeof (vers_data));
7500
7501                   get_data (&data, file, offset + si * sizeof (vers_data),
7502                             sizeof (data), 1, _("version data"));
7503
7504                   vers_data = byte_get (data, 2);
7505
7506                   is_nobits = (psym->st_shndx < elf_header.e_shnum
7507                                && section_headers[psym->st_shndx].sh_type
7508                                   == SHT_NOBITS);
7509
7510                   check_def = (psym->st_shndx != SHN_UNDEF);
7511
7512                   if ((vers_data & 0x8000) || vers_data > 1)
7513                     {
7514                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
7515                           && (is_nobits || ! check_def))
7516                         {
7517                           Elf_External_Verneed evn;
7518                           Elf_Internal_Verneed ivn;
7519                           Elf_Internal_Vernaux ivna;
7520
7521                           /* We must test both.  */
7522                           offset = offset_from_vma
7523                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
7524                              sizeof evn);
7525
7526                           do
7527                             {
7528                               unsigned long vna_off;
7529
7530                               get_data (&evn, file, offset, sizeof (evn), 1,
7531                                         _("version need"));
7532
7533                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
7534                               ivn.vn_next = BYTE_GET (evn.vn_next);
7535
7536                               vna_off = offset + ivn.vn_aux;
7537
7538                               do
7539                                 {
7540                                   Elf_External_Vernaux evna;
7541
7542                                   get_data (&evna, file, vna_off,
7543                                             sizeof (evna), 1,
7544                                             _("version need aux (3)"));
7545
7546                                   ivna.vna_other = BYTE_GET (evna.vna_other);
7547                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
7548                                   ivna.vna_name  = BYTE_GET (evna.vna_name);
7549
7550                                   vna_off += ivna.vna_next;
7551                                 }
7552                               while (ivna.vna_other != vers_data
7553                                      && ivna.vna_next != 0);
7554
7555                               if (ivna.vna_other == vers_data)
7556                                 break;
7557
7558                               offset += ivn.vn_next;
7559                             }
7560                           while (ivn.vn_next != 0);
7561
7562                           if (ivna.vna_other == vers_data)
7563                             {
7564                               printf ("@%s (%d)",
7565                                       ivna.vna_name < strtab_size
7566                                       ? strtab + ivna.vna_name : "<corrupt>",
7567                                       ivna.vna_other);
7568                               check_def = 0;
7569                             }
7570                           else if (! is_nobits)
7571                             error (_("bad dynamic symbol\n"));
7572                           else
7573                             check_def = 1;
7574                         }
7575
7576                       if (check_def)
7577                         {
7578                           if (vers_data != 0x8001
7579                               && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
7580                             {
7581                               Elf_Internal_Verdef ivd;
7582                               Elf_Internal_Verdaux ivda;
7583                               Elf_External_Verdaux evda;
7584                               unsigned long offset;
7585
7586                               offset = offset_from_vma
7587                                 (file,
7588                                  version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
7589                                  sizeof (Elf_External_Verdef));
7590
7591                               do
7592                                 {
7593                                   Elf_External_Verdef evd;
7594
7595                                   get_data (&evd, file, offset, sizeof (evd),
7596                                             1, _("version def"));
7597
7598                                   ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
7599                                   ivd.vd_aux = BYTE_GET (evd.vd_aux);
7600                                   ivd.vd_next = BYTE_GET (evd.vd_next);
7601
7602                                   offset += ivd.vd_next;
7603                                 }
7604                               while (ivd.vd_ndx != (vers_data & 0x7fff)
7605                                      && ivd.vd_next != 0);
7606
7607                               offset -= ivd.vd_next;
7608                               offset += ivd.vd_aux;
7609
7610                               get_data (&evda, file, offset, sizeof (evda),
7611                                         1, _("version def aux"));
7612
7613                               ivda.vda_name = BYTE_GET (evda.vda_name);
7614
7615                               if (psym->st_name != ivda.vda_name)
7616                                 printf ((vers_data & 0x8000)
7617                                         ? "@%s" : "@@%s",
7618                                         ivda.vda_name < strtab_size
7619                                         ? strtab + ivda.vda_name : "<corrupt>");
7620                             }
7621                         }
7622                     }
7623                 }
7624
7625               putchar ('\n');
7626             }
7627
7628           free (symtab);
7629           if (strtab != string_table)
7630             free (strtab);
7631         }
7632     }
7633   else if (do_syms)
7634     printf
7635       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7636
7637   if (do_histogram && buckets != NULL)
7638     {
7639       unsigned long *lengths;
7640       unsigned long *counts;
7641       unsigned long hn;
7642       bfd_vma si;
7643       unsigned long maxlength = 0;
7644       unsigned long nzero_counts = 0;
7645       unsigned long nsyms = 0;
7646
7647       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7648               (unsigned long) nbuckets);
7649       printf (_(" Length  Number     %% of total  Coverage\n"));
7650
7651       lengths = calloc (nbuckets, sizeof (*lengths));
7652       if (lengths == NULL)
7653         {
7654           error (_("Out of memory\n"));
7655           return 0;
7656         }
7657       for (hn = 0; hn < nbuckets; ++hn)
7658         {
7659           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
7660             {
7661               ++nsyms;
7662               if (maxlength < ++lengths[hn])
7663                 ++maxlength;
7664             }
7665         }
7666
7667       counts = calloc (maxlength + 1, sizeof (*counts));
7668       if (counts == NULL)
7669         {
7670           error (_("Out of memory\n"));
7671           return 0;
7672         }
7673
7674       for (hn = 0; hn < nbuckets; ++hn)
7675         ++counts[lengths[hn]];
7676
7677       if (nbuckets > 0)
7678         {
7679           unsigned long i;
7680           printf ("      0  %-10lu (%5.1f%%)\n",
7681                   counts[0], (counts[0] * 100.0) / nbuckets);
7682           for (i = 1; i <= maxlength; ++i)
7683             {
7684               nzero_counts += counts[i] * i;
7685               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
7686                       i, counts[i], (counts[i] * 100.0) / nbuckets,
7687                       (nzero_counts * 100.0) / nsyms);
7688             }
7689         }
7690
7691       free (counts);
7692       free (lengths);
7693     }
7694
7695   if (buckets != NULL)
7696     {
7697       free (buckets);
7698       free (chains);
7699     }
7700
7701   if (do_histogram && dynamic_info_DT_GNU_HASH)
7702     {
7703       unsigned long *lengths;
7704       unsigned long *counts;
7705       unsigned long hn;
7706       unsigned long maxlength = 0;
7707       unsigned long nzero_counts = 0;
7708       unsigned long nsyms = 0;
7709
7710       lengths = calloc (ngnubuckets, sizeof (*lengths));
7711       if (lengths == NULL)
7712         {
7713           error (_("Out of memory\n"));
7714           return 0;
7715         }
7716
7717       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7718               (unsigned long) ngnubuckets);
7719       printf (_(" Length  Number     %% of total  Coverage\n"));
7720
7721       for (hn = 0; hn < ngnubuckets; ++hn)
7722         if (gnubuckets[hn] != 0)
7723           {
7724             bfd_vma off, length = 1;
7725
7726             for (off = gnubuckets[hn] - gnusymidx;
7727                  (gnuchains[off] & 1) == 0; ++off)
7728               ++length;
7729             lengths[hn] = length;
7730             if (length > maxlength)
7731               maxlength = length;
7732             nsyms += length;
7733           }
7734
7735       counts = calloc (maxlength + 1, sizeof (*counts));
7736       if (counts == NULL)
7737         {
7738           error (_("Out of memory\n"));
7739           return 0;
7740         }
7741
7742       for (hn = 0; hn < ngnubuckets; ++hn)
7743         ++counts[lengths[hn]];
7744
7745       if (ngnubuckets > 0)
7746         {
7747           unsigned long j;
7748           printf ("      0  %-10lu (%5.1f%%)\n",
7749                   counts[0], (counts[0] * 100.0) / ngnubuckets);
7750           for (j = 1; j <= maxlength; ++j)
7751             {
7752               nzero_counts += counts[j] * j;
7753               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
7754                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
7755                       (nzero_counts * 100.0) / nsyms);
7756             }
7757         }
7758
7759       free (counts);
7760       free (lengths);
7761       free (gnubuckets);
7762       free (gnuchains);
7763     }
7764
7765   return 1;
7766 }
7767
7768 static int
7769 process_syminfo (FILE *file ATTRIBUTE_UNUSED)
7770 {
7771   unsigned int i;
7772
7773   if (dynamic_syminfo == NULL
7774       || !do_dynamic)
7775     /* No syminfo, this is ok.  */
7776     return 1;
7777
7778   /* There better should be a dynamic symbol section.  */
7779   if (dynamic_symbols == NULL || dynamic_strings == NULL)
7780     return 0;
7781
7782   if (dynamic_addr)
7783     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7784             dynamic_syminfo_offset, dynamic_syminfo_nent);
7785
7786   printf (_(" Num: Name                           BoundTo     Flags\n"));
7787   for (i = 0; i < dynamic_syminfo_nent; ++i)
7788     {
7789       unsigned short int flags = dynamic_syminfo[i].si_flags;
7790
7791       printf ("%4d: ", i);
7792       if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
7793         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
7794       else
7795         printf ("<corrupt: %19ld>", dynamic_symbols[i].st_name);
7796       putchar (' ');
7797
7798       switch (dynamic_syminfo[i].si_boundto)
7799         {
7800         case SYMINFO_BT_SELF:
7801           fputs ("SELF       ", stdout);
7802           break;
7803         case SYMINFO_BT_PARENT:
7804           fputs ("PARENT     ", stdout);
7805           break;
7806         default:
7807           if (dynamic_syminfo[i].si_boundto > 0
7808               && dynamic_syminfo[i].si_boundto < dynamic_nent
7809               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
7810             {
7811               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
7812               putchar (' ' );
7813             }
7814           else
7815             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
7816           break;
7817         }
7818
7819       if (flags & SYMINFO_FLG_DIRECT)
7820         printf (" DIRECT");
7821       if (flags & SYMINFO_FLG_PASSTHRU)
7822         printf (" PASSTHRU");
7823       if (flags & SYMINFO_FLG_COPY)
7824         printf (" COPY");
7825       if (flags & SYMINFO_FLG_LAZYLOAD)
7826         printf (" LAZYLOAD");
7827
7828       puts ("");
7829     }
7830
7831   return 1;
7832 }
7833
7834 #ifdef SUPPORT_DISASSEMBLY
7835 static int
7836 disassemble_section (Elf_Internal_Shdr *section, FILE *file)
7837 {
7838   printf (_("\nAssembly dump of section %s\n"),
7839           SECTION_NAME (section));
7840
7841   /* XXX -- to be done --- XXX */
7842
7843   return 1;
7844 }
7845 #endif
7846
7847 static int
7848 dump_section_as_strings (Elf_Internal_Shdr *section, FILE *file)
7849 {
7850   Elf_Internal_Shdr *relsec;
7851   bfd_size_type num_bytes;
7852   bfd_vma addr;
7853   char *data;
7854   char *end;
7855   char *start;
7856   char *name = SECTION_NAME (section);
7857   bfd_boolean some_strings_shown;
7858
7859   num_bytes = section->sh_size;
7860
7861   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
7862     {
7863       printf (_("\nSection '%s' has no data to dump.\n"), name);
7864       return 0;
7865     }
7866
7867   addr = section->sh_addr;
7868
7869   start = get_data (NULL, file, section->sh_offset, 1, num_bytes,
7870                     _("section data"));
7871   if (!start)
7872     return 0;
7873
7874   printf (_("\nString dump of section '%s':\n"), name);
7875
7876   /* If the section being dumped has relocations against it the user might
7877      be expecting these relocations to have been applied.  Check for this
7878      case and issue a warning message in order to avoid confusion.
7879      FIXME: Maybe we ought to have an option that dumps a section with
7880      relocs applied ?  */
7881   for (relsec = section_headers;
7882        relsec < section_headers + elf_header.e_shnum;
7883        ++relsec)
7884     {
7885       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
7886           || relsec->sh_info >= elf_header.e_shnum
7887           || section_headers + relsec->sh_info != section
7888           || relsec->sh_size == 0
7889           || relsec->sh_link >= elf_header.e_shnum)
7890         continue;
7891
7892       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7893       break;
7894     }
7895
7896   data = start;
7897   end  = start + num_bytes;
7898   some_strings_shown = FALSE;
7899
7900   while (data < end)
7901     {
7902       while (!ISPRINT (* data))
7903         if (++ data >= end)
7904           break;
7905
7906       if (data < end)
7907         {
7908 #ifndef __MSVCRT__
7909           printf ("  [%6tx]  %s\n", data - start, data);
7910 #else
7911           printf ("  [%6Ix]  %s\n", (size_t) (data - start), data);
7912 #endif
7913           data += strlen (data);
7914           some_strings_shown = TRUE;
7915         }
7916     }
7917
7918   if (! some_strings_shown)
7919     printf (_("  No strings found in this section."));
7920
7921   free (start);
7922
7923   putchar ('\n');
7924   return 1;
7925 }
7926
7927
7928 static int
7929 dump_section_as_bytes (Elf_Internal_Shdr *section, FILE *file)
7930 {
7931   Elf_Internal_Shdr *relsec;
7932   bfd_size_type bytes;
7933   bfd_vma addr;
7934   unsigned char *data;
7935   unsigned char *start;
7936
7937   bytes = section->sh_size;
7938
7939   if (bytes == 0 || section->sh_type == SHT_NOBITS)
7940     {
7941       printf (_("\nSection '%s' has no data to dump.\n"),
7942               SECTION_NAME (section));
7943       return 0;
7944     }
7945   else
7946     printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
7947
7948   addr = section->sh_addr;
7949
7950   start = get_data (NULL, file, section->sh_offset, 1, bytes,
7951                     _("section data"));
7952   if (!start)
7953     return 0;
7954
7955   /* If the section being dumped has relocations against it the user might
7956      be expecting these relocations to have been applied.  Check for this
7957      case and issue a warning message in order to avoid confusion.
7958      FIXME: Maybe we ought to have an option that dumps a section with
7959      relocs applied ?  */
7960   for (relsec = section_headers;
7961        relsec < section_headers + elf_header.e_shnum;
7962        ++relsec)
7963     {
7964       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
7965           || relsec->sh_info >= elf_header.e_shnum
7966           || section_headers + relsec->sh_info != section
7967           || relsec->sh_size == 0
7968           || relsec->sh_link >= elf_header.e_shnum)
7969         continue;
7970
7971       printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7972       break;
7973     }
7974
7975   data = start;
7976
7977   while (bytes)
7978     {
7979       int j;
7980       int k;
7981       int lbytes;
7982
7983       lbytes = (bytes > 16 ? 16 : bytes);
7984
7985       printf ("  0x%8.8lx ", (unsigned long) addr);
7986
7987       for (j = 0; j < 16; j++)
7988         {
7989           if (j < lbytes)
7990             printf ("%2.2x", data[j]);
7991           else
7992             printf ("  ");
7993
7994           if ((j & 3) == 3)
7995             printf (" ");
7996         }
7997
7998       for (j = 0; j < lbytes; j++)
7999         {
8000           k = data[j];
8001           if (k >= ' ' && k < 0x7f)
8002             printf ("%c", k);
8003           else
8004             printf (".");
8005         }
8006
8007       putchar ('\n');
8008
8009       data  += lbytes;
8010       addr  += lbytes;
8011       bytes -= lbytes;
8012     }
8013
8014   free (start);
8015
8016   putchar ('\n');
8017   return 1;
8018 }
8019
8020 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
8021    DWARF debug sections.  This is a target specific test.  Note - we do not
8022    go through the whole including-target-headers-multiple-times route, (as
8023    we have already done with <elf/h8.h>) because this would become very
8024    messy and even then this function would have to contain target specific
8025    information (the names of the relocs instead of their numeric values).
8026    FIXME: This is not the correct way to solve this problem.  The proper way
8027    is to have target specific reloc sizing and typing functions created by
8028    the reloc-macros.h header, in the same way that it already creates the
8029    reloc naming functions.  */
8030
8031 static bfd_boolean
8032 is_32bit_abs_reloc (unsigned int reloc_type)
8033 {
8034   switch (elf_header.e_machine)
8035     {
8036     case EM_386:
8037     case EM_486:
8038       return reloc_type == 1; /* R_386_32.  */
8039     case EM_68K:
8040       return reloc_type == 1; /* R_68K_32.  */
8041     case EM_860:
8042       return reloc_type == 1; /* R_860_32.  */
8043     case EM_ALPHA:
8044       return reloc_type == 1; /* XXX Is this right ?  */
8045     case EM_ARC:
8046       return reloc_type == 1; /* R_ARC_32.  */
8047     case EM_ARM:
8048       return reloc_type == 2; /* R_ARM_ABS32 */
8049     case EM_AVR_OLD:
8050     case EM_AVR:
8051       return reloc_type == 1;
8052     case EM_BLACKFIN:
8053       return reloc_type == 0x12; /* R_byte4_data.  */
8054     case EM_CRIS:
8055       return reloc_type == 3; /* R_CRIS_32.  */
8056     case EM_CR16:
8057       return reloc_type == 3; /* R_CR16_NUM32.  */
8058     case EM_CRX:
8059       return reloc_type == 15; /* R_CRX_NUM32.  */
8060     case EM_CYGNUS_FRV:
8061       return reloc_type == 1;
8062     case EM_CYGNUS_D10V:
8063     case EM_D10V:
8064       return reloc_type == 6; /* R_D10V_32.  */
8065     case EM_CYGNUS_D30V:
8066     case EM_D30V:
8067       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
8068     case EM_DLX:
8069       return reloc_type == 3; /* R_DLX_RELOC_32.  */
8070     case EM_CYGNUS_FR30:
8071     case EM_FR30:
8072       return reloc_type == 3; /* R_FR30_32.  */
8073     case EM_H8S:
8074     case EM_H8_300:
8075     case EM_H8_300H:
8076       return reloc_type == 1; /* R_H8_DIR32.  */
8077     case EM_IA_64:
8078       return reloc_type == 0x65; /* R_IA64_SECREL32LSB.  */
8079     case EM_IP2K_OLD:
8080     case EM_IP2K:
8081       return reloc_type == 2; /* R_IP2K_32.  */
8082     case EM_IQ2000:
8083       return reloc_type == 2; /* R_IQ2000_32.  */
8084     case EM_M32C:
8085       return reloc_type == 3; /* R_M32C_32.  */
8086     case EM_M32R:
8087       return reloc_type == 34; /* R_M32R_32_RELA.  */
8088     case EM_MCORE:
8089       return reloc_type == 1; /* R_MCORE_ADDR32.  */
8090     case EM_CYGNUS_MEP:
8091       return reloc_type == 4; /* R_MEP_32.  */
8092     case EM_MIPS:
8093       return reloc_type == 2; /* R_MIPS_32.  */
8094     case EM_MMIX:
8095       return reloc_type == 4; /* R_MMIX_32.  */
8096     case EM_CYGNUS_MN10200:
8097     case EM_MN10200:
8098       return reloc_type == 1; /* R_MN10200_32.  */
8099     case EM_CYGNUS_MN10300:
8100     case EM_MN10300:
8101       return reloc_type == 1; /* R_MN10300_32.  */
8102     case EM_MSP430_OLD:
8103     case EM_MSP430:
8104       return reloc_type == 1; /* R_MSP43_32.  */
8105     case EM_MT:
8106       return reloc_type == 2; /* R_MT_32.  */
8107     case EM_ALTERA_NIOS2:
8108     case EM_NIOS32:
8109       return reloc_type == 1; /* R_NIOS_32.  */
8110     case EM_OPENRISC:
8111     case EM_OR32:
8112       return reloc_type == 1; /* R_OR32_32.  */
8113     case EM_PARISC:
8114       return reloc_type == 1; /* R_PARISC_DIR32.  */
8115     case EM_PJ:
8116     case EM_PJ_OLD:
8117       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
8118     case EM_PPC64:
8119       return reloc_type == 1; /* R_PPC64_ADDR32.  */
8120     case EM_PPC:
8121       return reloc_type == 1; /* R_PPC_ADDR32.  */
8122     case EM_S370:
8123       return reloc_type == 1; /* R_I370_ADDR31.  */
8124     case EM_S390_OLD:
8125     case EM_S390:
8126       return reloc_type == 4; /* R_S390_32.  */
8127     case EM_SCORE:
8128       return reloc_type == 8; /* R_SCORE_ABS32.  */
8129     case EM_SH:
8130       return reloc_type == 1; /* R_SH_DIR32.  */
8131     case EM_SPARC32PLUS:
8132     case EM_SPARCV9:
8133     case EM_SPARC:
8134       return reloc_type == 3 /* R_SPARC_32.  */
8135         || reloc_type == 23; /* R_SPARC_UA32.  */
8136     case EM_SPU:
8137       return reloc_type == 6; /* R_SPU_ADDR32 */
8138     case EM_CYGNUS_V850:
8139     case EM_V850:
8140       return reloc_type == 6; /* R_V850_ABS32.  */
8141     case EM_VAX:
8142       return reloc_type == 1; /* R_VAX_32.  */
8143     case EM_X86_64:
8144       return reloc_type == 10; /* R_X86_64_32.  */
8145     case EM_XSTORMY16:
8146       return reloc_type == 1; /* R_XSTROMY16_32.  */
8147     case EM_XTENSA_OLD:
8148     case EM_XTENSA:
8149       return reloc_type == 1; /* R_XTENSA_32.  */
8150
8151     default:
8152       error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8153              elf_header.e_machine);
8154       abort ();
8155     }
8156 }
8157
8158 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8159    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
8160
8161 static bfd_boolean
8162 is_32bit_pcrel_reloc (unsigned int reloc_type)
8163 {
8164   switch (elf_header.e_machine)
8165     {
8166     case EM_386:
8167     case EM_486:
8168       return reloc_type == 2;  /* R_386_PC32.  */
8169     case EM_68K:
8170       return reloc_type == 4;  /* R_68K_PC32.  */
8171     case EM_ALPHA:
8172       return reloc_type == 10; /* R_ALPHA_SREL32.  */
8173     case EM_ARM:
8174       return reloc_type == 3;  /* R_ARM_REL32 */
8175     case EM_PARISC:
8176       return reloc_type == 0;  /* R_PARISC_NONE.  *//* FIXME: This reloc is generated, but it may be a bug.  */
8177     case EM_PPC:
8178       return reloc_type == 26; /* R_PPC_REL32.  */
8179     case EM_PPC64:
8180       return reloc_type == 26; /* R_PPC64_REL32.  */
8181     case EM_S390_OLD:
8182     case EM_S390:
8183       return reloc_type == 5;  /* R_390_PC32.  */
8184     case EM_SH:
8185       return reloc_type == 2;  /* R_SH_REL32.  */
8186     case EM_SPARC32PLUS:
8187     case EM_SPARCV9:
8188     case EM_SPARC:
8189       return reloc_type == 6;  /* R_SPARC_DISP32.  */
8190     case EM_SPU:
8191       return reloc_type == 13; /* R_SPU_REL32.  */
8192     case EM_X86_64:
8193       return reloc_type == 2;  /* R_X86_64_PC32.  */
8194     case EM_XTENSA_OLD:
8195     case EM_XTENSA:
8196       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
8197     default:
8198       /* Do not abort or issue an error message here.  Not all targets use
8199          pc-relative 32-bit relocs in their DWARF debug information and we
8200          have already tested for target coverage in is_32bit_abs_reloc.  A
8201          more helpful warning message will be generated by
8202          debug_apply_relocations anyway, so just return.  */
8203       return FALSE;
8204     }
8205 }
8206
8207 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8208    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
8209
8210 static bfd_boolean
8211 is_64bit_abs_reloc (unsigned int reloc_type)
8212 {
8213   switch (elf_header.e_machine)
8214     {
8215     case EM_ALPHA:
8216       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
8217     case EM_IA_64:
8218       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
8219     case EM_PARISC:
8220       return reloc_type == 80; /* R_PARISC_DIR64.  */
8221     case EM_PPC64:
8222       return reloc_type == 38; /* R_PPC64_ADDR64.  */
8223     case EM_SPARC32PLUS:
8224     case EM_SPARCV9:
8225     case EM_SPARC:
8226       return reloc_type == 54; /* R_SPARC_UA64.  */
8227     case EM_X86_64:
8228       return reloc_type == 1; /* R_X86_64_64.  */
8229     case EM_S390_OLD:
8230     case EM_S390:
8231       return reloc_type == 22;  /* R_S390_64 */
8232     default:
8233       return FALSE;
8234     }
8235 }
8236
8237 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8238    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
8239
8240 static bfd_boolean
8241 is_16bit_abs_reloc (unsigned int reloc_type)
8242 {
8243   switch (elf_header.e_machine)
8244     {
8245     case EM_AVR_OLD:
8246     case EM_AVR:
8247       return reloc_type == 4; /* R_AVR_16.  */
8248     case EM_CYGNUS_D10V:
8249     case EM_D10V:
8250       return reloc_type == 3; /* R_D10V_16.  */
8251     case EM_H8S:
8252     case EM_H8_300:
8253     case EM_H8_300H:
8254       return reloc_type == R_H8_DIR16;
8255     case EM_IP2K_OLD:
8256     case EM_IP2K:
8257       return reloc_type == 1; /* R_IP2K_16.  */
8258     case EM_M32C:
8259       return reloc_type == 1; /* R_M32C_16 */
8260     case EM_MSP430_OLD:
8261     case EM_MSP430:
8262       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
8263     case EM_ALTERA_NIOS2:
8264     case EM_NIOS32:
8265       return reloc_type == 9; /* R_NIOS_16.  */
8266     default:
8267       return FALSE;
8268     }
8269 }
8270
8271 /* Apply relocations to a debug section.  */
8272
8273 static void
8274 debug_apply_relocations (void *file,
8275                          Elf_Internal_Shdr *section,
8276                          unsigned char *start)
8277 {
8278   Elf_Internal_Shdr *relsec;
8279   unsigned char *end = start + section->sh_size;
8280
8281   if (elf_header.e_type != ET_REL)
8282     return;
8283
8284   /* Find the reloc section associated with the debug section.  */
8285   for (relsec = section_headers;
8286        relsec < section_headers + elf_header.e_shnum;
8287        ++relsec)
8288     {
8289       bfd_boolean is_rela;
8290       unsigned long num_relocs;
8291       Elf_Internal_Rela *relocs, *rp;
8292       Elf_Internal_Shdr *symsec;
8293       Elf_Internal_Sym *symtab;
8294       Elf_Internal_Sym *sym;
8295
8296       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
8297           || relsec->sh_info >= elf_header.e_shnum
8298           || section_headers + relsec->sh_info != section
8299           || relsec->sh_size == 0
8300           || relsec->sh_link >= elf_header.e_shnum)
8301         continue;
8302
8303       is_rela = relsec->sh_type == SHT_RELA;
8304
8305       if (is_rela)
8306         {
8307           if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
8308                                   & relocs, & num_relocs))
8309             return;
8310         }
8311       else
8312         {
8313           if (!slurp_rel_relocs (file, relsec->sh_offset, relsec->sh_size,
8314                                  & relocs, & num_relocs))
8315             return;
8316         }
8317
8318       /* SH uses RELA but uses in place value instead of the addend field.  */
8319       if (elf_header.e_machine == EM_SH)
8320         is_rela = FALSE;
8321
8322       symsec = section_headers + relsec->sh_link;
8323       symtab = GET_ELF_SYMBOLS (file, symsec);
8324
8325       for (rp = relocs; rp < relocs + num_relocs; ++rp)
8326         {
8327           bfd_vma         addend;
8328           unsigned int    reloc_type;
8329           unsigned int    reloc_size;
8330           unsigned char * loc;
8331
8332           /* In MIPS little-endian objects, r_info isn't really a
8333              64-bit little-endian value: it has a 32-bit little-endian
8334              symbol index followed by four individual byte fields.
8335              Reorder INFO accordingly.  */
8336           if (!is_32bit_elf
8337               && elf_header.e_machine == EM_MIPS
8338               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
8339             rp->r_info = (((rp->r_info & 0xffffffff) << 32)
8340                           | ((rp->r_info >> 56) & 0xff)
8341                           | ((rp->r_info >> 40) & 0xff00)
8342                           | ((rp->r_info >> 24) & 0xff0000)
8343                           | ((rp->r_info >> 8) & 0xff000000));
8344
8345           reloc_type = get_reloc_type (rp->r_info);
8346
8347           if (is_32bit_abs_reloc (reloc_type)
8348               || is_32bit_pcrel_reloc (reloc_type))
8349             reloc_size = 4;
8350           else if (is_64bit_abs_reloc (reloc_type))
8351             reloc_size = 8;
8352           else if (is_16bit_abs_reloc (reloc_type))
8353             reloc_size = 2;
8354           else
8355             {
8356               warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8357                     reloc_type, SECTION_NAME (section));
8358               continue;
8359             }
8360
8361           loc = start + rp->r_offset;
8362           if ((loc + reloc_size) > end)
8363             {
8364               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8365                     (unsigned long) rp->r_offset,
8366                     SECTION_NAME (section));
8367               continue;
8368             }
8369
8370           sym = symtab + get_reloc_symindex (rp->r_info);
8371
8372           /* If the reloc has a symbol associated with it,
8373              make sure that it is of an appropriate type.  */
8374           if (sym != symtab
8375               && ELF_ST_TYPE (sym->st_info) != STT_SECTION
8376               /* Relocations against symbols without type can happen.
8377                  Gcc -feliminate-dwarf2-dups may generate symbols
8378                  without type for debug info.  */
8379               && ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
8380               /* Relocations against object symbols can happen,
8381                  eg when referencing a global array.  For an
8382                  example of this see the _clz.o binary in libgcc.a.  */
8383               && ELF_ST_TYPE (sym->st_info) != STT_OBJECT)
8384             {
8385               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8386                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
8387                     (long int)(rp - relocs),
8388                     SECTION_NAME (relsec));
8389               continue;
8390             }
8391
8392           addend = is_rela ? rp->r_addend : byte_get (loc, reloc_size);
8393
8394           if (is_32bit_pcrel_reloc (reloc_type))
8395             byte_put (loc, (addend + sym->st_value) - rp->r_offset,
8396                       reloc_size);
8397           else
8398             byte_put (loc, addend + sym->st_value, reloc_size);
8399         }
8400
8401       free (symtab);
8402       free (relocs);
8403       break;
8404     }
8405 }
8406
8407 int
8408 load_debug_section (enum dwarf_section_display_enum debug, void *file)
8409 {
8410   struct dwarf_section *section = &debug_displays [debug].section;
8411   Elf_Internal_Shdr *sec;
8412   char buf [64];
8413
8414   /* If it is already loaded, do nothing.  */
8415   if (section->start != NULL)
8416     return 1;
8417
8418   /* Locate the debug section.  */
8419   sec = find_section (section->name);
8420   if (sec == NULL)
8421     return 0;
8422
8423   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
8424   section->address = sec->sh_addr;
8425   section->size = sec->sh_size;
8426   section->start = get_data (NULL, file, sec->sh_offset, 1,
8427                              sec->sh_size, buf);
8428
8429   if (debug_displays [debug].relocate)
8430     debug_apply_relocations (file, sec, section->start);
8431
8432   return section->start != NULL;
8433 }
8434
8435 void
8436 free_debug_section (enum dwarf_section_display_enum debug)
8437 {
8438   struct dwarf_section *section = &debug_displays [debug].section;
8439
8440   if (section->start == NULL)
8441     return;
8442
8443   free ((char *) section->start);
8444   section->start = NULL;
8445   section->address = 0;
8446   section->size = 0;
8447 }
8448
8449 static int
8450 display_debug_section (Elf_Internal_Shdr *section, FILE *file)
8451 {
8452   char *name = SECTION_NAME (section);
8453   bfd_size_type length;
8454   int result = 1;
8455   enum dwarf_section_display_enum i;
8456
8457   length = section->sh_size;
8458   if (length == 0)
8459     {
8460       printf (_("\nSection '%s' has no debugging data.\n"), name);
8461       return 0;
8462     }
8463
8464   if (const_strneq (name, ".gnu.linkonce.wi."))
8465     name = ".debug_info";
8466
8467   /* See if we know how to display the contents of this section.  */
8468   for (i = 0; i < max; i++)
8469     if (streq (debug_displays[i].section.name, name))
8470       {
8471         struct dwarf_section *sec = &debug_displays [i].section;
8472
8473         if (load_debug_section (i, file))
8474           {
8475             result &= debug_displays[i].display (sec, file);
8476
8477             if (i != info && i != abbrev)
8478               free_debug_section (i);
8479           }
8480
8481         break;
8482       }
8483
8484   if (i == max)
8485     {
8486       printf (_("Unrecognized debug section: %s\n"), name);
8487       result = 0;
8488     }
8489
8490   return result;
8491 }
8492
8493 /* Set DUMP_SECTS for all sections where dumps were requested
8494    based on section name.  */
8495
8496 static void
8497 initialise_dumps_byname (void)
8498 {
8499   struct dump_list_entry *cur;
8500
8501   for (cur = dump_sects_byname; cur; cur = cur->next)
8502     {
8503       unsigned int i;
8504       int any;
8505
8506       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
8507         if (streq (SECTION_NAME (section_headers + i), cur->name))
8508           {
8509             request_dump_bynumber (i, cur->type);
8510             any = 1;
8511           }
8512
8513       if (!any)
8514         warn (_("Section '%s' was not dumped because it does not exist!\n"),
8515               cur->name);
8516     }
8517 }
8518
8519 static void
8520 process_section_contents (FILE *file)
8521 {
8522   Elf_Internal_Shdr *section;
8523   unsigned int i;
8524
8525   if (! do_dump)
8526     return;
8527
8528   initialise_dumps_byname ();
8529
8530   for (i = 0, section = section_headers;
8531        i < elf_header.e_shnum && i < num_dump_sects;
8532        i++, section++)
8533     {
8534 #ifdef SUPPORT_DISASSEMBLY
8535       if (dump_sects[i] & DISASS_DUMP)
8536         disassemble_section (section, file);
8537 #endif
8538       if (dump_sects[i] & HEX_DUMP)
8539         dump_section_as_bytes (section, file);
8540
8541       if (dump_sects[i] & DEBUG_DUMP)
8542         display_debug_section (section, file);
8543
8544       if (dump_sects[i] & STRING_DUMP)
8545         dump_section_as_strings (section, file);
8546     }
8547
8548   /* Check to see if the user requested a
8549      dump of a section that does not exist.  */
8550   while (i++ < num_dump_sects)
8551     if (dump_sects[i])
8552       warn (_("Section %d was not dumped because it does not exist!\n"), i);
8553 }
8554
8555 static void
8556 process_mips_fpe_exception (int mask)
8557 {
8558   if (mask)
8559     {
8560       int first = 1;
8561       if (mask & OEX_FPU_INEX)
8562         fputs ("INEX", stdout), first = 0;
8563       if (mask & OEX_FPU_UFLO)
8564         printf ("%sUFLO", first ? "" : "|"), first = 0;
8565       if (mask & OEX_FPU_OFLO)
8566         printf ("%sOFLO", first ? "" : "|"), first = 0;
8567       if (mask & OEX_FPU_DIV0)
8568         printf ("%sDIV0", first ? "" : "|"), first = 0;
8569       if (mask & OEX_FPU_INVAL)
8570         printf ("%sINVAL", first ? "" : "|");
8571     }
8572   else
8573     fputs ("0", stdout);
8574 }
8575
8576 /* ARM EABI attributes section.  */
8577 typedef struct
8578 {
8579   int tag;
8580   const char *name;
8581   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
8582   int type;
8583   const char **table;
8584 } arm_attr_public_tag;
8585
8586 static const char *arm_attr_tag_CPU_arch[] =
8587   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8588    "v6K", "v7"};
8589 static const char *arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
8590 static const char *arm_attr_tag_THUMB_ISA_use[] =
8591   {"No", "Thumb-1", "Thumb-2"};
8592 static const char *arm_attr_tag_VFP_arch[] =
8593   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16"};
8594 static const char *arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1"};
8595 static const char *arm_attr_tag_NEON_arch[] = {"No", "NEONv1"};
8596 static const char *arm_attr_tag_ABI_PCS_config[] =
8597   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8598    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8599 static const char *arm_attr_tag_ABI_PCS_R9_use[] =
8600   {"V6", "SB", "TLS", "Unused"};
8601 static const char *arm_attr_tag_ABI_PCS_RW_data[] =
8602   {"Absolute", "PC-relative", "SB-relative", "None"};
8603 static const char *arm_attr_tag_ABI_PCS_RO_DATA[] =
8604   {"Absolute", "PC-relative", "None"};
8605 static const char *arm_attr_tag_ABI_PCS_GOT_use[] =
8606   {"None", "direct", "GOT-indirect"};
8607 static const char *arm_attr_tag_ABI_PCS_wchar_t[] =
8608   {"None", "??? 1", "2", "??? 3", "4"};
8609 static const char *arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
8610 static const char *arm_attr_tag_ABI_FP_denormal[] = {"Unused", "Needed"};
8611 static const char *arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
8612 static const char *arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
8613 static const char *arm_attr_tag_ABI_FP_number_model[] =
8614   {"Unused", "Finite", "RTABI", "IEEE 754"};
8615 static const char *arm_attr_tag_ABI_align8_needed[] = {"No", "Yes", "4-byte"};
8616 static const char *arm_attr_tag_ABI_align8_preserved[] =
8617   {"No", "Yes, except leaf SP", "Yes"};
8618 static const char *arm_attr_tag_ABI_enum_size[] =
8619   {"Unused", "small", "int", "forced to int"};
8620 static const char *arm_attr_tag_ABI_HardFP_use[] =
8621   {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8622 static const char *arm_attr_tag_ABI_VFP_args[] =
8623   {"AAPCS", "VFP registers", "custom"};
8624 static const char *arm_attr_tag_ABI_WMMX_args[] =
8625   {"AAPCS", "WMMX registers", "custom"};
8626 static const char *arm_attr_tag_ABI_optimization_goals[] =
8627   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8628     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8629 static const char *arm_attr_tag_ABI_FP_optimization_goals[] =
8630   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8631     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8632
8633 #define LOOKUP(id, name) \
8634   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8635 static arm_attr_public_tag arm_attr_public_tags[] =
8636 {
8637   {4, "CPU_raw_name", 1, NULL},
8638   {5, "CPU_name", 1, NULL},
8639   LOOKUP(6, CPU_arch),
8640   {7, "CPU_arch_profile", 0, NULL},
8641   LOOKUP(8, ARM_ISA_use),
8642   LOOKUP(9, THUMB_ISA_use),
8643   LOOKUP(10, VFP_arch),
8644   LOOKUP(11, WMMX_arch),
8645   LOOKUP(12, NEON_arch),
8646   LOOKUP(13, ABI_PCS_config),
8647   LOOKUP(14, ABI_PCS_R9_use),
8648   LOOKUP(15, ABI_PCS_RW_data),
8649   LOOKUP(16, ABI_PCS_RO_DATA),
8650   LOOKUP(17, ABI_PCS_GOT_use),
8651   LOOKUP(18, ABI_PCS_wchar_t),
8652   LOOKUP(19, ABI_FP_rounding),
8653   LOOKUP(20, ABI_FP_denormal),
8654   LOOKUP(21, ABI_FP_exceptions),
8655   LOOKUP(22, ABI_FP_user_exceptions),
8656   LOOKUP(23, ABI_FP_number_model),
8657   LOOKUP(24, ABI_align8_needed),
8658   LOOKUP(25, ABI_align8_preserved),
8659   LOOKUP(26, ABI_enum_size),
8660   LOOKUP(27, ABI_HardFP_use),
8661   LOOKUP(28, ABI_VFP_args),
8662   LOOKUP(29, ABI_WMMX_args),
8663   LOOKUP(30, ABI_optimization_goals),
8664   LOOKUP(31, ABI_FP_optimization_goals),
8665   {32, "compatibility", 0, NULL}
8666 };
8667 #undef LOOKUP
8668
8669 /* Read an unsigned LEB128 encoded value from p.  Set *PLEN to the number of
8670    bytes read.  */
8671 static unsigned int
8672 read_uleb128 (unsigned char *p, unsigned int *plen)
8673 {
8674   unsigned char c;
8675   unsigned int val;
8676   int shift;
8677   int len;
8678
8679   val = 0;
8680   shift = 0;
8681   len = 0;
8682   do
8683     {
8684       c = *(p++);
8685       len++;
8686       val |= ((unsigned int)c & 0x7f) << shift;
8687       shift += 7;
8688     }
8689   while (c & 0x80);
8690
8691   *plen = len;
8692   return val;
8693 }
8694
8695 static unsigned char *
8696 display_arm_attribute (unsigned char *p)
8697 {
8698   int tag;
8699   unsigned int len;
8700   int val;
8701   arm_attr_public_tag *attr;
8702   unsigned i;
8703   int type;
8704
8705   tag = read_uleb128 (p, &len);
8706   p += len;
8707   attr = NULL;
8708   for (i = 0; i < ARRAY_SIZE(arm_attr_public_tags); i++)
8709     {
8710       if (arm_attr_public_tags[i].tag == tag)
8711         {
8712           attr = &arm_attr_public_tags[i];
8713           break;
8714         }
8715     }
8716
8717   if (attr)
8718     {
8719       printf ("  Tag_%s: ", attr->name);
8720       switch (attr->type)
8721         {
8722         case 0:
8723           switch (tag)
8724             {
8725             case 7: /* Tag_CPU_arch_profile.  */
8726               val = read_uleb128 (p, &len);
8727               p += len;
8728               switch (val)
8729                 {
8730                 case 0: printf ("None\n"); break;
8731                 case 'A': printf ("Application\n"); break;
8732                 case 'R': printf ("Realtime\n"); break;
8733                 case 'M': printf ("Microcontroller\n"); break;
8734                 default: printf ("??? (%d)\n", val); break;
8735                 }
8736               break;
8737
8738             case 32: /* Tag_compatibility.  */
8739               val = read_uleb128 (p, &len);
8740               p += len;
8741               printf ("flag = %d, vendor = %s\n", val, p);
8742               p += strlen((char *)p) + 1;
8743               break;
8744
8745             default:
8746               abort();
8747             }
8748           return p;
8749
8750         case 1:
8751         case 2:
8752           type = attr->type;
8753           break;
8754
8755         default:
8756           assert (attr->type & 0x80);
8757           val = read_uleb128 (p, &len);
8758           p += len;
8759           type = attr->type & 0x7f;
8760           if (val >= type)
8761             printf ("??? (%d)\n", val);
8762           else
8763             printf ("%s\n", attr->table[val]);
8764           return p;
8765         }
8766     }
8767   else
8768     {
8769       if (tag & 1)
8770         type = 1; /* String.  */
8771       else
8772         type = 2; /* uleb128.  */
8773       printf ("  Tag_unknown_%d: ", tag);
8774     }
8775
8776   if (type == 1)
8777     {
8778       printf ("\"%s\"\n", p);
8779       p += strlen((char *)p) + 1;
8780     }
8781   else
8782     {
8783       val = read_uleb128 (p, &len);
8784       p += len;
8785       printf ("%d (0x%x)\n", val, val);
8786     }
8787
8788   return p;
8789 }
8790
8791 static unsigned char *
8792 display_gnu_attribute (unsigned char * p,
8793                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
8794 {
8795   int tag;
8796   unsigned int len;
8797   int val;
8798   int type;
8799
8800   tag = read_uleb128 (p, &len);
8801   p += len;
8802
8803   /* Tag_compatibility is the only generic GNU attribute defined at
8804      present.  */
8805   if (tag == 32)
8806     {
8807       val = read_uleb128 (p, &len);
8808       p += len;
8809       printf ("flag = %d, vendor = %s\n", val, p);
8810       p += strlen ((char *) p) + 1;
8811       return p;
8812     }
8813
8814   if ((tag & 2) == 0 && display_proc_gnu_attribute)
8815     return display_proc_gnu_attribute (p, tag);
8816
8817   if (tag & 1)
8818     type = 1; /* String.  */
8819   else
8820     type = 2; /* uleb128.  */
8821   printf ("  Tag_unknown_%d: ", tag);
8822
8823   if (type == 1)
8824     {
8825       printf ("\"%s\"\n", p);
8826       p += strlen ((char *) p) + 1;
8827     }
8828   else
8829     {
8830       val = read_uleb128 (p, &len);
8831       p += len;
8832       printf ("%d (0x%x)\n", val, val);
8833     }
8834
8835   return p;
8836 }
8837
8838 static unsigned char *
8839 display_power_gnu_attribute (unsigned char *p, int tag)
8840 {
8841   int type;
8842   unsigned int len;
8843   int val;
8844
8845   if (tag == Tag_GNU_Power_ABI_FP)
8846     {
8847       val = read_uleb128 (p, &len);
8848       p += len;
8849       printf ("  Tag_GNU_Power_ABI_FP: ");
8850
8851       switch (val)
8852         {
8853         case 0:
8854           printf ("Hard or soft float\n");
8855           break;
8856         case 1:
8857           printf ("Hard float\n");
8858           break;
8859         case 2:
8860           printf ("Soft float\n");
8861           break;
8862         default:
8863           printf ("??? (%d)\n", val);
8864           break;
8865         }
8866       return p;
8867    }
8868
8869   if (tag == Tag_GNU_Power_ABI_Vector)
8870     {
8871       val = read_uleb128 (p, &len);
8872       p += len;
8873       printf ("  Tag_GNU_Power_ABI_Vector: ");
8874       switch (val)
8875         {
8876         case 0:
8877           printf ("Any\n");
8878           break;
8879         case 1:
8880           printf ("Generic\n");
8881           break;
8882         case 2:
8883           printf ("AltiVec\n");
8884           break;
8885         case 3:
8886           printf ("SPE\n");
8887           break;
8888         default:
8889           printf ("??? (%d)\n", val);
8890           break;
8891         }
8892       return p;
8893    }
8894
8895   if (tag & 1)
8896     type = 1; /* String.  */
8897   else
8898     type = 2; /* uleb128.  */
8899   printf ("  Tag_unknown_%d: ", tag);
8900
8901   if (type == 1)
8902     {
8903       printf ("\"%s\"\n", p);
8904       p += strlen ((char *) p) + 1;
8905     }
8906   else
8907     {
8908       val = read_uleb128 (p, &len);
8909       p += len;
8910       printf ("%d (0x%x)\n", val, val);
8911     }
8912
8913   return p;
8914 }
8915
8916 static unsigned char *
8917 display_mips_gnu_attribute (unsigned char *p, int tag)
8918 {
8919   int type;
8920   unsigned int len;
8921   int val;
8922
8923   if (tag == Tag_GNU_MIPS_ABI_FP)
8924     {
8925       val = read_uleb128 (p, &len);
8926       p += len;
8927       printf ("  Tag_GNU_MIPS_ABI_FP: ");
8928
8929       switch (val)
8930         {
8931         case 0:
8932           printf ("Hard or soft float\n");
8933           break;
8934         case 1:
8935           printf ("Hard float (-mdouble-float)\n");
8936           break;
8937         case 2:
8938           printf ("Hard float (-msingle-float)\n");
8939           break;
8940         case 3:
8941           printf ("Soft float\n");
8942           break;
8943         case 4:
8944           printf ("64-bit float (-mips32r2 -mfp64)\n");
8945           break;
8946         default:
8947           printf ("??? (%d)\n", val);
8948           break;
8949         }
8950       return p;
8951    }
8952
8953   if (tag & 1)
8954     type = 1; /* String.  */
8955   else
8956     type = 2; /* uleb128.  */
8957   printf ("  Tag_unknown_%d: ", tag);
8958
8959   if (type == 1)
8960     {
8961       printf ("\"%s\"\n", p);
8962       p += strlen ((char *) p) + 1;
8963     }
8964   else
8965     {
8966       val = read_uleb128 (p, &len);
8967       p += len;
8968       printf ("%d (0x%x)\n", val, val);
8969     }
8970
8971   return p;
8972 }
8973
8974 static int
8975 process_attributes (FILE * file,
8976                     const char * public_name,
8977                     unsigned int proc_type,
8978                     unsigned char * (* display_pub_attribute) (unsigned char *),
8979                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
8980 {
8981   Elf_Internal_Shdr *sect;
8982   unsigned char *contents;
8983   unsigned char *p;
8984   unsigned char *end;
8985   bfd_vma section_len;
8986   bfd_vma len;
8987   unsigned i;
8988
8989   /* Find the section header so that we get the size.  */
8990   for (i = 0, sect = section_headers;
8991        i < elf_header.e_shnum;
8992        i++, sect++)
8993     {
8994       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
8995         continue;
8996
8997       contents = get_data (NULL, file, sect->sh_offset, 1, sect->sh_size,
8998                            _("attributes"));
8999       if (contents == NULL)
9000         continue;
9001
9002       p = contents;
9003       if (*p == 'A')
9004         {
9005           len = sect->sh_size - 1;
9006           p++;
9007
9008           while (len > 0)
9009             {
9010               int namelen;
9011               bfd_boolean public_section;
9012               bfd_boolean gnu_section;
9013
9014               section_len = byte_get (p, 4);
9015               p += 4;
9016
9017               if (section_len > len)
9018                 {
9019                   printf (_("ERROR: Bad section length (%d > %d)\n"),
9020                           (int) section_len, (int) len);
9021                   section_len = len;
9022                 }
9023
9024               len -= section_len;
9025               printf ("Attribute Section: %s\n", p);
9026
9027               if (public_name && streq ((char *) p, public_name))
9028                 public_section = TRUE;
9029               else
9030                 public_section = FALSE;
9031
9032               if (streq ((char *) p, "gnu"))
9033                 gnu_section = TRUE;
9034               else
9035                 gnu_section = FALSE;
9036
9037               namelen = strlen ((char *) p) + 1;
9038               p += namelen;
9039               section_len -= namelen + 4;
9040
9041               while (section_len > 0)
9042                 {
9043                   int tag = *(p++);
9044                   int val;
9045                   bfd_vma size;
9046
9047                   size = byte_get (p, 4);
9048                   if (size > section_len)
9049                     {
9050                       printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9051                               (int) size, (int) section_len);
9052                       size = section_len;
9053                     }
9054
9055                   section_len -= size;
9056                   end = p + size - 1;
9057                   p += 4;
9058
9059                   switch (tag)
9060                     {
9061                     case 1:
9062                       printf ("File Attributes\n");
9063                       break;
9064                     case 2:
9065                       printf ("Section Attributes:");
9066                       goto do_numlist;
9067                     case 3:
9068                       printf ("Symbol Attributes:");
9069                     do_numlist:
9070                       for (;;)
9071                         {
9072                           unsigned int i;
9073
9074                           val = read_uleb128 (p, &i);
9075                           p += i;
9076                           if (val == 0)
9077                             break;
9078                           printf (" %d", val);
9079                         }
9080                       printf ("\n");
9081                       break;
9082                     default:
9083                       printf ("Unknown tag: %d\n", tag);
9084                       public_section = FALSE;
9085                       break;
9086                     }
9087
9088                   if (public_section)
9089                     {
9090                       while (p < end)
9091                         p = display_pub_attribute (p);
9092                     }
9093                   else if (gnu_section)
9094                     {
9095                       while (p < end)
9096                         p = display_gnu_attribute (p,
9097                                                    display_proc_gnu_attribute);
9098                     }
9099                   else
9100                     {
9101                       /* ??? Do something sensible, like dump hex.  */
9102                       printf ("  Unknown section contexts\n");
9103                       p = end;
9104                     }
9105                 }
9106             }
9107         }
9108       else
9109         printf (_("Unknown format '%c'\n"), *p);
9110
9111       free (contents);
9112     }
9113   return 1;
9114 }
9115
9116 static int
9117 process_arm_specific (FILE *file)
9118 {
9119   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
9120                              display_arm_attribute, NULL);
9121 }
9122
9123 static int
9124 process_power_specific (FILE *file)
9125 {
9126   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
9127                              display_power_gnu_attribute);
9128 }
9129
9130 static int
9131 process_mips_specific (FILE *file)
9132 {
9133   Elf_Internal_Dyn *entry;
9134   size_t liblist_offset = 0;
9135   size_t liblistno = 0;
9136   size_t conflictsno = 0;
9137   size_t options_offset = 0;
9138   size_t conflicts_offset = 0;
9139
9140   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
9141                       display_mips_gnu_attribute);
9142
9143   /* We have a lot of special sections.  Thanks SGI!  */
9144   if (dynamic_section == NULL)
9145     /* No information available.  */
9146     return 0;
9147
9148   for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
9149     switch (entry->d_tag)
9150       {
9151       case DT_MIPS_LIBLIST:
9152         liblist_offset
9153           = offset_from_vma (file, entry->d_un.d_val,
9154                              liblistno * sizeof (Elf32_External_Lib));
9155         break;
9156       case DT_MIPS_LIBLISTNO:
9157         liblistno = entry->d_un.d_val;
9158         break;
9159       case DT_MIPS_OPTIONS:
9160         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
9161         break;
9162       case DT_MIPS_CONFLICT:
9163         conflicts_offset
9164           = offset_from_vma (file, entry->d_un.d_val,
9165                              conflictsno * sizeof (Elf32_External_Conflict));
9166         break;
9167       case DT_MIPS_CONFLICTNO:
9168         conflictsno = entry->d_un.d_val;
9169         break;
9170       default:
9171         break;
9172       }
9173
9174   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
9175     {
9176       Elf32_External_Lib *elib;
9177       size_t cnt;
9178
9179       elib = get_data (NULL, file, liblist_offset,
9180                        liblistno, sizeof (Elf32_External_Lib),
9181                        _("liblist"));
9182       if (elib)
9183         {
9184           printf ("\nSection '.liblist' contains %lu entries:\n",
9185                   (unsigned long) liblistno);
9186           fputs ("     Library              Time Stamp          Checksum   Version Flags\n",
9187                  stdout);
9188
9189           for (cnt = 0; cnt < liblistno; ++cnt)
9190             {
9191               Elf32_Lib liblist;
9192               time_t time;
9193               char timebuf[20];
9194               struct tm *tmp;
9195
9196               liblist.l_name = BYTE_GET (elib[cnt].l_name);
9197               time = BYTE_GET (elib[cnt].l_time_stamp);
9198               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9199               liblist.l_version = BYTE_GET (elib[cnt].l_version);
9200               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9201
9202               tmp = gmtime (&time);
9203               snprintf (timebuf, sizeof (timebuf),
9204                         "%04u-%02u-%02uT%02u:%02u:%02u",
9205                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9206                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9207
9208               printf ("%3lu: ", (unsigned long) cnt);
9209               if (VALID_DYNAMIC_NAME (liblist.l_name))
9210                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
9211               else
9212                 printf ("<corrupt: %9ld>", liblist.l_name);
9213               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
9214                       liblist.l_version);
9215
9216               if (liblist.l_flags == 0)
9217                 puts (" NONE");
9218               else
9219                 {
9220                   static const struct
9221                   {
9222                     const char *name;
9223                     int bit;
9224                   }
9225                   l_flags_vals[] =
9226                   {
9227                     { " EXACT_MATCH", LL_EXACT_MATCH },
9228                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
9229                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
9230                     { " EXPORTS", LL_EXPORTS },
9231                     { " DELAY_LOAD", LL_DELAY_LOAD },
9232                     { " DELTA", LL_DELTA }
9233                   };
9234                   int flags = liblist.l_flags;
9235                   size_t fcnt;
9236
9237                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
9238                     if ((flags & l_flags_vals[fcnt].bit) != 0)
9239                       {
9240                         fputs (l_flags_vals[fcnt].name, stdout);
9241                         flags ^= l_flags_vals[fcnt].bit;
9242                       }
9243                   if (flags != 0)
9244                     printf (" %#x", (unsigned int) flags);
9245
9246                   puts ("");
9247                 }
9248             }
9249
9250           free (elib);
9251         }
9252     }
9253
9254   if (options_offset != 0)
9255     {
9256       Elf_External_Options *eopt;
9257       Elf_Internal_Shdr *sect = section_headers;
9258       Elf_Internal_Options *iopt;
9259       Elf_Internal_Options *option;
9260       size_t offset;
9261       int cnt;
9262
9263       /* Find the section header so that we get the size.  */
9264       while (sect->sh_type != SHT_MIPS_OPTIONS)
9265         ++sect;
9266
9267       eopt = get_data (NULL, file, options_offset, 1, sect->sh_size,
9268                        _("options"));
9269       if (eopt)
9270         {
9271           iopt = cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (*iopt));
9272           if (iopt == NULL)
9273             {
9274               error (_("Out of memory\n"));
9275               return 0;
9276             }
9277
9278           offset = cnt = 0;
9279           option = iopt;
9280
9281           while (offset < sect->sh_size)
9282             {
9283               Elf_External_Options *eoption;
9284
9285               eoption = (Elf_External_Options *) ((char *) eopt + offset);
9286
9287               option->kind = BYTE_GET (eoption->kind);
9288               option->size = BYTE_GET (eoption->size);
9289               option->section = BYTE_GET (eoption->section);
9290               option->info = BYTE_GET (eoption->info);
9291
9292               offset += option->size;
9293
9294               ++option;
9295               ++cnt;
9296             }
9297
9298           printf (_("\nSection '%s' contains %d entries:\n"),
9299                   SECTION_NAME (sect), cnt);
9300
9301           option = iopt;
9302
9303           while (cnt-- > 0)
9304             {
9305               size_t len;
9306
9307               switch (option->kind)
9308                 {
9309                 case ODK_NULL:
9310                   /* This shouldn't happen.  */
9311                   printf (" NULL       %d %lx", option->section, option->info);
9312                   break;
9313                 case ODK_REGINFO:
9314                   printf (" REGINFO    ");
9315                   if (elf_header.e_machine == EM_MIPS)
9316                     {
9317                       /* 32bit form.  */
9318                       Elf32_External_RegInfo *ereg;
9319                       Elf32_RegInfo reginfo;
9320
9321                       ereg = (Elf32_External_RegInfo *) (option + 1);
9322                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9323                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9324                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9325                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9326                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9327                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
9328
9329                       printf ("GPR %08lx  GP 0x%lx\n",
9330                               reginfo.ri_gprmask,
9331                               (unsigned long) reginfo.ri_gp_value);
9332                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
9333                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9334                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9335                     }
9336                   else
9337                     {
9338                       /* 64 bit form.  */
9339                       Elf64_External_RegInfo *ereg;
9340                       Elf64_Internal_RegInfo reginfo;
9341
9342                       ereg = (Elf64_External_RegInfo *) (option + 1);
9343                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
9344                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9345                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9346                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9347                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9348                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
9349
9350                       printf ("GPR %08lx  GP 0x",
9351                               reginfo.ri_gprmask);
9352                       printf_vma (reginfo.ri_gp_value);
9353                       printf ("\n");
9354
9355                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
9356                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9357                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9358                     }
9359                   ++option;
9360                   continue;
9361                 case ODK_EXCEPTIONS:
9362                   fputs (" EXCEPTIONS fpe_min(", stdout);
9363                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
9364                   fputs (") fpe_max(", stdout);
9365                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
9366                   fputs (")", stdout);
9367
9368                   if (option->info & OEX_PAGE0)
9369                     fputs (" PAGE0", stdout);
9370                   if (option->info & OEX_SMM)
9371                     fputs (" SMM", stdout);
9372                   if (option->info & OEX_FPDBUG)
9373                     fputs (" FPDBUG", stdout);
9374                   if (option->info & OEX_DISMISS)
9375                     fputs (" DISMISS", stdout);
9376                   break;
9377                 case ODK_PAD:
9378                   fputs (" PAD       ", stdout);
9379                   if (option->info & OPAD_PREFIX)
9380                     fputs (" PREFIX", stdout);
9381                   if (option->info & OPAD_POSTFIX)
9382                     fputs (" POSTFIX", stdout);
9383                   if (option->info & OPAD_SYMBOL)
9384                     fputs (" SYMBOL", stdout);
9385                   break;
9386                 case ODK_HWPATCH:
9387                   fputs (" HWPATCH   ", stdout);
9388                   if (option->info & OHW_R4KEOP)
9389                     fputs (" R4KEOP", stdout);
9390                   if (option->info & OHW_R8KPFETCH)
9391                     fputs (" R8KPFETCH", stdout);
9392                   if (option->info & OHW_R5KEOP)
9393                     fputs (" R5KEOP", stdout);
9394                   if (option->info & OHW_R5KCVTL)
9395                     fputs (" R5KCVTL", stdout);
9396                   break;
9397                 case ODK_FILL:
9398                   fputs (" FILL       ", stdout);
9399                   /* XXX Print content of info word?  */
9400                   break;
9401                 case ODK_TAGS:
9402                   fputs (" TAGS       ", stdout);
9403                   /* XXX Print content of info word?  */
9404                   break;
9405                 case ODK_HWAND:
9406                   fputs (" HWAND     ", stdout);
9407                   if (option->info & OHWA0_R4KEOP_CHECKED)
9408                     fputs (" R4KEOP_CHECKED", stdout);
9409                   if (option->info & OHWA0_R4KEOP_CLEAN)
9410                     fputs (" R4KEOP_CLEAN", stdout);
9411                   break;
9412                 case ODK_HWOR:
9413                   fputs (" HWOR      ", stdout);
9414                   if (option->info & OHWA0_R4KEOP_CHECKED)
9415                     fputs (" R4KEOP_CHECKED", stdout);
9416                   if (option->info & OHWA0_R4KEOP_CLEAN)
9417                     fputs (" R4KEOP_CLEAN", stdout);
9418                   break;
9419                 case ODK_GP_GROUP:
9420                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
9421                           option->info & OGP_GROUP,
9422                           (option->info & OGP_SELF) >> 16);
9423                   break;
9424                 case ODK_IDENT:
9425                   printf (" IDENT     %#06lx  self-contained %#06lx",
9426                           option->info & OGP_GROUP,
9427                           (option->info & OGP_SELF) >> 16);
9428                   break;
9429                 default:
9430                   /* This shouldn't happen.  */
9431                   printf (" %3d ???     %d %lx",
9432                           option->kind, option->section, option->info);
9433                   break;
9434                 }
9435
9436               len = sizeof (*eopt);
9437               while (len < option->size)
9438                 if (((char *) option)[len] >= ' '
9439                     && ((char *) option)[len] < 0x7f)
9440                   printf ("%c", ((char *) option)[len++]);
9441                 else
9442                   printf ("\\%03o", ((char *) option)[len++]);
9443
9444               fputs ("\n", stdout);
9445               ++option;
9446             }
9447
9448           free (eopt);
9449         }
9450     }
9451
9452   if (conflicts_offset != 0 && conflictsno != 0)
9453     {
9454       Elf32_Conflict *iconf;
9455       size_t cnt;
9456
9457       if (dynamic_symbols == NULL)
9458         {
9459           error (_("conflict list found without a dynamic symbol table\n"));
9460           return 0;
9461         }
9462
9463       iconf = cmalloc (conflictsno, sizeof (*iconf));
9464       if (iconf == NULL)
9465         {
9466           error (_("Out of memory\n"));
9467           return 0;
9468         }
9469
9470       if (is_32bit_elf)
9471         {
9472           Elf32_External_Conflict *econf32;
9473
9474           econf32 = get_data (NULL, file, conflicts_offset,
9475                               conflictsno, sizeof (*econf32), _("conflict"));
9476           if (!econf32)
9477             return 0;
9478
9479           for (cnt = 0; cnt < conflictsno; ++cnt)
9480             iconf[cnt] = BYTE_GET (econf32[cnt]);
9481
9482           free (econf32);
9483         }
9484       else
9485         {
9486           Elf64_External_Conflict *econf64;
9487
9488           econf64 = get_data (NULL, file, conflicts_offset,
9489                               conflictsno, sizeof (*econf64), _("conflict"));
9490           if (!econf64)
9491             return 0;
9492
9493           for (cnt = 0; cnt < conflictsno; ++cnt)
9494             iconf[cnt] = BYTE_GET (econf64[cnt]);
9495
9496           free (econf64);
9497         }
9498
9499       printf (_("\nSection '.conflict' contains %lu entries:\n"),
9500               (unsigned long) conflictsno);
9501       puts (_("  Num:    Index       Value  Name"));
9502
9503       for (cnt = 0; cnt < conflictsno; ++cnt)
9504         {
9505           Elf_Internal_Sym *psym = & dynamic_symbols[iconf[cnt]];
9506
9507           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
9508           print_vma (psym->st_value, FULL_HEX);
9509           putchar (' ');
9510           if (VALID_DYNAMIC_NAME (psym->st_name))
9511             print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9512           else
9513             printf ("<corrupt: %14ld>", psym->st_name);
9514           putchar ('\n');
9515         }
9516
9517       free (iconf);
9518     }
9519
9520   return 1;
9521 }
9522
9523 static int
9524 process_gnu_liblist (FILE *file)
9525 {
9526   Elf_Internal_Shdr *section, *string_sec;
9527   Elf32_External_Lib *elib;
9528   char *strtab;
9529   size_t strtab_size;
9530   size_t cnt;
9531   unsigned i;
9532
9533   if (! do_arch)
9534     return 0;
9535
9536   for (i = 0, section = section_headers;
9537        i < elf_header.e_shnum;
9538        i++, section++)
9539     {
9540       switch (section->sh_type)
9541         {
9542         case SHT_GNU_LIBLIST:
9543           if (section->sh_link >= elf_header.e_shnum)
9544             break;
9545
9546           elib = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9547                            _("liblist"));
9548
9549           if (elib == NULL)
9550             break;
9551           string_sec = section_headers + section->sh_link;
9552
9553           strtab = get_data (NULL, file, string_sec->sh_offset, 1,
9554                              string_sec->sh_size, _("liblist string table"));
9555           strtab_size = string_sec->sh_size;
9556
9557           if (strtab == NULL
9558               || section->sh_entsize != sizeof (Elf32_External_Lib))
9559             {
9560               free (elib);
9561               break;
9562             }
9563
9564           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9565                   SECTION_NAME (section),
9566                   (long) (section->sh_size / sizeof (Elf32_External_Lib)));
9567
9568           puts ("     Library              Time Stamp          Checksum   Version Flags");
9569
9570           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
9571                ++cnt)
9572             {
9573               Elf32_Lib liblist;
9574               time_t time;
9575               char timebuf[20];
9576               struct tm *tmp;
9577
9578               liblist.l_name = BYTE_GET (elib[cnt].l_name);
9579               time = BYTE_GET (elib[cnt].l_time_stamp);
9580               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9581               liblist.l_version = BYTE_GET (elib[cnt].l_version);
9582               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9583
9584               tmp = gmtime (&time);
9585               snprintf (timebuf, sizeof (timebuf),
9586                         "%04u-%02u-%02uT%02u:%02u:%02u",
9587                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9588                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9589
9590               printf ("%3lu: ", (unsigned long) cnt);
9591               if (do_wide)
9592                 printf ("%-20s", liblist.l_name < strtab_size
9593                                  ? strtab + liblist.l_name : "<corrupt>");
9594               else
9595                 printf ("%-20.20s", liblist.l_name < strtab_size
9596                                     ? strtab + liblist.l_name : "<corrupt>");
9597               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
9598                       liblist.l_version, liblist.l_flags);
9599             }
9600
9601           free (elib);
9602         }
9603     }
9604
9605   return 1;
9606 }
9607
9608 static const char *
9609 get_note_type (unsigned e_type)
9610 {
9611   static char buff[64];
9612
9613   if (elf_header.e_type == ET_CORE)
9614     switch (e_type)
9615       {
9616       case NT_AUXV:
9617         return _("NT_AUXV (auxiliary vector)");
9618       case NT_PRSTATUS:
9619         return _("NT_PRSTATUS (prstatus structure)");
9620       case NT_FPREGSET:
9621         return _("NT_FPREGSET (floating point registers)");
9622       case NT_PRPSINFO:
9623         return _("NT_PRPSINFO (prpsinfo structure)");
9624       case NT_TASKSTRUCT:
9625         return _("NT_TASKSTRUCT (task structure)");
9626       case NT_PRXFPREG:
9627         return _("NT_PRXFPREG (user_xfpregs structure)");
9628       case NT_PPC_VMX:
9629         return _("NT_PPC_VMX (ppc Altivec registers)");
9630       case NT_PSTATUS:
9631         return _("NT_PSTATUS (pstatus structure)");
9632       case NT_FPREGS:
9633         return _("NT_FPREGS (floating point registers)");
9634       case NT_PSINFO:
9635         return _("NT_PSINFO (psinfo structure)");
9636       case NT_LWPSTATUS:
9637         return _("NT_LWPSTATUS (lwpstatus_t structure)");
9638       case NT_LWPSINFO:
9639         return _("NT_LWPSINFO (lwpsinfo_t structure)");
9640       case NT_WIN32PSTATUS:
9641         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9642       default:
9643         break;
9644       }
9645   else
9646     switch (e_type)
9647       {
9648       case NT_VERSION:
9649         return _("NT_VERSION (version)");
9650       case NT_ARCH:
9651         return _("NT_ARCH (architecture)");
9652       default:
9653         break;
9654       }
9655
9656   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9657   return buff;
9658 }
9659
9660 static const char *
9661 get_gnu_elf_note_type (unsigned e_type)
9662 {
9663   static char buff[64];
9664
9665   switch (e_type)
9666     {
9667     case NT_GNU_ABI_TAG:
9668       return _("NT_GNU_ABI_TAG (ABI version tag)");
9669     case NT_GNU_HWCAP:
9670       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
9671     case NT_GNU_BUILD_ID:
9672       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
9673     default:
9674       break;
9675     }
9676
9677   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9678   return buff;
9679 }
9680
9681 static const char *
9682 get_netbsd_elfcore_note_type (unsigned e_type)
9683 {
9684   static char buff[64];
9685
9686   if (e_type == NT_NETBSDCORE_PROCINFO)
9687     {
9688       /* NetBSD core "procinfo" structure.  */
9689       return _("NetBSD procinfo structure");
9690     }
9691
9692   /* As of Jan 2002 there are no other machine-independent notes
9693      defined for NetBSD core files.  If the note type is less
9694      than the start of the machine-dependent note types, we don't
9695      understand it.  */
9696
9697   if (e_type < NT_NETBSDCORE_FIRSTMACH)
9698     {
9699       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9700       return buff;
9701     }
9702
9703   switch (elf_header.e_machine)
9704     {
9705     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9706        and PT_GETFPREGS == mach+2.  */
9707
9708     case EM_OLD_ALPHA:
9709     case EM_ALPHA:
9710     case EM_SPARC:
9711     case EM_SPARC32PLUS:
9712     case EM_SPARCV9:
9713       switch (e_type)
9714         {
9715         case NT_NETBSDCORE_FIRSTMACH+0:
9716           return _("PT_GETREGS (reg structure)");
9717         case NT_NETBSDCORE_FIRSTMACH+2:
9718           return _("PT_GETFPREGS (fpreg structure)");
9719         default:
9720           break;
9721         }
9722       break;
9723
9724     /* On all other arch's, PT_GETREGS == mach+1 and
9725        PT_GETFPREGS == mach+3.  */
9726     default:
9727       switch (e_type)
9728         {
9729         case NT_NETBSDCORE_FIRSTMACH+1:
9730           return _("PT_GETREGS (reg structure)");
9731         case NT_NETBSDCORE_FIRSTMACH+3:
9732           return _("PT_GETFPREGS (fpreg structure)");
9733         default:
9734           break;
9735         }
9736     }
9737
9738   snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
9739             e_type - NT_NETBSDCORE_FIRSTMACH);
9740   return buff;
9741 }
9742
9743 /* Note that by the ELF standard, the name field is already null byte
9744    terminated, and namesz includes the terminating null byte.
9745    I.E. the value of namesz for the name "FSF" is 4.
9746
9747    If the value of namesz is zero, there is no name present.  */
9748 static int
9749 process_note (Elf_Internal_Note *pnote)
9750 {
9751   const char *name = pnote->namesz ? pnote->namedata : "(NONE)";
9752   const char *nt;
9753
9754   if (pnote->namesz == 0)
9755     /* If there is no note name, then use the default set of
9756        note type strings.  */
9757     nt = get_note_type (pnote->type);
9758
9759   else if (const_strneq (pnote->namedata, "GNU"))
9760     /* GNU-specific object file notes.  */
9761     nt = get_gnu_elf_note_type (pnote->type);
9762
9763   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
9764     /* NetBSD-specific core file notes.  */
9765     nt = get_netbsd_elfcore_note_type (pnote->type);
9766
9767   else if (strneq (pnote->namedata, "SPU/", 4))
9768     {
9769       /* SPU-specific core file notes.  */
9770       nt = pnote->namedata + 4;
9771       name = "SPU";
9772     }
9773
9774   else
9775     /* Don't recognize this note name; just use the default set of
9776        note type strings.  */
9777       nt = get_note_type (pnote->type);
9778
9779   printf ("  %s\t\t0x%08lx\t%s\n", name, pnote->descsz, nt);
9780   return 1;
9781 }
9782
9783
9784 static int
9785 process_corefile_note_segment (FILE *file, bfd_vma offset, bfd_vma length)
9786 {
9787   Elf_External_Note *pnotes;
9788   Elf_External_Note *external;
9789   int res = 1;
9790
9791   if (length <= 0)
9792     return 0;
9793
9794   pnotes = get_data (NULL, file, offset, 1, length, _("notes"));
9795   if (!pnotes)
9796     return 0;
9797
9798   external = pnotes;
9799
9800   printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9801           (unsigned long) offset, (unsigned long) length);
9802   printf (_("  Owner\t\tData size\tDescription\n"));
9803
9804   while (external < (Elf_External_Note *)((char *) pnotes + length))
9805     {
9806       Elf_External_Note *next;
9807       Elf_Internal_Note inote;
9808       char *temp = NULL;
9809
9810       inote.type     = BYTE_GET (external->type);
9811       inote.namesz   = BYTE_GET (external->namesz);
9812       inote.namedata = external->name;
9813       inote.descsz   = BYTE_GET (external->descsz);
9814       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
9815       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
9816
9817       next = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
9818
9819       if (((char *) next) > (((char *) pnotes) + length))
9820         {
9821           warn (_("corrupt note found at offset %lx into core notes\n"),
9822                 (long)((char *)external - (char *)pnotes));
9823           warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
9824                 inote.type, inote.namesz, inote.descsz);
9825           break;
9826         }
9827
9828       external = next;
9829
9830       /* Verify that name is null terminated.  It appears that at least
9831          one version of Linux (RedHat 6.0) generates corefiles that don't
9832          comply with the ELF spec by failing to include the null byte in
9833          namesz.  */
9834       if (inote.namedata[inote.namesz] != '\0')
9835         {
9836           temp = malloc (inote.namesz + 1);
9837
9838           if (temp == NULL)
9839             {
9840               error (_("Out of memory\n"));
9841               res = 0;
9842               break;
9843             }
9844
9845           strncpy (temp, inote.namedata, inote.namesz);
9846           temp[inote.namesz] = 0;
9847
9848           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
9849           inote.namedata = temp;
9850         }
9851
9852       res &= process_note (& inote);
9853
9854       if (temp != NULL)
9855         {
9856           free (temp);
9857           temp = NULL;
9858         }
9859     }
9860
9861   free (pnotes);
9862
9863   return res;
9864 }
9865
9866 static int
9867 process_corefile_note_segments (FILE *file)
9868 {
9869   Elf_Internal_Phdr *segment;
9870   unsigned int i;
9871   int res = 1;
9872
9873   if (! get_program_headers (file))
9874       return 0;
9875
9876   for (i = 0, segment = program_headers;
9877        i < elf_header.e_phnum;
9878        i++, segment++)
9879     {
9880       if (segment->p_type == PT_NOTE)
9881         res &= process_corefile_note_segment (file,
9882                                               (bfd_vma) segment->p_offset,
9883                                               (bfd_vma) segment->p_filesz);
9884     }
9885
9886   return res;
9887 }
9888
9889 static int
9890 process_note_sections (FILE *file)
9891 {
9892   Elf_Internal_Shdr *section;
9893   unsigned long i;
9894   int res = 1;
9895
9896   for (i = 0, section = section_headers;
9897        i < elf_header.e_shnum;
9898        i++, section++)
9899     if (section->sh_type == SHT_NOTE)
9900       res &= process_corefile_note_segment (file,
9901                                             (bfd_vma) section->sh_offset,
9902                                             (bfd_vma) section->sh_size);
9903
9904   return res;
9905 }
9906
9907 static int
9908 process_notes (FILE *file)
9909 {
9910   /* If we have not been asked to display the notes then do nothing.  */
9911   if (! do_notes)
9912     return 1;
9913
9914   if (elf_header.e_type != ET_CORE)
9915     return process_note_sections (file);
9916
9917   /* No program headers means no NOTE segment.  */
9918   if (elf_header.e_phnum > 0)
9919     return process_corefile_note_segments (file);
9920
9921   printf (_("No note segments present in the core file.\n"));
9922   return 1;
9923 }
9924
9925 static int
9926 process_arch_specific (FILE *file)
9927 {
9928   if (! do_arch)
9929     return 1;
9930
9931   switch (elf_header.e_machine)
9932     {
9933     case EM_ARM:
9934       return process_arm_specific (file);
9935     case EM_MIPS:
9936     case EM_MIPS_RS3_LE:
9937       return process_mips_specific (file);
9938       break;
9939     case EM_PPC:
9940       return process_power_specific (file);
9941       break;
9942     default:
9943       break;
9944     }
9945   return 1;
9946 }
9947
9948 static int
9949 get_file_header (FILE *file)
9950 {
9951   /* Read in the identity array.  */
9952   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
9953     return 0;
9954
9955   /* Determine how to read the rest of the header.  */
9956   switch (elf_header.e_ident[EI_DATA])
9957     {
9958     default: /* fall through */
9959     case ELFDATANONE: /* fall through */
9960     case ELFDATA2LSB:
9961       byte_get = byte_get_little_endian;
9962       byte_put = byte_put_little_endian;
9963       break;
9964     case ELFDATA2MSB:
9965       byte_get = byte_get_big_endian;
9966       byte_put = byte_put_big_endian;
9967       break;
9968     }
9969
9970   /* For now we only support 32 bit and 64 bit ELF files.  */
9971   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9972
9973   /* Read in the rest of the header.  */
9974   if (is_32bit_elf)
9975     {
9976       Elf32_External_Ehdr ehdr32;
9977
9978       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
9979         return 0;
9980
9981       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
9982       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
9983       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
9984       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
9985       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
9986       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
9987       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
9988       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
9989       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
9990       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
9991       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
9992       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
9993       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
9994     }
9995   else
9996     {
9997       Elf64_External_Ehdr ehdr64;
9998
9999       /* If we have been compiled with sizeof (bfd_vma) == 4, then
10000          we will not be able to cope with the 64bit data found in
10001          64 ELF files.  Detect this now and abort before we start
10002          overwriting things.  */
10003       if (sizeof (bfd_vma) < 8)
10004         {
10005           error (_("This instance of readelf has been built without support for a\n\
10006 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10007           return 0;
10008         }
10009
10010       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
10011         return 0;
10012
10013       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
10014       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
10015       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
10016       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
10017       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
10018       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
10019       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
10020       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
10021       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
10022       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
10023       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
10024       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
10025       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
10026     }
10027
10028   if (elf_header.e_shoff)
10029     {
10030       /* There may be some extensions in the first section header.  Don't
10031          bomb if we can't read it.  */
10032       if (is_32bit_elf)
10033         get_32bit_section_headers (file, 1);
10034       else
10035         get_64bit_section_headers (file, 1);
10036     }
10037
10038   return 1;
10039 }
10040
10041 /* Process one ELF object file according to the command line options.
10042    This file may actually be stored in an archive.  The file is
10043    positioned at the start of the ELF object.  */
10044
10045 static int
10046 process_object (char *file_name, FILE *file)
10047 {
10048   unsigned int i;
10049
10050   if (! get_file_header (file))
10051     {
10052       error (_("%s: Failed to read file header\n"), file_name);
10053       return 1;
10054     }
10055
10056   /* Initialise per file variables.  */
10057   for (i = ARRAY_SIZE (version_info); i--;)
10058     version_info[i] = 0;
10059
10060   for (i = ARRAY_SIZE (dynamic_info); i--;)
10061     dynamic_info[i] = 0;
10062
10063   /* Process the file.  */
10064   if (show_name)
10065     printf (_("\nFile: %s\n"), file_name);
10066
10067   /* Initialise the dump_sects array from the cmdline_dump_sects array.
10068      Note we do this even if cmdline_dump_sects is empty because we
10069      must make sure that the dump_sets array is zeroed out before each
10070      object file is processed.  */
10071   if (num_dump_sects > num_cmdline_dump_sects)
10072     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
10073
10074   if (num_cmdline_dump_sects > 0)
10075     {
10076       if (num_dump_sects == 0)
10077         /* A sneaky way of allocating the dump_sects array.  */
10078         request_dump_bynumber (num_cmdline_dump_sects, 0);
10079
10080       assert (num_dump_sects >= num_cmdline_dump_sects);
10081       memcpy (dump_sects, cmdline_dump_sects,
10082               num_cmdline_dump_sects * sizeof (* dump_sects));
10083     }
10084
10085   if (! process_file_header ())
10086     return 1;
10087
10088   if (! process_section_headers (file))
10089     {
10090       /* Without loaded section headers we cannot process lots of
10091          things.  */
10092       do_unwind = do_version = do_dump = do_arch = 0;
10093
10094       if (! do_using_dynamic)
10095         do_syms = do_reloc = 0;
10096     }
10097
10098   if (! process_section_groups (file))
10099     {
10100       /* Without loaded section groups we cannot process unwind.  */
10101       do_unwind = 0;
10102     }
10103
10104   if (process_program_headers (file))
10105     process_dynamic_section (file);
10106
10107   process_relocs (file);
10108
10109   process_unwind (file);
10110
10111   process_symbol_table (file);
10112
10113   process_syminfo (file);
10114
10115   process_version_sections (file);
10116
10117   process_section_contents (file);
10118
10119   process_notes (file);
10120
10121   process_gnu_liblist (file);
10122
10123   process_arch_specific (file);
10124
10125   if (program_headers)
10126     {
10127       free (program_headers);
10128       program_headers = NULL;
10129     }
10130
10131   if (section_headers)
10132     {
10133       free (section_headers);
10134       section_headers = NULL;
10135     }
10136
10137   if (string_table)
10138     {
10139       free (string_table);
10140       string_table = NULL;
10141       string_table_length = 0;
10142     }
10143
10144   if (dynamic_strings)
10145     {
10146       free (dynamic_strings);
10147       dynamic_strings = NULL;
10148       dynamic_strings_length = 0;
10149     }
10150
10151   if (dynamic_symbols)
10152     {
10153       free (dynamic_symbols);
10154       dynamic_symbols = NULL;
10155       num_dynamic_syms = 0;
10156     }
10157
10158   if (dynamic_syminfo)
10159     {
10160       free (dynamic_syminfo);
10161       dynamic_syminfo = NULL;
10162     }
10163
10164   if (section_headers_groups)
10165     {
10166       free (section_headers_groups);
10167       section_headers_groups = NULL;
10168     }
10169
10170   if (section_groups)
10171     {
10172       struct group_list *g, *next;
10173
10174       for (i = 0; i < group_count; i++)
10175         {
10176           for (g = section_groups [i].root; g != NULL; g = next)
10177             {
10178               next = g->next;
10179               free (g);
10180             }
10181         }
10182
10183       free (section_groups);
10184       section_groups = NULL;
10185     }
10186
10187   free_debug_memory ();
10188
10189   return 0;
10190 }
10191
10192 /* Process an ELF archive.
10193    On entry the file is positioned just after the ARMAG string.  */
10194
10195 static int
10196 process_archive (char *file_name, FILE *file)
10197 {
10198   struct ar_hdr arhdr;
10199   size_t got;
10200   unsigned long size;
10201   unsigned long index_num = 0;
10202   unsigned long *index_array = NULL;
10203   char *sym_table = NULL;
10204   unsigned long sym_size = 0;
10205   char *longnames = NULL;
10206   unsigned long longnames_size = 0;
10207   size_t file_name_size;
10208   int ret;
10209
10210   show_name = 1;
10211
10212   got = fread (&arhdr, 1, sizeof arhdr, file);
10213   if (got != sizeof arhdr)
10214     {
10215       if (got == 0)
10216         return 0;
10217
10218       error (_("%s: failed to read archive header\n"), file_name);
10219       return 1;
10220     }
10221
10222   /* See if this is the archive symbol table.  */
10223   if (const_strneq (arhdr.ar_name, "/               ")
10224       || const_strneq (arhdr.ar_name, "/SYM64/         "))
10225     {
10226       size = strtoul (arhdr.ar_size, NULL, 10);
10227       size = size + (size & 1);
10228
10229       if (do_archive_index)
10230         {
10231           unsigned long i;
10232           /* A buffer used to hold numbers read in from an archive index.
10233              These are always 4 bytes long and stored in big-endian format.  */
10234 #define SIZEOF_AR_INDEX_NUMBERS 4
10235           unsigned char integer_buffer[SIZEOF_AR_INDEX_NUMBERS];
10236           unsigned char * index_buffer;
10237
10238           /* Check the size of the archive index.  */
10239           if (size < SIZEOF_AR_INDEX_NUMBERS)
10240             {
10241               error (_("%s: the archive index is empty\n"), file_name);
10242               return 1;
10243             }
10244
10245           /* Read the numer of entries in the archive index.  */
10246           got = fread (integer_buffer, 1, sizeof integer_buffer, file);
10247           if (got != sizeof (integer_buffer))
10248             {
10249               error (_("%s: failed to read archive index\n"), file_name);
10250               return 1;
10251             }
10252           index_num = byte_get_big_endian (integer_buffer, sizeof integer_buffer);
10253           size -= SIZEOF_AR_INDEX_NUMBERS;
10254
10255           /* Read in the archive index.  */
10256           if (size < index_num * SIZEOF_AR_INDEX_NUMBERS)
10257             {
10258               error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
10259                      file_name, index_num);
10260               return 1;
10261             }
10262           index_buffer = malloc (index_num * SIZEOF_AR_INDEX_NUMBERS);
10263           if (index_buffer == NULL)
10264             {
10265               error (_("Out of memory whilst trying to read archive symbol index\n"));
10266               return 1;
10267             }
10268           got = fread (index_buffer, SIZEOF_AR_INDEX_NUMBERS, index_num, file);
10269           if (got != index_num)
10270             {
10271               free (index_buffer);
10272               error (_("%s: failed to read archive index\n"), file_name);
10273               ret = 1;
10274               goto out;
10275             }
10276           size -= index_num * SIZEOF_AR_INDEX_NUMBERS;
10277
10278           /* Convert the index numbers into the host's numeric format.  */
10279           index_array = malloc (index_num * sizeof (* index_array));
10280           if (index_array == NULL)
10281             {
10282               free (index_buffer);
10283               error (_("Out of memory whilst trying to convert the archive symbol index\n"));
10284               return 1;
10285             }
10286
10287           for (i = 0; i < index_num; i++)
10288             index_array[i] = byte_get_big_endian ((unsigned char *)(index_buffer + (i * SIZEOF_AR_INDEX_NUMBERS)),
10289                                                   SIZEOF_AR_INDEX_NUMBERS);
10290           free (index_buffer);
10291
10292           /* The remaining space in the header is taken up by the symbol table.  */
10293           if (size < 1)
10294             {
10295               error (_("%s: the archive has an index but no symbols\n"), file_name);
10296               ret = 1;
10297               goto out;
10298             }
10299           sym_table = malloc (size);
10300           sym_size = size;
10301           if (sym_table == NULL)
10302             {
10303               error (_("Out of memory whilst trying to read archive index symbol table\n"));
10304               ret = 1;
10305               goto out;
10306             }
10307           got = fread (sym_table, 1, size, file);
10308           if (got != size)
10309             {
10310               error (_("%s: failed to read archive index symbol table\n"), file_name);
10311               ret = 1;
10312               goto out;
10313             }
10314         }
10315       else
10316         {
10317           if (fseek (file, size, SEEK_CUR) != 0)
10318             {
10319               error (_("%s: failed to skip archive symbol table\n"), file_name);
10320               return 1;
10321             }
10322         }
10323
10324       got = fread (& arhdr, 1, sizeof arhdr, file);
10325       if (got != sizeof arhdr)
10326         {
10327           if (got == 0)
10328             {
10329               ret = 0;
10330               goto out;
10331             }
10332
10333           error (_("%s: failed to read archive header following archive index\n"), file_name);
10334           ret = 1;
10335           goto out;
10336         }
10337     }
10338   else if (do_archive_index)
10339     printf (_("%s has no archive index\n"), file_name);
10340
10341   if (const_strneq (arhdr.ar_name, "//              "))
10342     {
10343       /* This is the archive string table holding long member
10344          names.  */
10345
10346       longnames_size = strtoul (arhdr.ar_size, NULL, 10);
10347       longnames = malloc (longnames_size);
10348       if (longnames == NULL)
10349         {
10350           error (_("Out of memory reading long symbol names in archive\n"));
10351           ret = 1;
10352           goto out;
10353         }
10354
10355       if (fread (longnames, longnames_size, 1, file) != 1)
10356         {
10357           free (longnames);
10358           error (_("%s: failed to read long symbol name string table\n"), file_name);
10359           ret = 1;
10360           goto out;
10361         }
10362
10363       if ((longnames_size & 1) != 0)
10364         getc (file);
10365
10366       got = fread (& arhdr, 1, sizeof arhdr, file);
10367       if (got != sizeof arhdr)
10368         {
10369           if (got == 0)
10370             ret = 0;
10371           else
10372             {
10373               error (_("%s: failed to read archive header following long symbol names\n"), file_name);
10374               ret = 1;
10375             }
10376           goto out;
10377         }
10378     }
10379
10380   if (do_archive_index)
10381     {
10382       if (sym_table == NULL)
10383         error (_("%s: unable to dump the index as none was found\n"), file_name);
10384       else
10385         {
10386           unsigned int i, j, k, l;
10387           char elf_name[16];
10388           unsigned long current_pos;
10389
10390           printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
10391                   file_name, index_num, sym_size);
10392           current_pos = ftell (file);
10393
10394           for (i = l = 0; i < index_num; i++)
10395             {
10396               if ((i == 0) || ((i > 0) && (index_array[i] != index_array[i - 1])))
10397                 {
10398                   if (fseek (file, index_array[i], SEEK_SET) != 0)
10399                     {
10400                       error (_("%s: failed to seek to next file name\n"), file_name);
10401                       ret = 1;
10402                       goto out;
10403                     }
10404                   got = fread (elf_name, 1, 16, file);
10405                   if (got != 16)
10406                     {
10407                       error (_("%s: failed to read file name\n"), file_name);
10408                       ret = 1;
10409                       goto out;
10410                     }
10411
10412                   if (elf_name[0] == '/')
10413                     {
10414                       /* We have a long name.  */
10415                       k = j = strtoul (elf_name + 1, NULL, 10);
10416                       while ((j < longnames_size) && (longnames[j] != '/'))
10417                         j++;
10418                       longnames[j] = '\0';
10419                       printf (_("Binary %s contains:\n"), longnames + k);
10420                       longnames[j] = '/';
10421                     }
10422                   else
10423                     {
10424                       j = 0;
10425                       while ((elf_name[j] != '/') && (j < 16))
10426                         j++;
10427                       elf_name[j] = '\0';
10428                       printf(_("Binary %s contains:\n"), elf_name);
10429                     }
10430                 }
10431               if (l >= sym_size)
10432                 {
10433                   error (_("%s: end of the symbol table reached before the end of the index\n"),
10434                          file_name);
10435                   break;
10436                 }
10437               printf ("\t%s\n", sym_table + l);
10438               l += strlen (sym_table + l) + 1;
10439             }
10440
10441           if (l < sym_size)
10442             error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
10443                    file_name);
10444
10445           free (index_array);
10446           index_array = NULL;
10447           free (sym_table);
10448           sym_table = NULL;
10449           if (fseek (file, current_pos, SEEK_SET) != 0)
10450             {
10451               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
10452               return 1;
10453             }
10454         }
10455
10456       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
10457           && !do_segments && !do_header && !do_dump && !do_version
10458           && !do_histogram && !do_debugging && !do_arch && !do_notes
10459           && !do_section_groups)
10460         return 0; /* Archive index only.  */
10461     }
10462
10463   file_name_size = strlen (file_name);
10464   ret = 0;
10465
10466   while (1)
10467     {
10468       char *name;
10469       char *nameend;
10470       char *namealc;
10471
10472       if (arhdr.ar_name[0] == '/')
10473         {
10474           unsigned long off;
10475
10476           off = strtoul (arhdr.ar_name + 1, NULL, 10);
10477           if (off >= longnames_size)
10478             {
10479               error (_("%s: invalid archive string table offset %lu\n"), file_name, off);
10480               ret = 1;
10481               break;
10482             }
10483
10484           name = longnames + off;
10485           nameend = memchr (name, '/', longnames_size - off);
10486         }
10487       else
10488         {
10489           name = arhdr.ar_name;
10490           nameend = memchr (name, '/', 16);
10491         }
10492
10493       if (nameend == NULL)
10494         {
10495           error (_("%s: bad archive file name\n"), file_name);
10496           ret = 1;
10497           break;
10498         }
10499
10500       namealc = malloc (file_name_size + (nameend - name) + 3);
10501       if (namealc == NULL)
10502         {
10503           error (_("Out of memory\n"));
10504           ret = 1;
10505           break;
10506         }
10507
10508       memcpy (namealc, file_name, file_name_size);
10509       namealc[file_name_size] = '(';
10510       memcpy (namealc + file_name_size + 1, name, nameend - name);
10511       namealc[file_name_size + 1 + (nameend - name)] = ')';
10512       namealc[file_name_size + 2 + (nameend - name)] = '\0';
10513
10514       archive_file_offset = ftell (file);
10515       archive_file_size = strtoul (arhdr.ar_size, NULL, 10);
10516
10517       ret |= process_object (namealc, file);
10518
10519       free (namealc);
10520
10521       if (fseek (file,
10522                  (archive_file_offset
10523                   + archive_file_size
10524                   + (archive_file_size & 1)),
10525                  SEEK_SET) != 0)
10526         {
10527           error (_("%s: failed to seek to next archive header\n"), file_name);
10528           ret = 1;
10529           break;
10530         }
10531
10532       got = fread (&arhdr, 1, sizeof arhdr, file);
10533       if (got != sizeof arhdr)
10534         {
10535           if (got == 0)
10536             break;
10537
10538           error (_("%s: failed to read archive header\n"), file_name);
10539           ret = 1;
10540           break;
10541         }
10542     }
10543
10544  out:
10545   if (index_array != NULL)
10546     free (index_array);
10547   if (sym_table != NULL)
10548     free (sym_table);
10549   if (longnames != NULL)
10550     free (longnames);
10551
10552   return ret;
10553 }
10554
10555 static int
10556 process_file (char *file_name)
10557 {
10558   FILE *file;
10559   struct stat statbuf;
10560   char armag[SARMAG];
10561   int ret;
10562
10563   if (stat (file_name, &statbuf) < 0)
10564     {
10565       if (errno == ENOENT)
10566         error (_("'%s': No such file\n"), file_name);
10567       else
10568         error (_("Could not locate '%s'.  System error message: %s\n"),
10569                file_name, strerror (errno));
10570       return 1;
10571     }
10572
10573   if (! S_ISREG (statbuf.st_mode))
10574     {
10575       error (_("'%s' is not an ordinary file\n"), file_name);
10576       return 1;
10577     }
10578
10579   file = fopen (file_name, "rb");
10580   if (file == NULL)
10581     {
10582       error (_("Input file '%s' is not readable.\n"), file_name);
10583       return 1;
10584     }
10585
10586   if (fread (armag, SARMAG, 1, file) != 1)
10587     {
10588       error (_("%s: Failed to read file's magic number\n"), file_name);
10589       fclose (file);
10590       return 1;
10591     }
10592
10593   if (memcmp (armag, ARMAG, SARMAG) == 0)
10594     ret = process_archive (file_name, file);
10595   else
10596     {
10597       if (do_archive_index)
10598         error (_("File %s is not an archive so its index cannot be displayed.\n"),
10599                file_name);
10600
10601       rewind (file);
10602       archive_file_size = archive_file_offset = 0;
10603       ret = process_object (file_name, file);
10604     }
10605
10606   fclose (file);
10607
10608   return ret;
10609 }
10610
10611 #ifdef SUPPORT_DISASSEMBLY
10612 /* Needed by the i386 disassembler.  For extra credit, someone could
10613    fix this so that we insert symbolic addresses here, esp for GOT/PLT
10614    symbols.  */
10615
10616 void
10617 print_address (unsigned int addr, FILE *outfile)
10618 {
10619   fprintf (outfile,"0x%8.8x", addr);
10620 }
10621
10622 /* Needed by the i386 disassembler.  */
10623 void
10624 db_task_printsym (unsigned int addr)
10625 {
10626   print_address (addr, stderr);
10627 }
10628 #endif
10629
10630 int
10631 main (int argc, char **argv)
10632 {
10633   int err;
10634
10635 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10636   setlocale (LC_MESSAGES, "");
10637 #endif
10638 #if defined (HAVE_SETLOCALE)
10639   setlocale (LC_CTYPE, "");
10640 #endif
10641   bindtextdomain (PACKAGE, LOCALEDIR);
10642   textdomain (PACKAGE);
10643
10644   expandargv (&argc, &argv);
10645
10646   parse_args (argc, argv);
10647
10648   if (num_dump_sects > 0)
10649     {
10650       /* Make a copy of the dump_sects array.  */
10651       cmdline_dump_sects = malloc (num_dump_sects * sizeof (* dump_sects));
10652       if (cmdline_dump_sects == NULL)
10653         error (_("Out of memory allocating dump request table.\n"));
10654       else
10655         {
10656           memcpy (cmdline_dump_sects, dump_sects,
10657                   num_dump_sects * sizeof (* dump_sects));
10658           num_cmdline_dump_sects = num_dump_sects;
10659         }
10660     }
10661
10662   if (optind < (argc - 1))
10663     show_name = 1;
10664
10665   err = 0;
10666   while (optind < argc)
10667     err |= process_file (argv[optind++]);
10668
10669   if (dump_sects != NULL)
10670     free (dump_sects);
10671   if (cmdline_dump_sects != NULL)
10672     free (cmdline_dump_sects);
10673
10674   return err;
10675 }