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           printf ("  [%6tx]  %s\n", data - start, data);
8628 #else
8629           printf ("  [%6Ix]  %s\n", (size_t) (data - start), data);
8630 #endif
8631           data += strlen (data);
8632           some_strings_shown = TRUE;
8633         }
8634     }
8635
8636   if (! some_strings_shown)
8637     printf (_("  No strings found in this section."));
8638
8639   free (start);
8640
8641   putchar ('\n');
8642 }
8643
8644 static void
8645 dump_section_as_bytes (Elf_Internal_Shdr * section,
8646                        FILE * file,
8647                        bfd_boolean relocate)
8648 {
8649   Elf_Internal_Shdr * relsec;
8650   bfd_size_type bytes;
8651   bfd_vma addr;
8652   unsigned char * data;
8653   unsigned char * start;
8654
8655   start = (unsigned char *) get_section_contents (section, file);
8656   if (start == NULL)
8657     return;
8658
8659   printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
8660
8661   if (relocate)
8662     {
8663       apply_relocations (file, section, start);
8664     }
8665   else
8666     {
8667       /* If the section being dumped has relocations against it the user might
8668          be expecting these relocations to have been applied.  Check for this
8669          case and issue a warning message in order to avoid confusion.
8670          FIXME: Maybe we ought to have an option that dumps a section with
8671          relocs applied ?  */
8672       for (relsec = section_headers;
8673            relsec < section_headers + elf_header.e_shnum;
8674            ++relsec)
8675         {
8676           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
8677               || relsec->sh_info >= elf_header.e_shnum
8678               || section_headers + relsec->sh_info != section
8679               || relsec->sh_size == 0
8680               || relsec->sh_link >= elf_header.e_shnum)
8681             continue;
8682
8683           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8684           break;
8685         }
8686     }
8687
8688   addr = section->sh_addr;
8689   bytes = section->sh_size;
8690   data = start;
8691
8692   while (bytes)
8693     {
8694       int j;
8695       int k;
8696       int lbytes;
8697
8698       lbytes = (bytes > 16 ? 16 : bytes);
8699
8700       printf ("  0x%8.8lx ", (unsigned long) addr);
8701
8702       for (j = 0; j < 16; j++)
8703         {
8704           if (j < lbytes)
8705             printf ("%2.2x", data[j]);
8706           else
8707             printf ("  ");
8708
8709           if ((j & 3) == 3)
8710             printf (" ");
8711         }
8712
8713       for (j = 0; j < lbytes; j++)
8714         {
8715           k = data[j];
8716           if (k >= ' ' && k < 0x7f)
8717             printf ("%c", k);
8718           else
8719             printf (".");
8720         }
8721
8722       putchar ('\n');
8723
8724       data  += lbytes;
8725       addr  += lbytes;
8726       bytes -= lbytes;
8727     }
8728
8729   free (start);
8730
8731   putchar ('\n');
8732 }
8733
8734 /* Uncompresses a section that was compressed using zlib, in place.
8735    This is a copy of bfd_uncompress_section_contents, in bfd/compress.c  */
8736
8737 static int
8738 uncompress_section_contents (unsigned char ** buffer, dwarf_size_type * size)
8739 {
8740 #ifndef HAVE_ZLIB_H
8741   /* These are just to quiet gcc.  */
8742   buffer = 0;
8743   size = 0;
8744   return FALSE;
8745 #else
8746   dwarf_size_type compressed_size = *size;
8747   unsigned char * compressed_buffer = *buffer;
8748   dwarf_size_type uncompressed_size;
8749   unsigned char * uncompressed_buffer;
8750   z_stream strm;
8751   int rc;
8752   dwarf_size_type header_size = 12;
8753
8754   /* Read the zlib header.  In this case, it should be "ZLIB" followed
8755      by the uncompressed section size, 8 bytes in big-endian order.  */
8756   if (compressed_size < header_size
8757       || ! streq ((char *) compressed_buffer, "ZLIB"))
8758     return 0;
8759
8760   uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
8761   uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
8762   uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
8763   uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
8764   uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
8765   uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
8766   uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
8767   uncompressed_size += compressed_buffer[11];
8768
8769   /* It is possible the section consists of several compressed
8770      buffers concatenated together, so we uncompress in a loop.  */
8771   strm.zalloc = NULL;
8772   strm.zfree = NULL;
8773   strm.opaque = NULL;
8774   strm.avail_in = compressed_size - header_size;
8775   strm.next_in = (Bytef *) compressed_buffer + header_size;
8776   strm.avail_out = uncompressed_size;
8777   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
8778
8779   rc = inflateInit (& strm);
8780   while (strm.avail_in > 0)
8781     {
8782       if (rc != Z_OK)
8783         goto fail;
8784       strm.next_out = ((Bytef *) uncompressed_buffer
8785                        + (uncompressed_size - strm.avail_out));
8786       rc = inflate (&strm, Z_FINISH);
8787       if (rc != Z_STREAM_END)
8788         goto fail;
8789       rc = inflateReset (& strm);
8790     }
8791   rc = inflateEnd (& strm);
8792   if (rc != Z_OK
8793       || strm.avail_out != 0)
8794     goto fail;
8795
8796   free (compressed_buffer);
8797   *buffer = uncompressed_buffer;
8798   *size = uncompressed_size;
8799   return 1;
8800
8801  fail:
8802   free (uncompressed_buffer);
8803   return 0;
8804 #endif  /* HAVE_ZLIB_H */
8805 }
8806
8807 static int
8808 load_specific_debug_section (enum dwarf_section_display_enum debug,
8809                              Elf_Internal_Shdr * sec, void * file)
8810 {
8811   struct dwarf_section * section = &debug_displays [debug].section;
8812   char buf [64];
8813   int section_is_compressed;
8814
8815   /* If it is already loaded, do nothing.  */
8816   if (section->start != NULL)
8817     return 1;
8818
8819   section_is_compressed = section->name == section->compressed_name;
8820
8821   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
8822   section->address = sec->sh_addr;
8823   section->size = sec->sh_size;
8824   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
8825                                                sec->sh_offset, 1,
8826                                                sec->sh_size, buf);
8827   if (section->start == NULL)
8828     return 0;
8829
8830   if (section_is_compressed)
8831     if (! uncompress_section_contents (&section->start, &section->size))
8832       return 0;
8833
8834   if (debug_displays [debug].relocate)
8835     apply_relocations ((FILE *) file, sec, section->start);
8836
8837   return 1;
8838 }
8839
8840 int
8841 load_debug_section (enum dwarf_section_display_enum debug, void * file)
8842 {
8843   struct dwarf_section * section = &debug_displays [debug].section;
8844   Elf_Internal_Shdr * sec;
8845
8846   /* Locate the debug section.  */
8847   sec = find_section (section->uncompressed_name);
8848   if (sec != NULL)
8849     section->name = section->uncompressed_name;
8850   else
8851     {
8852       sec = find_section (section->compressed_name);
8853       if (sec != NULL)
8854         section->name = section->compressed_name;
8855     }
8856   if (sec == NULL)
8857     return 0;
8858
8859   return load_specific_debug_section (debug, sec, (FILE *) file);
8860 }
8861
8862 void
8863 free_debug_section (enum dwarf_section_display_enum debug)
8864 {
8865   struct dwarf_section * section = &debug_displays [debug].section;
8866
8867   if (section->start == NULL)
8868     return;
8869
8870   free ((char *) section->start);
8871   section->start = NULL;
8872   section->address = 0;
8873   section->size = 0;
8874 }
8875
8876 static int
8877 display_debug_section (Elf_Internal_Shdr * section, FILE * file)
8878 {
8879   char * name = SECTION_NAME (section);
8880   bfd_size_type length;
8881   int result = 1;
8882   int i;
8883
8884   length = section->sh_size;
8885   if (length == 0)
8886     {
8887       printf (_("\nSection '%s' has no debugging data.\n"), name);
8888       return 0;
8889     }
8890   if (section->sh_type == SHT_NOBITS)
8891     {
8892       /* There is no point in dumping the contents of a debugging section
8893          which has the NOBITS type - the bits in the file will be random.
8894          This can happen when a file containing a .eh_frame section is
8895          stripped with the --only-keep-debug command line option.  */
8896       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
8897       return 0;
8898     }
8899
8900   if (const_strneq (name, ".gnu.linkonce.wi."))
8901     name = ".debug_info";
8902
8903   /* See if we know how to display the contents of this section.  */
8904   for (i = 0; i < max; i++)
8905     if (streq (debug_displays[i].section.uncompressed_name, name)
8906         || streq (debug_displays[i].section.compressed_name, name))
8907       {
8908         struct dwarf_section * sec = &debug_displays [i].section;
8909         int secondary = (section != find_section (name));
8910
8911         if (secondary)
8912           free_debug_section ((enum dwarf_section_display_enum) i);
8913
8914         if (streq (sec->uncompressed_name, name))
8915           sec->name = sec->uncompressed_name;
8916         else
8917           sec->name = sec->compressed_name;
8918         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
8919                                          section, file))
8920           {
8921             result &= debug_displays[i].display (sec, file);
8922
8923             if (secondary || (i != info && i != abbrev))
8924               free_debug_section ((enum dwarf_section_display_enum) i);
8925           }
8926
8927         break;
8928       }
8929
8930   if (i == max)
8931     {
8932       printf (_("Unrecognized debug section: %s\n"), name);
8933       result = 0;
8934     }
8935
8936   return result;
8937 }
8938
8939 /* Set DUMP_SECTS for all sections where dumps were requested
8940    based on section name.  */
8941
8942 static void
8943 initialise_dumps_byname (void)
8944 {
8945   struct dump_list_entry * cur;
8946
8947   for (cur = dump_sects_byname; cur; cur = cur->next)
8948     {
8949       unsigned int i;
8950       int any;
8951
8952       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
8953         if (streq (SECTION_NAME (section_headers + i), cur->name))
8954           {
8955             request_dump_bynumber (i, cur->type);
8956             any = 1;
8957           }
8958
8959       if (!any)
8960         warn (_("Section '%s' was not dumped because it does not exist!\n"),
8961               cur->name);
8962     }
8963 }
8964
8965 static void
8966 process_section_contents (FILE * file)
8967 {
8968   Elf_Internal_Shdr * section;
8969   unsigned int i;
8970
8971   if (! do_dump)
8972     return;
8973
8974   initialise_dumps_byname ();
8975
8976   for (i = 0, section = section_headers;
8977        i < elf_header.e_shnum && i < num_dump_sects;
8978        i++, section++)
8979     {
8980 #ifdef SUPPORT_DISASSEMBLY
8981       if (dump_sects[i] & DISASS_DUMP)
8982         disassemble_section (section, file);
8983 #endif
8984       if (dump_sects[i] & HEX_DUMP)
8985         dump_section_as_bytes (section, file, FALSE);
8986
8987       if (dump_sects[i] & RELOC_DUMP)
8988         dump_section_as_bytes (section, file, TRUE);
8989
8990       if (dump_sects[i] & STRING_DUMP)
8991         dump_section_as_strings (section, file);
8992
8993       if (dump_sects[i] & DEBUG_DUMP)
8994         display_debug_section (section, file);
8995     }
8996
8997   /* Check to see if the user requested a
8998      dump of a section that does not exist.  */
8999   while (i++ < num_dump_sects)
9000     if (dump_sects[i])
9001       warn (_("Section %d was not dumped because it does not exist!\n"), i);
9002 }
9003
9004 static void
9005 process_mips_fpe_exception (int mask)
9006 {
9007   if (mask)
9008     {
9009       int first = 1;
9010       if (mask & OEX_FPU_INEX)
9011         fputs ("INEX", stdout), first = 0;
9012       if (mask & OEX_FPU_UFLO)
9013         printf ("%sUFLO", first ? "" : "|"), first = 0;
9014       if (mask & OEX_FPU_OFLO)
9015         printf ("%sOFLO", first ? "" : "|"), first = 0;
9016       if (mask & OEX_FPU_DIV0)
9017         printf ("%sDIV0", first ? "" : "|"), first = 0;
9018       if (mask & OEX_FPU_INVAL)
9019         printf ("%sINVAL", first ? "" : "|");
9020     }
9021   else
9022     fputs ("0", stdout);
9023 }
9024
9025 /* ARM EABI attributes section.  */
9026 typedef struct
9027 {
9028   int tag;
9029   const char * name;
9030   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
9031   int type;
9032   const char ** table;
9033 } arm_attr_public_tag;
9034
9035 static const char * arm_attr_tag_CPU_arch[] =
9036   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
9037    "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
9038 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
9039 static const char * arm_attr_tag_THUMB_ISA_use[] =
9040   {"No", "Thumb-1", "Thumb-2"};
9041 static const char * arm_attr_tag_VFP_arch[] =
9042   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
9043 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
9044 static const char * arm_attr_tag_Advanced_SIMD_arch[] = {"No", "NEONv1"};
9045 static const char * arm_attr_tag_PCS_config[] =
9046   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
9047    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
9048 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
9049   {"V6", "SB", "TLS", "Unused"};
9050 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
9051   {"Absolute", "PC-relative", "SB-relative", "None"};
9052 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
9053   {"Absolute", "PC-relative", "None"};
9054 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
9055   {"None", "direct", "GOT-indirect"};
9056 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
9057   {"None", "??? 1", "2", "??? 3", "4"};
9058 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
9059 static const char * arm_attr_tag_ABI_FP_denormal[] =
9060   {"Unused", "Needed", "Sign only"};
9061 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
9062 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
9063 static const char * arm_attr_tag_ABI_FP_number_model[] =
9064   {"Unused", "Finite", "RTABI", "IEEE 754"};
9065 static const char * arm_attr_tag_ABI_align8_needed[] = {"No", "Yes", "4-byte"};
9066 static const char * arm_attr_tag_ABI_align8_preserved[] =
9067   {"No", "Yes, except leaf SP", "Yes"};
9068 static const char * arm_attr_tag_ABI_enum_size[] =
9069   {"Unused", "small", "int", "forced to int"};
9070 static const char * arm_attr_tag_ABI_HardFP_use[] =
9071   {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
9072 static const char * arm_attr_tag_ABI_VFP_args[] =
9073   {"AAPCS", "VFP registers", "custom"};
9074 static const char * arm_attr_tag_ABI_WMMX_args[] =
9075   {"AAPCS", "WMMX registers", "custom"};
9076 static const char * arm_attr_tag_ABI_optimization_goals[] =
9077   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9078     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
9079 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
9080   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9081     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
9082 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
9083 static const char * arm_attr_tag_VFP_HP_extension[] =
9084   {"Not Allowed", "Allowed"};
9085 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
9086   {"None", "IEEE 754", "Alternative Format"};
9087 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
9088 static const char * arm_attr_tag_Virtualization_use[] =
9089   {"Not Allowed", "Allowed"};
9090 static const char * arm_attr_tag_MPextension_use[] = {"Not Allowed", "Allowed"};
9091
9092 #define LOOKUP(id, name) \
9093   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
9094 static arm_attr_public_tag arm_attr_public_tags[] =
9095 {
9096   {4, "CPU_raw_name", 1, NULL},
9097   {5, "CPU_name", 1, NULL},
9098   LOOKUP(6, CPU_arch),
9099   {7, "CPU_arch_profile", 0, NULL},
9100   LOOKUP(8, ARM_ISA_use),
9101   LOOKUP(9, THUMB_ISA_use),
9102   LOOKUP(10, VFP_arch),
9103   LOOKUP(11, WMMX_arch),
9104   LOOKUP(12, Advanced_SIMD_arch),
9105   LOOKUP(13, PCS_config),
9106   LOOKUP(14, ABI_PCS_R9_use),
9107   LOOKUP(15, ABI_PCS_RW_data),
9108   LOOKUP(16, ABI_PCS_RO_data),
9109   LOOKUP(17, ABI_PCS_GOT_use),
9110   LOOKUP(18, ABI_PCS_wchar_t),
9111   LOOKUP(19, ABI_FP_rounding),
9112   LOOKUP(20, ABI_FP_denormal),
9113   LOOKUP(21, ABI_FP_exceptions),
9114   LOOKUP(22, ABI_FP_user_exceptions),
9115   LOOKUP(23, ABI_FP_number_model),
9116   LOOKUP(24, ABI_align8_needed),
9117   LOOKUP(25, ABI_align8_preserved),
9118   LOOKUP(26, ABI_enum_size),
9119   LOOKUP(27, ABI_HardFP_use),
9120   LOOKUP(28, ABI_VFP_args),
9121   LOOKUP(29, ABI_WMMX_args),
9122   LOOKUP(30, ABI_optimization_goals),
9123   LOOKUP(31, ABI_FP_optimization_goals),
9124   {32, "compatibility", 0, NULL},
9125   LOOKUP(34, CPU_unaligned_access),
9126   LOOKUP(36, VFP_HP_extension),
9127   LOOKUP(38, ABI_FP_16bit_format),
9128   {64, "nodefaults", 0, NULL},
9129   {65, "also_compatible_with", 0, NULL},
9130   LOOKUP(66, T2EE_use),
9131   {67, "conformance", 1, NULL},
9132   LOOKUP(68, Virtualization_use),
9133   LOOKUP(70, MPextension_use)
9134 };
9135 #undef LOOKUP
9136
9137 /* Read an unsigned LEB128 encoded value from p.  Set *PLEN to the number of
9138    bytes read.  */
9139
9140 static unsigned int
9141 read_uleb128 (unsigned char * p, unsigned int * plen)
9142 {
9143   unsigned char c;
9144   unsigned int val;
9145   int shift;
9146   int len;
9147
9148   val = 0;
9149   shift = 0;
9150   len = 0;
9151   do
9152     {
9153       c = *(p++);
9154       len++;
9155       val |= ((unsigned int)c & 0x7f) << shift;
9156       shift += 7;
9157     }
9158   while (c & 0x80);
9159
9160   *plen = len;
9161   return val;
9162 }
9163
9164 static unsigned char *
9165 display_arm_attribute (unsigned char * p)
9166 {
9167   int tag;
9168   unsigned int len;
9169   int val;
9170   arm_attr_public_tag * attr;
9171   unsigned i;
9172   int type;
9173
9174   tag = read_uleb128 (p, &len);
9175   p += len;
9176   attr = NULL;
9177   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
9178     {
9179       if (arm_attr_public_tags[i].tag == tag)
9180         {
9181           attr = &arm_attr_public_tags[i];
9182           break;
9183         }
9184     }
9185
9186   if (attr)
9187     {
9188       printf ("  Tag_%s: ", attr->name);
9189       switch (attr->type)
9190         {
9191         case 0:
9192           switch (tag)
9193             {
9194             case 7: /* Tag_CPU_arch_profile.  */
9195               val = read_uleb128 (p, &len);
9196               p += len;
9197               switch (val)
9198                 {
9199                 case 0: printf ("None\n"); break;
9200                 case 'A': printf ("Application\n"); break;
9201                 case 'R': printf ("Realtime\n"); break;
9202                 case 'M': printf ("Microcontroller\n"); break;
9203                 default: printf ("??? (%d)\n", val); break;
9204                 }
9205               break;
9206
9207             case 32: /* Tag_compatibility.  */
9208               val = read_uleb128 (p, &len);
9209               p += len;
9210               printf ("flag = %d, vendor = %s\n", val, p);
9211               p += strlen ((char *) p) + 1;
9212               break;
9213
9214             case 64: /* Tag_nodefaults.  */
9215               p++;
9216               printf ("True\n");
9217               break;
9218
9219             case 65: /* Tag_also_compatible_with.  */
9220               val = read_uleb128 (p, &len);
9221               p += len;
9222               if (val == 6 /* Tag_CPU_arch.  */)
9223                 {
9224                   val = read_uleb128 (p, &len);
9225                   p += len;
9226                   if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
9227                     printf ("??? (%d)\n", val);
9228                   else
9229                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
9230                 }
9231               else
9232                 printf ("???\n");
9233               while (*(p++) != '\0' /* NUL terminator.  */);
9234               break;
9235
9236             default:
9237               abort ();
9238             }
9239           return p;
9240
9241         case 1:
9242         case 2:
9243           type = attr->type;
9244           break;
9245
9246         default:
9247           assert (attr->type & 0x80);
9248           val = read_uleb128 (p, &len);
9249           p += len;
9250           type = attr->type & 0x7f;
9251           if (val >= type)
9252             printf ("??? (%d)\n", val);
9253           else
9254             printf ("%s\n", attr->table[val]);
9255           return p;
9256         }
9257     }
9258   else
9259     {
9260       if (tag & 1)
9261         type = 1; /* String.  */
9262       else
9263         type = 2; /* uleb128.  */
9264       printf ("  Tag_unknown_%d: ", tag);
9265     }
9266
9267   if (type == 1)
9268     {
9269       printf ("\"%s\"\n", p);
9270       p += strlen ((char *) p) + 1;
9271     }
9272   else
9273     {
9274       val = read_uleb128 (p, &len);
9275       p += len;
9276       printf ("%d (0x%x)\n", val, val);
9277     }
9278
9279   return p;
9280 }
9281
9282 static unsigned char *
9283 display_gnu_attribute (unsigned char * p,
9284                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
9285 {
9286   int tag;
9287   unsigned int len;
9288   int val;
9289   int type;
9290
9291   tag = read_uleb128 (p, &len);
9292   p += len;
9293
9294   /* Tag_compatibility is the only generic GNU attribute defined at
9295      present.  */
9296   if (tag == 32)
9297     {
9298       val = read_uleb128 (p, &len);
9299       p += len;
9300       printf ("flag = %d, vendor = %s\n", val, p);
9301       p += strlen ((char *) p) + 1;
9302       return p;
9303     }
9304
9305   if ((tag & 2) == 0 && display_proc_gnu_attribute)
9306     return display_proc_gnu_attribute (p, tag);
9307
9308   if (tag & 1)
9309     type = 1; /* String.  */
9310   else
9311     type = 2; /* uleb128.  */
9312   printf ("  Tag_unknown_%d: ", tag);
9313
9314   if (type == 1)
9315     {
9316       printf ("\"%s\"\n", p);
9317       p += strlen ((char *) p) + 1;
9318     }
9319   else
9320     {
9321       val = read_uleb128 (p, &len);
9322       p += len;
9323       printf ("%d (0x%x)\n", val, val);
9324     }
9325
9326   return p;
9327 }
9328
9329 static unsigned char *
9330 display_power_gnu_attribute (unsigned char * p, int tag)
9331 {
9332   int type;
9333   unsigned int len;
9334   int val;
9335
9336   if (tag == Tag_GNU_Power_ABI_FP)
9337     {
9338       val = read_uleb128 (p, &len);
9339       p += len;
9340       printf ("  Tag_GNU_Power_ABI_FP: ");
9341
9342       switch (val)
9343         {
9344         case 0:
9345           printf ("Hard or soft float\n");
9346           break;
9347         case 1:
9348           printf ("Hard float\n");
9349           break;
9350         case 2:
9351           printf ("Soft float\n");
9352           break;
9353         case 3:
9354           printf ("Single-precision hard float\n");
9355           break;
9356         default:
9357           printf ("??? (%d)\n", val);
9358           break;
9359         }
9360       return p;
9361    }
9362
9363   if (tag == Tag_GNU_Power_ABI_Vector)
9364     {
9365       val = read_uleb128 (p, &len);
9366       p += len;
9367       printf ("  Tag_GNU_Power_ABI_Vector: ");
9368       switch (val)
9369         {
9370         case 0:
9371           printf ("Any\n");
9372           break;
9373         case 1:
9374           printf ("Generic\n");
9375           break;
9376         case 2:
9377           printf ("AltiVec\n");
9378           break;
9379         case 3:
9380           printf ("SPE\n");
9381           break;
9382         default:
9383           printf ("??? (%d)\n", val);
9384           break;
9385         }
9386       return p;
9387    }
9388
9389   if (tag == Tag_GNU_Power_ABI_Struct_Return)
9390     {
9391       val = read_uleb128 (p, &len);
9392       p += len;
9393       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
9394       switch (val)
9395        {
9396        case 0:
9397          printf ("Any\n");
9398          break;
9399        case 1:
9400          printf ("r3/r4\n");
9401          break;
9402        case 2:
9403          printf ("Memory\n");
9404          break;
9405        default:
9406          printf ("??? (%d)\n", val);
9407          break;
9408        }
9409       return p;
9410     }
9411
9412   if (tag & 1)
9413     type = 1; /* String.  */
9414   else
9415     type = 2; /* uleb128.  */
9416   printf ("  Tag_unknown_%d: ", tag);
9417
9418   if (type == 1)
9419     {
9420       printf ("\"%s\"\n", p);
9421       p += strlen ((char *) p) + 1;
9422     }
9423   else
9424     {
9425       val = read_uleb128 (p, &len);
9426       p += len;
9427       printf ("%d (0x%x)\n", val, val);
9428     }
9429
9430   return p;
9431 }
9432
9433 static unsigned char *
9434 display_mips_gnu_attribute (unsigned char * p, int tag)
9435 {
9436   int type;
9437   unsigned int len;
9438   int val;
9439
9440   if (tag == Tag_GNU_MIPS_ABI_FP)
9441     {
9442       val = read_uleb128 (p, &len);
9443       p += len;
9444       printf ("  Tag_GNU_MIPS_ABI_FP: ");
9445
9446       switch (val)
9447         {
9448         case 0:
9449           printf ("Hard or soft float\n");
9450           break;
9451         case 1:
9452           printf ("Hard float (-mdouble-float)\n");
9453           break;
9454         case 2:
9455           printf ("Hard float (-msingle-float)\n");
9456           break;
9457         case 3:
9458           printf ("Soft float\n");
9459           break;
9460         case 4:
9461           printf ("64-bit float (-mips32r2 -mfp64)\n");
9462           break;
9463         default:
9464           printf ("??? (%d)\n", val);
9465           break;
9466         }
9467       return p;
9468    }
9469
9470   if (tag & 1)
9471     type = 1; /* String.  */
9472   else
9473     type = 2; /* uleb128.  */
9474   printf ("  Tag_unknown_%d: ", tag);
9475
9476   if (type == 1)
9477     {
9478       printf ("\"%s\"\n", p);
9479       p += strlen ((char *) p) + 1;
9480     }
9481   else
9482     {
9483       val = read_uleb128 (p, &len);
9484       p += len;
9485       printf ("%d (0x%x)\n", val, val);
9486     }
9487
9488   return p;
9489 }
9490
9491 static int
9492 process_attributes (FILE * file,
9493                     const char * public_name,
9494                     unsigned int proc_type,
9495                     unsigned char * (* display_pub_attribute) (unsigned char *),
9496                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
9497 {
9498   Elf_Internal_Shdr * sect;
9499   unsigned char * contents;
9500   unsigned char * p;
9501   unsigned char * end;
9502   bfd_vma section_len;
9503   bfd_vma len;
9504   unsigned i;
9505
9506   /* Find the section header so that we get the size.  */
9507   for (i = 0, sect = section_headers;
9508        i < elf_header.e_shnum;
9509        i++, sect++)
9510     {
9511       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
9512         continue;
9513
9514       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
9515                                              sect->sh_size, _("attributes"));
9516       if (contents == NULL)
9517         continue;
9518
9519       p = contents;
9520       if (*p == 'A')
9521         {
9522           len = sect->sh_size - 1;
9523           p++;
9524
9525           while (len > 0)
9526             {
9527               int namelen;
9528               bfd_boolean public_section;
9529               bfd_boolean gnu_section;
9530
9531               section_len = byte_get (p, 4);
9532               p += 4;
9533
9534               if (section_len > len)
9535                 {
9536                   printf (_("ERROR: Bad section length (%d > %d)\n"),
9537                           (int) section_len, (int) len);
9538                   section_len = len;
9539                 }
9540
9541               len -= section_len;
9542               printf ("Attribute Section: %s\n", p);
9543
9544               if (public_name && streq ((char *) p, public_name))
9545                 public_section = TRUE;
9546               else
9547                 public_section = FALSE;
9548
9549               if (streq ((char *) p, "gnu"))
9550                 gnu_section = TRUE;
9551               else
9552                 gnu_section = FALSE;
9553
9554               namelen = strlen ((char *) p) + 1;
9555               p += namelen;
9556               section_len -= namelen + 4;
9557
9558               while (section_len > 0)
9559                 {
9560                   int tag = *(p++);
9561                   int val;
9562                   bfd_vma size;
9563
9564                   size = byte_get (p, 4);
9565                   if (size > section_len)
9566                     {
9567                       printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9568                               (int) size, (int) section_len);
9569                       size = section_len;
9570                     }
9571
9572                   section_len -= size;
9573                   end = p + size - 1;
9574                   p += 4;
9575
9576                   switch (tag)
9577                     {
9578                     case 1:
9579                       printf ("File Attributes\n");
9580                       break;
9581                     case 2:
9582                       printf ("Section Attributes:");
9583                       goto do_numlist;
9584                     case 3:
9585                       printf ("Symbol Attributes:");
9586                     do_numlist:
9587                       for (;;)
9588                         {
9589                           unsigned int j;
9590
9591                           val = read_uleb128 (p, &j);
9592                           p += j;
9593                           if (val == 0)
9594                             break;
9595                           printf (" %d", val);
9596                         }
9597                       printf ("\n");
9598                       break;
9599                     default:
9600                       printf ("Unknown tag: %d\n", tag);
9601                       public_section = FALSE;
9602                       break;
9603                     }
9604
9605                   if (public_section)
9606                     {
9607                       while (p < end)
9608                         p = display_pub_attribute (p);
9609                     }
9610                   else if (gnu_section)
9611                     {
9612                       while (p < end)
9613                         p = display_gnu_attribute (p,
9614                                                    display_proc_gnu_attribute);
9615                     }
9616                   else
9617                     {
9618                       /* ??? Do something sensible, like dump hex.  */
9619                       printf ("  Unknown section contexts\n");
9620                       p = end;
9621                     }
9622                 }
9623             }
9624         }
9625       else
9626         printf (_("Unknown format '%c'\n"), *p);
9627
9628       free (contents);
9629     }
9630   return 1;
9631 }
9632
9633 static int
9634 process_arm_specific (FILE * file)
9635 {
9636   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
9637                              display_arm_attribute, NULL);
9638 }
9639
9640 static int
9641 process_power_specific (FILE * file)
9642 {
9643   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
9644                              display_power_gnu_attribute);
9645 }
9646
9647 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9648    Print the Address, Access and Initial fields of an entry at VMA ADDR
9649    and return the VMA of the next entry.  */
9650
9651 static bfd_vma
9652 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
9653 {
9654   printf ("  ");
9655   print_vma (addr, LONG_HEX);
9656   printf (" ");
9657   if (addr < pltgot + 0xfff0)
9658     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
9659   else
9660     printf ("%10s", "");
9661   printf (" ");
9662   if (data == NULL)
9663     printf ("%*s", is_32bit_elf ? 8 : 16, "<unknown>");
9664   else
9665     {
9666       bfd_vma entry;
9667
9668       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
9669       print_vma (entry, LONG_HEX);
9670     }
9671   return addr + (is_32bit_elf ? 4 : 8);
9672 }
9673
9674 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9675    PLTGOT.  Print the Address and Initial fields of an entry at VMA
9676    ADDR and return the VMA of the next entry.  */
9677
9678 static bfd_vma
9679 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
9680 {
9681   printf ("  ");
9682   print_vma (addr, LONG_HEX);
9683   printf (" ");
9684   if (data == NULL)
9685     printf ("%*s", is_32bit_elf ? 8 : 16, "<unknown>");
9686   else
9687     {
9688       bfd_vma entry;
9689
9690       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
9691       print_vma (entry, LONG_HEX);
9692     }
9693   return addr + (is_32bit_elf ? 4 : 8);
9694 }
9695
9696 static int
9697 process_mips_specific (FILE * file)
9698 {
9699   Elf_Internal_Dyn * entry;
9700   size_t liblist_offset = 0;
9701   size_t liblistno = 0;
9702   size_t conflictsno = 0;
9703   size_t options_offset = 0;
9704   size_t conflicts_offset = 0;
9705   size_t pltrelsz = 0;
9706   size_t pltrel = 0;
9707   bfd_vma pltgot = 0;
9708   bfd_vma mips_pltgot = 0;
9709   bfd_vma jmprel = 0;
9710   bfd_vma local_gotno = 0;
9711   bfd_vma gotsym = 0;
9712   bfd_vma symtabno = 0;
9713
9714   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
9715                       display_mips_gnu_attribute);
9716
9717   /* We have a lot of special sections.  Thanks SGI!  */
9718   if (dynamic_section == NULL)
9719     /* No information available.  */
9720     return 0;
9721
9722   for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
9723     switch (entry->d_tag)
9724       {
9725       case DT_MIPS_LIBLIST:
9726         liblist_offset
9727           = offset_from_vma (file, entry->d_un.d_val,
9728                              liblistno * sizeof (Elf32_External_Lib));
9729         break;
9730       case DT_MIPS_LIBLISTNO:
9731         liblistno = entry->d_un.d_val;
9732         break;
9733       case DT_MIPS_OPTIONS:
9734         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
9735         break;
9736       case DT_MIPS_CONFLICT:
9737         conflicts_offset
9738           = offset_from_vma (file, entry->d_un.d_val,
9739                              conflictsno * sizeof (Elf32_External_Conflict));
9740         break;
9741       case DT_MIPS_CONFLICTNO:
9742         conflictsno = entry->d_un.d_val;
9743         break;
9744       case DT_PLTGOT:
9745         pltgot = entry->d_un.d_ptr;
9746         break;
9747       case DT_MIPS_LOCAL_GOTNO:
9748         local_gotno = entry->d_un.d_val;
9749         break;
9750       case DT_MIPS_GOTSYM:
9751         gotsym = entry->d_un.d_val;
9752         break;
9753       case DT_MIPS_SYMTABNO:
9754         symtabno = entry->d_un.d_val;
9755         break;
9756       case DT_MIPS_PLTGOT:
9757         mips_pltgot = entry->d_un.d_ptr;
9758         break;
9759       case DT_PLTREL:
9760         pltrel = entry->d_un.d_val;
9761         break;
9762       case DT_PLTRELSZ:
9763         pltrelsz = entry->d_un.d_val;
9764         break;
9765       case DT_JMPREL:
9766         jmprel = entry->d_un.d_ptr;
9767         break;
9768       default:
9769         break;
9770       }
9771
9772   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
9773     {
9774       Elf32_External_Lib * elib;
9775       size_t cnt;
9776
9777       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
9778                                               liblistno,
9779                                               sizeof (Elf32_External_Lib),
9780                                               _("liblist"));
9781       if (elib)
9782         {
9783           printf ("\nSection '.liblist' contains %lu entries:\n",
9784                   (unsigned long) liblistno);
9785           fputs ("     Library              Time Stamp          Checksum   Version Flags\n",
9786                  stdout);
9787
9788           for (cnt = 0; cnt < liblistno; ++cnt)
9789             {
9790               Elf32_Lib liblist;
9791               time_t atime;
9792               char timebuf[20];
9793               struct tm * tmp;
9794
9795               liblist.l_name = BYTE_GET (elib[cnt].l_name);
9796               atime = BYTE_GET (elib[cnt].l_time_stamp);
9797               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9798               liblist.l_version = BYTE_GET (elib[cnt].l_version);
9799               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9800
9801               tmp = gmtime (&atime);
9802               snprintf (timebuf, sizeof (timebuf),
9803                         "%04u-%02u-%02uT%02u:%02u:%02u",
9804                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9805                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9806
9807               printf ("%3lu: ", (unsigned long) cnt);
9808               if (VALID_DYNAMIC_NAME (liblist.l_name))
9809                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
9810               else
9811                 printf ("<corrupt: %9ld>", liblist.l_name);
9812               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
9813                       liblist.l_version);
9814
9815               if (liblist.l_flags == 0)
9816                 puts (" NONE");
9817               else
9818                 {
9819                   static const struct
9820                   {
9821                     const char * name;
9822                     int bit;
9823                   }
9824                   l_flags_vals[] =
9825                   {
9826                     { " EXACT_MATCH", LL_EXACT_MATCH },
9827                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
9828                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
9829                     { " EXPORTS", LL_EXPORTS },
9830                     { " DELAY_LOAD", LL_DELAY_LOAD },
9831                     { " DELTA", LL_DELTA }
9832                   };
9833                   int flags = liblist.l_flags;
9834                   size_t fcnt;
9835
9836                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
9837                     if ((flags & l_flags_vals[fcnt].bit) != 0)
9838                       {
9839                         fputs (l_flags_vals[fcnt].name, stdout);
9840                         flags ^= l_flags_vals[fcnt].bit;
9841                       }
9842                   if (flags != 0)
9843                     printf (" %#x", (unsigned int) flags);
9844
9845                   puts ("");
9846                 }
9847             }
9848
9849           free (elib);
9850         }
9851     }
9852
9853   if (options_offset != 0)
9854     {
9855       Elf_External_Options * eopt;
9856       Elf_Internal_Shdr * sect = section_headers;
9857       Elf_Internal_Options * iopt;
9858       Elf_Internal_Options * option;
9859       size_t offset;
9860       int cnt;
9861
9862       /* Find the section header so that we get the size.  */
9863       while (sect->sh_type != SHT_MIPS_OPTIONS)
9864         ++sect;
9865
9866       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
9867                                                 sect->sh_size, _("options"));
9868       if (eopt)
9869         {
9870           iopt = (Elf_Internal_Options *)
9871               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
9872           if (iopt == NULL)
9873             {
9874               error (_("Out of memory\n"));
9875               return 0;
9876             }
9877
9878           offset = cnt = 0;
9879           option = iopt;
9880
9881           while (offset < sect->sh_size)
9882             {
9883               Elf_External_Options * eoption;
9884
9885               eoption = (Elf_External_Options *) ((char *) eopt + offset);
9886
9887               option->kind = BYTE_GET (eoption->kind);
9888               option->size = BYTE_GET (eoption->size);
9889               option->section = BYTE_GET (eoption->section);
9890               option->info = BYTE_GET (eoption->info);
9891
9892               offset += option->size;
9893
9894               ++option;
9895               ++cnt;
9896             }
9897
9898           printf (_("\nSection '%s' contains %d entries:\n"),
9899                   SECTION_NAME (sect), cnt);
9900
9901           option = iopt;
9902
9903           while (cnt-- > 0)
9904             {
9905               size_t len;
9906
9907               switch (option->kind)
9908                 {
9909                 case ODK_NULL:
9910                   /* This shouldn't happen.  */
9911                   printf (" NULL       %d %lx", option->section, option->info);
9912                   break;
9913                 case ODK_REGINFO:
9914                   printf (" REGINFO    ");
9915                   if (elf_header.e_machine == EM_MIPS)
9916                     {
9917                       /* 32bit form.  */
9918                       Elf32_External_RegInfo * ereg;
9919                       Elf32_RegInfo reginfo;
9920
9921                       ereg = (Elf32_External_RegInfo *) (option + 1);
9922                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9923                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9924                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9925                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9926                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9927                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
9928
9929                       printf ("GPR %08lx  GP 0x%lx\n",
9930                               reginfo.ri_gprmask,
9931                               (unsigned long) reginfo.ri_gp_value);
9932                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
9933                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9934                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9935                     }
9936                   else
9937                     {
9938                       /* 64 bit form.  */
9939                       Elf64_External_RegInfo * ereg;
9940                       Elf64_Internal_RegInfo reginfo;
9941
9942                       ereg = (Elf64_External_RegInfo *) (option + 1);
9943                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
9944                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9945                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9946                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9947                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9948                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
9949
9950                       printf ("GPR %08lx  GP 0x",
9951                               reginfo.ri_gprmask);
9952                       printf_vma (reginfo.ri_gp_value);
9953                       printf ("\n");
9954
9955                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
9956                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9957                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9958                     }
9959                   ++option;
9960                   continue;
9961                 case ODK_EXCEPTIONS:
9962                   fputs (" EXCEPTIONS fpe_min(", stdout);
9963                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
9964                   fputs (") fpe_max(", stdout);
9965                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
9966                   fputs (")", stdout);
9967
9968                   if (option->info & OEX_PAGE0)
9969                     fputs (" PAGE0", stdout);
9970                   if (option->info & OEX_SMM)
9971                     fputs (" SMM", stdout);
9972                   if (option->info & OEX_FPDBUG)
9973                     fputs (" FPDBUG", stdout);
9974                   if (option->info & OEX_DISMISS)
9975                     fputs (" DISMISS", stdout);
9976                   break;
9977                 case ODK_PAD:
9978                   fputs (" PAD       ", stdout);
9979                   if (option->info & OPAD_PREFIX)
9980                     fputs (" PREFIX", stdout);
9981                   if (option->info & OPAD_POSTFIX)
9982                     fputs (" POSTFIX", stdout);
9983                   if (option->info & OPAD_SYMBOL)
9984                     fputs (" SYMBOL", stdout);
9985                   break;
9986                 case ODK_HWPATCH:
9987                   fputs (" HWPATCH   ", stdout);
9988                   if (option->info & OHW_R4KEOP)
9989                     fputs (" R4KEOP", stdout);
9990                   if (option->info & OHW_R8KPFETCH)
9991                     fputs (" R8KPFETCH", stdout);
9992                   if (option->info & OHW_R5KEOP)
9993                     fputs (" R5KEOP", stdout);
9994                   if (option->info & OHW_R5KCVTL)
9995                     fputs (" R5KCVTL", stdout);
9996                   break;
9997                 case ODK_FILL:
9998                   fputs (" FILL       ", stdout);
9999                   /* XXX Print content of info word?  */
10000                   break;
10001                 case ODK_TAGS:
10002                   fputs (" TAGS       ", stdout);
10003                   /* XXX Print content of info word?  */
10004                   break;
10005                 case ODK_HWAND:
10006                   fputs (" HWAND     ", stdout);
10007                   if (option->info & OHWA0_R4KEOP_CHECKED)
10008                     fputs (" R4KEOP_CHECKED", stdout);
10009                   if (option->info & OHWA0_R4KEOP_CLEAN)
10010                     fputs (" R4KEOP_CLEAN", stdout);
10011                   break;
10012                 case ODK_HWOR:
10013                   fputs (" HWOR      ", stdout);
10014                   if (option->info & OHWA0_R4KEOP_CHECKED)
10015                     fputs (" R4KEOP_CHECKED", stdout);
10016                   if (option->info & OHWA0_R4KEOP_CLEAN)
10017                     fputs (" R4KEOP_CLEAN", stdout);
10018                   break;
10019                 case ODK_GP_GROUP:
10020                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
10021                           option->info & OGP_GROUP,
10022                           (option->info & OGP_SELF) >> 16);
10023                   break;
10024                 case ODK_IDENT:
10025                   printf (" IDENT     %#06lx  self-contained %#06lx",
10026                           option->info & OGP_GROUP,
10027                           (option->info & OGP_SELF) >> 16);
10028                   break;
10029                 default:
10030                   /* This shouldn't happen.  */
10031                   printf (" %3d ???     %d %lx",
10032                           option->kind, option->section, option->info);
10033                   break;
10034                 }
10035
10036               len = sizeof (* eopt);
10037               while (len < option->size)
10038                 if (((char *) option)[len] >= ' '
10039                     && ((char *) option)[len] < 0x7f)
10040                   printf ("%c", ((char *) option)[len++]);
10041                 else
10042                   printf ("\\%03o", ((char *) option)[len++]);
10043
10044               fputs ("\n", stdout);
10045               ++option;
10046             }
10047
10048           free (eopt);
10049         }
10050     }
10051
10052   if (conflicts_offset != 0 && conflictsno != 0)
10053     {
10054       Elf32_Conflict * iconf;
10055       size_t cnt;
10056
10057       if (dynamic_symbols == NULL)
10058         {
10059           error (_("conflict list found without a dynamic symbol table\n"));
10060           return 0;
10061         }
10062
10063       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
10064       if (iconf == NULL)
10065         {
10066           error (_("Out of memory\n"));
10067           return 0;
10068         }
10069
10070       if (is_32bit_elf)
10071         {
10072           Elf32_External_Conflict * econf32;
10073
10074           econf32 = (Elf32_External_Conflict *)
10075               get_data (NULL, file, conflicts_offset, conflictsno,
10076                         sizeof (* econf32), _("conflict"));
10077           if (!econf32)
10078             return 0;
10079
10080           for (cnt = 0; cnt < conflictsno; ++cnt)
10081             iconf[cnt] = BYTE_GET (econf32[cnt]);
10082
10083           free (econf32);
10084         }
10085       else
10086         {
10087           Elf64_External_Conflict * econf64;
10088
10089           econf64 = (Elf64_External_Conflict *)
10090               get_data (NULL, file, conflicts_offset, conflictsno,
10091                         sizeof (* econf64), _("conflict"));
10092           if (!econf64)
10093             return 0;
10094
10095           for (cnt = 0; cnt < conflictsno; ++cnt)
10096             iconf[cnt] = BYTE_GET (econf64[cnt]);
10097
10098           free (econf64);
10099         }
10100
10101       printf (_("\nSection '.conflict' contains %lu entries:\n"),
10102               (unsigned long) conflictsno);
10103       puts (_("  Num:    Index       Value  Name"));
10104
10105       for (cnt = 0; cnt < conflictsno; ++cnt)
10106         {
10107           Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
10108
10109           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
10110           print_vma (psym->st_value, FULL_HEX);
10111           putchar (' ');
10112           if (VALID_DYNAMIC_NAME (psym->st_name))
10113             print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10114           else
10115             printf ("<corrupt: %14ld>", psym->st_name);
10116           putchar ('\n');
10117         }
10118
10119       free (iconf);
10120     }
10121
10122   if (pltgot != 0 && local_gotno != 0)
10123     {
10124       bfd_vma ent, local_end, global_end;
10125       size_t i, offset;
10126       unsigned char * data;
10127       int addr_size;
10128
10129       ent = pltgot;
10130       addr_size = (is_32bit_elf ? 4 : 8);
10131       local_end = pltgot + local_gotno * addr_size;
10132       global_end = local_end + (symtabno - gotsym) * addr_size;
10133
10134       offset = offset_from_vma (file, pltgot, global_end - pltgot);
10135       data = (unsigned char *) get_data (NULL, file, offset,
10136                                          global_end - pltgot, 1, _("GOT"));
10137       printf (_("\nPrimary GOT:\n"));
10138       printf (_(" Canonical gp value: "));
10139       print_vma (pltgot + 0x7ff0, LONG_HEX);
10140       printf ("\n\n");
10141
10142       printf (_(" Reserved entries:\n"));
10143       printf (_("  %*s %10s %*s Purpose\n"),
10144               addr_size * 2, "Address", "Access",
10145               addr_size * 2, "Initial");
10146       ent = print_mips_got_entry (data, pltgot, ent);
10147       printf (" Lazy resolver\n");
10148       if (data
10149           && (byte_get (data + ent - pltgot, addr_size)
10150               >> (addr_size * 8 - 1)) != 0)
10151         {
10152           ent = print_mips_got_entry (data, pltgot, ent);
10153           printf (" Module pointer (GNU extension)\n");
10154         }
10155       printf ("\n");
10156
10157       if (ent < local_end)
10158         {
10159           printf (_(" Local entries:\n"));
10160           printf (_("  %*s %10s %*s\n"),
10161                   addr_size * 2, "Address", "Access",
10162                   addr_size * 2, "Initial");
10163           while (ent < local_end)
10164             {
10165               ent = print_mips_got_entry (data, pltgot, ent);
10166               printf ("\n");
10167             }
10168           printf ("\n");
10169         }
10170
10171       if (gotsym < symtabno)
10172         {
10173           int sym_width;
10174
10175           printf (_(" Global entries:\n"));
10176           printf (_("  %*s %10s %*s %*s %-7s %3s %s\n"),
10177                   addr_size * 2, "Address", "Access",
10178                   addr_size * 2, "Initial",
10179                   addr_size * 2, "Sym.Val.", "Type", "Ndx", "Name");
10180           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
10181           for (i = gotsym; i < symtabno; i++)
10182             {
10183               Elf_Internal_Sym * psym;
10184
10185               psym = dynamic_symbols + i;
10186               ent = print_mips_got_entry (data, pltgot, ent);
10187               printf (" ");
10188               print_vma (psym->st_value, LONG_HEX);
10189               printf (" %-7s %3s ",
10190                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
10191                       get_symbol_index_type (psym->st_shndx));
10192               if (VALID_DYNAMIC_NAME (psym->st_name))
10193                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
10194               else
10195                 printf ("<corrupt: %14ld>", psym->st_name);
10196               printf ("\n");
10197             }
10198           printf ("\n");
10199         }
10200
10201       if (data)
10202         free (data);
10203     }
10204
10205   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
10206     {
10207       bfd_vma ent, end;
10208       size_t offset, rel_offset;
10209       unsigned long count, i;
10210       unsigned char * data;
10211       int addr_size, sym_width;
10212       Elf_Internal_Rela * rels;
10213
10214       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
10215       if (pltrel == DT_RELA)
10216         {
10217           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
10218             return 0;
10219         }
10220       else
10221         {
10222           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
10223             return 0;
10224         }
10225
10226       ent = mips_pltgot;
10227       addr_size = (is_32bit_elf ? 4 : 8);
10228       end = mips_pltgot + (2 + count) * addr_size;
10229
10230       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
10231       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
10232                                          1, _("PLT GOT"));
10233       printf (_("\nPLT GOT:\n\n"));
10234       printf (_(" Reserved entries:\n"));
10235       printf (_("  %*s %*s Purpose\n"),
10236               addr_size * 2, "Address", addr_size * 2, "Initial");
10237       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
10238       printf (" PLT lazy resolver\n");
10239       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
10240       printf (" Module pointer\n");
10241       printf ("\n");
10242
10243       printf (_(" Entries:\n"));
10244       printf (_("  %*s %*s %*s %-7s %3s %s\n"),
10245               addr_size * 2, "Address",
10246               addr_size * 2, "Initial",
10247               addr_size * 2, "Sym.Val.", "Type", "Ndx", "Name");
10248       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
10249       for (i = 0; i < count; i++)
10250         {
10251           Elf_Internal_Sym * psym;
10252
10253           psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
10254           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
10255           printf (" ");
10256           print_vma (psym->st_value, LONG_HEX);
10257           printf (" %-7s %3s ",
10258                   get_symbol_type (ELF_ST_TYPE (psym->st_info)),
10259                   get_symbol_index_type (psym->st_shndx));
10260           if (VALID_DYNAMIC_NAME (psym->st_name))
10261             print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
10262           else
10263             printf ("<corrupt: %14ld>", psym->st_name);
10264           printf ("\n");
10265         }
10266       printf ("\n");
10267
10268       if (data)
10269         free (data);
10270       free (rels);
10271     }
10272
10273   return 1;
10274 }
10275
10276 static int
10277 process_gnu_liblist (FILE * file)
10278 {
10279   Elf_Internal_Shdr * section;
10280   Elf_Internal_Shdr * string_sec;
10281   Elf32_External_Lib * elib;
10282   char * strtab;
10283   size_t strtab_size;
10284   size_t cnt;
10285   unsigned i;
10286
10287   if (! do_arch)
10288     return 0;
10289
10290   for (i = 0, section = section_headers;
10291        i < elf_header.e_shnum;
10292        i++, section++)
10293     {
10294       switch (section->sh_type)
10295         {
10296         case SHT_GNU_LIBLIST:
10297           if (section->sh_link >= elf_header.e_shnum)
10298             break;
10299
10300           elib = (Elf32_External_Lib *)
10301               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
10302                         _("liblist"));
10303
10304           if (elib == NULL)
10305             break;
10306           string_sec = section_headers + section->sh_link;
10307
10308           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
10309                                       string_sec->sh_size,
10310                                       _("liblist string table"));
10311           strtab_size = string_sec->sh_size;
10312
10313           if (strtab == NULL
10314               || section->sh_entsize != sizeof (Elf32_External_Lib))
10315             {
10316               free (elib);
10317               break;
10318             }
10319
10320           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10321                   SECTION_NAME (section),
10322                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
10323
10324           puts ("     Library              Time Stamp          Checksum   Version Flags");
10325
10326           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
10327                ++cnt)
10328             {
10329               Elf32_Lib liblist;
10330               time_t atime;
10331               char timebuf[20];
10332               struct tm * tmp;
10333
10334               liblist.l_name = BYTE_GET (elib[cnt].l_name);
10335               atime = BYTE_GET (elib[cnt].l_time_stamp);
10336               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
10337               liblist.l_version = BYTE_GET (elib[cnt].l_version);
10338               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
10339
10340               tmp = gmtime (&atime);
10341               snprintf (timebuf, sizeof (timebuf),
10342                         "%04u-%02u-%02uT%02u:%02u:%02u",
10343                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10344                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10345
10346               printf ("%3lu: ", (unsigned long) cnt);
10347               if (do_wide)
10348                 printf ("%-20s", liblist.l_name < strtab_size
10349                                  ? strtab + liblist.l_name : "<corrupt>");
10350               else
10351                 printf ("%-20.20s", liblist.l_name < strtab_size
10352                                     ? strtab + liblist.l_name : "<corrupt>");
10353               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
10354                       liblist.l_version, liblist.l_flags);
10355             }
10356
10357           free (elib);
10358         }
10359     }
10360
10361   return 1;
10362 }
10363
10364 static const char *
10365 get_note_type (unsigned e_type)
10366 {
10367   static char buff[64];
10368
10369   if (elf_header.e_type == ET_CORE)
10370     switch (e_type)
10371       {
10372       case NT_AUXV:
10373         return _("NT_AUXV (auxiliary vector)");
10374       case NT_PRSTATUS:
10375         return _("NT_PRSTATUS (prstatus structure)");
10376       case NT_FPREGSET:
10377         return _("NT_FPREGSET (floating point registers)");
10378       case NT_PRPSINFO:
10379         return _("NT_PRPSINFO (prpsinfo structure)");
10380       case NT_TASKSTRUCT:
10381         return _("NT_TASKSTRUCT (task structure)");
10382       case NT_PRXFPREG:
10383         return _("NT_PRXFPREG (user_xfpregs structure)");
10384       case NT_PPC_VMX:
10385         return _("NT_PPC_VMX (ppc Altivec registers)");
10386       case NT_PPC_VSX:
10387         return _("NT_PPC_VSX (ppc VSX registers)");
10388       case NT_S390_HIGH_GPRS:
10389         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
10390       case NT_PSTATUS:
10391         return _("NT_PSTATUS (pstatus structure)");
10392       case NT_FPREGS:
10393         return _("NT_FPREGS (floating point registers)");
10394       case NT_PSINFO:
10395         return _("NT_PSINFO (psinfo structure)");
10396       case NT_LWPSTATUS:
10397         return _("NT_LWPSTATUS (lwpstatus_t structure)");
10398       case NT_LWPSINFO:
10399         return _("NT_LWPSINFO (lwpsinfo_t structure)");
10400       case NT_WIN32PSTATUS:
10401         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10402       default:
10403         break;
10404       }
10405   else
10406     switch (e_type)
10407       {
10408       case NT_VERSION:
10409         return _("NT_VERSION (version)");
10410       case NT_ARCH:
10411         return _("NT_ARCH (architecture)");
10412       default:
10413         break;
10414       }
10415
10416   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
10417   return buff;
10418 }
10419
10420 static const char *
10421 get_gnu_elf_note_type (unsigned e_type)
10422 {
10423   static char buff[64];
10424
10425   switch (e_type)
10426     {
10427     case NT_GNU_ABI_TAG:
10428       return _("NT_GNU_ABI_TAG (ABI version tag)");
10429     case NT_GNU_HWCAP:
10430       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10431     case NT_GNU_BUILD_ID:
10432       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
10433     case NT_GNU_GOLD_VERSION:
10434       return _("NT_GNU_GOLD_VERSION (gold version)");
10435     default:
10436       break;
10437     }
10438
10439   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
10440   return buff;
10441 }
10442
10443 static const char *
10444 get_netbsd_elfcore_note_type (unsigned e_type)
10445 {
10446   static char buff[64];
10447
10448   if (e_type == NT_NETBSDCORE_PROCINFO)
10449     {
10450       /* NetBSD core "procinfo" structure.  */
10451       return _("NetBSD procinfo structure");
10452     }
10453
10454   /* As of Jan 2002 there are no other machine-independent notes
10455      defined for NetBSD core files.  If the note type is less
10456      than the start of the machine-dependent note types, we don't
10457      understand it.  */
10458
10459   if (e_type < NT_NETBSDCORE_FIRSTMACH)
10460     {
10461       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
10462       return buff;
10463     }
10464
10465   switch (elf_header.e_machine)
10466     {
10467     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10468        and PT_GETFPREGS == mach+2.  */
10469
10470     case EM_OLD_ALPHA:
10471     case EM_ALPHA:
10472     case EM_SPARC:
10473     case EM_SPARC32PLUS:
10474     case EM_SPARCV9:
10475       switch (e_type)
10476         {
10477         case NT_NETBSDCORE_FIRSTMACH+0:
10478           return _("PT_GETREGS (reg structure)");
10479         case NT_NETBSDCORE_FIRSTMACH+2:
10480           return _("PT_GETFPREGS (fpreg structure)");
10481         default:
10482           break;
10483         }
10484       break;
10485
10486     /* On all other arch's, PT_GETREGS == mach+1 and
10487        PT_GETFPREGS == mach+3.  */
10488     default:
10489       switch (e_type)
10490         {
10491         case NT_NETBSDCORE_FIRSTMACH+1:
10492           return _("PT_GETREGS (reg structure)");
10493         case NT_NETBSDCORE_FIRSTMACH+3:
10494           return _("PT_GETFPREGS (fpreg structure)");
10495         default:
10496           break;
10497         }
10498     }
10499
10500   snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
10501             e_type - NT_NETBSDCORE_FIRSTMACH);
10502   return buff;
10503 }
10504
10505 /* Note that by the ELF standard, the name field is already null byte
10506    terminated, and namesz includes the terminating null byte.
10507    I.E. the value of namesz for the name "FSF" is 4.
10508
10509    If the value of namesz is zero, there is no name present.  */
10510 static int
10511 process_note (Elf_Internal_Note * pnote)
10512 {
10513   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
10514   const char * nt;
10515
10516   if (pnote->namesz == 0)
10517     /* If there is no note name, then use the default set of
10518        note type strings.  */
10519     nt = get_note_type (pnote->type);
10520
10521   else if (const_strneq (pnote->namedata, "GNU"))
10522     /* GNU-specific object file notes.  */
10523     nt = get_gnu_elf_note_type (pnote->type);
10524
10525   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
10526     /* NetBSD-specific core file notes.  */
10527     nt = get_netbsd_elfcore_note_type (pnote->type);
10528
10529   else if (strneq (pnote->namedata, "SPU/", 4))
10530     {
10531       /* SPU-specific core file notes.  */
10532       nt = pnote->namedata + 4;
10533       name = "SPU";
10534     }
10535
10536   else
10537     /* Don't recognize this note name; just use the default set of
10538        note type strings.  */
10539       nt = get_note_type (pnote->type);
10540
10541   printf ("  %s\t\t0x%08lx\t%s\n", name, pnote->descsz, nt);
10542   return 1;
10543 }
10544
10545
10546 static int
10547 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
10548 {
10549   Elf_External_Note * pnotes;
10550   Elf_External_Note * external;
10551   int res = 1;
10552
10553   if (length <= 0)
10554     return 0;
10555
10556   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
10557                                            _("notes"));
10558   if (!pnotes)
10559     return 0;
10560
10561   external = pnotes;
10562
10563   printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10564           (unsigned long) offset, (unsigned long) length);
10565   printf (_("  Owner\t\tData size\tDescription\n"));
10566
10567   while (external < (Elf_External_Note *) ((char *) pnotes + length))
10568     {
10569       Elf_External_Note * next;
10570       Elf_Internal_Note inote;
10571       char * temp = NULL;
10572
10573       inote.type     = BYTE_GET (external->type);
10574       inote.namesz   = BYTE_GET (external->namesz);
10575       inote.namedata = external->name;
10576       inote.descsz   = BYTE_GET (external->descsz);
10577       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
10578       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
10579
10580       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
10581
10582       if (((char *) next) > (((char *) pnotes) + length))
10583         {
10584           warn (_("corrupt note found at offset %lx into core notes\n"),
10585                 (unsigned long) ((char *) external - (char *) pnotes));
10586           warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10587                 inote.type, inote.namesz, inote.descsz);
10588           break;
10589         }
10590
10591       external = next;
10592
10593       /* Verify that name is null terminated.  It appears that at least
10594          one version of Linux (RedHat 6.0) generates corefiles that don't
10595          comply with the ELF spec by failing to include the null byte in
10596          namesz.  */
10597       if (inote.namedata[inote.namesz] != '\0')
10598         {
10599           temp = (char *) malloc (inote.namesz + 1);
10600
10601           if (temp == NULL)
10602             {
10603               error (_("Out of memory\n"));
10604               res = 0;
10605               break;
10606             }
10607
10608           strncpy (temp, inote.namedata, inote.namesz);
10609           temp[inote.namesz] = 0;
10610
10611           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
10612           inote.namedata = temp;
10613         }
10614
10615       res &= process_note (& inote);
10616
10617       if (temp != NULL)
10618         {
10619           free (temp);
10620           temp = NULL;
10621         }
10622     }
10623
10624   free (pnotes);
10625
10626   return res;
10627 }
10628
10629 static int
10630 process_corefile_note_segments (FILE * file)
10631 {
10632   Elf_Internal_Phdr * segment;
10633   unsigned int i;
10634   int res = 1;
10635
10636   if (! get_program_headers (file))
10637       return 0;
10638
10639   for (i = 0, segment = program_headers;
10640        i < elf_header.e_phnum;
10641        i++, segment++)
10642     {
10643       if (segment->p_type == PT_NOTE)
10644         res &= process_corefile_note_segment (file,
10645                                               (bfd_vma) segment->p_offset,
10646                                               (bfd_vma) segment->p_filesz);
10647     }
10648
10649   return res;
10650 }
10651
10652 static int
10653 process_note_sections (FILE * file)
10654 {
10655   Elf_Internal_Shdr * section;
10656   unsigned long i;
10657   int res = 1;
10658
10659   for (i = 0, section = section_headers;
10660        i < elf_header.e_shnum;
10661        i++, section++)
10662     if (section->sh_type == SHT_NOTE)
10663       res &= process_corefile_note_segment (file,
10664                                             (bfd_vma) section->sh_offset,
10665                                             (bfd_vma) section->sh_size);
10666
10667   return res;
10668 }
10669
10670 static int
10671 process_notes (FILE * file)
10672 {
10673   /* If we have not been asked to display the notes then do nothing.  */
10674   if (! do_notes)
10675     return 1;
10676
10677   if (elf_header.e_type != ET_CORE)
10678     return process_note_sections (file);
10679
10680   /* No program headers means no NOTE segment.  */
10681   if (elf_header.e_phnum > 0)
10682     return process_corefile_note_segments (file);
10683
10684   printf (_("No note segments present in the core file.\n"));
10685   return 1;
10686 }
10687
10688 static int
10689 process_arch_specific (FILE * file)
10690 {
10691   if (! do_arch)
10692     return 1;
10693
10694   switch (elf_header.e_machine)
10695     {
10696     case EM_ARM:
10697       return process_arm_specific (file);
10698     case EM_MIPS:
10699     case EM_MIPS_RS3_LE:
10700       return process_mips_specific (file);
10701       break;
10702     case EM_PPC:
10703       return process_power_specific (file);
10704       break;
10705     default:
10706       break;
10707     }
10708   return 1;
10709 }
10710
10711 static int
10712 get_file_header (FILE * file)
10713 {
10714   /* Read in the identity array.  */
10715   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
10716     return 0;
10717
10718   /* Determine how to read the rest of the header.  */
10719   switch (elf_header.e_ident[EI_DATA])
10720     {
10721     default: /* fall through */
10722     case ELFDATANONE: /* fall through */
10723     case ELFDATA2LSB:
10724       byte_get = byte_get_little_endian;
10725       byte_put = byte_put_little_endian;
10726       break;
10727     case ELFDATA2MSB:
10728       byte_get = byte_get_big_endian;
10729       byte_put = byte_put_big_endian;
10730       break;
10731     }
10732
10733   /* For now we only support 32 bit and 64 bit ELF files.  */
10734   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
10735
10736   /* Read in the rest of the header.  */
10737   if (is_32bit_elf)
10738     {
10739       Elf32_External_Ehdr ehdr32;
10740
10741       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
10742         return 0;
10743
10744       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
10745       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
10746       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
10747       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
10748       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
10749       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
10750       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
10751       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
10752       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
10753       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
10754       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
10755       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
10756       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
10757     }
10758   else
10759     {
10760       Elf64_External_Ehdr ehdr64;
10761
10762       /* If we have been compiled with sizeof (bfd_vma) == 4, then
10763          we will not be able to cope with the 64bit data found in
10764          64 ELF files.  Detect this now and abort before we start
10765          overwriting things.  */
10766       if (sizeof (bfd_vma) < 8)
10767         {
10768           error (_("This instance of readelf has been built without support for a\n\
10769 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10770           return 0;
10771         }
10772
10773       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
10774         return 0;
10775
10776       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
10777       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
10778       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
10779       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
10780       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
10781       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
10782       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
10783       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
10784       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
10785       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
10786       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
10787       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
10788       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
10789     }
10790
10791   if (elf_header.e_shoff)
10792     {
10793       /* There may be some extensions in the first section header.  Don't
10794          bomb if we can't read it.  */
10795       if (is_32bit_elf)
10796         get_32bit_section_headers (file, 1);
10797       else
10798         get_64bit_section_headers (file, 1);
10799     }
10800
10801   return 1;
10802 }
10803
10804 /* Process one ELF object file according to the command line options.
10805    This file may actually be stored in an archive.  The file is
10806    positioned at the start of the ELF object.  */
10807
10808 static int
10809 process_object (char * file_name, FILE * file)
10810 {
10811   unsigned int i;
10812
10813   if (! get_file_header (file))
10814     {
10815       error (_("%s: Failed to read file header\n"), file_name);
10816       return 1;
10817     }
10818
10819   /* Initialise per file variables.  */
10820   for (i = ARRAY_SIZE (version_info); i--;)
10821     version_info[i] = 0;
10822
10823   for (i = ARRAY_SIZE (dynamic_info); i--;)
10824     dynamic_info[i] = 0;
10825
10826   /* Process the file.  */
10827   if (show_name)
10828     printf (_("\nFile: %s\n"), file_name);
10829
10830   /* Initialise the dump_sects array from the cmdline_dump_sects array.
10831      Note we do this even if cmdline_dump_sects is empty because we
10832      must make sure that the dump_sets array is zeroed out before each
10833      object file is processed.  */
10834   if (num_dump_sects > num_cmdline_dump_sects)
10835     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
10836
10837   if (num_cmdline_dump_sects > 0)
10838     {
10839       if (num_dump_sects == 0)
10840         /* A sneaky way of allocating the dump_sects array.  */
10841         request_dump_bynumber (num_cmdline_dump_sects, 0);
10842
10843       assert (num_dump_sects >= num_cmdline_dump_sects);
10844       memcpy (dump_sects, cmdline_dump_sects,
10845               num_cmdline_dump_sects * sizeof (* dump_sects));
10846     }
10847
10848   if (! process_file_header ())
10849     return 1;
10850
10851   if (! process_section_headers (file))
10852     {
10853       /* Without loaded section headers we cannot process lots of
10854          things.  */
10855       do_unwind = do_version = do_dump = do_arch = 0;
10856
10857       if (! do_using_dynamic)
10858         do_syms = do_reloc = 0;
10859     }
10860
10861   if (! process_section_groups (file))
10862     {
10863       /* Without loaded section groups we cannot process unwind.  */
10864       do_unwind = 0;
10865     }
10866
10867   if (process_program_headers (file))
10868     process_dynamic_section (file);
10869
10870   process_relocs (file);
10871
10872   process_unwind (file);
10873
10874   process_symbol_table (file);
10875
10876   process_syminfo (file);
10877
10878   process_version_sections (file);
10879
10880   process_section_contents (file);
10881
10882   process_notes (file);
10883
10884   process_gnu_liblist (file);
10885
10886   process_arch_specific (file);
10887
10888   if (program_headers)
10889     {
10890       free (program_headers);
10891       program_headers = NULL;
10892     }
10893
10894   if (section_headers)
10895     {
10896       free (section_headers);
10897       section_headers = NULL;
10898     }
10899
10900   if (string_table)
10901     {
10902       free (string_table);
10903       string_table = NULL;
10904       string_table_length = 0;
10905     }
10906
10907   if (dynamic_strings)
10908     {
10909       free (dynamic_strings);
10910       dynamic_strings = NULL;
10911       dynamic_strings_length = 0;
10912     }
10913
10914   if (dynamic_symbols)
10915     {
10916       free (dynamic_symbols);
10917       dynamic_symbols = NULL;
10918       num_dynamic_syms = 0;
10919     }
10920
10921   if (dynamic_syminfo)
10922     {
10923       free (dynamic_syminfo);
10924       dynamic_syminfo = NULL;
10925     }
10926
10927   if (section_headers_groups)
10928     {
10929       free (section_headers_groups);
10930       section_headers_groups = NULL;
10931     }
10932
10933   if (section_groups)
10934     {
10935       struct group_list * g;
10936       struct group_list * next;
10937
10938       for (i = 0; i < group_count; i++)
10939         {
10940           for (g = section_groups [i].root; g != NULL; g = next)
10941             {
10942               next = g->next;
10943               free (g);
10944             }
10945         }
10946
10947       free (section_groups);
10948       section_groups = NULL;
10949     }
10950
10951   free_debug_memory ();
10952
10953   return 0;
10954 }
10955
10956 /* Return the path name for a proxy entry in a thin archive, adjusted relative
10957    to the path name of the thin archive itself if necessary.  Always returns
10958    a pointer to malloc'ed memory.  */
10959
10960 static char *
10961 adjust_relative_path (char * file_name, char * name, int name_len)
10962 {
10963   char * member_file_name;
10964   const char * base_name = lbasename (file_name);
10965
10966   /* This is a proxy entry for a thin archive member.
10967      If the extended name table contains an absolute path
10968      name, or if the archive is in the current directory,
10969      use the path name as given.  Otherwise, we need to
10970      find the member relative to the directory where the
10971      archive is located.  */
10972   if (IS_ABSOLUTE_PATH (name) || base_name == file_name)
10973     {
10974       member_file_name = (char *) malloc (name_len + 1);
10975       if (member_file_name == NULL)
10976         {
10977           error (_("Out of memory\n"));
10978           return NULL;
10979         }
10980       memcpy (member_file_name, name, name_len);
10981       member_file_name[name_len] = '\0';
10982     }
10983   else
10984     {
10985       /* Concatenate the path components of the archive file name
10986          to the relative path name from the extended name table.  */
10987       size_t prefix_len = base_name - file_name;
10988       member_file_name = (char *) malloc (prefix_len + name_len + 1);
10989       if (member_file_name == NULL)
10990         {
10991           error (_("Out of memory\n"));
10992           return NULL;
10993         }
10994       memcpy (member_file_name, file_name, prefix_len);
10995       memcpy (member_file_name + prefix_len, name, name_len);
10996       member_file_name[prefix_len + name_len] = '\0';
10997     }
10998   return member_file_name;
10999 }
11000
11001 /* Structure to hold information about an archive file.  */
11002
11003 struct archive_info
11004 {
11005   char * file_name;                     /* Archive file name.  */
11006   FILE * file;                          /* Open file descriptor.  */
11007   unsigned long index_num;              /* Number of symbols in table.  */
11008   unsigned long * index_array;          /* The array of member offsets.  */
11009   char * sym_table;                     /* The symbol table.  */
11010   unsigned long sym_size;               /* Size of the symbol table.  */
11011   char * longnames;                     /* The long file names table.  */
11012   unsigned long longnames_size;         /* Size of the long file names table.  */
11013   unsigned long nested_member_origin;   /* Origin in the nested archive of the current member.  */
11014   unsigned long next_arhdr_offset;      /* Offset of the next archive header.  */
11015   bfd_boolean is_thin_archive;          /* TRUE if this is a thin archive.  */
11016   struct ar_hdr arhdr;                  /* Current archive header.  */
11017 };
11018
11019 /* Read the symbol table and long-name table from an archive.  */
11020
11021 static int
11022 setup_archive (struct archive_info * arch, char * file_name, FILE * file,
11023                bfd_boolean is_thin_archive, bfd_boolean read_symbols)
11024 {
11025   size_t got;
11026   unsigned long size;
11027
11028   arch->file_name = strdup (file_name);
11029   arch->file = file;
11030   arch->index_num = 0;
11031   arch->index_array = NULL;
11032   arch->sym_table = NULL;
11033   arch->sym_size = 0;
11034   arch->longnames = NULL;
11035   arch->longnames_size = 0;
11036   arch->nested_member_origin = 0;
11037   arch->is_thin_archive = is_thin_archive;
11038   arch->next_arhdr_offset = SARMAG;
11039
11040   /* Read the first archive member header.  */
11041   if (fseek (file, SARMAG, SEEK_SET) != 0)
11042     {
11043       error (_("%s: failed to seek to first archive header\n"), file_name);
11044       return 1;
11045     }
11046   got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
11047   if (got != sizeof arch->arhdr)
11048     {
11049       if (got == 0)
11050         return 0;
11051
11052       error (_("%s: failed to read archive header\n"), file_name);
11053       return 1;
11054     }
11055
11056   /* See if this is the archive symbol table.  */
11057   if (const_strneq (arch->arhdr.ar_name, "/               ")
11058       || const_strneq (arch->arhdr.ar_name, "/SYM64/         "))
11059     {
11060       size = strtoul (arch->arhdr.ar_size, NULL, 10);
11061       size = size + (size & 1);
11062
11063       arch->next_arhdr_offset += sizeof arch->arhdr + size;
11064
11065       if (read_symbols)
11066         {
11067           unsigned long i;
11068           /* A buffer used to hold numbers read in from an archive index.
11069              These are always 4 bytes long and stored in big-endian format.  */
11070 #define SIZEOF_AR_INDEX_NUMBERS 4
11071           unsigned char integer_buffer[SIZEOF_AR_INDEX_NUMBERS];
11072           unsigned char * index_buffer;
11073
11074           /* Check the size of the archive index.  */
11075           if (size < SIZEOF_AR_INDEX_NUMBERS)
11076             {
11077               error (_("%s: the archive index is empty\n"), file_name);
11078               return 1;
11079             }
11080
11081           /* Read the numer of entries in the archive index.  */
11082           got = fread (integer_buffer, 1, sizeof integer_buffer, file);
11083           if (got != sizeof (integer_buffer))
11084             {
11085               error (_("%s: failed to read archive index\n"), file_name);
11086               return 1;
11087             }
11088           arch->index_num = byte_get_big_endian (integer_buffer, sizeof integer_buffer);
11089           size -= SIZEOF_AR_INDEX_NUMBERS;
11090
11091           /* Read in the archive index.  */
11092           if (size < arch->index_num * SIZEOF_AR_INDEX_NUMBERS)
11093             {
11094               error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
11095                      file_name, arch->index_num);
11096               return 1;
11097             }
11098           index_buffer = (unsigned char *)
11099               malloc (arch->index_num * SIZEOF_AR_INDEX_NUMBERS);
11100           if (index_buffer == NULL)
11101             {
11102               error (_("Out of memory whilst trying to read archive symbol index\n"));
11103               return 1;
11104             }
11105           got = fread (index_buffer, SIZEOF_AR_INDEX_NUMBERS, arch->index_num, file);
11106           if (got != arch->index_num)
11107             {
11108               free (index_buffer);
11109               error (_("%s: failed to read archive index\n"), file_name);
11110               return 1;
11111             }
11112           size -= arch->index_num * SIZEOF_AR_INDEX_NUMBERS;
11113
11114           /* Convert the index numbers into the host's numeric format.  */
11115           arch->index_array = (long unsigned int *)
11116               malloc (arch->index_num * sizeof (* arch->index_array));
11117           if (arch->index_array == NULL)
11118             {
11119               free (index_buffer);
11120               error (_("Out of memory whilst trying to convert the archive symbol index\n"));
11121               return 1;
11122             }
11123
11124           for (i = 0; i < arch->index_num; i++)
11125             arch->index_array[i] = byte_get_big_endian ((unsigned char *) (index_buffer + (i * SIZEOF_AR_INDEX_NUMBERS)),
11126                                                         SIZEOF_AR_INDEX_NUMBERS);
11127           free (index_buffer);
11128
11129           /* The remaining space in the header is taken up by the symbol table.  */
11130           if (size < 1)
11131             {
11132               error (_("%s: the archive has an index but no symbols\n"), file_name);
11133               return 1;
11134             }
11135           arch->sym_table = (char *) malloc (size);
11136           arch->sym_size = size;
11137           if (arch->sym_table == NULL)
11138             {
11139               error (_("Out of memory whilst trying to read archive index symbol table\n"));
11140               return 1;
11141             }
11142           got = fread (arch->sym_table, 1, size, file);
11143           if (got != size)
11144             {
11145               error (_("%s: failed to read archive index symbol table\n"), file_name);
11146               return 1;
11147             }
11148         }
11149       else
11150         {
11151           if (fseek (file, size, SEEK_CUR) != 0)
11152             {
11153               error (_("%s: failed to skip archive symbol table\n"), file_name);
11154               return 1;
11155             }
11156         }
11157
11158       /* Read the next archive header.  */
11159       got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
11160       if (got != sizeof arch->arhdr)
11161         {
11162           if (got == 0)
11163             return 0;
11164           error (_("%s: failed to read archive header following archive index\n"), file_name);
11165           return 1;
11166         }
11167     }
11168   else if (read_symbols)
11169     printf (_("%s has no archive index\n"), file_name);
11170
11171   if (const_strneq (arch->arhdr.ar_name, "//              "))
11172     {
11173       /* This is the archive string table holding long member names.  */
11174       arch->longnames_size = strtoul (arch->arhdr.ar_size, NULL, 10);
11175       arch->next_arhdr_offset += sizeof arch->arhdr + arch->longnames_size;
11176
11177       arch->longnames = (char *) malloc (arch->longnames_size);
11178       if (arch->longnames == NULL)
11179         {
11180           error (_("Out of memory reading long symbol names in archive\n"));
11181           return 1;
11182         }
11183
11184       if (fread (arch->longnames, arch->longnames_size, 1, file) != 1)
11185         {
11186           free (arch->longnames);
11187           arch->longnames = NULL;
11188           error (_("%s: failed to read long symbol name string table\n"), file_name);
11189           return 1;
11190         }
11191
11192       if ((arch->longnames_size & 1) != 0)
11193         getc (file);
11194     }
11195
11196   return 0;
11197 }
11198
11199 /* Release the memory used for the archive information.  */
11200
11201 static void
11202 release_archive (struct archive_info * arch)
11203 {
11204   if (arch->file_name != NULL)
11205     free (arch->file_name);
11206   if (arch->index_array != NULL)
11207     free (arch->index_array);
11208   if (arch->sym_table != NULL)
11209     free (arch->sym_table);
11210   if (arch->longnames != NULL)
11211     free (arch->longnames);
11212 }
11213
11214 /* Open and setup a nested archive, if not already open.  */
11215
11216 static int
11217 setup_nested_archive (struct archive_info * nested_arch, char * member_file_name)
11218 {
11219   FILE * member_file;
11220
11221   /* Have we already setup this archive?  */
11222   if (nested_arch->file_name != NULL
11223       && streq (nested_arch->file_name, member_file_name))
11224     return 0;
11225
11226   /* Close previous file and discard cached information.  */
11227   if (nested_arch->file != NULL)
11228     fclose (nested_arch->file);
11229   release_archive (nested_arch);
11230
11231   member_file = fopen (member_file_name, "rb");
11232   if (member_file == NULL)
11233     return 1;
11234   return setup_archive (nested_arch, member_file_name, member_file, FALSE, FALSE);
11235 }
11236
11237 static char *
11238 get_archive_member_name_at (struct archive_info *  arch,
11239                             unsigned long          offset,
11240                             struct archive_info *  nested_arch);
11241
11242 /* Get the name of an archive member from the current archive header.
11243    For simple names, this will modify the ar_name field of the current
11244    archive header.  For long names, it will return a pointer to the
11245    longnames table.  For nested archives, it will open the nested archive
11246    and get the name recursively.  NESTED_ARCH is a single-entry cache so
11247    we don't keep rereading the same information from a nested archive.  */
11248
11249 static char *
11250 get_archive_member_name (struct archive_info *  arch,
11251                          struct archive_info *  nested_arch)
11252 {
11253   unsigned long j, k;
11254
11255   if (arch->arhdr.ar_name[0] == '/')
11256     {
11257       /* We have a long name.  */
11258       char * endp;
11259       char * member_file_name;
11260       char * member_name;
11261
11262       arch->nested_member_origin = 0;
11263       k = j = strtoul (arch->arhdr.ar_name + 1, &endp, 10);
11264       if (arch->is_thin_archive && endp != NULL && * endp == ':')
11265         arch->nested_member_origin = strtoul (endp + 1, NULL, 10);
11266
11267       while ((j < arch->longnames_size)
11268              && (arch->longnames[j] != '\n')
11269              && (arch->longnames[j] != '\0'))
11270         j++;
11271       if (arch->longnames[j-1] == '/')
11272         j--;
11273       arch->longnames[j] = '\0';
11274
11275       if (!arch->is_thin_archive || arch->nested_member_origin == 0)
11276         return arch->longnames + k;
11277
11278       /* This is a proxy for a member of a nested archive.
11279          Find the name of the member in that archive.  */
11280       member_file_name = adjust_relative_path (arch->file_name, arch->longnames + k, j - k);
11281       if (member_file_name != NULL
11282           && setup_nested_archive (nested_arch, member_file_name) == 0
11283           && (member_name = get_archive_member_name_at (nested_arch, arch->nested_member_origin, NULL)) != NULL)
11284         {
11285           free (member_file_name);
11286           return member_name;
11287         }
11288       free (member_file_name);
11289
11290       /* Last resort: just return the name of the nested archive.  */
11291       return arch->longnames + k;
11292     }
11293
11294   /* We have a normal (short) name.  */
11295   j = 0;
11296   while ((arch->arhdr.ar_name[j] != '/') && (j < 16))
11297     j++;
11298   arch->arhdr.ar_name[j] = '\0';
11299   return arch->arhdr.ar_name;
11300 }
11301
11302 /* Get the name of an archive member at a given OFFSET within an archive ARCH.  */
11303
11304 static char *
11305 get_archive_member_name_at (struct archive_info * arch,
11306                             unsigned long         offset,
11307                             struct archive_info * nested_arch)
11308 {
11309   size_t got;
11310
11311   if (fseek (arch->file, offset, SEEK_SET) != 0)
11312     {
11313       error (_("%s: failed to seek to next file name\n"), arch->file_name);
11314       return NULL;
11315     }
11316   got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file);
11317   if (got != sizeof arch->arhdr)
11318     {
11319       error (_("%s: failed to read archive header\n"), arch->file_name);
11320       return NULL;
11321     }
11322   if (memcmp (arch->arhdr.ar_fmag, ARFMAG, 2) != 0)
11323     {
11324       error (_("%s: did not find a valid archive header\n"), arch->file_name);
11325       return NULL;
11326     }
11327
11328   return get_archive_member_name (arch, nested_arch);
11329 }
11330
11331 /* Construct a string showing the name of the archive member, qualified
11332    with the name of the containing archive file.  For thin archives, we
11333    use square brackets to denote the indirection.  For nested archives,
11334    we show the qualified name of the external member inside the square
11335    brackets (e.g., "thin.a[normal.a(foo.o)]").  */
11336
11337 static char *
11338 make_qualified_name (struct archive_info * arch,
11339                      struct archive_info * nested_arch,
11340                      char * member_name)
11341 {
11342   size_t len;
11343   char * name;
11344
11345   len = strlen (arch->file_name) + strlen (member_name) + 3;
11346   if (arch->is_thin_archive && arch->nested_member_origin != 0)
11347     len += strlen (nested_arch->file_name) + 2;
11348
11349   name = (char *) malloc (len);
11350   if (name == NULL)
11351     {
11352       error (_("Out of memory\n"));
11353       return NULL;
11354     }
11355
11356   if (arch->is_thin_archive && arch->nested_member_origin != 0)
11357     snprintf (name, len, "%s[%s(%s)]", arch->file_name, nested_arch->file_name, member_name);
11358   else if (arch->is_thin_archive)
11359     snprintf (name, len, "%s[%s]", arch->file_name, member_name);
11360   else
11361     snprintf (name, len, "%s(%s)", arch->file_name, member_name);
11362
11363   return name;
11364 }
11365
11366 /* Process an ELF archive.
11367    On entry the file is positioned just after the ARMAG string.  */
11368
11369 static int
11370 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
11371 {
11372   struct archive_info arch;
11373   struct archive_info nested_arch;
11374   size_t got;
11375   size_t file_name_size;
11376   int ret;
11377
11378   show_name = 1;
11379
11380   /* The ARCH structure is used to hold information about this archive.  */
11381   arch.file_name = NULL;
11382   arch.file = NULL;
11383   arch.index_array = NULL;
11384   arch.sym_table = NULL;
11385   arch.longnames = NULL;
11386
11387   /* The NESTED_ARCH structure is used as a single-item cache of information
11388      about a nested archive (when members of a thin archive reside within
11389      another regular archive file).  */
11390   nested_arch.file_name = NULL;
11391   nested_arch.file = NULL;
11392   nested_arch.index_array = NULL;
11393   nested_arch.sym_table = NULL;
11394   nested_arch.longnames = NULL;
11395
11396   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
11397     {
11398       ret = 1;
11399       goto out;
11400     }
11401
11402   if (do_archive_index)
11403     {
11404       if (arch.sym_table == NULL)
11405         error (_("%s: unable to dump the index as none was found\n"), file_name);
11406       else
11407         {
11408           unsigned int i, l;
11409           unsigned long current_pos;
11410
11411           printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
11412                   file_name, arch.index_num, arch.sym_size);
11413           current_pos = ftell (file);
11414
11415           for (i = l = 0; i < arch.index_num; i++)
11416             {
11417               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
11418                 {
11419                   char * member_name;
11420
11421                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
11422
11423                   if (member_name != NULL)
11424                     {
11425                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
11426
11427                       if (qualified_name != NULL)
11428                         {
11429                           printf (_("Binary %s contains:\n"), qualified_name);
11430                           free (qualified_name);
11431                         }
11432                     }
11433                 }
11434
11435               if (l >= arch.sym_size)
11436                 {
11437                   error (_("%s: end of the symbol table reached before the end of the index\n"),
11438                          file_name);
11439                   break;
11440                 }
11441               printf ("\t%s\n", arch.sym_table + l);
11442               l += strlen (arch.sym_table + l) + 1;
11443             }
11444
11445           if (l & 01)
11446             ++l;
11447           if (l < arch.sym_size)
11448             error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
11449                    file_name);
11450
11451           if (fseek (file, current_pos, SEEK_SET) != 0)
11452             {
11453               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
11454               ret = 1;
11455               goto out;
11456             }
11457         }
11458
11459       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
11460           && !do_segments && !do_header && !do_dump && !do_version
11461           && !do_histogram && !do_debugging && !do_arch && !do_notes
11462           && !do_section_groups)
11463         {
11464           ret = 0; /* Archive index only.  */
11465           goto out;
11466         }
11467     }
11468
11469   file_name_size = strlen (file_name);
11470   ret = 0;
11471
11472   while (1)
11473     {
11474       char * name;
11475       size_t namelen;
11476       char * qualified_name;
11477
11478       /* Read the next archive header.  */
11479       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
11480         {
11481           error (_("%s: failed to seek to next archive header\n"), file_name);
11482           return 1;
11483         }
11484       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
11485       if (got != sizeof arch.arhdr)
11486         {
11487           if (got == 0)
11488             break;
11489           error (_("%s: failed to read archive header\n"), file_name);
11490           ret = 1;
11491           break;
11492         }
11493       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
11494         {
11495           error (_("%s: did not find a valid archive header\n"), arch.file_name);
11496           ret = 1;
11497           break;
11498         }
11499
11500       arch.next_arhdr_offset += sizeof arch.arhdr;
11501
11502       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
11503       if (archive_file_size & 01)
11504         ++archive_file_size;
11505
11506       name = get_archive_member_name (&arch, &nested_arch);
11507       if (name == NULL)
11508         {
11509           error (_("%s: bad archive file name\n"), file_name);
11510           ret = 1;
11511           break;
11512         }
11513       namelen = strlen (name);
11514
11515       qualified_name = make_qualified_name (&arch, &nested_arch, name);
11516       if (qualified_name == NULL)
11517         {
11518           error (_("%s: bad archive file name\n"), file_name);
11519           ret = 1;
11520           break;
11521         }
11522
11523       if (is_thin_archive && arch.nested_member_origin == 0)
11524         {
11525           /* This is a proxy for an external member of a thin archive.  */
11526           FILE * member_file;
11527           char * member_file_name = adjust_relative_path (file_name, name, namelen);
11528           if (member_file_name == NULL)
11529             {
11530               ret = 1;
11531               break;
11532             }
11533
11534           member_file = fopen (member_file_name, "rb");
11535           if (member_file == NULL)
11536             {
11537               error (_("Input file '%s' is not readable.\n"), member_file_name);
11538               free (member_file_name);
11539               ret = 1;
11540               break;
11541             }
11542
11543           archive_file_offset = arch.nested_member_origin;
11544
11545           ret |= process_object (qualified_name, member_file);
11546
11547           fclose (member_file);
11548           free (member_file_name);
11549         }
11550       else if (is_thin_archive)
11551         {
11552           /* This is a proxy for a member of a nested archive.  */
11553           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
11554
11555           /* The nested archive file will have been opened and setup by
11556              get_archive_member_name.  */
11557           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
11558             {
11559               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
11560               ret = 1;
11561               break;
11562             }
11563
11564           ret |= process_object (qualified_name, nested_arch.file);
11565         }
11566       else
11567         {
11568           archive_file_offset = arch.next_arhdr_offset;
11569           arch.next_arhdr_offset += archive_file_size;
11570
11571           ret |= process_object (qualified_name, file);
11572         }
11573
11574       free (qualified_name);
11575     }
11576
11577  out:
11578   if (nested_arch.file != NULL)
11579     fclose (nested_arch.file);
11580   release_archive (&nested_arch);
11581   release_archive (&arch);
11582
11583   return ret;
11584 }
11585
11586 static int
11587 process_file (char * file_name)
11588 {
11589   FILE * file;
11590   struct stat statbuf;
11591   char armag[SARMAG];
11592   int ret;
11593
11594   if (stat (file_name, &statbuf) < 0)
11595     {
11596       if (errno == ENOENT)
11597         error (_("'%s': No such file\n"), file_name);
11598       else
11599         error (_("Could not locate '%s'.  System error message: %s\n"),
11600                file_name, strerror (errno));
11601       return 1;
11602     }
11603
11604   if (! S_ISREG (statbuf.st_mode))
11605     {
11606       error (_("'%s' is not an ordinary file\n"), file_name);
11607       return 1;
11608     }
11609
11610   file = fopen (file_name, "rb");
11611   if (file == NULL)
11612     {
11613       error (_("Input file '%s' is not readable.\n"), file_name);
11614       return 1;
11615     }
11616
11617   if (fread (armag, SARMAG, 1, file) != 1)
11618     {
11619       error (_("%s: Failed to read file's magic number\n"), file_name);
11620       fclose (file);
11621       return 1;
11622     }
11623
11624   if (memcmp (armag, ARMAG, SARMAG) == 0)
11625     ret = process_archive (file_name, file, FALSE);
11626   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
11627     ret = process_archive (file_name, file, TRUE);
11628   else
11629     {
11630       if (do_archive_index)
11631         error (_("File %s is not an archive so its index cannot be displayed.\n"),
11632                file_name);
11633
11634       rewind (file);
11635       archive_file_size = archive_file_offset = 0;
11636       ret = process_object (file_name, file);
11637     }
11638
11639   fclose (file);
11640
11641   return ret;
11642 }
11643
11644 #ifdef SUPPORT_DISASSEMBLY
11645 /* Needed by the i386 disassembler.  For extra credit, someone could
11646    fix this so that we insert symbolic addresses here, esp for GOT/PLT
11647    symbols.  */
11648
11649 void
11650 print_address (unsigned int addr, FILE * outfile)
11651 {
11652   fprintf (outfile,"0x%8.8x", addr);
11653 }
11654
11655 /* Needed by the i386 disassembler.  */
11656 void
11657 db_task_printsym (unsigned int addr)
11658 {
11659   print_address (addr, stderr);
11660 }
11661 #endif
11662
11663 int
11664 main (int argc, char ** argv)
11665 {
11666   int err;
11667
11668 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11669   setlocale (LC_MESSAGES, "");
11670 #endif
11671 #if defined (HAVE_SETLOCALE)
11672   setlocale (LC_CTYPE, "");
11673 #endif
11674   bindtextdomain (PACKAGE, LOCALEDIR);
11675   textdomain (PACKAGE);
11676
11677   expandargv (&argc, &argv);
11678
11679   parse_args (argc, argv);
11680
11681   if (num_dump_sects > 0)
11682     {
11683       /* Make a copy of the dump_sects array.  */
11684       cmdline_dump_sects = (dump_type *)
11685           malloc (num_dump_sects * sizeof (* dump_sects));
11686       if (cmdline_dump_sects == NULL)
11687         error (_("Out of memory allocating dump request table.\n"));
11688       else
11689         {
11690           memcpy (cmdline_dump_sects, dump_sects,
11691                   num_dump_sects * sizeof (* dump_sects));
11692           num_cmdline_dump_sects = num_dump_sects;
11693         }
11694     }
11695
11696   if (optind < (argc - 1))
11697     show_name = 1;
11698
11699   err = 0;
11700   while (optind < argc)
11701     err |= process_file (argv[optind++]);
11702
11703   if (dump_sects != NULL)
11704     free (dump_sects);
11705   if (cmdline_dump_sects != NULL)
11706     free (cmdline_dump_sects);
11707
11708   return err;
11709 }