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