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