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