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