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