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