binutils/readelf.c

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