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   char * data;
9342   char * end;
9343   char * start;
9344   char * name = SECTION_NAME (section);
9345   bfd_boolean some_strings_shown;
9346
9347   start = get_section_contents (section, file);
9348   if (start == NULL)
9349     return;
9350
9351   printf (_("\nString dump of section '%s':\n"), name);
9352
9353   /* If the section being dumped has relocations against it the user might
9354      be expecting these relocations to have been applied.  Check for this
9355      case and issue a warning message in order to avoid confusion.
9356      FIXME: Maybe we ought to have an option that dumps a section with
9357      relocs applied ?  */
9358   for (relsec = section_headers;
9359        relsec < section_headers + elf_header.e_shnum;
9360        ++relsec)
9361     {
9362       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9363           || relsec->sh_info >= elf_header.e_shnum
9364           || section_headers + relsec->sh_info != section
9365           || relsec->sh_size == 0
9366           || relsec->sh_link >= elf_header.e_shnum)
9367         continue;
9368
9369       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9370       break;
9371     }
9372
9373   num_bytes = section->sh_size;
9374   data = start;
9375   end  = start + num_bytes;
9376   some_strings_shown = FALSE;
9377
9378   while (data < end)
9379     {
9380       while (!ISPRINT (* data))
9381         if (++ data >= end)
9382           break;
9383
9384       if (data < end)
9385         {
9386 #ifndef __MSVCRT__
9387           /* PR 11128: Use two separate invocations in order to work
9388              around bugs in the Solaris 8 implementation of printf.  */
9389           printf ("  [%6tx]  ", data - start);
9390           printf ("%s\n", data);
9391 #else
9392           printf ("  [%6Ix]  %s\n", (size_t) (data - start), data);
9393 #endif
9394           data += strlen (data);
9395           some_strings_shown = TRUE;
9396         }
9397     }
9398
9399   if (! some_strings_shown)
9400     printf (_("  No strings found in this section."));
9401
9402   free (start);
9403
9404   putchar ('\n');
9405 }
9406
9407 static void
9408 dump_section_as_bytes (Elf_Internal_Shdr * section,
9409                        FILE * file,
9410                        bfd_boolean relocate)
9411 {
9412   Elf_Internal_Shdr * relsec;
9413   bfd_size_type bytes;
9414   bfd_vma addr;
9415   unsigned char * data;
9416   unsigned char * start;
9417
9418   start = (unsigned char *) get_section_contents (section, file);
9419   if (start == NULL)
9420     return;
9421
9422   printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
9423
9424   if (relocate)
9425     {
9426       apply_relocations (file, section, start);
9427     }
9428   else
9429     {
9430       /* If the section being dumped has relocations against it the user might
9431          be expecting these relocations to have been applied.  Check for this
9432          case and issue a warning message in order to avoid confusion.
9433          FIXME: Maybe we ought to have an option that dumps a section with
9434          relocs applied ?  */
9435       for (relsec = section_headers;
9436            relsec < section_headers + elf_header.e_shnum;
9437            ++relsec)
9438         {
9439           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9440               || relsec->sh_info >= elf_header.e_shnum
9441               || section_headers + relsec->sh_info != section
9442               || relsec->sh_size == 0
9443               || relsec->sh_link >= elf_header.e_shnum)
9444             continue;
9445
9446           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9447           break;
9448         }
9449     }
9450
9451   addr = section->sh_addr;
9452   bytes = section->sh_size;
9453   data = start;
9454
9455   while (bytes)
9456     {
9457       int j;
9458       int k;
9459       int lbytes;
9460
9461       lbytes = (bytes > 16 ? 16 : bytes);
9462
9463       printf ("  0x%8.8lx ", (unsigned long) addr);
9464
9465       for (j = 0; j < 16; j++)
9466         {
9467           if (j < lbytes)
9468             printf ("%2.2x", data[j]);
9469           else
9470             printf ("  ");
9471
9472           if ((j & 3) == 3)
9473             printf (" ");
9474         }
9475
9476       for (j = 0; j < lbytes; j++)
9477         {
9478           k = data[j];
9479           if (k >= ' ' && k < 0x7f)
9480             printf ("%c", k);
9481           else
9482             printf (".");
9483         }
9484
9485       putchar ('\n');
9486
9487       data  += lbytes;
9488       addr  += lbytes;
9489       bytes -= lbytes;
9490     }
9491
9492   free (start);
9493
9494   putchar ('\n');
9495 }
9496
9497 /* Uncompresses a section that was compressed using zlib, in place.
9498    This is a copy of bfd_uncompress_section_contents, in bfd/compress.c  */
9499
9500 static int
9501 uncompress_section_contents (unsigned char ** buffer, dwarf_size_type * size)
9502 {
9503 #ifndef HAVE_ZLIB_H
9504   /* These are just to quiet gcc.  */
9505   buffer = 0;
9506   size = 0;
9507   return FALSE;
9508 #else
9509   dwarf_size_type compressed_size = *size;
9510   unsigned char * compressed_buffer = *buffer;
9511   dwarf_size_type uncompressed_size;
9512   unsigned char * uncompressed_buffer;
9513   z_stream strm;
9514   int rc;
9515   dwarf_size_type header_size = 12;
9516
9517   /* Read the zlib header.  In this case, it should be "ZLIB" followed
9518      by the uncompressed section size, 8 bytes in big-endian order.  */
9519   if (compressed_size < header_size
9520       || ! streq ((char *) compressed_buffer, "ZLIB"))
9521     return 0;
9522
9523   uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
9524   uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
9525   uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
9526   uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
9527   uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
9528   uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
9529   uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
9530   uncompressed_size += compressed_buffer[11];
9531
9532   /* It is possible the section consists of several compressed
9533      buffers concatenated together, so we uncompress in a loop.  */
9534   strm.zalloc = NULL;
9535   strm.zfree = NULL;
9536   strm.opaque = NULL;
9537   strm.avail_in = compressed_size - header_size;
9538   strm.next_in = (Bytef *) compressed_buffer + header_size;
9539   strm.avail_out = uncompressed_size;
9540   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
9541
9542   rc = inflateInit (& strm);
9543   while (strm.avail_in > 0)
9544     {
9545       if (rc != Z_OK)
9546         goto fail;
9547       strm.next_out = ((Bytef *) uncompressed_buffer
9548                        + (uncompressed_size - strm.avail_out));
9549       rc = inflate (&strm, Z_FINISH);
9550       if (rc != Z_STREAM_END)
9551         goto fail;
9552       rc = inflateReset (& strm);
9553     }
9554   rc = inflateEnd (& strm);
9555   if (rc != Z_OK
9556       || strm.avail_out != 0)
9557     goto fail;
9558
9559   free (compressed_buffer);
9560   *buffer = uncompressed_buffer;
9561   *size = uncompressed_size;
9562   return 1;
9563
9564  fail:
9565   free (uncompressed_buffer);
9566   return 0;
9567 #endif  /* HAVE_ZLIB_H */
9568 }
9569
9570 static int
9571 load_specific_debug_section (enum dwarf_section_display_enum debug,
9572                              Elf_Internal_Shdr * sec, void * file)
9573 {
9574   struct dwarf_section * section = &debug_displays [debug].section;
9575   char buf [64];
9576   int section_is_compressed;
9577
9578   /* If it is already loaded, do nothing.  */
9579   if (section->start != NULL)
9580     return 1;
9581
9582   section_is_compressed = section->name == section->compressed_name;
9583
9584   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
9585   section->address = sec->sh_addr;
9586   section->size = sec->sh_size;
9587   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
9588                                                sec->sh_offset, 1,
9589                                                sec->sh_size, buf);
9590   if (section->start == NULL)
9591     return 0;
9592
9593   if (section_is_compressed)
9594     if (! uncompress_section_contents (&section->start, &section->size))
9595       return 0;
9596
9597   if (debug_displays [debug].relocate)
9598     apply_relocations ((FILE *) file, sec, section->start);
9599
9600   return 1;
9601 }
9602
9603 int
9604 load_debug_section (enum dwarf_section_display_enum debug, void * file)
9605 {
9606   struct dwarf_section * section = &debug_displays [debug].section;
9607   Elf_Internal_Shdr * sec;
9608
9609   /* Locate the debug section.  */
9610   sec = find_section (section->uncompressed_name);
9611   if (sec != NULL)
9612     section->name = section->uncompressed_name;
9613   else
9614     {
9615       sec = find_section (section->compressed_name);
9616       if (sec != NULL)
9617         section->name = section->compressed_name;
9618     }
9619   if (sec == NULL)
9620     return 0;
9621
9622   return load_specific_debug_section (debug, sec, (FILE *) file);
9623 }
9624
9625 void
9626 free_debug_section (enum dwarf_section_display_enum debug)
9627 {
9628   struct dwarf_section * section = &debug_displays [debug].section;
9629
9630   if (section->start == NULL)
9631     return;
9632
9633   free ((char *) section->start);
9634   section->start = NULL;
9635   section->address = 0;
9636   section->size = 0;
9637 }
9638
9639 static int
9640 display_debug_section (Elf_Internal_Shdr * section, FILE * file)
9641 {
9642   char * name = SECTION_NAME (section);
9643   bfd_size_type length;
9644   int result = 1;
9645   int i;
9646
9647   length = section->sh_size;
9648   if (length == 0)
9649     {
9650       printf (_("\nSection '%s' has no debugging data.\n"), name);
9651       return 0;
9652     }
9653   if (section->sh_type == SHT_NOBITS)
9654     {
9655       /* There is no point in dumping the contents of a debugging section
9656          which has the NOBITS type - the bits in the file will be random.
9657          This can happen when a file containing a .eh_frame section is
9658          stripped with the --only-keep-debug command line option.  */
9659       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
9660       return 0;
9661     }
9662
9663   if (const_strneq (name, ".gnu.linkonce.wi."))
9664     name = ".debug_info";
9665
9666   /* See if we know how to display the contents of this section.  */
9667   for (i = 0; i < max; i++)
9668     if (streq (debug_displays[i].section.uncompressed_name, name)
9669         || streq (debug_displays[i].section.compressed_name, name))
9670       {
9671         struct dwarf_section * sec = &debug_displays [i].section;
9672         int secondary = (section != find_section (name));
9673
9674         if (secondary)
9675           free_debug_section ((enum dwarf_section_display_enum) i);
9676
9677         if (streq (sec->uncompressed_name, name))
9678           sec->name = sec->uncompressed_name;
9679         else
9680           sec->name = sec->compressed_name;
9681         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
9682                                          section, file))
9683           {
9684             result &= debug_displays[i].display (sec, file);
9685
9686             if (secondary || (i != info && i != abbrev))
9687               free_debug_section ((enum dwarf_section_display_enum) i);
9688           }
9689
9690         break;
9691       }
9692
9693   if (i == max)
9694     {
9695       printf (_("Unrecognized debug section: %s\n"), name);
9696       result = 0;
9697     }
9698
9699   return result;
9700 }
9701
9702 /* Set DUMP_SECTS for all sections where dumps were requested
9703    based on section name.  */
9704
9705 static void
9706 initialise_dumps_byname (void)
9707 {
9708   struct dump_list_entry * cur;
9709
9710   for (cur = dump_sects_byname; cur; cur = cur->next)
9711     {
9712       unsigned int i;
9713       int any;
9714
9715       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
9716         if (streq (SECTION_NAME (section_headers + i), cur->name))
9717           {
9718             request_dump_bynumber (i, cur->type);
9719             any = 1;
9720           }
9721
9722       if (!any)
9723         warn (_("Section '%s' was not dumped because it does not exist!\n"),
9724               cur->name);
9725     }
9726 }
9727
9728 static void
9729 process_section_contents (FILE * file)
9730 {
9731   Elf_Internal_Shdr * section;
9732   unsigned int i;
9733
9734   if (! do_dump)
9735     return;
9736
9737   initialise_dumps_byname ();
9738
9739   for (i = 0, section = section_headers;
9740        i < elf_header.e_shnum && i < num_dump_sects;
9741        i++, section++)
9742     {
9743 #ifdef SUPPORT_DISASSEMBLY
9744       if (dump_sects[i] & DISASS_DUMP)
9745         disassemble_section (section, file);
9746 #endif
9747       if (dump_sects[i] & HEX_DUMP)
9748         dump_section_as_bytes (section, file, FALSE);
9749
9750       if (dump_sects[i] & RELOC_DUMP)
9751         dump_section_as_bytes (section, file, TRUE);
9752
9753       if (dump_sects[i] & STRING_DUMP)
9754         dump_section_as_strings (section, file);
9755
9756       if (dump_sects[i] & DEBUG_DUMP)
9757         display_debug_section (section, file);
9758     }
9759
9760   /* Check to see if the user requested a
9761      dump of a section that does not exist.  */
9762   while (i++ < num_dump_sects)
9763     if (dump_sects[i])
9764       warn (_("Section %d was not dumped because it does not exist!\n"), i);
9765 }
9766
9767 static void
9768 process_mips_fpe_exception (int mask)
9769 {
9770   if (mask)
9771     {
9772       int first = 1;
9773       if (mask & OEX_FPU_INEX)
9774         fputs ("INEX", stdout), first = 0;
9775       if (mask & OEX_FPU_UFLO)
9776         printf ("%sUFLO", first ? "" : "|"), first = 0;
9777       if (mask & OEX_FPU_OFLO)
9778         printf ("%sOFLO", first ? "" : "|"), first = 0;
9779       if (mask & OEX_FPU_DIV0)
9780         printf ("%sDIV0", first ? "" : "|"), first = 0;
9781       if (mask & OEX_FPU_INVAL)
9782         printf ("%sINVAL", first ? "" : "|");
9783     }
9784   else
9785     fputs ("0", stdout);
9786 }
9787
9788 /* ARM EABI attributes section.  */
9789 typedef struct
9790 {
9791   int tag;
9792   const char * name;
9793   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
9794   int type;
9795   const char ** table;
9796 } arm_attr_public_tag;
9797
9798 static const char * arm_attr_tag_CPU_arch[] =
9799   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
9800    "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
9801 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
9802 static const char * arm_attr_tag_THUMB_ISA_use[] =
9803   {"No", "Thumb-1", "Thumb-2"};
9804 static const char * arm_attr_tag_VFP_arch[] =
9805   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
9806 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
9807 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
9808   {"No", "NEONv1", "NEONv1 with Fused-MAC"};
9809 static const char * arm_attr_tag_PCS_config[] =
9810   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
9811    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
9812 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
9813   {"V6", "SB", "TLS", "Unused"};
9814 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
9815   {"Absolute", "PC-relative", "SB-relative", "None"};
9816 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
9817   {"Absolute", "PC-relative", "None"};
9818 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
9819   {"None", "direct", "GOT-indirect"};
9820 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
9821   {"None", "??? 1", "2", "??? 3", "4"};
9822 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
9823 static const char * arm_attr_tag_ABI_FP_denormal[] =
9824   {"Unused", "Needed", "Sign only"};
9825 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
9826 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
9827 static const char * arm_attr_tag_ABI_FP_number_model[] =
9828   {"Unused", "Finite", "RTABI", "IEEE 754"};
9829 static const char * arm_attr_tag_ABI_align8_needed[] = {"No", "Yes", "4-byte"};
9830 static const char * arm_attr_tag_ABI_align8_preserved[] =
9831   {"No", "Yes, except leaf SP", "Yes"};
9832 static const char * arm_attr_tag_ABI_enum_size[] =
9833   {"Unused", "small", "int", "forced to int"};
9834 static const char * arm_attr_tag_ABI_HardFP_use[] =
9835   {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
9836 static const char * arm_attr_tag_ABI_VFP_args[] =
9837   {"AAPCS", "VFP registers", "custom"};
9838 static const char * arm_attr_tag_ABI_WMMX_args[] =
9839   {"AAPCS", "WMMX registers", "custom"};
9840 static const char * arm_attr_tag_ABI_optimization_goals[] =
9841   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9842     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
9843 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
9844   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9845     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
9846 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
9847 static const char * arm_attr_tag_VFP_HP_extension[] =
9848   {"Not Allowed", "Allowed"};
9849 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
9850   {"None", "IEEE 754", "Alternative Format"};
9851 static const char * arm_attr_tag_MPextension_use[] =
9852   {"Not Allowed", "Allowed"};
9853 static const char * arm_attr_tag_DIV_use[] =
9854   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
9855     "Allowed in v7-A with integer division extension"};
9856 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
9857 static const char * arm_attr_tag_Virtualization_use[] =
9858   {"Not Allowed", "TrustZone", "Virtualization Extensions",
9859     "TrustZone and Virtualization Extensions"};
9860 static const char * arm_attr_tag_MPextension_use_legacy[] =
9861   {"Not Allowed", "Allowed"};
9862
9863 #define LOOKUP(id, name) \
9864   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
9865 static arm_attr_public_tag arm_attr_public_tags[] =
9866 {
9867   {4, "CPU_raw_name", 1, NULL},
9868   {5, "CPU_name", 1, NULL},
9869   LOOKUP(6, CPU_arch),
9870   {7, "CPU_arch_profile", 0, NULL},
9871   LOOKUP(8, ARM_ISA_use),
9872   LOOKUP(9, THUMB_ISA_use),
9873   LOOKUP(10, VFP_arch),
9874   LOOKUP(11, WMMX_arch),
9875   LOOKUP(12, Advanced_SIMD_arch),
9876   LOOKUP(13, PCS_config),
9877   LOOKUP(14, ABI_PCS_R9_use),
9878   LOOKUP(15, ABI_PCS_RW_data),
9879   LOOKUP(16, ABI_PCS_RO_data),
9880   LOOKUP(17, ABI_PCS_GOT_use),
9881   LOOKUP(18, ABI_PCS_wchar_t),
9882   LOOKUP(19, ABI_FP_rounding),
9883   LOOKUP(20, ABI_FP_denormal),
9884   LOOKUP(21, ABI_FP_exceptions),
9885   LOOKUP(22, ABI_FP_user_exceptions),
9886   LOOKUP(23, ABI_FP_number_model),
9887   LOOKUP(24, ABI_align8_needed),
9888   LOOKUP(25, ABI_align8_preserved),
9889   LOOKUP(26, ABI_enum_size),
9890   LOOKUP(27, ABI_HardFP_use),
9891   LOOKUP(28, ABI_VFP_args),
9892   LOOKUP(29, ABI_WMMX_args),
9893   LOOKUP(30, ABI_optimization_goals),
9894   LOOKUP(31, ABI_FP_optimization_goals),
9895   {32, "compatibility", 0, NULL},
9896   LOOKUP(34, CPU_unaligned_access),
9897   LOOKUP(36, VFP_HP_extension),
9898   LOOKUP(38, ABI_FP_16bit_format),
9899   LOOKUP(42, MPextension_use),
9900   LOOKUP(44, DIV_use),
9901   {64, "nodefaults", 0, NULL},
9902   {65, "also_compatible_with", 0, NULL},
9903   LOOKUP(66, T2EE_use),
9904   {67, "conformance", 1, NULL},
9905   LOOKUP(68, Virtualization_use),
9906   LOOKUP(70, MPextension_use_legacy)
9907 };
9908 #undef LOOKUP
9909
9910 static unsigned char *
9911 display_arm_attribute (unsigned char * p)
9912 {
9913   int tag;
9914   unsigned int len;
9915   int val;
9916   arm_attr_public_tag * attr;
9917   unsigned i;
9918   int type;
9919
9920   tag = read_uleb128 (p, &len);
9921   p += len;
9922   attr = NULL;
9923   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
9924     {
9925       if (arm_attr_public_tags[i].tag == tag)
9926         {
9927           attr = &arm_attr_public_tags[i];
9928           break;
9929         }
9930     }
9931
9932   if (attr)
9933     {
9934       printf ("  Tag_%s: ", attr->name);
9935       switch (attr->type)
9936         {
9937         case 0:
9938           switch (tag)
9939             {
9940             case 7: /* Tag_CPU_arch_profile.  */
9941               val = read_uleb128 (p, &len);
9942               p += len;
9943               switch (val)
9944                 {
9945                 case 0: printf ("None\n"); break;
9946                 case 'A': printf ("Application\n"); break;
9947                 case 'R': printf ("Realtime\n"); break;
9948                 case 'M': printf ("Microcontroller\n"); break;
9949                 default: printf ("??? (%d)\n", val); break;
9950                 }
9951               break;
9952
9953             case 32: /* Tag_compatibility.  */
9954               val = read_uleb128 (p, &len);
9955               p += len;
9956               printf ("flag = %d, vendor = %s\n", val, p);
9957               p += strlen ((char *) p) + 1;
9958               break;
9959
9960             case 64: /* Tag_nodefaults.  */
9961               p++;
9962               printf ("True\n");
9963               break;
9964
9965             case 65: /* Tag_also_compatible_with.  */
9966               val = read_uleb128 (p, &len);
9967               p += len;
9968               if (val == 6 /* Tag_CPU_arch.  */)
9969                 {
9970                   val = read_uleb128 (p, &len);
9971                   p += len;
9972                   if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
9973                     printf ("??? (%d)\n", val);
9974                   else
9975                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
9976                 }
9977               else
9978                 printf ("???\n");
9979               while (*(p++) != '\0' /* NUL terminator.  */);
9980               break;
9981
9982             default:
9983               abort ();
9984             }
9985           return p;
9986
9987         case 1:
9988         case 2:
9989           type = attr->type;
9990           break;
9991
9992         default:
9993           assert (attr->type & 0x80);
9994           val = read_uleb128 (p, &len);
9995           p += len;
9996           type = attr->type & 0x7f;
9997           if (val >= type)
9998             printf ("??? (%d)\n", val);
9999           else
10000             printf ("%s\n", attr->table[val]);
10001           return p;
10002         }
10003     }
10004   else
10005     {
10006       if (tag & 1)
10007         type = 1; /* String.  */
10008       else
10009         type = 2; /* uleb128.  */
10010       printf ("  Tag_unknown_%d: ", tag);
10011     }
10012
10013   if (type == 1)
10014     {
10015       printf ("\"%s\"\n", p);
10016       p += strlen ((char *) p) + 1;
10017     }
10018   else
10019     {
10020       val = read_uleb128 (p, &len);
10021       p += len;
10022       printf ("%d (0x%x)\n", val, val);
10023     }
10024
10025   return p;
10026 }
10027
10028 static unsigned char *
10029 display_gnu_attribute (unsigned char * p,
10030                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
10031 {
10032   int tag;
10033   unsigned int len;
10034   int val;
10035   int type;
10036
10037   tag = read_uleb128 (p, &len);
10038   p += len;
10039
10040   /* Tag_compatibility is the only generic GNU attribute defined at
10041      present.  */
10042   if (tag == 32)
10043     {
10044       val = read_uleb128 (p, &len);
10045       p += len;
10046       printf ("flag = %d, vendor = %s\n", val, p);
10047       p += strlen ((char *) p) + 1;
10048       return p;
10049     }
10050
10051   if ((tag & 2) == 0 && display_proc_gnu_attribute)
10052     return display_proc_gnu_attribute (p, tag);
10053
10054   if (tag & 1)
10055     type = 1; /* String.  */
10056   else
10057     type = 2; /* uleb128.  */
10058   printf ("  Tag_unknown_%d: ", tag);
10059
10060   if (type == 1)
10061     {
10062       printf ("\"%s\"\n", p);
10063       p += strlen ((char *) p) + 1;
10064     }
10065   else
10066     {
10067       val = read_uleb128 (p, &len);
10068       p += len;
10069       printf ("%d (0x%x)\n", val, val);
10070     }
10071
10072   return p;
10073 }
10074
10075 static unsigned char *
10076 display_power_gnu_attribute (unsigned char * p, int tag)
10077 {
10078   int type;
10079   unsigned int len;
10080   int val;
10081
10082   if (tag == Tag_GNU_Power_ABI_FP)
10083     {
10084       val = read_uleb128 (p, &len);
10085       p += len;
10086       printf ("  Tag_GNU_Power_ABI_FP: ");
10087
10088       switch (val)
10089         {
10090         case 0:
10091           printf ("Hard or soft float\n");
10092           break;
10093         case 1:
10094           printf ("Hard float\n");
10095           break;
10096         case 2:
10097           printf ("Soft float\n");
10098           break;
10099         case 3:
10100           printf ("Single-precision hard float\n");
10101           break;
10102         default:
10103           printf ("??? (%d)\n", val);
10104           break;
10105         }
10106       return p;
10107    }
10108
10109   if (tag == Tag_GNU_Power_ABI_Vector)
10110     {
10111       val = read_uleb128 (p, &len);
10112       p += len;
10113       printf ("  Tag_GNU_Power_ABI_Vector: ");
10114       switch (val)
10115         {
10116         case 0:
10117           printf ("Any\n");
10118           break;
10119         case 1:
10120           printf ("Generic\n");
10121           break;
10122         case 2:
10123           printf ("AltiVec\n");
10124           break;
10125         case 3:
10126           printf ("SPE\n");
10127           break;
10128         default:
10129           printf ("??? (%d)\n", val);
10130           break;
10131         }
10132       return p;
10133    }
10134
10135   if (tag == Tag_GNU_Power_ABI_Struct_Return)
10136     {
10137       val = read_uleb128 (p, &len);
10138       p += len;
10139       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
10140       switch (val)
10141        {
10142        case 0:
10143          printf ("Any\n");
10144          break;
10145        case 1:
10146          printf ("r3/r4\n");
10147          break;
10148        case 2:
10149          printf ("Memory\n");
10150          break;
10151        default:
10152          printf ("??? (%d)\n", val);
10153          break;
10154        }
10155       return p;
10156     }
10157
10158   if (tag & 1)
10159     type = 1; /* String.  */
10160   else
10161     type = 2; /* uleb128.  */
10162   printf ("  Tag_unknown_%d: ", tag);
10163
10164   if (type == 1)
10165     {
10166       printf ("\"%s\"\n", p);
10167       p += strlen ((char *) p) + 1;
10168     }
10169   else
10170     {
10171       val = read_uleb128 (p, &len);
10172       p += len;
10173       printf ("%d (0x%x)\n", val, val);
10174     }
10175
10176   return p;
10177 }
10178
10179 static unsigned char *
10180 display_mips_gnu_attribute (unsigned char * p, int tag)
10181 {
10182   int type;
10183   unsigned int len;
10184   int val;
10185
10186   if (tag == Tag_GNU_MIPS_ABI_FP)
10187     {
10188       val = read_uleb128 (p, &len);
10189       p += len;
10190       printf ("  Tag_GNU_MIPS_ABI_FP: ");
10191
10192       switch (val)
10193         {
10194         case 0:
10195           printf ("Hard or soft float\n");
10196           break;
10197         case 1:
10198           printf ("Hard float (-mdouble-float)\n");
10199           break;
10200         case 2:
10201           printf ("Hard float (-msingle-float)\n");
10202           break;
10203         case 3:
10204           printf ("Soft float\n");
10205           break;
10206         case 4:
10207           printf ("64-bit float (-mips32r2 -mfp64)\n");
10208           break;
10209         default:
10210           printf ("??? (%d)\n", val);
10211           break;
10212         }
10213       return p;
10214    }
10215
10216   if (tag & 1)
10217     type = 1; /* String.  */
10218   else
10219     type = 2; /* uleb128.  */
10220   printf ("  Tag_unknown_%d: ", tag);
10221
10222   if (type == 1)
10223     {
10224       printf ("\"%s\"\n", p);
10225       p += strlen ((char *) p) + 1;
10226     }
10227   else
10228     {
10229       val = read_uleb128 (p, &len);
10230       p += len;
10231       printf ("%d (0x%x)\n", val, val);
10232     }
10233
10234   return p;
10235 }
10236
10237 static int
10238 process_attributes (FILE * file,
10239                     const char * public_name,
10240                     unsigned int proc_type,
10241                     unsigned char * (* display_pub_attribute) (unsigned char *),
10242                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
10243 {
10244   Elf_Internal_Shdr * sect;
10245   unsigned char * contents;
10246   unsigned char * p;
10247   unsigned char * end;
10248   bfd_vma section_len;
10249   bfd_vma len;
10250   unsigned i;
10251
10252   /* Find the section header so that we get the size.  */
10253   for (i = 0, sect = section_headers;
10254        i < elf_header.e_shnum;
10255        i++, sect++)
10256     {
10257       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
10258         continue;
10259
10260       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
10261                                              sect->sh_size, _("attributes"));
10262       if (contents == NULL)
10263         continue;
10264
10265       p = contents;
10266       if (*p == 'A')
10267         {
10268           len = sect->sh_size - 1;
10269           p++;
10270
10271           while (len > 0)
10272             {
10273               int namelen;
10274               bfd_boolean public_section;
10275               bfd_boolean gnu_section;
10276
10277               section_len = byte_get (p, 4);
10278               p += 4;
10279
10280               if (section_len > len)
10281                 {
10282                   printf (_("ERROR: Bad section length (%d > %d)\n"),
10283                           (int) section_len, (int) len);
10284                   section_len = len;
10285                 }
10286
10287               len -= section_len;
10288               printf ("Attribute Section: %s\n", p);
10289
10290               if (public_name && streq ((char *) p, public_name))
10291                 public_section = TRUE;
10292               else
10293                 public_section = FALSE;
10294
10295               if (streq ((char *) p, "gnu"))
10296                 gnu_section = TRUE;
10297               else
10298                 gnu_section = FALSE;
10299
10300               namelen = strlen ((char *) p) + 1;
10301               p += namelen;
10302               section_len -= namelen + 4;
10303
10304               while (section_len > 0)
10305                 {
10306                   int tag = *(p++);
10307                   int val;
10308                   bfd_vma size;
10309
10310                   size = byte_get (p, 4);
10311                   if (size > section_len)
10312                     {
10313                       printf (_("ERROR: Bad subsection length (%d > %d)\n"),
10314                               (int) size, (int) section_len);
10315                       size = section_len;
10316                     }
10317
10318                   section_len -= size;
10319                   end = p + size - 1;
10320                   p += 4;
10321
10322                   switch (tag)
10323                     {
10324                     case 1:
10325                       printf ("File Attributes\n");
10326                       break;
10327                     case 2:
10328                       printf ("Section Attributes:");
10329                       goto do_numlist;
10330                     case 3:
10331                       printf ("Symbol Attributes:");
10332                     do_numlist:
10333                       for (;;)
10334                         {
10335                           unsigned int j;
10336
10337                           val = read_uleb128 (p, &j);
10338                           p += j;
10339                           if (val == 0)
10340                             break;
10341                           printf (" %d", val);
10342                         }
10343                       printf ("\n");
10344                       break;
10345                     default:
10346                       printf ("Unknown tag: %d\n", tag);
10347                       public_section = FALSE;
10348                       break;
10349                     }
10350
10351                   if (public_section)
10352                     {
10353                       while (p < end)
10354                         p = display_pub_attribute (p);
10355                     }
10356                   else if (gnu_section)
10357                     {
10358                       while (p < end)
10359                         p = display_gnu_attribute (p,
10360                                                    display_proc_gnu_attribute);
10361                     }
10362                   else
10363                     {
10364                       /* ??? Do something sensible, like dump hex.  */
10365                       printf ("  Unknown section contexts\n");
10366                       p = end;
10367                     }
10368                 }
10369             }
10370         }
10371       else
10372         printf (_("Unknown format '%c'\n"), *p);
10373
10374       free (contents);
10375     }
10376   return 1;
10377 }
10378
10379 static int
10380 process_arm_specific (FILE * file)
10381 {
10382   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
10383                              display_arm_attribute, NULL);
10384 }
10385
10386 static int
10387 process_power_specific (FILE * file)
10388 {
10389   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
10390                              display_power_gnu_attribute);
10391 }
10392
10393 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
10394    Print the Address, Access and Initial fields of an entry at VMA ADDR
10395    and return the VMA of the next entry.  */
10396
10397 static bfd_vma
10398 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
10399 {
10400   printf ("  ");
10401   print_vma (addr, LONG_HEX);
10402   printf (" ");
10403   if (addr < pltgot + 0xfff0)
10404     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
10405   else
10406     printf ("%10s", "");
10407   printf (" ");
10408   if (data == NULL)
10409     printf ("%*s", is_32bit_elf ? 8 : 16, "<unknown>");
10410   else
10411     {
10412       bfd_vma entry;
10413
10414       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
10415       print_vma (entry, LONG_HEX);
10416     }
10417   return addr + (is_32bit_elf ? 4 : 8);
10418 }
10419
10420 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
10421    PLTGOT.  Print the Address and Initial fields of an entry at VMA
10422    ADDR and return the VMA of the next entry.  */
10423
10424 static bfd_vma
10425 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
10426 {
10427   printf ("  ");
10428   print_vma (addr, LONG_HEX);
10429   printf (" ");
10430   if (data == NULL)
10431     printf ("%*s", is_32bit_elf ? 8 : 16, "<unknown>");
10432   else
10433     {
10434       bfd_vma entry;
10435
10436       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
10437       print_vma (entry, LONG_HEX);
10438     }
10439   return addr + (is_32bit_elf ? 4 : 8);
10440 }
10441
10442 static int
10443 process_mips_specific (FILE * file)
10444 {
10445   Elf_Internal_Dyn * entry;
10446   size_t liblist_offset = 0;
10447   size_t liblistno = 0;
10448   size_t conflictsno = 0;
10449   size_t options_offset = 0;
10450   size_t conflicts_offset = 0;
10451   size_t pltrelsz = 0;
10452   size_t pltrel = 0;
10453   bfd_vma pltgot = 0;
10454   bfd_vma mips_pltgot = 0;
10455   bfd_vma jmprel = 0;
10456   bfd_vma local_gotno = 0;
10457   bfd_vma gotsym = 0;
10458   bfd_vma symtabno = 0;
10459
10460   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
10461                       display_mips_gnu_attribute);
10462
10463   /* We have a lot of special sections.  Thanks SGI!  */
10464   if (dynamic_section == NULL)
10465     /* No information available.  */
10466     return 0;
10467
10468   for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
10469     switch (entry->d_tag)
10470       {
10471       case DT_MIPS_LIBLIST:
10472         liblist_offset
10473           = offset_from_vma (file, entry->d_un.d_val,
10474                              liblistno * sizeof (Elf32_External_Lib));
10475         break;
10476       case DT_MIPS_LIBLISTNO:
10477         liblistno = entry->d_un.d_val;
10478         break;
10479       case DT_MIPS_OPTIONS:
10480         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
10481         break;
10482       case DT_MIPS_CONFLICT:
10483         conflicts_offset
10484           = offset_from_vma (file, entry->d_un.d_val,
10485                              conflictsno * sizeof (Elf32_External_Conflict));
10486         break;
10487       case DT_MIPS_CONFLICTNO:
10488         conflictsno = entry->d_un.d_val;
10489         break;
10490       case DT_PLTGOT:
10491         pltgot = entry->d_un.d_ptr;
10492         break;
10493       case DT_MIPS_LOCAL_GOTNO:
10494         local_gotno = entry->d_un.d_val;
10495         break;
10496       case DT_MIPS_GOTSYM:
10497         gotsym = entry->d_un.d_val;
10498         break;
10499       case DT_MIPS_SYMTABNO:
10500         symtabno = entry->d_un.d_val;
10501         break;
10502       case DT_MIPS_PLTGOT:
10503         mips_pltgot = entry->d_un.d_ptr;
10504         break;
10505       case DT_PLTREL:
10506         pltrel = entry->d_un.d_val;
10507         break;
10508       case DT_PLTRELSZ:
10509         pltrelsz = entry->d_un.d_val;
10510         break;
10511       case DT_JMPREL:
10512         jmprel = entry->d_un.d_ptr;
10513         break;
10514       default:
10515         break;
10516       }
10517
10518   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
10519     {
10520       Elf32_External_Lib * elib;
10521       size_t cnt;
10522
10523       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
10524                                               liblistno,
10525                                               sizeof (Elf32_External_Lib),
10526                                               _("liblist"));
10527       if (elib)
10528         {
10529           printf ("\nSection '.liblist' contains %lu entries:\n",
10530                   (unsigned long) liblistno);
10531           fputs ("     Library              Time Stamp          Checksum   Version Flags\n",
10532                  stdout);
10533
10534           for (cnt = 0; cnt < liblistno; ++cnt)
10535             {
10536               Elf32_Lib liblist;
10537               time_t atime;
10538               char timebuf[20];
10539               struct tm * tmp;
10540
10541               liblist.l_name = BYTE_GET (elib[cnt].l_name);
10542               atime = BYTE_GET (elib[cnt].l_time_stamp);
10543               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
10544               liblist.l_version = BYTE_GET (elib[cnt].l_version);
10545               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
10546
10547               tmp = gmtime (&atime);
10548               snprintf (timebuf, sizeof (timebuf),
10549                         "%04u-%02u-%02uT%02u:%02u:%02u",
10550                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10551                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10552
10553               printf ("%3lu: ", (unsigned long) cnt);
10554               if (VALID_DYNAMIC_NAME (liblist.l_name))
10555                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
10556               else
10557                 printf ("<corrupt: %9ld>", liblist.l_name);
10558               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
10559                       liblist.l_version);
10560
10561               if (liblist.l_flags == 0)
10562                 puts (" NONE");
10563               else
10564                 {
10565                   static const struct
10566                   {
10567                     const char * name;
10568                     int bit;
10569                   }
10570                   l_flags_vals[] =
10571                   {
10572                     { " EXACT_MATCH", LL_EXACT_MATCH },
10573                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
10574                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
10575                     { " EXPORTS", LL_EXPORTS },
10576                     { " DELAY_LOAD", LL_DELAY_LOAD },
10577                     { " DELTA", LL_DELTA }
10578                   };
10579                   int flags = liblist.l_flags;
10580                   size_t fcnt;
10581
10582                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
10583                     if ((flags & l_flags_vals[fcnt].bit) != 0)
10584                       {
10585                         fputs (l_flags_vals[fcnt].name, stdout);
10586                         flags ^= l_flags_vals[fcnt].bit;
10587                       }
10588                   if (flags != 0)
10589                     printf (" %#x", (unsigned int) flags);
10590
10591                   puts ("");
10592                 }
10593             }
10594
10595           free (elib);
10596         }
10597     }
10598
10599   if (options_offset != 0)
10600     {
10601       Elf_External_Options * eopt;
10602       Elf_Internal_Shdr * sect = section_headers;
10603       Elf_Internal_Options * iopt;
10604       Elf_Internal_Options * option;
10605       size_t offset;
10606       int cnt;
10607
10608       /* Find the section header so that we get the size.  */
10609       while (sect->sh_type != SHT_MIPS_OPTIONS)
10610         ++sect;
10611
10612       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
10613                                                 sect->sh_size, _("options"));
10614       if (eopt)
10615         {
10616           iopt = (Elf_Internal_Options *)
10617               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
10618           if (iopt == NULL)
10619             {
10620               error (_("Out of memory\n"));
10621               return 0;
10622             }
10623
10624           offset = cnt = 0;
10625           option = iopt;
10626
10627           while (offset < sect->sh_size)
10628             {
10629               Elf_External_Options * eoption;
10630
10631               eoption = (Elf_External_Options *) ((char *) eopt + offset);
10632
10633               option->kind = BYTE_GET (eoption->kind);
10634               option->size = BYTE_GET (eoption->size);
10635               option->section = BYTE_GET (eoption->section);
10636               option->info = BYTE_GET (eoption->info);
10637
10638               offset += option->size;
10639
10640               ++option;
10641               ++cnt;
10642             }
10643
10644           printf (_("\nSection '%s' contains %d entries:\n"),
10645                   SECTION_NAME (sect), cnt);
10646
10647           option = iopt;
10648
10649           while (cnt-- > 0)
10650             {
10651               size_t len;
10652
10653               switch (option->kind)
10654                 {
10655                 case ODK_NULL:
10656                   /* This shouldn't happen.  */
10657                   printf (" NULL       %d %lx", option->section, option->info);
10658                   break;
10659                 case ODK_REGINFO:
10660                   printf (" REGINFO    ");
10661                   if (elf_header.e_machine == EM_MIPS)
10662                     {
10663                       /* 32bit form.  */
10664                       Elf32_External_RegInfo * ereg;
10665                       Elf32_RegInfo reginfo;
10666
10667                       ereg = (Elf32_External_RegInfo *) (option + 1);
10668                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
10669                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
10670                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
10671                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
10672                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
10673                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
10674
10675                       printf ("GPR %08lx  GP 0x%lx\n",
10676                               reginfo.ri_gprmask,
10677                               (unsigned long) reginfo.ri_gp_value);
10678                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
10679                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
10680                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
10681                     }
10682                   else
10683                     {
10684                       /* 64 bit form.  */
10685                       Elf64_External_RegInfo * ereg;
10686                       Elf64_Internal_RegInfo reginfo;
10687
10688                       ereg = (Elf64_External_RegInfo *) (option + 1);
10689                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
10690                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
10691                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
10692                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
10693                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
10694                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
10695
10696                       printf ("GPR %08lx  GP 0x",
10697                               reginfo.ri_gprmask);
10698                       printf_vma (reginfo.ri_gp_value);
10699                       printf ("\n");
10700
10701                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
10702                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
10703                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
10704                     }
10705                   ++option;
10706                   continue;
10707                 case ODK_EXCEPTIONS:
10708                   fputs (" EXCEPTIONS fpe_min(", stdout);
10709                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
10710                   fputs (") fpe_max(", stdout);
10711                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
10712                   fputs (")", stdout);
10713
10714                   if (option->info & OEX_PAGE0)
10715                     fputs (" PAGE0", stdout);
10716                   if (option->info & OEX_SMM)
10717                     fputs (" SMM", stdout);
10718                   if (option->info & OEX_FPDBUG)
10719                     fputs (" FPDBUG", stdout);
10720                   if (option->info & OEX_DISMISS)
10721                     fputs (" DISMISS", stdout);
10722                   break;
10723                 case ODK_PAD:
10724                   fputs (" PAD       ", stdout);
10725                   if (option->info & OPAD_PREFIX)
10726                     fputs (" PREFIX", stdout);
10727                   if (option->info & OPAD_POSTFIX)
10728                     fputs (" POSTFIX", stdout);
10729                   if (option->info & OPAD_SYMBOL)
10730                     fputs (" SYMBOL", stdout);
10731                   break;
10732                 case ODK_HWPATCH:
10733                   fputs (" HWPATCH   ", stdout);
10734                   if (option->info & OHW_R4KEOP)
10735                     fputs (" R4KEOP", stdout);
10736                   if (option->info & OHW_R8KPFETCH)
10737                     fputs (" R8KPFETCH", stdout);
10738                   if (option->info & OHW_R5KEOP)
10739                     fputs (" R5KEOP", stdout);
10740                   if (option->info & OHW_R5KCVTL)
10741                     fputs (" R5KCVTL", stdout);
10742                   break;
10743                 case ODK_FILL:
10744                   fputs (" FILL       ", stdout);
10745                   /* XXX Print content of info word?  */
10746                   break;
10747                 case ODK_TAGS:
10748                   fputs (" TAGS       ", stdout);
10749                   /* XXX Print content of info word?  */
10750                   break;
10751                 case ODK_HWAND:
10752                   fputs (" HWAND     ", stdout);
10753                   if (option->info & OHWA0_R4KEOP_CHECKED)
10754                     fputs (" R4KEOP_CHECKED", stdout);
10755                   if (option->info & OHWA0_R4KEOP_CLEAN)
10756                     fputs (" R4KEOP_CLEAN", stdout);
10757                   break;
10758                 case ODK_HWOR:
10759                   fputs (" HWOR      ", stdout);
10760                   if (option->info & OHWA0_R4KEOP_CHECKED)
10761                     fputs (" R4KEOP_CHECKED", stdout);
10762                   if (option->info & OHWA0_R4KEOP_CLEAN)
10763                     fputs (" R4KEOP_CLEAN", stdout);
10764                   break;
10765                 case ODK_GP_GROUP:
10766                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
10767                           option->info & OGP_GROUP,
10768                           (option->info & OGP_SELF) >> 16);
10769                   break;
10770                 case ODK_IDENT:
10771                   printf (" IDENT     %#06lx  self-contained %#06lx",
10772                           option->info & OGP_GROUP,
10773                           (option->info & OGP_SELF) >> 16);
10774                   break;
10775                 default:
10776                   /* This shouldn't happen.  */
10777                   printf (" %3d ???     %d %lx",
10778                           option->kind, option->section, option->info);
10779                   break;
10780                 }
10781
10782               len = sizeof (* eopt);
10783               while (len < option->size)
10784                 if (((char *) option)[len] >= ' '
10785                     && ((char *) option)[len] < 0x7f)
10786                   printf ("%c", ((char *) option)[len++]);
10787                 else
10788                   printf ("\\%03o", ((char *) option)[len++]);
10789
10790               fputs ("\n", stdout);
10791               ++option;
10792             }
10793
10794           free (eopt);
10795         }
10796     }
10797
10798   if (conflicts_offset != 0 && conflictsno != 0)
10799     {
10800       Elf32_Conflict * iconf;
10801       size_t cnt;
10802
10803       if (dynamic_symbols == NULL)
10804         {
10805           error (_("conflict list found without a dynamic symbol table\n"));
10806           return 0;
10807         }
10808
10809       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
10810       if (iconf == NULL)
10811         {
10812           error (_("Out of memory\n"));
10813           return 0;
10814         }
10815
10816       if (is_32bit_elf)
10817         {
10818           Elf32_External_Conflict * econf32;
10819
10820           econf32 = (Elf32_External_Conflict *)
10821               get_data (NULL, file, conflicts_offset, conflictsno,
10822                         sizeof (* econf32), _("conflict"));
10823           if (!econf32)
10824             return 0;
10825
10826           for (cnt = 0; cnt < conflictsno; ++cnt)
10827             iconf[cnt] = BYTE_GET (econf32[cnt]);
10828
10829           free (econf32);
10830         }
10831       else
10832         {
10833           Elf64_External_Conflict * econf64;
10834
10835           econf64 = (Elf64_External_Conflict *)
10836               get_data (NULL, file, conflicts_offset, conflictsno,
10837                         sizeof (* econf64), _("conflict"));
10838           if (!econf64)
10839             return 0;
10840
10841           for (cnt = 0; cnt < conflictsno; ++cnt)
10842             iconf[cnt] = BYTE_GET (econf64[cnt]);
10843
10844           free (econf64);
10845         }
10846
10847       printf (_("\nSection '.conflict' contains %lu entries:\n"),
10848               (unsigned long) conflictsno);
10849       puts (_("  Num:    Index       Value  Name"));
10850
10851       for (cnt = 0; cnt < conflictsno; ++cnt)
10852         {
10853           Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
10854
10855           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
10856           print_vma (psym->st_value, FULL_HEX);
10857           putchar (' ');
10858           if (VALID_DYNAMIC_NAME (psym->st_name))
10859             print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10860           else
10861             printf ("<corrupt: %14ld>", psym->st_name);
10862           putchar ('\n');
10863         }
10864
10865       free (iconf);
10866     }
10867
10868   if (pltgot != 0 && local_gotno != 0)
10869     {
10870       bfd_vma ent, local_end, global_end;
10871       size_t i, offset;
10872       unsigned char * data;
10873       int addr_size;
10874
10875       ent = pltgot;
10876       addr_size = (is_32bit_elf ? 4 : 8);
10877       local_end = pltgot + local_gotno * addr_size;
10878       global_end = local_end + (symtabno - gotsym) * addr_size;
10879
10880       offset = offset_from_vma (file, pltgot, global_end - pltgot);
10881       data = (unsigned char *) get_data (NULL, file, offset,
10882                                          global_end - pltgot, 1, _("GOT"));
10883       printf (_("\nPrimary GOT:\n"));
10884       printf (_(" Canonical gp value: "));
10885       print_vma (pltgot + 0x7ff0, LONG_HEX);
10886       printf ("\n\n");
10887
10888       printf (_(" Reserved entries:\n"));
10889       printf (_("  %*s %10s %*s Purpose\n"),
10890               addr_size * 2, "Address", "Access",
10891               addr_size * 2, "Initial");
10892       ent = print_mips_got_entry (data, pltgot, ent);
10893       printf (" Lazy resolver\n");
10894       if (data
10895           && (byte_get (data + ent - pltgot, addr_size)
10896               >> (addr_size * 8 - 1)) != 0)
10897         {
10898           ent = print_mips_got_entry (data, pltgot, ent);
10899           printf (" Module pointer (GNU extension)\n");
10900         }
10901       printf ("\n");
10902
10903       if (ent < local_end)
10904         {
10905           printf (_(" Local entries:\n"));
10906           printf (_("  %*s %10s %*s\n"),
10907                   addr_size * 2, "Address", "Access",
10908                   addr_size * 2, "Initial");
10909           while (ent < local_end)
10910             {
10911               ent = print_mips_got_entry (data, pltgot, ent);
10912               printf ("\n");
10913             }
10914           printf ("\n");
10915         }
10916
10917       if (gotsym < symtabno)
10918         {
10919           int sym_width;
10920
10921           printf (_(" Global entries:\n"));
10922           printf (_("  %*s %10s %*s %*s %-7s %3s %s\n"),
10923                   addr_size * 2, "Address", "Access",
10924                   addr_size * 2, "Initial",
10925                   addr_size * 2, "Sym.Val.", "Type", "Ndx", "Name");
10926           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
10927           for (i = gotsym; i < symtabno; i++)
10928             {
10929               Elf_Internal_Sym * psym;
10930
10931               psym = dynamic_symbols + i;
10932               ent = print_mips_got_entry (data, pltgot, ent);
10933               printf (" ");
10934               print_vma (psym->st_value, LONG_HEX);
10935               printf (" %-7s %3s ",
10936                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
10937                       get_symbol_index_type (psym->st_shndx));
10938               if (VALID_DYNAMIC_NAME (psym->st_name))
10939                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
10940               else
10941                 printf ("<corrupt: %14ld>", psym->st_name);
10942               printf ("\n");
10943             }
10944           printf ("\n");
10945         }
10946
10947       if (data)
10948         free (data);
10949     }
10950
10951   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
10952     {
10953       bfd_vma ent, end;
10954       size_t offset, rel_offset;
10955       unsigned long count, i;
10956       unsigned char * data;
10957       int addr_size, sym_width;
10958       Elf_Internal_Rela * rels;
10959
10960       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
10961       if (pltrel == DT_RELA)
10962         {
10963           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
10964             return 0;
10965         }
10966       else
10967         {
10968           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
10969             return 0;
10970         }
10971
10972       ent = mips_pltgot;
10973       addr_size = (is_32bit_elf ? 4 : 8);
10974       end = mips_pltgot + (2 + count) * addr_size;
10975
10976       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
10977       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
10978                                          1, _("PLT GOT"));
10979       printf (_("\nPLT GOT:\n\n"));
10980       printf (_(" Reserved entries:\n"));
10981       printf (_("  %*s %*s Purpose\n"),
10982               addr_size * 2, "Address", addr_size * 2, "Initial");
10983       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
10984       printf (" PLT lazy resolver\n");
10985       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
10986       printf (" Module pointer\n");
10987       printf ("\n");
10988
10989       printf (_(" Entries:\n"));
10990       printf (_("  %*s %*s %*s %-7s %3s %s\n"),
10991               addr_size * 2, "Address",
10992               addr_size * 2, "Initial",
10993               addr_size * 2, "Sym.Val.", "Type", "Ndx", "Name");
10994       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
10995       for (i = 0; i < count; i++)
10996         {
10997           Elf_Internal_Sym * psym;
10998
10999           psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
11000           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
11001           printf (" ");
11002           print_vma (psym->st_value, LONG_HEX);
11003           printf (" %-7s %3s ",
11004                   get_symbol_type (ELF_ST_TYPE (psym->st_info)),
11005                   get_symbol_index_type (psym->st_shndx));
11006           if (VALID_DYNAMIC_NAME (psym->st_name))
11007             print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
11008           else
11009             printf ("<corrupt: %14ld>", psym->st_name);
11010           printf ("\n");
11011         }
11012       printf ("\n");
11013
11014       if (data)
11015         free (data);
11016       free (rels);
11017     }
11018
11019   return 1;
11020 }
11021
11022 static int
11023 process_gnu_liblist (FILE * file)
11024 {
11025   Elf_Internal_Shdr * section;
11026   Elf_Internal_Shdr * string_sec;
11027   Elf32_External_Lib * elib;
11028   char * strtab;
11029   size_t strtab_size;
11030   size_t cnt;
11031   unsigned i;
11032
11033   if (! do_arch)
11034     return 0;
11035
11036   for (i = 0, section = section_headers;
11037        i < elf_header.e_shnum;
11038        i++, section++)
11039     {
11040       switch (section->sh_type)
11041         {
11042         case SHT_GNU_LIBLIST:
11043           if (section->sh_link >= elf_header.e_shnum)
11044             break;
11045
11046           elib = (Elf32_External_Lib *)
11047               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
11048                         _("liblist"));
11049
11050           if (elib == NULL)
11051             break;
11052           string_sec = section_headers + section->sh_link;
11053
11054           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
11055                                       string_sec->sh_size,
11056                                       _("liblist string table"));
11057           strtab_size = string_sec->sh_size;
11058
11059           if (strtab == NULL
11060               || section->sh_entsize != sizeof (Elf32_External_Lib))
11061             {
11062               free (elib);
11063               break;
11064             }
11065
11066           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11067                   SECTION_NAME (section),
11068                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
11069
11070           puts ("     Library              Time Stamp          Checksum   Version Flags");
11071
11072           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
11073                ++cnt)
11074             {
11075               Elf32_Lib liblist;
11076               time_t atime;
11077               char timebuf[20];
11078               struct tm * tmp;
11079
11080               liblist.l_name = BYTE_GET (elib[cnt].l_name);
11081               atime = BYTE_GET (elib[cnt].l_time_stamp);
11082               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11083               liblist.l_version = BYTE_GET (elib[cnt].l_version);
11084               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11085
11086               tmp = gmtime (&atime);
11087               snprintf (timebuf, sizeof (timebuf),
11088                         "%04u-%02u-%02uT%02u:%02u:%02u",
11089                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11090                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
11091
11092               printf ("%3lu: ", (unsigned long) cnt);
11093               if (do_wide)
11094                 printf ("%-20s", liblist.l_name < strtab_size
11095                                  ? strtab + liblist.l_name : "<corrupt>");
11096               else
11097                 printf ("%-20.20s", liblist.l_name < strtab_size
11098                                     ? strtab + liblist.l_name : "<corrupt>");
11099               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
11100                       liblist.l_version, liblist.l_flags);
11101             }
11102
11103           free (elib);
11104         }
11105     }
11106
11107   return 1;
11108 }
11109
11110 static const char *
11111 get_note_type (unsigned e_type)
11112 {
11113   static char buff[64];
11114
11115   if (elf_header.e_type == ET_CORE)
11116     switch (e_type)
11117       {
11118       case NT_AUXV:
11119         return _("NT_AUXV (auxiliary vector)");
11120       case NT_PRSTATUS:
11121         return _("NT_PRSTATUS (prstatus structure)");
11122       case NT_FPREGSET:
11123         return _("NT_FPREGSET (floating point registers)");
11124       case NT_PRPSINFO:
11125         return _("NT_PRPSINFO (prpsinfo structure)");
11126       case NT_TASKSTRUCT:
11127         return _("NT_TASKSTRUCT (task structure)");
11128       case NT_PRXFPREG:
11129         return _("NT_PRXFPREG (user_xfpregs structure)");
11130       case NT_PPC_VMX:
11131         return _("NT_PPC_VMX (ppc Altivec registers)");
11132       case NT_PPC_VSX:
11133         return _("NT_PPC_VSX (ppc VSX registers)");
11134       case NT_X86_XSTATE:
11135         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
11136       case NT_S390_HIGH_GPRS:
11137         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
11138       case NT_S390_TIMER:
11139         return _("NT_S390_TIMER (s390 timer register)");
11140       case NT_S390_TODCMP:
11141         return _("NT_S390_TODCMP (s390 TOD comparator register)");
11142       case NT_S390_TODPREG:
11143         return _("NT_S390_TODPREG (s390 TOD programmable register)");
11144       case NT_S390_CTRS:
11145         return _("NT_S390_CTRS (s390 control registers)");
11146       case NT_S390_PREFIX:
11147         return _("NT_S390_PREFIX (s390 prefix register)");
11148       case NT_PSTATUS:
11149         return _("NT_PSTATUS (pstatus structure)");
11150       case NT_FPREGS:
11151         return _("NT_FPREGS (floating point registers)");
11152       case NT_PSINFO:
11153         return _("NT_PSINFO (psinfo structure)");
11154       case NT_LWPSTATUS:
11155         return _("NT_LWPSTATUS (lwpstatus_t structure)");
11156       case NT_LWPSINFO:
11157         return _("NT_LWPSINFO (lwpsinfo_t structure)");
11158       case NT_WIN32PSTATUS:
11159         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11160       default:
11161         break;
11162       }
11163   else
11164     switch (e_type)
11165       {
11166       case NT_VERSION:
11167         return _("NT_VERSION (version)");
11168       case NT_ARCH:
11169         return _("NT_ARCH (architecture)");
11170       default:
11171         break;
11172       }
11173
11174   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11175   return buff;
11176 }
11177
11178 static const char *
11179 get_gnu_elf_note_type (unsigned e_type)
11180 {
11181   static char buff[64];
11182
11183   switch (e_type)
11184     {
11185     case NT_GNU_ABI_TAG:
11186       return _("NT_GNU_ABI_TAG (ABI version tag)");
11187     case NT_GNU_HWCAP:
11188       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
11189     case NT_GNU_BUILD_ID:
11190       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
11191     case NT_GNU_GOLD_VERSION:
11192       return _("NT_GNU_GOLD_VERSION (gold version)");
11193     default:
11194       break;
11195     }
11196
11197   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11198   return buff;
11199 }
11200
11201 static const char *
11202 get_netbsd_elfcore_note_type (unsigned e_type)
11203 {
11204   static char buff[64];
11205
11206   if (e_type == NT_NETBSDCORE_PROCINFO)
11207     {
11208       /* NetBSD core "procinfo" structure.  */
11209       return _("NetBSD procinfo structure");
11210     }
11211
11212   /* As of Jan 2002 there are no other machine-independent notes
11213      defined for NetBSD core files.  If the note type is less
11214      than the start of the machine-dependent note types, we don't
11215      understand it.  */
11216
11217   if (e_type < NT_NETBSDCORE_FIRSTMACH)
11218     {
11219       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11220       return buff;
11221     }
11222
11223   switch (elf_header.e_machine)
11224     {
11225     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11226        and PT_GETFPREGS == mach+2.  */
11227
11228     case EM_OLD_ALPHA:
11229     case EM_ALPHA:
11230     case EM_SPARC:
11231     case EM_SPARC32PLUS:
11232     case EM_SPARCV9:
11233       switch (e_type)
11234         {
11235         case NT_NETBSDCORE_FIRSTMACH+0:
11236           return _("PT_GETREGS (reg structure)");
11237         case NT_NETBSDCORE_FIRSTMACH+2:
11238           return _("PT_GETFPREGS (fpreg structure)");
11239         default:
11240           break;
11241         }
11242       break;
11243
11244     /* On all other arch's, PT_GETREGS == mach+1 and
11245        PT_GETFPREGS == mach+3.  */
11246     default:
11247       switch (e_type)
11248         {
11249         case NT_NETBSDCORE_FIRSTMACH+1:
11250           return _("PT_GETREGS (reg structure)");
11251         case NT_NETBSDCORE_FIRSTMACH+3:
11252           return _("PT_GETFPREGS (fpreg structure)");
11253         default:
11254           break;
11255         }
11256     }
11257
11258   snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
11259             e_type - NT_NETBSDCORE_FIRSTMACH);
11260   return buff;
11261 }
11262
11263 /* Note that by the ELF standard, the name field is already null byte
11264    terminated, and namesz includes the terminating null byte.
11265    I.E. the value of namesz for the name "FSF" is 4.
11266
11267    If the value of namesz is zero, there is no name present.  */
11268 static int
11269 process_note (Elf_Internal_Note * pnote)
11270 {
11271   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
11272   const char * nt;
11273
11274   if (pnote->namesz == 0)
11275     /* If there is no note name, then use the default set of
11276        note type strings.  */
11277     nt = get_note_type (pnote->type);
11278
11279   else if (const_strneq (pnote->namedata, "GNU"))
11280     /* GNU-specific object file notes.  */
11281     nt = get_gnu_elf_note_type (pnote->type);
11282
11283   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
11284     /* NetBSD-specific core file notes.  */
11285     nt = get_netbsd_elfcore_note_type (pnote->type);
11286
11287   else if (strneq (pnote->namedata, "SPU/", 4))
11288     {
11289       /* SPU-specific core file notes.  */
11290       nt = pnote->namedata + 4;
11291       name = "SPU";
11292     }
11293
11294   else
11295     /* Don't recognize this note name; just use the default set of
11296        note type strings.  */
11297       nt = get_note_type (pnote->type);
11298
11299   printf ("  %s\t\t0x%08lx\t%s\n", name, pnote->descsz, nt);
11300   return 1;
11301 }
11302
11303
11304 static int
11305 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
11306 {
11307   Elf_External_Note * pnotes;
11308   Elf_External_Note * external;
11309   int res = 1;
11310
11311   if (length <= 0)
11312     return 0;
11313
11314   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
11315                                            _("notes"));
11316   if (!pnotes)
11317     return 0;
11318
11319   external = pnotes;
11320
11321   printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11322           (unsigned long) offset, (unsigned long) length);
11323   printf (_("  Owner\t\tData size\tDescription\n"));
11324
11325   while (external < (Elf_External_Note *) ((char *) pnotes + length))
11326     {
11327       Elf_External_Note * next;
11328       Elf_Internal_Note inote;
11329       char * temp = NULL;
11330
11331       inote.type     = BYTE_GET (external->type);
11332       inote.namesz   = BYTE_GET (external->namesz);
11333       inote.namedata = external->name;
11334       inote.descsz   = BYTE_GET (external->descsz);
11335       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
11336       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
11337
11338       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
11339
11340       if (((char *) next) > (((char *) pnotes) + length))
11341         {
11342           warn (_("corrupt note found at offset %lx into core notes\n"),
11343                 (unsigned long) ((char *) external - (char *) pnotes));
11344           warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
11345                 inote.type, inote.namesz, inote.descsz);
11346           break;
11347         }
11348
11349       external = next;
11350
11351       /* Verify that name is null terminated.  It appears that at least
11352          one version of Linux (RedHat 6.0) generates corefiles that don't
11353          comply with the ELF spec by failing to include the null byte in
11354          namesz.  */
11355       if (inote.namedata[inote.namesz] != '\0')
11356         {
11357           temp = (char *) malloc (inote.namesz + 1);
11358
11359           if (temp == NULL)
11360             {
11361               error (_("Out of memory\n"));
11362               res = 0;
11363               break;
11364             }
11365
11366           strncpy (temp, inote.namedata, inote.namesz);
11367           temp[inote.namesz] = 0;
11368
11369           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
11370           inote.namedata = temp;
11371         }
11372
11373       res &= process_note (& inote);
11374
11375       if (temp != NULL)
11376         {
11377           free (temp);
11378           temp = NULL;
11379         }
11380     }
11381
11382   free (pnotes);
11383
11384   return res;
11385 }
11386
11387 static int
11388 process_corefile_note_segments (FILE * file)
11389 {
11390   Elf_Internal_Phdr * segment;
11391   unsigned int i;
11392   int res = 1;
11393
11394   if (! get_program_headers (file))
11395       return 0;
11396
11397   for (i = 0, segment = program_headers;
11398        i < elf_header.e_phnum;
11399        i++, segment++)
11400     {
11401       if (segment->p_type == PT_NOTE)
11402         res &= process_corefile_note_segment (file,
11403                                               (bfd_vma) segment->p_offset,
11404                                               (bfd_vma) segment->p_filesz);
11405     }
11406
11407   return res;
11408 }
11409
11410 static int
11411 process_note_sections (FILE * file)
11412 {
11413   Elf_Internal_Shdr * section;
11414   unsigned long i;
11415   int res = 1;
11416
11417   for (i = 0, section = section_headers;
11418        i < elf_header.e_shnum;
11419        i++, section++)
11420     if (section->sh_type == SHT_NOTE)
11421       res &= process_corefile_note_segment (file,
11422                                             (bfd_vma) section->sh_offset,
11423                                             (bfd_vma) section->sh_size);
11424
11425   return res;
11426 }
11427
11428 static int
11429 process_notes (FILE * file)
11430 {
11431   /* If we have not been asked to display the notes then do nothing.  */
11432   if (! do_notes)
11433     return 1;
11434
11435   if (elf_header.e_type != ET_CORE)
11436     return process_note_sections (file);
11437
11438   /* No program headers means no NOTE segment.  */
11439   if (elf_header.e_phnum > 0)
11440     return process_corefile_note_segments (file);
11441
11442   printf (_("No note segments present in the core file.\n"));
11443   return 1;
11444 }
11445
11446 static int
11447 process_arch_specific (FILE * file)
11448 {
11449   if (! do_arch)
11450     return 1;
11451
11452   switch (elf_header.e_machine)
11453     {
11454     case EM_ARM:
11455       return process_arm_specific (file);
11456     case EM_MIPS:
11457     case EM_MIPS_RS3_LE:
11458       return process_mips_specific (file);
11459       break;
11460     case EM_PPC:
11461       return process_power_specific (file);
11462       break;
11463     default:
11464       break;
11465     }
11466   return 1;
11467 }
11468
11469 static int
11470 get_file_header (FILE * file)
11471 {
11472   /* Read in the identity array.  */
11473   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
11474     return 0;
11475
11476   /* Determine how to read the rest of the header.  */
11477   switch (elf_header.e_ident[EI_DATA])
11478     {
11479     default: /* fall through */
11480     case ELFDATANONE: /* fall through */
11481     case ELFDATA2LSB:
11482       byte_get = byte_get_little_endian;
11483       byte_put = byte_put_little_endian;
11484       break;
11485     case ELFDATA2MSB:
11486       byte_get = byte_get_big_endian;
11487       byte_put = byte_put_big_endian;
11488       break;
11489     }
11490
11491   /* For now we only support 32 bit and 64 bit ELF files.  */
11492   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
11493
11494   /* Read in the rest of the header.  */
11495   if (is_32bit_elf)
11496     {
11497       Elf32_External_Ehdr ehdr32;
11498
11499       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
11500         return 0;
11501
11502       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
11503       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
11504       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
11505       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
11506       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
11507       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
11508       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
11509       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
11510       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
11511       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
11512       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
11513       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
11514       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
11515     }
11516   else
11517     {
11518       Elf64_External_Ehdr ehdr64;
11519
11520       /* If we have been compiled with sizeof (bfd_vma) == 4, then
11521          we will not be able to cope with the 64bit data found in
11522          64 ELF files.  Detect this now and abort before we start
11523          overwriting things.  */
11524       if (sizeof (bfd_vma) < 8)
11525         {
11526           error (_("This instance of readelf has been built without support for a\n\
11527 64 bit data type and so it cannot read 64 bit ELF files.\n"));
11528           return 0;
11529         }
11530
11531       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
11532         return 0;
11533
11534       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
11535       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
11536       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
11537       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
11538       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
11539       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
11540       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
11541       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
11542       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
11543       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
11544       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
11545       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
11546       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
11547     }
11548
11549   if (elf_header.e_shoff)
11550     {
11551       /* There may be some extensions in the first section header.  Don't
11552          bomb if we can't read it.  */
11553       if (is_32bit_elf)
11554         get_32bit_section_headers (file, 1);
11555       else
11556         get_64bit_section_headers (file, 1);
11557     }
11558
11559   return 1;
11560 }
11561
11562 /* Process one ELF object file according to the command line options.
11563    This file may actually be stored in an archive.  The file is
11564    positioned at the start of the ELF object.  */
11565
11566 static int
11567 process_object (char * file_name, FILE * file)
11568 {
11569   unsigned int i;
11570
11571   if (! get_file_header (file))
11572     {
11573       error (_("%s: Failed to read file header\n"), file_name);
11574       return 1;
11575     }
11576
11577   /* Initialise per file variables.  */
11578   for (i = ARRAY_SIZE (version_info); i--;)
11579     version_info[i] = 0;
11580
11581   for (i = ARRAY_SIZE (dynamic_info); i--;)
11582     dynamic_info[i] = 0;
11583
11584   /* Process the file.  */
11585   if (show_name)
11586     printf (_("\nFile: %s\n"), file_name);
11587
11588   /* Initialise the dump_sects array from the cmdline_dump_sects array.
11589      Note we do this even if cmdline_dump_sects is empty because we
11590      must make sure that the dump_sets array is zeroed out before each
11591      object file is processed.  */
11592   if (num_dump_sects > num_cmdline_dump_sects)
11593     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
11594
11595   if (num_cmdline_dump_sects > 0)
11596     {
11597       if (num_dump_sects == 0)
11598         /* A sneaky way of allocating the dump_sects array.  */
11599         request_dump_bynumber (num_cmdline_dump_sects, 0);
11600
11601       assert (num_dump_sects >= num_cmdline_dump_sects);
11602       memcpy (dump_sects, cmdline_dump_sects,
11603               num_cmdline_dump_sects * sizeof (* dump_sects));
11604     }
11605
11606   if (! process_file_header ())
11607     return 1;
11608
11609   if (! process_section_headers (file))
11610     {
11611       /* Without loaded section headers we cannot process lots of
11612          things.  */
11613       do_unwind = do_version = do_dump = do_arch = 0;
11614
11615       if (! do_using_dynamic)
11616         do_syms = do_dyn_syms = do_reloc = 0;
11617     }
11618
11619   if (! process_section_groups (file))
11620     {
11621       /* Without loaded section groups we cannot process unwind.  */
11622       do_unwind = 0;
11623     }
11624
11625   if (process_program_headers (file))
11626     process_dynamic_section (file);
11627
11628   process_relocs (file);
11629
11630   process_unwind (file);
11631
11632   process_symbol_table (file);
11633
11634   process_syminfo (file);
11635
11636   process_version_sections (file);
11637
11638   process_section_contents (file);
11639
11640   process_notes (file);
11641
11642   process_gnu_liblist (file);
11643
11644   process_arch_specific (file);
11645
11646   if (program_headers)
11647     {
11648       free (program_headers);
11649       program_headers = NULL;
11650     }
11651
11652   if (section_headers)
11653     {
11654       free (section_headers);
11655       section_headers = NULL;
11656     }
11657
11658   if (string_table)
11659     {
11660       free (string_table);
11661       string_table = NULL;
11662       string_table_length = 0;
11663     }
11664
11665   if (dynamic_strings)
11666     {
11667       free (dynamic_strings);
11668       dynamic_strings = NULL;
11669       dynamic_strings_length = 0;
11670     }
11671
11672   if (dynamic_symbols)
11673     {
11674       free (dynamic_symbols);
11675       dynamic_symbols = NULL;
11676       num_dynamic_syms = 0;
11677     }
11678
11679   if (dynamic_syminfo)
11680     {
11681       free (dynamic_syminfo);
11682       dynamic_syminfo = NULL;
11683     }
11684
11685   if (section_headers_groups)
11686     {
11687       free (section_headers_groups);
11688       section_headers_groups = NULL;
11689     }
11690
11691   if (section_groups)
11692     {
11693       struct group_list * g;
11694       struct group_list * next;
11695
11696       for (i = 0; i < group_count; i++)
11697         {
11698           for (g = section_groups [i].root; g != NULL; g = next)
11699             {
11700               next = g->next;
11701               free (g);
11702             }
11703         }
11704
11705       free (section_groups);
11706       section_groups = NULL;
11707     }
11708
11709   free_debug_memory ();
11710
11711   return 0;
11712 }
11713
11714 /* Return the path name for a proxy entry in a thin archive, adjusted relative
11715    to the path name of the thin archive itself if necessary.  Always returns
11716    a pointer to malloc'ed memory.  */
11717
11718 static char *
11719 adjust_relative_path (char * file_name, char * name, int name_len)
11720 {
11721   char * member_file_name;
11722   const char * base_name = lbasename (file_name);
11723
11724   /* This is a proxy entry for a thin archive member.
11725      If the extended name table contains an absolute path
11726      name, or if the archive is in the current directory,
11727      use the path name as given.  Otherwise, we need to
11728      find the member relative to the directory where the
11729      archive is located.  */
11730   if (IS_ABSOLUTE_PATH (name) || base_name == file_name)
11731     {
11732       member_file_name = (char *) malloc (name_len + 1);
11733       if (member_file_name == NULL)
11734         {
11735           error (_("Out of memory\n"));
11736           return NULL;
11737         }
11738       memcpy (member_file_name, name, name_len);
11739       member_file_name[name_len] = '\0';
11740     }
11741   else
11742     {
11743       /* Concatenate the path components of the archive file name
11744          to the relative path name from the extended name table.  */
11745       size_t prefix_len = base_name - file_name;
11746       member_file_name = (char *) malloc (prefix_len + name_len + 1);
11747       if (member_file_name == NULL)
11748         {
11749           error (_("Out of memory\n"));
11750           return NULL;
11751         }
11752       memcpy (member_file_name, file_name, prefix_len);
11753       memcpy (member_file_name + prefix_len, name, name_len);
11754       member_file_name[prefix_len + name_len] = '\0';
11755     }
11756   return member_file_name;
11757 }
11758
11759 /* Structure to hold information about an archive file.  */
11760
11761 struct archive_info
11762 {
11763   char * file_name;                     /* Archive file name.  */
11764   FILE * file;                          /* Open file descriptor.  */
11765   unsigned long index_num;              /* Number of symbols in table.  */
11766   unsigned long * index_array;          /* The array of member offsets.  */
11767   char * sym_table;                     /* The symbol table.  */
11768   unsigned long sym_size;               /* Size of the symbol table.  */
11769   char * longnames;                     /* The long file names table.  */
11770   unsigned long longnames_size;         /* Size of the long file names table.  */
11771   unsigned long nested_member_origin;   /* Origin in the nested archive of the current member.  */
11772   unsigned long next_arhdr_offset;      /* Offset of the next archive header.  */
11773   bfd_boolean is_thin_archive;          /* TRUE if this is a thin archive.  */
11774   struct ar_hdr arhdr;                  /* Current archive header.  */
11775 };
11776
11777 /* Read the symbol table and long-name table from an archive.  */
11778
11779 static int
11780 setup_archive (struct archive_info * arch, char * file_name, FILE * file,
11781                bfd_boolean is_thin_archive, bfd_boolean read_symbols)
11782 {
11783   size_t got;
11784   unsigned long size;
11785
11786   arch->file_name = strdup (file_name);
11787   arch->file = file;
11788   arch->index_num = 0;
11789   arch->index_array = NULL;
11790   arch->sym_table = NULL;
11791   arch->sym_size = 0;
11792   arch->longnames = NULL;
11793   arch->longnames_size = 0;
11794   arch->nested_member_origin = 0;
11795   arch->is_thin_archive = is_thin_archive;
11796   arch->next_arhdr_offset = SARMAG;
11797
11798   /* Read the first archive member header.  */
11799   if (fseek (file, SARMAG, SEEK_SET) != 0)
11800     {
11801       error (_("%s: failed to seek to first archive header\n"), file_name);
11802       return 1;
11803     }
11804   got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
11805   if (got != sizeof arch->arhdr)
11806     {
11807       if (got == 0)
11808         return 0;
11809
11810       error (_("%s: failed to read archive header\n"), file_name);
11811       return 1;
11812     }
11813
11814   /* See if this is the archive symbol table.  */
11815   if (const_strneq (arch->arhdr.ar_name, "/               ")
11816       || const_strneq (arch->arhdr.ar_name, "/SYM64/         "))
11817     {
11818       size = strtoul (arch->arhdr.ar_size, NULL, 10);
11819       size = size + (size & 1);
11820
11821       arch->next_arhdr_offset += sizeof arch->arhdr + size;
11822
11823       if (read_symbols)
11824         {
11825           unsigned long i;
11826           /* A buffer used to hold numbers read in from an archive index.
11827              These are always 4 bytes long and stored in big-endian format.  */
11828 #define SIZEOF_AR_INDEX_NUMBERS 4
11829           unsigned char integer_buffer[SIZEOF_AR_INDEX_NUMBERS];
11830           unsigned char * index_buffer;
11831
11832           /* Check the size of the archive index.  */
11833           if (size < SIZEOF_AR_INDEX_NUMBERS)
11834             {
11835               error (_("%s: the archive index is empty\n"), file_name);
11836               return 1;
11837             }
11838
11839           /* Read the numer of entries in the archive index.  */
11840           got = fread (integer_buffer, 1, sizeof integer_buffer, file);
11841           if (got != sizeof (integer_buffer))
11842             {
11843               error (_("%s: failed to read archive index\n"), file_name);
11844               return 1;
11845             }
11846           arch->index_num = byte_get_big_endian (integer_buffer, sizeof integer_buffer);
11847           size -= SIZEOF_AR_INDEX_NUMBERS;
11848
11849           /* Read in the archive index.  */
11850           if (size < arch->index_num * SIZEOF_AR_INDEX_NUMBERS)
11851             {
11852               error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
11853                      file_name, arch->index_num);
11854               return 1;
11855             }
11856           index_buffer = (unsigned char *)
11857               malloc (arch->index_num * SIZEOF_AR_INDEX_NUMBERS);
11858           if (index_buffer == NULL)
11859             {
11860               error (_("Out of memory whilst trying to read archive symbol index\n"));
11861               return 1;
11862             }
11863           got = fread (index_buffer, SIZEOF_AR_INDEX_NUMBERS, arch->index_num, file);
11864           if (got != arch->index_num)
11865             {
11866               free (index_buffer);
11867               error (_("%s: failed to read archive index\n"), file_name);
11868               return 1;
11869             }
11870           size -= arch->index_num * SIZEOF_AR_INDEX_NUMBERS;
11871
11872           /* Convert the index numbers into the host's numeric format.  */
11873           arch->index_array = (long unsigned int *)
11874               malloc (arch->index_num * sizeof (* arch->index_array));
11875           if (arch->index_array == NULL)
11876             {
11877               free (index_buffer);
11878               error (_("Out of memory whilst trying to convert the archive symbol index\n"));
11879               return 1;
11880             }
11881
11882           for (i = 0; i < arch->index_num; i++)
11883             arch->index_array[i] = byte_get_big_endian ((unsigned char *) (index_buffer + (i * SIZEOF_AR_INDEX_NUMBERS)),
11884                                                         SIZEOF_AR_INDEX_NUMBERS);
11885           free (index_buffer);
11886
11887           /* The remaining space in the header is taken up by the symbol table.  */
11888           if (size < 1)
11889             {
11890               error (_("%s: the archive has an index but no symbols\n"), file_name);
11891               return 1;
11892             }
11893           arch->sym_table = (char *) malloc (size);
11894           arch->sym_size = size;
11895           if (arch->sym_table == NULL)
11896             {
11897               error (_("Out of memory whilst trying to read archive index symbol table\n"));
11898               return 1;
11899             }
11900           got = fread (arch->sym_table, 1, size, file);
11901           if (got != size)
11902             {
11903               error (_("%s: failed to read archive index symbol table\n"), file_name);
11904               return 1;
11905             }
11906         }
11907       else
11908         {
11909           if (fseek (file, size, SEEK_CUR) != 0)
11910             {
11911               error (_("%s: failed to skip archive symbol table\n"), file_name);
11912               return 1;
11913             }
11914         }
11915
11916       /* Read the next archive header.  */
11917       got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
11918       if (got != sizeof arch->arhdr)
11919         {
11920           if (got == 0)
11921             return 0;
11922           error (_("%s: failed to read archive header following archive index\n"), file_name);
11923           return 1;
11924         }
11925     }
11926   else if (read_symbols)
11927     printf (_("%s has no archive index\n"), file_name);
11928
11929   if (const_strneq (arch->arhdr.ar_name, "//              "))
11930     {
11931       /* This is the archive string table holding long member names.  */
11932       arch->longnames_size = strtoul (arch->arhdr.ar_size, NULL, 10);
11933       arch->next_arhdr_offset += sizeof arch->arhdr + arch->longnames_size;
11934
11935       arch->longnames = (char *) malloc (arch->longnames_size);
11936       if (arch->longnames == NULL)
11937         {
11938           error (_("Out of memory reading long symbol names in archive\n"));
11939           return 1;
11940         }
11941
11942       if (fread (arch->longnames, arch->longnames_size, 1, file) != 1)
11943         {
11944           free (arch->longnames);
11945           arch->longnames = NULL;
11946           error (_("%s: failed to read long symbol name string table\n"), file_name);
11947           return 1;
11948         }
11949
11950       if ((arch->longnames_size & 1) != 0)
11951         getc (file);
11952     }
11953
11954   return 0;
11955 }
11956
11957 /* Release the memory used for the archive information.  */
11958
11959 static void
11960 release_archive (struct archive_info * arch)
11961 {
11962   if (arch->file_name != NULL)
11963     free (arch->file_name);
11964   if (arch->index_array != NULL)
11965     free (arch->index_array);
11966   if (arch->sym_table != NULL)
11967     free (arch->sym_table);
11968   if (arch->longnames != NULL)
11969     free (arch->longnames);
11970 }
11971
11972 /* Open and setup a nested archive, if not already open.  */
11973
11974 static int
11975 setup_nested_archive (struct archive_info * nested_arch, char * member_file_name)
11976 {
11977   FILE * member_file;
11978
11979   /* Have we already setup this archive?  */
11980   if (nested_arch->file_name != NULL
11981       && streq (nested_arch->file_name, member_file_name))
11982     return 0;
11983
11984   /* Close previous file and discard cached information.  */
11985   if (nested_arch->file != NULL)
11986     fclose (nested_arch->file);
11987   release_archive (nested_arch);
11988
11989   member_file = fopen (member_file_name, "rb");
11990   if (member_file == NULL)
11991     return 1;
11992   return setup_archive (nested_arch, member_file_name, member_file, FALSE, FALSE);
11993 }
11994
11995 static char *
11996 get_archive_member_name_at (struct archive_info *  arch,
11997                             unsigned long          offset,
11998                             struct archive_info *  nested_arch);
11999
12000 /* Get the name of an archive member from the current archive header.
12001    For simple names, this will modify the ar_name field of the current
12002    archive header.  For long names, it will return a pointer to the
12003    longnames table.  For nested archives, it will open the nested archive
12004    and get the name recursively.  NESTED_ARCH is a single-entry cache so
12005    we don't keep rereading the same information from a nested archive.  */
12006
12007 static char *
12008 get_archive_member_name (struct archive_info *  arch,
12009                          struct archive_info *  nested_arch)
12010 {
12011   unsigned long j, k;
12012
12013   if (arch->arhdr.ar_name[0] == '/')
12014     {
12015       /* We have a long name.  */
12016       char * endp;
12017       char * member_file_name;
12018       char * member_name;
12019
12020       arch->nested_member_origin = 0;
12021       k = j = strtoul (arch->arhdr.ar_name + 1, &endp, 10);
12022       if (arch->is_thin_archive && endp != NULL && * endp == ':')
12023         arch->nested_member_origin = strtoul (endp + 1, NULL, 10);
12024
12025       while ((j < arch->longnames_size)
12026              && (arch->longnames[j] != '\n')
12027              && (arch->longnames[j] != '\0'))
12028         j++;
12029       if (arch->longnames[j-1] == '/')
12030         j--;
12031       arch->longnames[j] = '\0';
12032
12033       if (!arch->is_thin_archive || arch->nested_member_origin == 0)
12034         return arch->longnames + k;
12035
12036       /* This is a proxy for a member of a nested archive.
12037          Find the name of the member in that archive.  */
12038       member_file_name = adjust_relative_path (arch->file_name, arch->longnames + k, j - k);
12039       if (member_file_name != NULL
12040           && setup_nested_archive (nested_arch, member_file_name) == 0
12041           && (member_name = get_archive_member_name_at (nested_arch, arch->nested_member_origin, NULL)) != NULL)
12042         {
12043           free (member_file_name);
12044           return member_name;
12045         }
12046       free (member_file_name);
12047
12048       /* Last resort: just return the name of the nested archive.  */
12049       return arch->longnames + k;
12050     }
12051
12052   /* We have a normal (short) name.  */
12053   j = 0;
12054   while ((arch->arhdr.ar_name[j] != '/') && (j < 16))
12055     j++;
12056   arch->arhdr.ar_name[j] = '\0';
12057   return arch->arhdr.ar_name;
12058 }
12059
12060 /* Get the name of an archive member at a given OFFSET within an archive ARCH.  */
12061
12062 static char *
12063 get_archive_member_name_at (struct archive_info * arch,
12064                             unsigned long         offset,
12065                             struct archive_info * nested_arch)
12066 {
12067   size_t got;
12068
12069   if (fseek (arch->file, offset, SEEK_SET) != 0)
12070     {
12071       error (_("%s: failed to seek to next file name\n"), arch->file_name);
12072       return NULL;
12073     }
12074   got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file);
12075   if (got != sizeof arch->arhdr)
12076     {
12077       error (_("%s: failed to read archive header\n"), arch->file_name);
12078       return NULL;
12079     }
12080   if (memcmp (arch->arhdr.ar_fmag, ARFMAG, 2) != 0)
12081     {
12082       error (_("%s: did not find a valid archive header\n"), arch->file_name);
12083       return NULL;
12084     }
12085
12086   return get_archive_member_name (arch, nested_arch);
12087 }
12088
12089 /* Construct a string showing the name of the archive member, qualified
12090    with the name of the containing archive file.  For thin archives, we
12091    use square brackets to denote the indirection.  For nested archives,
12092    we show the qualified name of the external member inside the square
12093    brackets (e.g., "thin.a[normal.a(foo.o)]").  */
12094
12095 static char *
12096 make_qualified_name (struct archive_info * arch,
12097                      struct archive_info * nested_arch,
12098                      char * member_name)
12099 {
12100   size_t len;
12101   char * name;
12102
12103   len = strlen (arch->file_name) + strlen (member_name) + 3;
12104   if (arch->is_thin_archive && arch->nested_member_origin != 0)
12105     len += strlen (nested_arch->file_name) + 2;
12106
12107   name = (char *) malloc (len);
12108   if (name == NULL)
12109     {
12110       error (_("Out of memory\n"));
12111       return NULL;
12112     }
12113
12114   if (arch->is_thin_archive && arch->nested_member_origin != 0)
12115     snprintf (name, len, "%s[%s(%s)]", arch->file_name, nested_arch->file_name, member_name);
12116   else if (arch->is_thin_archive)
12117     snprintf (name, len, "%s[%s]", arch->file_name, member_name);
12118   else
12119     snprintf (name, len, "%s(%s)", arch->file_name, member_name);
12120
12121   return name;
12122 }
12123
12124 /* Process an ELF archive.
12125    On entry the file is positioned just after the ARMAG string.  */
12126
12127 static int
12128 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
12129 {
12130   struct archive_info arch;
12131   struct archive_info nested_arch;
12132   size_t got;
12133   int ret;
12134
12135   show_name = 1;
12136
12137   /* The ARCH structure is used to hold information about this archive.  */
12138   arch.file_name = NULL;
12139   arch.file = NULL;
12140   arch.index_array = NULL;
12141   arch.sym_table = NULL;
12142   arch.longnames = NULL;
12143
12144   /* The NESTED_ARCH structure is used as a single-item cache of information
12145      about a nested archive (when members of a thin archive reside within
12146      another regular archive file).  */
12147   nested_arch.file_name = NULL;
12148   nested_arch.file = NULL;
12149   nested_arch.index_array = NULL;
12150   nested_arch.sym_table = NULL;
12151   nested_arch.longnames = NULL;
12152
12153   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
12154     {
12155       ret = 1;
12156       goto out;
12157     }
12158
12159   if (do_archive_index)
12160     {
12161       if (arch.sym_table == NULL)
12162         error (_("%s: unable to dump the index as none was found\n"), file_name);
12163       else
12164         {
12165           unsigned int i, l;
12166           unsigned long current_pos;
12167
12168           printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
12169                   file_name, arch.index_num, arch.sym_size);
12170           current_pos = ftell (file);
12171
12172           for (i = l = 0; i < arch.index_num; i++)
12173             {
12174               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
12175                 {
12176                   char * member_name;
12177
12178                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
12179
12180                   if (member_name != NULL)
12181                     {
12182                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
12183
12184                       if (qualified_name != NULL)
12185                         {
12186                           printf (_("Binary %s contains:\n"), qualified_name);
12187                           free (qualified_name);
12188                         }
12189                     }
12190                 }
12191
12192               if (l >= arch.sym_size)
12193                 {
12194                   error (_("%s: end of the symbol table reached before the end of the index\n"),
12195                          file_name);
12196                   break;
12197                 }
12198               printf ("\t%s\n", arch.sym_table + l);
12199               l += strlen (arch.sym_table + l) + 1;
12200             }
12201
12202           if (l & 01)
12203             ++l;
12204           if (l < arch.sym_size)
12205             error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
12206                    file_name);
12207
12208           if (fseek (file, current_pos, SEEK_SET) != 0)
12209             {
12210               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
12211               ret = 1;
12212               goto out;
12213             }
12214         }
12215
12216       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
12217           && !do_segments && !do_header && !do_dump && !do_version
12218           && !do_histogram && !do_debugging && !do_arch && !do_notes
12219           && !do_section_groups && !do_dyn_syms)
12220         {
12221           ret = 0; /* Archive index only.  */
12222           goto out;
12223         }
12224     }
12225
12226   ret = 0;
12227
12228   while (1)
12229     {
12230       char * name;
12231       size_t namelen;
12232       char * qualified_name;
12233
12234       /* Read the next archive header.  */
12235       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
12236         {
12237           error (_("%s: failed to seek to next archive header\n"), file_name);
12238           return 1;
12239         }
12240       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
12241       if (got != sizeof arch.arhdr)
12242         {
12243           if (got == 0)
12244             break;
12245           error (_("%s: failed to read archive header\n"), file_name);
12246           ret = 1;
12247           break;
12248         }
12249       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
12250         {
12251           error (_("%s: did not find a valid archive header\n"), arch.file_name);
12252           ret = 1;
12253           break;
12254         }
12255
12256       arch.next_arhdr_offset += sizeof arch.arhdr;
12257
12258       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
12259       if (archive_file_size & 01)
12260         ++archive_file_size;
12261
12262       name = get_archive_member_name (&arch, &nested_arch);
12263       if (name == NULL)
12264         {
12265           error (_("%s: bad archive file name\n"), file_name);
12266           ret = 1;
12267           break;
12268         }
12269       namelen = strlen (name);
12270
12271       qualified_name = make_qualified_name (&arch, &nested_arch, name);
12272       if (qualified_name == NULL)
12273         {
12274           error (_("%s: bad archive file name\n"), file_name);
12275           ret = 1;
12276           break;
12277         }
12278
12279       if (is_thin_archive && arch.nested_member_origin == 0)
12280         {
12281           /* This is a proxy for an external member of a thin archive.  */
12282           FILE * member_file;
12283           char * member_file_name = adjust_relative_path (file_name, name, namelen);
12284           if (member_file_name == NULL)
12285             {
12286               ret = 1;
12287               break;
12288             }
12289
12290           member_file = fopen (member_file_name, "rb");
12291           if (member_file == NULL)
12292             {
12293               error (_("Input file '%s' is not readable.\n"), member_file_name);
12294               free (member_file_name);
12295               ret = 1;
12296               break;
12297             }
12298
12299           archive_file_offset = arch.nested_member_origin;
12300
12301           ret |= process_object (qualified_name, member_file);
12302
12303           fclose (member_file);
12304           free (member_file_name);
12305         }
12306       else if (is_thin_archive)
12307         {
12308           /* This is a proxy for a member of a nested archive.  */
12309           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
12310
12311           /* The nested archive file will have been opened and setup by
12312              get_archive_member_name.  */
12313           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
12314             {
12315               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
12316               ret = 1;
12317               break;
12318             }
12319
12320           ret |= process_object (qualified_name, nested_arch.file);
12321         }
12322       else
12323         {
12324           archive_file_offset = arch.next_arhdr_offset;
12325           arch.next_arhdr_offset += archive_file_size;
12326
12327           ret |= process_object (qualified_name, file);
12328         }
12329
12330       free (qualified_name);
12331     }
12332
12333  out:
12334   if (nested_arch.file != NULL)
12335     fclose (nested_arch.file);
12336   release_archive (&nested_arch);
12337   release_archive (&arch);
12338
12339   return ret;
12340 }
12341
12342 static int
12343 process_file (char * file_name)
12344 {
12345   FILE * file;
12346   struct stat statbuf;
12347   char armag[SARMAG];
12348   int ret;
12349
12350   if (stat (file_name, &statbuf) < 0)
12351     {
12352       if (errno == ENOENT)
12353         error (_("'%s': No such file\n"), file_name);
12354       else
12355         error (_("Could not locate '%s'.  System error message: %s\n"),
12356                file_name, strerror (errno));
12357       return 1;
12358     }
12359
12360   if (! S_ISREG (statbuf.st_mode))
12361     {
12362       error (_("'%s' is not an ordinary file\n"), file_name);
12363       return 1;
12364     }
12365
12366   file = fopen (file_name, "rb");
12367   if (file == NULL)
12368     {
12369       error (_("Input file '%s' is not readable.\n"), file_name);
12370       return 1;
12371     }
12372
12373   if (fread (armag, SARMAG, 1, file) != 1)
12374     {
12375       error (_("%s: Failed to read file's magic number\n"), file_name);
12376       fclose (file);
12377       return 1;
12378     }
12379
12380   if (memcmp (armag, ARMAG, SARMAG) == 0)
12381     ret = process_archive (file_name, file, FALSE);
12382   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
12383     ret = process_archive (file_name, file, TRUE);
12384   else
12385     {
12386       if (do_archive_index)
12387         error (_("File %s is not an archive so its index cannot be displayed.\n"),
12388                file_name);
12389
12390       rewind (file);
12391       archive_file_size = archive_file_offset = 0;
12392       ret = process_object (file_name, file);
12393     }
12394
12395   fclose (file);
12396
12397   return ret;
12398 }
12399
12400 #ifdef SUPPORT_DISASSEMBLY
12401 /* Needed by the i386 disassembler.  For extra credit, someone could
12402    fix this so that we insert symbolic addresses here, esp for GOT/PLT
12403    symbols.  */
12404
12405 void
12406 print_address (unsigned int addr, FILE * outfile)
12407 {
12408   fprintf (outfile,"0x%8.8x", addr);
12409 }
12410
12411 /* Needed by the i386 disassembler.  */
12412 void
12413 db_task_printsym (unsigned int addr)
12414 {
12415   print_address (addr, stderr);
12416 }
12417 #endif
12418
12419 int
12420 main (int argc, char ** argv)
12421 {
12422   int err;
12423
12424 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12425   setlocale (LC_MESSAGES, "");
12426 #endif
12427 #if defined (HAVE_SETLOCALE)
12428   setlocale (LC_CTYPE, "");
12429 #endif
12430   bindtextdomain (PACKAGE, LOCALEDIR);
12431   textdomain (PACKAGE);
12432
12433   expandargv (&argc, &argv);
12434
12435   parse_args (argc, argv);
12436
12437   if (num_dump_sects > 0)
12438     {
12439       /* Make a copy of the dump_sects array.  */
12440       cmdline_dump_sects = (dump_type *)
12441           malloc (num_dump_sects * sizeof (* dump_sects));
12442       if (cmdline_dump_sects == NULL)
12443         error (_("Out of memory allocating dump request table.\n"));
12444       else
12445         {
12446           memcpy (cmdline_dump_sects, dump_sects,
12447                   num_dump_sects * sizeof (* dump_sects));
12448           num_cmdline_dump_sects = num_dump_sects;
12449         }
12450     }
12451
12452   if (optind < (argc - 1))
12453     show_name = 1;
12454
12455   err = 0;
12456   while (optind < argc)
12457     err |= process_file (argv[optind++]);
12458
12459   if (dump_sects != NULL)
12460     free (dump_sects);
12461   if (cmdline_dump_sects != NULL)
12462     free (cmdline_dump_sects);
12463
12464   return err;
12465 }