binutils/readelf.c

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