binutils/readelf.c

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