contrib/binutils-2.21/binutils/readelf.c

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