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