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