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