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