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