binutils/readelf.c

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