binutils/readelf.c

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