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