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