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