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