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