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