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 != SHN_UNDEF
3209                && elf_header.e_shstrndx >= elf_header.e_shnum)
3210         printf (" <corrupt: out of range>");
3211       putc ('\n', stdout);
3212     }
3213
3214   if (section_headers != NULL)
3215     {
3216       if (elf_header.e_shnum == SHN_UNDEF)
3217         elf_header.e_shnum = section_headers[0].sh_size;
3218       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3219         elf_header.e_shstrndx = section_headers[0].sh_link;
3220       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3221         elf_header.e_shstrndx = SHN_UNDEF;
3222       free (section_headers);
3223       section_headers = NULL;
3224     }
3225
3226   return 1;
3227 }
3228
3229
3230 static int
3231 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * program_headers)
3232 {
3233   Elf32_External_Phdr * phdrs;
3234   Elf32_External_Phdr * external;
3235   Elf_Internal_Phdr *   internal;
3236   unsigned int i;
3237
3238   phdrs = get_data (NULL, file, elf_header.e_phoff,
3239                     elf_header.e_phentsize, elf_header.e_phnum,
3240                     _("program headers"));
3241   if (!phdrs)
3242     return 0;
3243
3244   for (i = 0, internal = program_headers, external = phdrs;
3245        i < elf_header.e_phnum;
3246        i++, internal++, external++)
3247     {
3248       internal->p_type   = BYTE_GET (external->p_type);
3249       internal->p_offset = BYTE_GET (external->p_offset);
3250       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
3251       internal->p_paddr  = BYTE_GET (external->p_paddr);
3252       internal->p_filesz = BYTE_GET (external->p_filesz);
3253       internal->p_memsz  = BYTE_GET (external->p_memsz);
3254       internal->p_flags  = BYTE_GET (external->p_flags);
3255       internal->p_align  = BYTE_GET (external->p_align);
3256     }
3257
3258   free (phdrs);
3259
3260   return 1;
3261 }
3262
3263 static int
3264 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * program_headers)
3265 {
3266   Elf64_External_Phdr * phdrs;
3267   Elf64_External_Phdr * external;
3268   Elf_Internal_Phdr *   internal;
3269   unsigned int i;
3270
3271   phdrs = get_data (NULL, file, elf_header.e_phoff,
3272                     elf_header.e_phentsize, elf_header.e_phnum,
3273                     _("program headers"));
3274   if (!phdrs)
3275     return 0;
3276
3277   for (i = 0, internal = program_headers, external = phdrs;
3278        i < elf_header.e_phnum;
3279        i++, internal++, external++)
3280     {
3281       internal->p_type   = BYTE_GET (external->p_type);
3282       internal->p_flags  = BYTE_GET (external->p_flags);
3283       internal->p_offset = BYTE_GET (external->p_offset);
3284       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
3285       internal->p_paddr  = BYTE_GET (external->p_paddr);
3286       internal->p_filesz = BYTE_GET (external->p_filesz);
3287       internal->p_memsz  = BYTE_GET (external->p_memsz);
3288       internal->p_align  = BYTE_GET (external->p_align);
3289     }
3290
3291   free (phdrs);
3292
3293   return 1;
3294 }
3295
3296 /* Returns 1 if the program headers were read into `program_headers'.  */
3297
3298 static int
3299 get_program_headers (FILE * file)
3300 {
3301   Elf_Internal_Phdr * phdrs;
3302
3303   /* Check cache of prior read.  */
3304   if (program_headers != NULL)
3305     return 1;
3306
3307   phdrs = cmalloc (elf_header.e_phnum, sizeof (Elf_Internal_Phdr));
3308
3309   if (phdrs == NULL)
3310     {
3311       error (_("Out of memory\n"));
3312       return 0;
3313     }
3314
3315   if (is_32bit_elf
3316       ? get_32bit_program_headers (file, phdrs)
3317       : get_64bit_program_headers (file, phdrs))
3318     {
3319       program_headers = phdrs;
3320       return 1;
3321     }
3322
3323   free (phdrs);
3324   return 0;
3325 }
3326
3327 /* Returns 1 if the program headers were loaded.  */
3328
3329 static int
3330 process_program_headers (FILE * file)
3331 {
3332   Elf_Internal_Phdr * segment;
3333   unsigned int i;
3334
3335   if (elf_header.e_phnum == 0)
3336     {
3337       if (do_segments)
3338         printf (_("\nThere are no program headers in this file.\n"));
3339       return 0;
3340     }
3341
3342   if (do_segments && !do_header)
3343     {
3344       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3345       printf (_("Entry point "));
3346       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3347       printf (_("\nThere are %d program headers, starting at offset "),
3348               elf_header.e_phnum);
3349       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3350       printf ("\n");
3351     }
3352
3353   if (! get_program_headers (file))
3354       return 0;
3355
3356   if (do_segments)
3357     {
3358       if (elf_header.e_phnum > 1)
3359         printf (_("\nProgram Headers:\n"));
3360       else
3361         printf (_("\nProgram Headers:\n"));
3362
3363       if (is_32bit_elf)
3364         printf
3365           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
3366       else if (do_wide)
3367         printf
3368           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
3369       else
3370         {
3371           printf
3372             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
3373           printf
3374             (_("                 FileSiz            MemSiz              Flags  Align\n"));
3375         }
3376     }
3377
3378   dynamic_addr = 0;
3379   dynamic_size = 0;
3380
3381   for (i = 0, segment = program_headers;
3382        i < elf_header.e_phnum;
3383        i++, segment++)
3384     {
3385       if (do_segments)
3386         {
3387           printf ("  %-14.14s ", get_segment_type (segment->p_type));
3388
3389           if (is_32bit_elf)
3390             {
3391               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3392               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3393               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3394               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3395               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3396               printf ("%c%c%c ",
3397                       (segment->p_flags & PF_R ? 'R' : ' '),
3398                       (segment->p_flags & PF_W ? 'W' : ' '),
3399                       (segment->p_flags & PF_X ? 'E' : ' '));
3400               printf ("%#lx", (unsigned long) segment->p_align);
3401             }
3402           else if (do_wide)
3403             {
3404               if ((unsigned long) segment->p_offset == segment->p_offset)
3405                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3406               else
3407                 {
3408                   print_vma (segment->p_offset, FULL_HEX);
3409                   putchar (' ');
3410                 }
3411
3412               print_vma (segment->p_vaddr, FULL_HEX);
3413               putchar (' ');
3414               print_vma (segment->p_paddr, FULL_HEX);
3415               putchar (' ');
3416
3417               if ((unsigned long) segment->p_filesz == segment->p_filesz)
3418                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3419               else
3420                 {
3421                   print_vma (segment->p_filesz, FULL_HEX);
3422                   putchar (' ');
3423                 }
3424
3425               if ((unsigned long) segment->p_memsz == segment->p_memsz)
3426                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3427               else
3428                 {
3429                   print_vma (segment->p_offset, FULL_HEX);
3430                 }
3431
3432               printf (" %c%c%c ",
3433                       (segment->p_flags & PF_R ? 'R' : ' '),
3434                       (segment->p_flags & PF_W ? 'W' : ' '),
3435                       (segment->p_flags & PF_X ? 'E' : ' '));
3436
3437               if ((unsigned long) segment->p_align == segment->p_align)
3438                 printf ("%#lx", (unsigned long) segment->p_align);
3439               else
3440                 {
3441                   print_vma (segment->p_align, PREFIX_HEX);
3442                 }
3443             }
3444           else
3445             {
3446               print_vma (segment->p_offset, FULL_HEX);
3447               putchar (' ');
3448               print_vma (segment->p_vaddr, FULL_HEX);
3449               putchar (' ');
3450               print_vma (segment->p_paddr, FULL_HEX);
3451               printf ("\n                 ");
3452               print_vma (segment->p_filesz, FULL_HEX);
3453               putchar (' ');
3454               print_vma (segment->p_memsz, FULL_HEX);
3455               printf ("  %c%c%c    ",
3456                       (segment->p_flags & PF_R ? 'R' : ' '),
3457                       (segment->p_flags & PF_W ? 'W' : ' '),
3458                       (segment->p_flags & PF_X ? 'E' : ' '));
3459               print_vma (segment->p_align, HEX);
3460             }
3461         }
3462
3463       switch (segment->p_type)
3464         {
3465         case PT_DYNAMIC:
3466           if (dynamic_addr)
3467             error (_("more than one dynamic segment\n"));
3468
3469           /* By default, assume that the .dynamic section is the first
3470              section in the DYNAMIC segment.  */
3471           dynamic_addr = segment->p_offset;
3472           dynamic_size = segment->p_filesz;
3473
3474           /* Try to locate the .dynamic section. If there is
3475              a section header table, we can easily locate it.  */
3476           if (section_headers != NULL)
3477             {
3478               Elf_Internal_Shdr * sec;
3479
3480               sec = find_section (".dynamic");
3481               if (sec == NULL || sec->sh_size == 0)
3482                 {
3483                   error (_("no .dynamic section in the dynamic segment\n"));
3484                   break;
3485                 }
3486
3487               if (sec->sh_type == SHT_NOBITS)
3488                 {
3489                   dynamic_size = 0;
3490                   break;
3491                 }
3492
3493               dynamic_addr = sec->sh_offset;
3494               dynamic_size = sec->sh_size;
3495
3496               if (dynamic_addr < segment->p_offset
3497                   || dynamic_addr > segment->p_offset + segment->p_filesz)
3498                 warn (_("the .dynamic section is not contained"
3499                         " within the dynamic segment\n"));
3500               else if (dynamic_addr > segment->p_offset)
3501                 warn (_("the .dynamic section is not the first section"
3502                         " in the dynamic segment.\n"));
3503             }
3504           break;
3505
3506         case PT_INTERP:
3507           if (fseek (file, archive_file_offset + (long) segment->p_offset,
3508                      SEEK_SET))
3509             error (_("Unable to find program interpreter name\n"));
3510           else
3511             {
3512               char fmt [32];
3513               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3514
3515               if (ret >= (int) sizeof (fmt) || ret < 0)
3516                 error (_("Internal error: failed to create format string to display program interpreter\n"));
3517
3518               program_interpreter[0] = 0;
3519               if (fscanf (file, fmt, program_interpreter) <= 0)
3520                 error (_("Unable to read program interpreter name\n"));
3521
3522               if (do_segments)
3523                 printf (_("\n      [Requesting program interpreter: %s]"),
3524                     program_interpreter);
3525             }
3526           break;
3527         }
3528
3529       if (do_segments)
3530         putc ('\n', stdout);
3531     }
3532
3533   if (do_segments && section_headers != NULL && string_table != NULL)
3534     {
3535       printf (_("\n Section to Segment mapping:\n"));
3536       printf (_("  Segment Sections...\n"));
3537
3538       for (i = 0; i < elf_header.e_phnum; i++)
3539         {
3540           unsigned int j;
3541           Elf_Internal_Shdr * section;
3542
3543           segment = program_headers + i;
3544           section = section_headers + 1;
3545
3546           printf ("   %2.2d     ", i);
3547
3548           for (j = 1; j < elf_header.e_shnum; j++, section++)
3549             {
3550               if (ELF_IS_SECTION_IN_SEGMENT_MEMORY (section, segment))
3551                 printf ("%s ", SECTION_NAME (section));
3552             }
3553
3554           putc ('\n',stdout);
3555         }
3556     }
3557
3558   return 1;
3559 }
3560
3561
3562 /* Find the file offset corresponding to VMA by using the program headers.  */
3563
3564 static long
3565 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
3566 {
3567   Elf_Internal_Phdr * seg;
3568
3569   if (! get_program_headers (file))
3570     {
3571       warn (_("Cannot interpret virtual addresses without program headers.\n"));
3572       return (long) vma;
3573     }
3574
3575   for (seg = program_headers;
3576        seg < program_headers + elf_header.e_phnum;
3577        ++seg)
3578     {
3579       if (seg->p_type != PT_LOAD)
3580         continue;
3581
3582       if (vma >= (seg->p_vaddr & -seg->p_align)
3583           && vma + size <= seg->p_vaddr + seg->p_filesz)
3584         return vma - seg->p_vaddr + seg->p_offset;
3585     }
3586
3587   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3588         (unsigned long) vma);
3589   return (long) vma;
3590 }
3591
3592
3593 static int
3594 get_32bit_section_headers (FILE * file, unsigned int num)
3595 {
3596   Elf32_External_Shdr * shdrs;
3597   Elf_Internal_Shdr *   internal;
3598   unsigned int i;
3599
3600   shdrs = get_data (NULL, file, elf_header.e_shoff,
3601                     elf_header.e_shentsize, num, _("section headers"));
3602   if (!shdrs)
3603     return 0;
3604
3605   section_headers = cmalloc (num, sizeof (Elf_Internal_Shdr));
3606
3607   if (section_headers == NULL)
3608     {
3609       error (_("Out of memory\n"));
3610       return 0;
3611     }
3612
3613   for (i = 0, internal = section_headers;
3614        i < num;
3615        i++, internal++)
3616     {
3617       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
3618       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
3619       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
3620       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
3621       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
3622       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
3623       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
3624       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
3625       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3626       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
3627     }
3628
3629   free (shdrs);
3630
3631   return 1;
3632 }
3633
3634 static int
3635 get_64bit_section_headers (FILE * file, unsigned int num)
3636 {
3637   Elf64_External_Shdr * shdrs;
3638   Elf_Internal_Shdr *   internal;
3639   unsigned int i;
3640
3641   shdrs = get_data (NULL, file, elf_header.e_shoff,
3642                     elf_header.e_shentsize, num, _("section headers"));
3643   if (!shdrs)
3644     return 0;
3645
3646   section_headers = cmalloc (num, sizeof (Elf_Internal_Shdr));
3647
3648   if (section_headers == NULL)
3649     {
3650       error (_("Out of memory\n"));
3651       return 0;
3652     }
3653
3654   for (i = 0, internal = section_headers;
3655        i < num;
3656        i++, internal++)
3657     {
3658       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
3659       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
3660       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
3661       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
3662       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
3663       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
3664       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
3665       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
3666       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
3667       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3668     }
3669
3670   free (shdrs);
3671
3672   return 1;
3673 }
3674
3675 static Elf_Internal_Sym *
3676 get_32bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
3677 {
3678   unsigned long number;
3679   Elf32_External_Sym * esyms;
3680   Elf_External_Sym_Shndx * shndx;
3681   Elf_Internal_Sym * isyms;
3682   Elf_Internal_Sym * psym;
3683   unsigned int j;
3684
3685   esyms = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
3686                     _("symbols"));
3687   if (!esyms)
3688     return NULL;
3689
3690   shndx = NULL;
3691   if (symtab_shndx_hdr != NULL
3692       && (symtab_shndx_hdr->sh_link
3693           == (unsigned long) (section - section_headers)))
3694     {
3695       shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3696                         1, symtab_shndx_hdr->sh_size, _("symtab shndx"));
3697       if (!shndx)
3698         {
3699           free (esyms);
3700           return NULL;
3701         }
3702     }
3703
3704   number = section->sh_size / section->sh_entsize;
3705   isyms = cmalloc (number, sizeof (Elf_Internal_Sym));
3706
3707   if (isyms == NULL)
3708     {
3709       error (_("Out of memory\n"));
3710       if (shndx)
3711         free (shndx);
3712       free (esyms);
3713       return NULL;
3714     }
3715
3716   for (j = 0, psym = isyms;
3717        j < number;
3718        j++, psym++)
3719     {
3720       psym->st_name  = BYTE_GET (esyms[j].st_name);
3721       psym->st_value = BYTE_GET (esyms[j].st_value);
3722       psym->st_size  = BYTE_GET (esyms[j].st_size);
3723       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3724       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
3725         psym->st_shndx
3726           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3727       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
3728         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
3729       psym->st_info  = BYTE_GET (esyms[j].st_info);
3730       psym->st_other = BYTE_GET (esyms[j].st_other);
3731     }
3732
3733   if (shndx)
3734     free (shndx);
3735   free (esyms);
3736
3737   return isyms;
3738 }
3739
3740 static Elf_Internal_Sym *
3741 get_64bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
3742 {
3743   unsigned long number;
3744   Elf64_External_Sym * esyms;
3745   Elf_External_Sym_Shndx * shndx;
3746   Elf_Internal_Sym * isyms;
3747   Elf_Internal_Sym * psym;
3748   unsigned int j;
3749
3750   esyms = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
3751                     _("symbols"));
3752   if (!esyms)
3753     return NULL;
3754
3755   shndx = NULL;
3756   if (symtab_shndx_hdr != NULL
3757       && (symtab_shndx_hdr->sh_link
3758           == (unsigned long) (section - section_headers)))
3759     {
3760       shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3761                         1, symtab_shndx_hdr->sh_size, _("symtab shndx"));
3762       if (!shndx)
3763         {
3764           free (esyms);
3765           return NULL;
3766         }
3767     }
3768
3769   number = section->sh_size / section->sh_entsize;
3770   isyms = cmalloc (number, sizeof (Elf_Internal_Sym));
3771
3772   if (isyms == NULL)
3773     {
3774       error (_("Out of memory\n"));
3775       if (shndx)
3776         free (shndx);
3777       free (esyms);
3778       return NULL;
3779     }
3780
3781   for (j = 0, psym = isyms;
3782        j < number;
3783        j++, psym++)
3784     {
3785       psym->st_name  = BYTE_GET (esyms[j].st_name);
3786       psym->st_info  = BYTE_GET (esyms[j].st_info);
3787       psym->st_other = BYTE_GET (esyms[j].st_other);
3788       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3789       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
3790         psym->st_shndx
3791           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3792       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
3793         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
3794       psym->st_value = BYTE_GET (esyms[j].st_value);
3795       psym->st_size  = BYTE_GET (esyms[j].st_size);
3796     }
3797
3798   if (shndx)
3799     free (shndx);
3800   free (esyms);
3801
3802   return isyms;
3803 }
3804
3805 static const char *
3806 get_elf_section_flags (bfd_vma sh_flags)
3807 {
3808   static char buff[1024];
3809   char * p = buff;
3810   int field_size = is_32bit_elf ? 8 : 16;
3811   int index, size = sizeof (buff) - (field_size + 4 + 1);
3812   bfd_vma os_flags = 0;
3813   bfd_vma proc_flags = 0;
3814   bfd_vma unknown_flags = 0;
3815   static const struct
3816     {
3817       const char * str;
3818       int len;
3819     }
3820   flags [] =
3821     {
3822         { "WRITE", 5 },
3823         { "ALLOC", 5 },
3824         { "EXEC", 4 },
3825         { "MERGE", 5 },
3826         { "STRINGS", 7 },
3827         { "INFO LINK", 9 },
3828         { "LINK ORDER", 10 },
3829         { "OS NONCONF", 10 },
3830         { "GROUP", 5 },
3831         { "TLS", 3 },
3832         /* IA-64 specific.  */
3833         { "SHORT", 5 },
3834         { "NORECOV", 7 },
3835         /* IA-64 OpenVMS specific.  */
3836         { "VMS_GLOBAL", 10 },
3837         { "VMS_OVERLAID", 12 },
3838         { "VMS_SHARED", 10 },
3839         { "VMS_VECTOR", 10 },
3840         { "VMS_ALLOC_64BIT", 15 },
3841         { "VMS_PROTECTED", 13}
3842     };
3843
3844   if (do_section_details)
3845     {
3846       sprintf (buff, "[%*.*lx]: ",
3847                field_size, field_size, (unsigned long) sh_flags);
3848       p += field_size + 4;
3849     }
3850
3851   while (sh_flags)
3852     {
3853       bfd_vma flag;
3854
3855       flag = sh_flags & - sh_flags;
3856       sh_flags &= ~ flag;
3857
3858       if (do_section_details)
3859         {
3860           switch (flag)
3861             {
3862             case SHF_WRITE:             index = 0; break;
3863             case SHF_ALLOC:             index = 1; break;
3864             case SHF_EXECINSTR:         index = 2; break;
3865             case SHF_MERGE:             index = 3; break;
3866             case SHF_STRINGS:           index = 4; break;
3867             case SHF_INFO_LINK:         index = 5; break;
3868             case SHF_LINK_ORDER:        index = 6; break;
3869             case SHF_OS_NONCONFORMING:  index = 7; break;
3870             case SHF_GROUP:             index = 8; break;
3871             case SHF_TLS:               index = 9; break;
3872
3873             default:
3874               index = -1;
3875               if (elf_header.e_machine == EM_IA_64)
3876                 {
3877                   if (flag == SHF_IA_64_SHORT)
3878                     index = 10;
3879                   else if (flag == SHF_IA_64_NORECOV)
3880                     index = 11;
3881 #ifdef BFD64
3882                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3883                     switch (flag)
3884                       {
3885                       case SHF_IA_64_VMS_GLOBAL:      index = 12; break;
3886                       case SHF_IA_64_VMS_OVERLAID:    index = 13; break;
3887                       case SHF_IA_64_VMS_SHARED:      index = 14; break;
3888                       case SHF_IA_64_VMS_VECTOR:      index = 15; break;
3889                       case SHF_IA_64_VMS_ALLOC_64BIT: index = 16; break;
3890                       case SHF_IA_64_VMS_PROTECTED:   index = 17; break;
3891                       default:                        break;
3892                       }
3893 #endif
3894                 }
3895               break;
3896             }
3897
3898           if (index != -1)
3899             {
3900               if (p != buff + field_size + 4)
3901                 {
3902                   if (size < (10 + 2))
3903                     abort ();
3904                   size -= 2;
3905                   *p++ = ',';
3906                   *p++ = ' ';
3907                 }
3908
3909               size -= flags [index].len;
3910               p = stpcpy (p, flags [index].str);
3911             }
3912           else if (flag & SHF_MASKOS)
3913             os_flags |= flag;
3914           else if (flag & SHF_MASKPROC)
3915             proc_flags |= flag;
3916           else
3917             unknown_flags |= flag;
3918         }
3919       else
3920         {
3921           switch (flag)
3922             {
3923             case SHF_WRITE:             *p = 'W'; break;
3924             case SHF_ALLOC:             *p = 'A'; break;
3925             case SHF_EXECINSTR:         *p = 'X'; break;
3926             case SHF_MERGE:             *p = 'M'; break;
3927             case SHF_STRINGS:           *p = 'S'; break;
3928             case SHF_INFO_LINK:         *p = 'I'; break;
3929             case SHF_LINK_ORDER:        *p = 'L'; break;
3930             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
3931             case SHF_GROUP:             *p = 'G'; break;
3932             case SHF_TLS:               *p = 'T'; break;
3933
3934             default:
3935               if (elf_header.e_machine == EM_X86_64
3936                   && flag == SHF_X86_64_LARGE)
3937                 *p = 'l';
3938               else if (flag & SHF_MASKOS)
3939                 {
3940                   *p = 'o';
3941                   sh_flags &= ~ SHF_MASKOS;
3942                 }
3943               else if (flag & SHF_MASKPROC)
3944                 {
3945                   *p = 'p';
3946                   sh_flags &= ~ SHF_MASKPROC;
3947                 }
3948               else
3949                 *p = 'x';
3950               break;
3951             }
3952           p++;
3953         }
3954     }
3955
3956   if (do_section_details)
3957     {
3958       if (os_flags)
3959         {
3960           size -= 5 + field_size;
3961           if (p != buff + field_size + 4)
3962             {
3963               if (size < (2 + 1))
3964                 abort ();
3965               size -= 2;
3966               *p++ = ',';
3967               *p++ = ' ';
3968             }
3969           sprintf (p, "OS (%*.*lx)", field_size, field_size,
3970                    (unsigned long) os_flags);
3971           p += 5 + field_size;
3972         }
3973       if (proc_flags)
3974         {
3975           size -= 7 + field_size;
3976           if (p != buff + field_size + 4)
3977             {
3978               if (size < (2 + 1))
3979                 abort ();
3980               size -= 2;
3981               *p++ = ',';
3982               *p++ = ' ';
3983             }
3984           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
3985                    (unsigned long) proc_flags);
3986           p += 7 + field_size;
3987         }
3988       if (unknown_flags)
3989         {
3990           size -= 10 + field_size;
3991           if (p != buff + field_size + 4)
3992             {
3993               if (size < (2 + 1))
3994                 abort ();
3995               size -= 2;
3996               *p++ = ',';
3997               *p++ = ' ';
3998             }
3999           sprintf (p, "UNKNOWN (%*.*lx)", field_size, field_size,
4000                    (unsigned long) unknown_flags);
4001           p += 10 + field_size;
4002         }
4003     }
4004
4005   *p = '\0';
4006   return buff;
4007 }
4008
4009 static int
4010 process_section_headers (FILE * file)
4011 {
4012   Elf_Internal_Shdr * section;
4013   unsigned int i;
4014
4015   section_headers = NULL;
4016
4017   if (elf_header.e_shnum == 0)
4018     {
4019       if (do_sections)
4020         printf (_("\nThere are no sections in this file.\n"));
4021
4022       return 1;
4023     }
4024
4025   if (do_sections && !do_header)
4026     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4027             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4028
4029   if (is_32bit_elf)
4030     {
4031       if (! get_32bit_section_headers (file, elf_header.e_shnum))
4032         return 0;
4033     }
4034   else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4035     return 0;
4036
4037   /* Read in the string table, so that we have names to display.  */
4038   if (elf_header.e_shstrndx != SHN_UNDEF
4039        && elf_header.e_shstrndx < elf_header.e_shnum)
4040     {
4041       section = section_headers + elf_header.e_shstrndx;
4042
4043       if (section->sh_size != 0)
4044         {
4045           string_table = get_data (NULL, file, section->sh_offset,
4046                                    1, section->sh_size, _("string table"));
4047
4048           string_table_length = string_table != NULL ? section->sh_size : 0;
4049         }
4050     }
4051
4052   /* Scan the sections for the dynamic symbol table
4053      and dynamic string table and debug sections.  */
4054   dynamic_symbols = NULL;
4055   dynamic_strings = NULL;
4056   dynamic_syminfo = NULL;
4057   symtab_shndx_hdr = NULL;
4058
4059   eh_addr_size = is_32bit_elf ? 4 : 8;
4060   switch (elf_header.e_machine)
4061     {
4062     case EM_MIPS:
4063     case EM_MIPS_RS3_LE:
4064       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4065          FDE addresses.  However, the ABI also has a semi-official ILP32
4066          variant for which the normal FDE address size rules apply.
4067
4068          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4069          section, where XX is the size of longs in bits.  Unfortunately,
4070          earlier compilers provided no way of distinguishing ILP32 objects
4071          from LP64 objects, so if there's any doubt, we should assume that
4072          the official LP64 form is being used.  */
4073       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4074           && find_section (".gcc_compiled_long32") == NULL)
4075         eh_addr_size = 8;
4076       break;
4077
4078     case EM_H8_300:
4079     case EM_H8_300H:
4080       switch (elf_header.e_flags & EF_H8_MACH)
4081         {
4082         case E_H8_MACH_H8300:
4083         case E_H8_MACH_H8300HN:
4084         case E_H8_MACH_H8300SN:
4085         case E_H8_MACH_H8300SXN:
4086           eh_addr_size = 2;
4087           break;
4088         case E_H8_MACH_H8300H:
4089         case E_H8_MACH_H8300S:
4090         case E_H8_MACH_H8300SX:
4091           eh_addr_size = 4;
4092           break;
4093         }
4094       break;
4095
4096     case EM_M32C_OLD:
4097     case EM_M32C:
4098       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4099         {
4100         case EF_M32C_CPU_M16C:
4101           eh_addr_size = 2;
4102           break;
4103         }
4104       break;
4105     }
4106
4107 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4108   do                                                                        \
4109     {                                                                       \
4110       size_t expected_entsize                                               \
4111         = is_32bit_elf ? size32 : size64;                                   \
4112       if (section->sh_entsize != expected_entsize)                          \
4113         error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4114                i, (unsigned long int) section->sh_entsize,                  \
4115                (unsigned long int) expected_entsize);                       \
4116       section->sh_entsize = expected_entsize;                               \
4117     }                                                                       \
4118   while (0)
4119 #define CHECK_ENTSIZE(section, i, type) \
4120   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
4121                         sizeof (Elf64_External_##type))
4122
4123   for (i = 0, section = section_headers;
4124        i < elf_header.e_shnum;
4125        i++, section++)
4126     {
4127       char * name = SECTION_NAME (section);
4128
4129       if (section->sh_type == SHT_DYNSYM)
4130         {
4131           if (dynamic_symbols != NULL)
4132             {
4133               error (_("File contains multiple dynamic symbol tables\n"));
4134               continue;
4135             }
4136
4137           CHECK_ENTSIZE (section, i, Sym);
4138           num_dynamic_syms = section->sh_size / section->sh_entsize;
4139           dynamic_symbols = GET_ELF_SYMBOLS (file, section);
4140         }
4141       else if (section->sh_type == SHT_STRTAB
4142                && streq (name, ".dynstr"))
4143         {
4144           if (dynamic_strings != NULL)
4145             {
4146               error (_("File contains multiple dynamic string tables\n"));
4147               continue;
4148             }
4149
4150           dynamic_strings = get_data (NULL, file, section->sh_offset,
4151                                       1, section->sh_size, _("dynamic strings"));
4152           dynamic_strings_length = section->sh_size;
4153         }
4154       else if (section->sh_type == SHT_SYMTAB_SHNDX)
4155         {
4156           if (symtab_shndx_hdr != NULL)
4157             {
4158               error (_("File contains multiple symtab shndx tables\n"));
4159               continue;
4160             }
4161           symtab_shndx_hdr = section;
4162         }
4163       else if (section->sh_type == SHT_SYMTAB)
4164         CHECK_ENTSIZE (section, i, Sym);
4165       else if (section->sh_type == SHT_GROUP)
4166         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4167       else if (section->sh_type == SHT_REL)
4168         CHECK_ENTSIZE (section, i, Rel);
4169       else if (section->sh_type == SHT_RELA)
4170         CHECK_ENTSIZE (section, i, Rela);
4171       else if ((do_debugging || do_debug_info || do_debug_abbrevs
4172                 || do_debug_lines || do_debug_pubnames
4173                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
4174                 || do_debug_str || do_debug_loc || do_debug_ranges)
4175                && (const_strneq (name, ".debug_")
4176                    || const_strneq (name, ".zdebug_")))
4177         {
4178           if (name[1] == 'z')
4179             name += sizeof (".zdebug_") - 1;
4180           else
4181             name += sizeof (".debug_") - 1;
4182
4183           if (do_debugging
4184               || (do_debug_info     && streq (name, "info"))
4185               || (do_debug_abbrevs  && streq (name, "abbrev"))
4186               || (do_debug_lines    && streq (name, "line"))
4187               || (do_debug_pubnames && streq (name, "pubnames"))
4188               || (do_debug_aranges  && streq (name, "aranges"))
4189               || (do_debug_ranges   && streq (name, "ranges"))
4190               || (do_debug_frames   && streq (name, "frame"))
4191               || (do_debug_macinfo  && streq (name, "macinfo"))
4192               || (do_debug_str      && streq (name, "str"))
4193               || (do_debug_loc      && streq (name, "loc"))
4194               )
4195             request_dump_bynumber (i, DEBUG_DUMP);
4196         }
4197       /* Linkonce section to be combined with .debug_info at link time.  */
4198       else if ((do_debugging || do_debug_info)
4199                && const_strneq (name, ".gnu.linkonce.wi."))
4200         request_dump_bynumber (i, DEBUG_DUMP);
4201       else if (do_debug_frames && streq (name, ".eh_frame"))
4202         request_dump_bynumber (i, DEBUG_DUMP);
4203     }
4204
4205   if (! do_sections)
4206     return 1;
4207
4208   if (elf_header.e_shnum > 1)
4209     printf (_("\nSection Headers:\n"));
4210   else
4211     printf (_("\nSection Header:\n"));
4212
4213   if (is_32bit_elf)
4214     {
4215       if (do_section_details)
4216         {
4217           printf (_("  [Nr] Name\n"));
4218           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
4219         }
4220       else
4221         printf
4222           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
4223     }
4224   else if (do_wide)
4225     {
4226       if (do_section_details)
4227         {
4228           printf (_("  [Nr] Name\n"));
4229           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
4230         }
4231       else
4232         printf
4233           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
4234     }
4235   else
4236     {
4237       if (do_section_details)
4238         {
4239           printf (_("  [Nr] Name\n"));
4240           printf (_("       Type              Address          Offset            Link\n"));
4241           printf (_("       Size              EntSize          Info              Align\n"));
4242         }
4243       else
4244         {
4245           printf (_("  [Nr] Name              Type             Address           Offset\n"));
4246           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
4247         }
4248     }
4249
4250   if (do_section_details)
4251     printf (_("       Flags\n"));
4252
4253   for (i = 0, section = section_headers;
4254        i < elf_header.e_shnum;
4255        i++, section++)
4256     {
4257       if (do_section_details)
4258         {
4259           printf ("  [%2u] %s\n",
4260                   i,
4261                   SECTION_NAME (section));
4262           if (is_32bit_elf || do_wide)
4263             printf ("       %-15.15s ",
4264                     get_section_type_name (section->sh_type));
4265         }
4266       else
4267         printf ((do_wide ? "  [%2u] %-17s %-15s "
4268                          : "  [%2u] %-17.17s %-15.15s "),
4269                 i,
4270                 SECTION_NAME (section),
4271                 get_section_type_name (section->sh_type));
4272
4273       if (is_32bit_elf)
4274         {
4275           print_vma (section->sh_addr, LONG_HEX);
4276
4277           printf ( " %6.6lx %6.6lx %2.2lx",
4278                    (unsigned long) section->sh_offset,
4279                    (unsigned long) section->sh_size,
4280                    (unsigned long) section->sh_entsize);
4281
4282           if (do_section_details)
4283             fputs ("  ", stdout);
4284           else
4285             printf (" %3s ", get_elf_section_flags (section->sh_flags));
4286
4287           printf ("%2u %3u %2lu\n",
4288                   section->sh_link,
4289                   section->sh_info,
4290                   (unsigned long) section->sh_addralign);
4291         }
4292       else if (do_wide)
4293         {
4294           print_vma (section->sh_addr, LONG_HEX);
4295
4296           if ((long) section->sh_offset == section->sh_offset)
4297             printf (" %6.6lx", (unsigned long) section->sh_offset);
4298           else
4299             {
4300               putchar (' ');
4301               print_vma (section->sh_offset, LONG_HEX);
4302             }
4303
4304           if ((unsigned long) section->sh_size == section->sh_size)
4305             printf (" %6.6lx", (unsigned long) section->sh_size);
4306           else
4307             {
4308               putchar (' ');
4309               print_vma (section->sh_size, LONG_HEX);
4310             }
4311
4312           if ((unsigned long) section->sh_entsize == section->sh_entsize)
4313             printf (" %2.2lx", (unsigned long) section->sh_entsize);
4314           else
4315             {
4316               putchar (' ');
4317               print_vma (section->sh_entsize, LONG_HEX);
4318             }
4319
4320           if (do_section_details)
4321             fputs ("  ", stdout);
4322           else
4323             printf (" %3s ", get_elf_section_flags (section->sh_flags));
4324
4325           printf ("%2u %3u ", section->sh_link, section->sh_info);
4326
4327           if ((unsigned long) section->sh_addralign == section->sh_addralign)
4328             printf ("%2lu\n", (unsigned long) section->sh_addralign);
4329           else
4330             {
4331               print_vma (section->sh_addralign, DEC);
4332               putchar ('\n');
4333             }
4334         }
4335       else if (do_section_details)
4336         {
4337           printf ("       %-15.15s  ",
4338                   get_section_type_name (section->sh_type));
4339           print_vma (section->sh_addr, LONG_HEX);
4340           if ((long) section->sh_offset == section->sh_offset)
4341             printf ("  %16.16lx", (unsigned long) section->sh_offset);
4342           else
4343             {
4344               printf ("  ");
4345               print_vma (section->sh_offset, LONG_HEX);
4346             }
4347           printf ("  %u\n       ", section->sh_link);
4348           print_vma (section->sh_size, LONG_HEX);
4349           putchar (' ');
4350           print_vma (section->sh_entsize, LONG_HEX);
4351
4352           printf ("  %-16u  %lu\n",
4353                   section->sh_info,
4354                   (unsigned long) section->sh_addralign);
4355         }
4356       else
4357         {
4358           putchar (' ');
4359           print_vma (section->sh_addr, LONG_HEX);
4360           if ((long) section->sh_offset == section->sh_offset)
4361             printf ("  %8.8lx", (unsigned long) section->sh_offset);
4362           else
4363             {
4364               printf ("  ");
4365               print_vma (section->sh_offset, LONG_HEX);
4366             }
4367           printf ("\n       ");
4368           print_vma (section->sh_size, LONG_HEX);
4369           printf ("  ");
4370           print_vma (section->sh_entsize, LONG_HEX);
4371
4372           printf (" %3s ", get_elf_section_flags (section->sh_flags));
4373
4374           printf ("     %2u   %3u     %lu\n",
4375                   section->sh_link,
4376                   section->sh_info,
4377                   (unsigned long) section->sh_addralign);
4378         }
4379
4380       if (do_section_details)
4381         printf ("       %s\n", get_elf_section_flags (section->sh_flags));
4382     }
4383
4384   if (!do_section_details)
4385     printf (_("Key to Flags:\n\
4386   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4387   I (info), L (link order), G (group), x (unknown)\n\
4388   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4389
4390   return 1;
4391 }
4392
4393 static const char *
4394 get_group_flags (unsigned int flags)
4395 {
4396   static char buff[32];
4397   switch (flags)
4398     {
4399     case GRP_COMDAT:
4400       return "COMDAT";
4401
4402    default:
4403       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x]"), flags);
4404       break;
4405     }
4406   return buff;
4407 }
4408
4409 static int
4410 process_section_groups (FILE * file)
4411 {
4412   Elf_Internal_Shdr * section;
4413   unsigned int i;
4414   struct group * group;
4415   Elf_Internal_Shdr * symtab_sec;
4416   Elf_Internal_Shdr * strtab_sec;
4417   Elf_Internal_Sym * symtab;
4418   char * strtab;
4419   size_t strtab_size;
4420
4421   /* Don't process section groups unless needed.  */
4422   if (!do_unwind && !do_section_groups)
4423     return 1;
4424
4425   if (elf_header.e_shnum == 0)
4426     {
4427       if (do_section_groups)
4428         printf (_("\nThere are no sections in this file.\n"));
4429
4430       return 1;
4431     }
4432
4433   if (section_headers == NULL)
4434     {
4435       error (_("Section headers are not available!\n"));
4436       abort ();
4437     }
4438
4439   section_headers_groups = calloc (elf_header.e_shnum,
4440                                    sizeof (struct group *));
4441
4442   if (section_headers_groups == NULL)
4443     {
4444       error (_("Out of memory\n"));
4445       return 0;
4446     }
4447
4448   /* Scan the sections for the group section.  */
4449   group_count = 0;
4450   for (i = 0, section = section_headers;
4451        i < elf_header.e_shnum;
4452        i++, section++)
4453     if (section->sh_type == SHT_GROUP)
4454       group_count++;
4455
4456   if (group_count == 0)
4457     {
4458       if (do_section_groups)
4459         printf (_("\nThere are no section groups in this file.\n"));
4460
4461       return 1;
4462     }
4463
4464   section_groups = calloc (group_count, sizeof (struct group));
4465
4466   if (section_groups == NULL)
4467     {
4468       error (_("Out of memory\n"));
4469       return 0;
4470     }
4471
4472   symtab_sec = NULL;
4473   strtab_sec = NULL;
4474   symtab = NULL;
4475   strtab = NULL;
4476   strtab_size = 0;
4477   for (i = 0, section = section_headers, group = section_groups;
4478        i < elf_header.e_shnum;
4479        i++, section++)
4480     {
4481       if (section->sh_type == SHT_GROUP)
4482         {
4483           char * name = SECTION_NAME (section);
4484           char * group_name;
4485           unsigned char * start;
4486           unsigned char * indices;
4487           unsigned int entry, j, size;
4488           Elf_Internal_Shdr * sec;
4489           Elf_Internal_Sym * sym;
4490
4491           /* Get the symbol table.  */
4492           if (section->sh_link >= elf_header.e_shnum
4493               || ((sec = section_headers + section->sh_link)->sh_type
4494                   != SHT_SYMTAB))
4495             {
4496               error (_("Bad sh_link in group section `%s'\n"), name);
4497               continue;
4498             }
4499
4500           if (symtab_sec != sec)
4501             {
4502               symtab_sec = sec;
4503               if (symtab)
4504                 free (symtab);
4505               symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4506             }
4507
4508           sym = symtab + section->sh_info;
4509
4510           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4511             {
4512               if (sym->st_shndx == 0
4513                   || sym->st_shndx >= elf_header.e_shnum)
4514                 {
4515                   error (_("Bad sh_info in group section `%s'\n"), name);
4516                   continue;
4517                 }
4518
4519               group_name = SECTION_NAME (section_headers + sym->st_shndx);
4520               strtab_sec = NULL;
4521               if (strtab)
4522                 free (strtab);
4523               strtab = NULL;
4524               strtab_size = 0;
4525             }
4526           else
4527             {
4528               /* Get the string table.  */
4529               if (symtab_sec->sh_link >= elf_header.e_shnum)
4530                 {
4531                   strtab_sec = NULL;
4532                   if (strtab)
4533                     free (strtab);
4534                   strtab = NULL;
4535                   strtab_size = 0;
4536                 }
4537               else if (strtab_sec
4538                        != (sec = section_headers + symtab_sec->sh_link))
4539                 {
4540                   strtab_sec = sec;
4541                   if (strtab)
4542                     free (strtab);
4543                   strtab = get_data (NULL, file, strtab_sec->sh_offset,
4544                                      1, strtab_sec->sh_size,
4545                                      _("string table"));
4546                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
4547                 }
4548               group_name = sym->st_name < strtab_size
4549                            ? strtab + sym->st_name : "<corrupt>";
4550             }
4551
4552           start = get_data (NULL, file, section->sh_offset,
4553                             1, section->sh_size, _("section data"));
4554
4555           indices = start;
4556           size = (section->sh_size / section->sh_entsize) - 1;
4557           entry = byte_get (indices, 4);
4558           indices += 4;
4559
4560           if (do_section_groups)
4561             {
4562               printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4563                       get_group_flags (entry), i, name, group_name, size);
4564
4565               printf (_("   [Index]    Name\n"));
4566             }
4567
4568           group->group_index = i;
4569
4570           for (j = 0; j < size; j++)
4571             {
4572               struct group_list * g;
4573
4574               entry = byte_get (indices, 4);
4575               indices += 4;
4576
4577               if (entry >= elf_header.e_shnum)
4578                 {
4579                   error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4580                          entry, i, elf_header.e_shnum - 1);
4581                   continue;
4582                 }
4583
4584               if (section_headers_groups [entry] != NULL)
4585                 {
4586                   if (entry)
4587                     {
4588                       error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4589                              entry, i,
4590                              section_headers_groups [entry]->group_index);
4591                       continue;
4592                     }
4593                   else
4594                     {
4595                       /* Intel C/C++ compiler may put section 0 in a
4596                          section group. We just warn it the first time
4597                          and ignore it afterwards.  */
4598                       static int warned = 0;
4599                       if (!warned)
4600                         {
4601                           error (_("section 0 in group section [%5u]\n"),
4602                                  section_headers_groups [entry]->group_index);
4603                           warned++;
4604                         }
4605                     }
4606                 }
4607
4608               section_headers_groups [entry] = group;
4609
4610               if (do_section_groups)
4611                 {
4612                   sec = section_headers + entry;
4613                   printf ("   [%5u]   %s\n", entry, SECTION_NAME (sec));
4614                 }
4615
4616               g = xmalloc (sizeof (struct group_list));
4617               g->section_index = entry;
4618               g->next = group->root;
4619               group->root = g;
4620             }
4621
4622           if (start)
4623             free (start);
4624
4625           group++;
4626         }
4627     }
4628
4629   if (symtab)
4630     free (symtab);
4631   if (strtab)
4632     free (strtab);
4633   return 1;
4634 }
4635
4636 static struct
4637 {
4638   const char * name;
4639   int reloc;
4640   int size;
4641   int rela;
4642 } dynamic_relocations [] =
4643 {
4644     { "REL", DT_REL, DT_RELSZ, FALSE },
4645     { "RELA", DT_RELA, DT_RELASZ, TRUE },
4646     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
4647 };
4648
4649 /* Process the reloc section.  */
4650
4651 static int
4652 process_relocs (FILE * file)
4653 {
4654   unsigned long rel_size;
4655   unsigned long rel_offset;
4656
4657
4658   if (!do_reloc)
4659     return 1;
4660
4661   if (do_using_dynamic)
4662     {
4663       int is_rela;
4664       const char * name;
4665       int has_dynamic_reloc;
4666       unsigned int i;
4667
4668       has_dynamic_reloc = 0;
4669
4670       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
4671         {
4672           is_rela = dynamic_relocations [i].rela;
4673           name = dynamic_relocations [i].name;
4674           rel_size = dynamic_info [dynamic_relocations [i].size];
4675           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
4676
4677           has_dynamic_reloc |= rel_size;
4678
4679           if (is_rela == UNKNOWN)
4680             {
4681               if (dynamic_relocations [i].reloc == DT_JMPREL)
4682                 switch (dynamic_info[DT_PLTREL])
4683                   {
4684                   case DT_REL:
4685                     is_rela = FALSE;
4686                     break;
4687                   case DT_RELA:
4688                     is_rela = TRUE;
4689                     break;
4690                   }
4691             }
4692
4693           if (rel_size)
4694             {
4695               printf
4696                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4697                  name, rel_offset, rel_size);
4698
4699               dump_relocations (file,
4700                                 offset_from_vma (file, rel_offset, rel_size),
4701                                 rel_size,
4702                                 dynamic_symbols, num_dynamic_syms,
4703                                 dynamic_strings, dynamic_strings_length, is_rela);
4704             }
4705         }
4706
4707       if (! has_dynamic_reloc)
4708         printf (_("\nThere are no dynamic relocations in this file.\n"));
4709     }
4710   else
4711     {
4712       Elf_Internal_Shdr * section;
4713       unsigned long i;
4714       int found = 0;
4715
4716       for (i = 0, section = section_headers;
4717            i < elf_header.e_shnum;
4718            i++, section++)
4719         {
4720           if (   section->sh_type != SHT_RELA
4721               && section->sh_type != SHT_REL)
4722             continue;
4723
4724           rel_offset = section->sh_offset;
4725           rel_size   = section->sh_size;
4726
4727           if (rel_size)
4728             {
4729               Elf_Internal_Shdr * strsec;
4730               int is_rela;
4731
4732               printf (_("\nRelocation section "));
4733
4734               if (string_table == NULL)
4735                 printf ("%d", section->sh_name);
4736               else
4737                 printf (_("'%s'"), SECTION_NAME (section));
4738
4739               printf (_(" at offset 0x%lx contains %lu entries:\n"),
4740                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
4741
4742               is_rela = section->sh_type == SHT_RELA;
4743
4744               if (section->sh_link != 0
4745                   && section->sh_link < elf_header.e_shnum)
4746                 {
4747                   Elf_Internal_Shdr * symsec;
4748                   Elf_Internal_Sym *  symtab;
4749                   unsigned long nsyms;
4750                   unsigned long strtablen = 0;
4751                   char * strtab = NULL;
4752
4753                   symsec = section_headers + section->sh_link;
4754                   if (symsec->sh_type != SHT_SYMTAB
4755                       && symsec->sh_type != SHT_DYNSYM)
4756                     continue;
4757
4758                   nsyms = symsec->sh_size / symsec->sh_entsize;
4759                   symtab = GET_ELF_SYMBOLS (file, symsec);
4760
4761                   if (symtab == NULL)
4762                     continue;
4763
4764                   if (symsec->sh_link != 0
4765                       && symsec->sh_link < elf_header.e_shnum)
4766                     {
4767                       strsec = section_headers + symsec->sh_link;
4768
4769                       strtab = get_data (NULL, file, strsec->sh_offset,
4770                                          1, strsec->sh_size,
4771                                          _("string table"));
4772                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
4773                     }
4774
4775                   dump_relocations (file, rel_offset, rel_size,
4776                                     symtab, nsyms, strtab, strtablen, is_rela);
4777                   if (strtab)
4778                     free (strtab);
4779                   free (symtab);
4780                 }
4781               else
4782                 dump_relocations (file, rel_offset, rel_size,
4783                                   NULL, 0, NULL, 0, is_rela);
4784
4785               found = 1;
4786             }
4787         }
4788
4789       if (! found)
4790         printf (_("\nThere are no relocations in this file.\n"));
4791     }
4792
4793   return 1;
4794 }
4795
4796 /* Process the unwind section.  */
4797
4798 #include "unwind-ia64.h"
4799
4800 /* An absolute address consists of a section and an offset.  If the
4801    section is NULL, the offset itself is the address, otherwise, the
4802    address equals to LOAD_ADDRESS(section) + offset.  */
4803
4804 struct absaddr
4805   {
4806     unsigned short section;
4807     bfd_vma offset;
4808   };
4809
4810 #define ABSADDR(a) \
4811   ((a).section \
4812    ? section_headers [(a).section].sh_addr + (a).offset \
4813    : (a).offset)
4814
4815 struct ia64_unw_aux_info
4816   {
4817     struct ia64_unw_table_entry
4818       {
4819         struct absaddr start;
4820         struct absaddr end;
4821         struct absaddr info;
4822       }
4823     *table;                     /* Unwind table.  */
4824     unsigned long table_len;    /* Length of unwind table.  */
4825     unsigned char * info;       /* Unwind info.  */
4826     unsigned long info_size;    /* Size of unwind info.  */
4827     bfd_vma info_addr;          /* starting address of unwind info.  */
4828     bfd_vma seg_base;           /* Starting address of segment.  */
4829     Elf_Internal_Sym * symtab;  /* The symbol table.  */
4830     unsigned long nsyms;        /* Number of symbols.  */
4831     char * strtab;              /* The string table.  */
4832     unsigned long strtab_size;  /* Size of string table.  */
4833   };
4834
4835 static void
4836 find_symbol_for_address (Elf_Internal_Sym * symtab,
4837                          unsigned long nsyms,
4838                          const char * strtab,
4839                          unsigned long strtab_size,
4840                          struct absaddr addr,
4841                          const char ** symname,
4842                          bfd_vma * offset)
4843 {
4844   bfd_vma dist = 0x100000;
4845   Elf_Internal_Sym * sym;
4846   Elf_Internal_Sym * best = NULL;
4847   unsigned long i;
4848
4849   for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4850     {
4851       if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
4852           && sym->st_name != 0
4853           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
4854           && addr.offset >= sym->st_value
4855           && addr.offset - sym->st_value < dist)
4856         {
4857           best = sym;
4858           dist = addr.offset - sym->st_value;
4859           if (!dist)
4860             break;
4861         }
4862     }
4863   if (best)
4864     {
4865       *symname = (best->st_name >= strtab_size
4866                   ? "<corrupt>" : strtab + best->st_name);
4867       *offset = dist;
4868       return;
4869     }
4870   *symname = NULL;
4871   *offset = addr.offset;
4872 }
4873
4874 static void
4875 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
4876 {
4877   struct ia64_unw_table_entry * tp;
4878   int in_body;
4879
4880   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
4881     {
4882       bfd_vma stamp;
4883       bfd_vma offset;
4884       const unsigned char * dp;
4885       const unsigned char * head;
4886       const char * procname;
4887
4888       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
4889                                aux->strtab_size, tp->start, &procname, &offset);
4890
4891       fputs ("\n<", stdout);
4892
4893       if (procname)
4894         {
4895           fputs (procname, stdout);
4896
4897           if (offset)
4898             printf ("+%lx", (unsigned long) offset);
4899         }
4900
4901       fputs (">: [", stdout);
4902       print_vma (tp->start.offset, PREFIX_HEX);
4903       fputc ('-', stdout);
4904       print_vma (tp->end.offset, PREFIX_HEX);
4905       printf ("], info at +0x%lx\n",
4906               (unsigned long) (tp->info.offset - aux->seg_base));
4907
4908       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
4909       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4910
4911       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4912               (unsigned) UNW_VER (stamp),
4913               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
4914               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
4915               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
4916               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4917
4918       if (UNW_VER (stamp) != 1)
4919         {
4920           printf ("\tUnknown version.\n");
4921           continue;
4922         }
4923
4924       in_body = 0;
4925       for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4926         dp = unw_decode (dp, in_body, & in_body);
4927     }
4928 }
4929
4930 static int
4931 slurp_ia64_unwind_table (FILE * file,
4932                          struct ia64_unw_aux_info * aux,
4933                          Elf_Internal_Shdr * sec)
4934 {
4935   unsigned long size, nrelas, i;
4936   Elf_Internal_Phdr * seg;
4937   struct ia64_unw_table_entry * tep;
4938   Elf_Internal_Shdr * relsec;
4939   Elf_Internal_Rela * rela;
4940   Elf_Internal_Rela * rp;
4941   unsigned char * table;
4942   unsigned char * tp;
4943   Elf_Internal_Sym * sym;
4944   const char * relname;
4945
4946   /* First, find the starting address of the segment that includes
4947      this section: */
4948
4949   if (elf_header.e_phnum)
4950     {
4951       if (! get_program_headers (file))
4952           return 0;
4953
4954       for (seg = program_headers;
4955            seg < program_headers + elf_header.e_phnum;
4956            ++seg)
4957         {
4958           if (seg->p_type != PT_LOAD)
4959             continue;
4960
4961           if (sec->sh_addr >= seg->p_vaddr
4962               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
4963             {
4964               aux->seg_base = seg->p_vaddr;
4965               break;
4966             }
4967         }
4968     }
4969
4970   /* Second, build the unwind table from the contents of the unwind section:  */
4971   size = sec->sh_size;
4972   table = get_data (NULL, file, sec->sh_offset, 1, size, _("unwind table"));
4973   if (!table)
4974     return 0;
4975
4976   aux->table = xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
4977   tep = aux->table;
4978   for (tp = table; tp < table + size; ++tep)
4979     {
4980       tep->start.section = SHN_UNDEF;
4981       tep->end.section   = SHN_UNDEF;
4982       tep->info.section  = SHN_UNDEF;
4983       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4984       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4985       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
4986       tep->start.offset += aux->seg_base;
4987       tep->end.offset   += aux->seg_base;
4988       tep->info.offset  += aux->seg_base;
4989     }
4990   free (table);
4991
4992   /* Third, apply any relocations to the unwind table:  */
4993   for (relsec = section_headers;
4994        relsec < section_headers + elf_header.e_shnum;
4995        ++relsec)
4996     {
4997       if (relsec->sh_type != SHT_RELA
4998           || relsec->sh_info >= elf_header.e_shnum
4999           || section_headers + relsec->sh_info != sec)
5000         continue;
5001
5002       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5003                               & rela, & nrelas))
5004         return 0;
5005
5006       for (rp = rela; rp < rela + nrelas; ++rp)
5007         {
5008           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5009           sym = aux->symtab + get_reloc_symindex (rp->r_info);
5010
5011           if (! const_strneq (relname, "R_IA64_SEGREL"))
5012             {
5013               warn (_("Skipping unexpected relocation type %s\n"), relname);
5014               continue;
5015             }
5016
5017           i = rp->r_offset / (3 * eh_addr_size);
5018
5019           switch (rp->r_offset/eh_addr_size % 3)
5020             {
5021             case 0:
5022               aux->table[i].start.section = sym->st_shndx;
5023               aux->table[i].start.offset += rp->r_addend + sym->st_value;
5024               break;
5025             case 1:
5026               aux->table[i].end.section   = sym->st_shndx;
5027               aux->table[i].end.offset   += rp->r_addend + sym->st_value;
5028               break;
5029             case 2:
5030               aux->table[i].info.section  = sym->st_shndx;
5031               aux->table[i].info.offset  += rp->r_addend + sym->st_value;
5032               break;
5033             default:
5034               break;
5035             }
5036         }
5037
5038       free (rela);
5039     }
5040
5041   aux->table_len = size / (3 * eh_addr_size);
5042   return 1;
5043 }
5044
5045 static int
5046 ia64_process_unwind (FILE * file)
5047 {
5048   Elf_Internal_Shdr * sec;
5049   Elf_Internal_Shdr * unwsec = NULL;
5050   Elf_Internal_Shdr * strsec;
5051   unsigned long i, unwcount = 0, unwstart = 0;
5052   struct ia64_unw_aux_info aux;
5053
5054   memset (& aux, 0, sizeof (aux));
5055
5056   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5057     {
5058       if (sec->sh_type == SHT_SYMTAB
5059           && sec->sh_link < elf_header.e_shnum)
5060         {
5061           aux.nsyms = sec->sh_size / sec->sh_entsize;
5062           aux.symtab = GET_ELF_SYMBOLS (file, sec);
5063
5064           strsec = section_headers + sec->sh_link;
5065           aux.strtab = get_data (NULL, file, strsec->sh_offset,
5066                                  1, strsec->sh_size, _("string table"));
5067           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5068         }
5069       else if (sec->sh_type == SHT_IA_64_UNWIND)
5070         unwcount++;
5071     }
5072
5073   if (!unwcount)
5074     printf (_("\nThere are no unwind sections in this file.\n"));
5075
5076   while (unwcount-- > 0)
5077     {
5078       char * suffix;
5079       size_t len, len2;
5080
5081       for (i = unwstart, sec = section_headers + unwstart;
5082            i < elf_header.e_shnum; ++i, ++sec)
5083         if (sec->sh_type == SHT_IA_64_UNWIND)
5084           {
5085             unwsec = sec;
5086             break;
5087           }
5088
5089       unwstart = i + 1;
5090       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5091
5092       if ((unwsec->sh_flags & SHF_GROUP) != 0)
5093         {
5094           /* We need to find which section group it is in.  */
5095           struct group_list * g = section_headers_groups [i]->root;
5096
5097           for (; g != NULL; g = g->next)
5098             {
5099               sec = section_headers + g->section_index;
5100
5101               if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
5102                 break;
5103             }
5104
5105           if (g == NULL)
5106             i = elf_header.e_shnum;
5107         }
5108       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
5109         {
5110           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
5111           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5112           suffix = SECTION_NAME (unwsec) + len;
5113           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5114                ++i, ++sec)
5115             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5116                 && streq (SECTION_NAME (sec) + len2, suffix))
5117               break;
5118         }
5119       else
5120         {
5121           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5122              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
5123           len = sizeof (ELF_STRING_ia64_unwind) - 1;
5124           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5125           suffix = "";
5126           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
5127             suffix = SECTION_NAME (unwsec) + len;
5128           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5129                ++i, ++sec)
5130             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5131                 && streq (SECTION_NAME (sec) + len2, suffix))
5132               break;
5133         }
5134
5135       if (i == elf_header.e_shnum)
5136         {
5137           printf (_("\nCould not find unwind info section for "));
5138
5139           if (string_table == NULL)
5140             printf ("%d", unwsec->sh_name);
5141           else
5142             printf (_("'%s'"), SECTION_NAME (unwsec));
5143         }
5144       else
5145         {
5146           aux.info_size = sec->sh_size;
5147           aux.info_addr = sec->sh_addr;
5148           aux.info = get_data (NULL, file, sec->sh_offset, 1, aux.info_size,
5149                                _("unwind info"));
5150
5151           printf (_("\nUnwind section "));
5152
5153           if (string_table == NULL)
5154             printf ("%d", unwsec->sh_name);
5155           else
5156             printf (_("'%s'"), SECTION_NAME (unwsec));
5157
5158           printf (_(" at offset 0x%lx contains %lu entries:\n"),
5159                   (unsigned long) unwsec->sh_offset,
5160                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
5161
5162           (void) slurp_ia64_unwind_table (file, & aux, unwsec);
5163
5164           if (aux.table_len > 0)
5165             dump_ia64_unwind (& aux);
5166
5167           if (aux.table)
5168             free ((char *) aux.table);
5169           if (aux.info)
5170             free ((char *) aux.info);
5171           aux.table = NULL;
5172           aux.info = NULL;
5173         }
5174     }
5175
5176   if (aux.symtab)
5177     free (aux.symtab);
5178   if (aux.strtab)
5179     free ((char *) aux.strtab);
5180
5181   return 1;
5182 }
5183
5184 struct hppa_unw_aux_info
5185   {
5186     struct hppa_unw_table_entry
5187       {
5188         struct absaddr start;
5189         struct absaddr end;
5190         unsigned int Cannot_unwind:1;                   /* 0 */
5191         unsigned int Millicode:1;                       /* 1 */
5192         unsigned int Millicode_save_sr0:1;              /* 2 */
5193         unsigned int Region_description:2;              /* 3..4 */
5194         unsigned int reserved1:1;                       /* 5 */
5195         unsigned int Entry_SR:1;                        /* 6 */
5196         unsigned int Entry_FR:4;     /* number saved */ /* 7..10 */
5197         unsigned int Entry_GR:5;     /* number saved */ /* 11..15 */
5198         unsigned int Args_stored:1;                     /* 16 */
5199         unsigned int Variable_Frame:1;                  /* 17 */
5200         unsigned int Separate_Package_Body:1;           /* 18 */
5201         unsigned int Frame_Extension_Millicode:1;       /* 19 */
5202         unsigned int Stack_Overflow_Check:1;            /* 20 */
5203         unsigned int Two_Instruction_SP_Increment:1;    /* 21 */
5204         unsigned int Ada_Region:1;                      /* 22 */
5205         unsigned int cxx_info:1;                        /* 23 */
5206         unsigned int cxx_try_catch:1;                   /* 24 */
5207         unsigned int sched_entry_seq:1;                 /* 25 */
5208         unsigned int reserved2:1;                       /* 26 */
5209         unsigned int Save_SP:1;                         /* 27 */
5210         unsigned int Save_RP:1;                         /* 28 */
5211         unsigned int Save_MRP_in_frame:1;               /* 29 */
5212         unsigned int extn_ptr_defined:1;                /* 30 */
5213         unsigned int Cleanup_defined:1;                 /* 31 */
5214
5215         unsigned int MPE_XL_interrupt_marker:1;         /* 0 */
5216         unsigned int HP_UX_interrupt_marker:1;          /* 1 */
5217         unsigned int Large_frame:1;                     /* 2 */
5218         unsigned int Pseudo_SP_Set:1;                   /* 3 */
5219         unsigned int reserved4:1;                       /* 4 */
5220         unsigned int Total_frame_size:27;               /* 5..31 */
5221       }
5222     *table;                     /* Unwind table.  */
5223     unsigned long table_len;    /* Length of unwind table.  */
5224     bfd_vma seg_base;           /* Starting address of segment.  */
5225     Elf_Internal_Sym * symtab;  /* The symbol table.  */
5226     unsigned long nsyms;        /* Number of symbols.  */
5227     char * strtab;              /* The string table.  */
5228     unsigned long strtab_size;  /* Size of string table.  */
5229   };
5230
5231 static void
5232 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
5233 {
5234   struct hppa_unw_table_entry * tp;
5235
5236   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5237     {
5238       bfd_vma offset;
5239       const char * procname;
5240
5241       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5242                                aux->strtab_size, tp->start, &procname,
5243                                &offset);
5244
5245       fputs ("\n<", stdout);
5246
5247       if (procname)
5248         {
5249           fputs (procname, stdout);
5250
5251           if (offset)
5252             printf ("+%lx", (unsigned long) offset);
5253         }
5254
5255       fputs (">: [", stdout);
5256       print_vma (tp->start.offset, PREFIX_HEX);
5257       fputc ('-', stdout);
5258       print_vma (tp->end.offset, PREFIX_HEX);
5259       printf ("]\n\t");
5260
5261 #define PF(_m) if (tp->_m) printf (#_m " ");
5262 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5263       PF(Cannot_unwind);
5264       PF(Millicode);
5265       PF(Millicode_save_sr0);
5266       /* PV(Region_description);  */
5267       PF(Entry_SR);
5268       PV(Entry_FR);
5269       PV(Entry_GR);
5270       PF(Args_stored);
5271       PF(Variable_Frame);
5272       PF(Separate_Package_Body);
5273       PF(Frame_Extension_Millicode);
5274       PF(Stack_Overflow_Check);
5275       PF(Two_Instruction_SP_Increment);
5276       PF(Ada_Region);
5277       PF(cxx_info);
5278       PF(cxx_try_catch);
5279       PF(sched_entry_seq);
5280       PF(Save_SP);
5281       PF(Save_RP);
5282       PF(Save_MRP_in_frame);
5283       PF(extn_ptr_defined);
5284       PF(Cleanup_defined);
5285       PF(MPE_XL_interrupt_marker);
5286       PF(HP_UX_interrupt_marker);
5287       PF(Large_frame);
5288       PF(Pseudo_SP_Set);
5289       PV(Total_frame_size);
5290 #undef PF
5291 #undef PV
5292     }
5293
5294   printf ("\n");
5295 }
5296
5297 static int
5298 slurp_hppa_unwind_table (FILE * file,
5299                          struct hppa_unw_aux_info * aux,
5300                          Elf_Internal_Shdr * sec)
5301 {
5302   unsigned long size, unw_ent_size, nentries, nrelas, i;
5303   Elf_Internal_Phdr * seg;
5304   struct hppa_unw_table_entry * tep;
5305   Elf_Internal_Shdr * relsec;
5306   Elf_Internal_Rela * rela;
5307   Elf_Internal_Rela * rp;
5308   unsigned char * table;
5309   unsigned char * tp;
5310   Elf_Internal_Sym * sym;
5311   const char * relname;
5312
5313   /* First, find the starting address of the segment that includes
5314      this section.  */
5315
5316   if (elf_header.e_phnum)
5317     {
5318       if (! get_program_headers (file))
5319         return 0;
5320
5321       for (seg = program_headers;
5322            seg < program_headers + elf_header.e_phnum;
5323            ++seg)
5324         {
5325           if (seg->p_type != PT_LOAD)
5326             continue;
5327
5328           if (sec->sh_addr >= seg->p_vaddr
5329               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5330             {
5331               aux->seg_base = seg->p_vaddr;
5332               break;
5333             }
5334         }
5335     }
5336
5337   /* Second, build the unwind table from the contents of the unwind
5338      section.  */
5339   size = sec->sh_size;
5340   table = get_data (NULL, file, sec->sh_offset, 1, size, _("unwind table"));
5341   if (!table)
5342     return 0;
5343
5344   unw_ent_size = 16;
5345   nentries = size / unw_ent_size;
5346   size = unw_ent_size * nentries;
5347
5348   tep = aux->table = xcmalloc (nentries, sizeof (aux->table[0]));
5349
5350   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
5351     {
5352       unsigned int tmp1, tmp2;
5353
5354       tep->start.section = SHN_UNDEF;
5355       tep->end.section   = SHN_UNDEF;
5356
5357       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
5358       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
5359       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
5360       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
5361
5362       tep->start.offset += aux->seg_base;
5363       tep->end.offset   += aux->seg_base;
5364
5365       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
5366       tep->Millicode = (tmp1 >> 30) & 0x1;
5367       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
5368       tep->Region_description = (tmp1 >> 27) & 0x3;
5369       tep->reserved1 = (tmp1 >> 26) & 0x1;
5370       tep->Entry_SR = (tmp1 >> 25) & 0x1;
5371       tep->Entry_FR = (tmp1 >> 21) & 0xf;
5372       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
5373       tep->Args_stored = (tmp1 >> 15) & 0x1;
5374       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
5375       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
5376       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
5377       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
5378       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
5379       tep->Ada_Region = (tmp1 >> 9) & 0x1;
5380       tep->cxx_info = (tmp1 >> 8) & 0x1;
5381       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
5382       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
5383       tep->reserved2 = (tmp1 >> 5) & 0x1;
5384       tep->Save_SP = (tmp1 >> 4) & 0x1;
5385       tep->Save_RP = (tmp1 >> 3) & 0x1;
5386       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
5387       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
5388       tep->Cleanup_defined = tmp1 & 0x1;
5389
5390       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
5391       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
5392       tep->Large_frame = (tmp2 >> 29) & 0x1;
5393       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
5394       tep->reserved4 = (tmp2 >> 27) & 0x1;
5395       tep->Total_frame_size = tmp2 & 0x7ffffff;
5396     }
5397   free (table);
5398
5399   /* Third, apply any relocations to the unwind table.  */
5400   for (relsec = section_headers;
5401        relsec < section_headers + elf_header.e_shnum;
5402        ++relsec)
5403     {
5404       if (relsec->sh_type != SHT_RELA
5405           || relsec->sh_info >= elf_header.e_shnum
5406           || section_headers + relsec->sh_info != sec)
5407         continue;
5408
5409       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5410                               & rela, & nrelas))
5411         return 0;
5412
5413       for (rp = rela; rp < rela + nrelas; ++rp)
5414         {
5415           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
5416           sym = aux->symtab + get_reloc_symindex (rp->r_info);
5417
5418           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
5419           if (! const_strneq (relname, "R_PARISC_SEGREL"))
5420             {
5421               warn (_("Skipping unexpected relocation type %s\n"), relname);
5422               continue;
5423             }
5424
5425           i = rp->r_offset / unw_ent_size;
5426
5427           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
5428             {
5429             case 0:
5430               aux->table[i].start.section = sym->st_shndx;
5431               aux->table[i].start.offset += sym->st_value + rp->r_addend;
5432               break;
5433             case 1:
5434               aux->table[i].end.section   = sym->st_shndx;
5435               aux->table[i].end.offset   += sym->st_value + rp->r_addend;
5436               break;
5437             default:
5438               break;
5439             }
5440         }
5441
5442       free (rela);
5443     }
5444
5445   aux->table_len = nentries;
5446
5447   return 1;
5448 }
5449
5450 static int
5451 hppa_process_unwind (FILE * file)
5452 {
5453   struct hppa_unw_aux_info aux;
5454   Elf_Internal_Shdr * unwsec = NULL;
5455   Elf_Internal_Shdr * strsec;
5456   Elf_Internal_Shdr * sec;
5457   unsigned long i;
5458
5459   memset (& aux, 0, sizeof (aux));
5460
5461   if (string_table == NULL)
5462     return 1;
5463
5464   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5465     {
5466       if (sec->sh_type == SHT_SYMTAB
5467           && sec->sh_link < elf_header.e_shnum)
5468         {
5469           aux.nsyms = sec->sh_size / sec->sh_entsize;
5470           aux.symtab = GET_ELF_SYMBOLS (file, sec);
5471
5472           strsec = section_headers + sec->sh_link;
5473           aux.strtab = get_data (NULL, file, strsec->sh_offset,
5474                                  1, strsec->sh_size, _("string table"));
5475           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5476         }
5477       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5478         unwsec = sec;
5479     }
5480
5481   if (!unwsec)
5482     printf (_("\nThere are no unwind sections in this file.\n"));
5483
5484   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5485     {
5486       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5487         {
5488           printf (_("\nUnwind section "));
5489           printf (_("'%s'"), SECTION_NAME (sec));
5490
5491           printf (_(" at offset 0x%lx contains %lu entries:\n"),
5492                   (unsigned long) sec->sh_offset,
5493                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
5494
5495           slurp_hppa_unwind_table (file, &aux, sec);
5496           if (aux.table_len > 0)
5497             dump_hppa_unwind (&aux);
5498
5499           if (aux.table)
5500             free ((char *) aux.table);
5501           aux.table = NULL;
5502         }
5503     }
5504
5505   if (aux.symtab)
5506     free (aux.symtab);
5507   if (aux.strtab)
5508     free ((char *) aux.strtab);
5509
5510   return 1;
5511 }
5512
5513 static int
5514 process_unwind (FILE * file)
5515 {
5516   struct unwind_handler
5517   {
5518     int machtype;
5519     int (* handler)(FILE *);
5520   } handlers[] =
5521   {
5522     { EM_IA_64, ia64_process_unwind },
5523     { EM_PARISC, hppa_process_unwind },
5524     { 0, 0 }
5525   };
5526   int i;
5527
5528   if (!do_unwind)
5529     return 1;
5530
5531   for (i = 0; handlers[i].handler != NULL; i++)
5532     if (elf_header.e_machine == handlers[i].machtype)
5533       return handlers[i].handler (file);
5534
5535   printf (_("\nThere are no unwind sections in this file.\n"));
5536   return 1;
5537 }
5538
5539 static void
5540 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
5541 {
5542   switch (entry->d_tag)
5543     {
5544     case DT_MIPS_FLAGS:
5545       if (entry->d_un.d_val == 0)
5546         printf ("NONE\n");
5547       else
5548         {
5549           static const char * opts[] =
5550           {
5551             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5552             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5553             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5554             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5555             "RLD_ORDER_SAFE"
5556           };
5557           unsigned int cnt;
5558           int first = 1;
5559           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
5560             if (entry->d_un.d_val & (1 << cnt))
5561               {
5562                 printf ("%s%s", first ? "" : " ", opts[cnt]);
5563                 first = 0;
5564               }
5565           puts ("");
5566         }
5567       break;
5568
5569     case DT_MIPS_IVERSION:
5570       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
5571         printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
5572       else
5573         printf ("<corrupt: %ld>\n", (long) entry->d_un.d_ptr);
5574       break;
5575
5576     case DT_MIPS_TIME_STAMP:
5577       {
5578         char timebuf[20];
5579         struct tm * tmp;
5580
5581         time_t time = entry->d_un.d_val;
5582         tmp = gmtime (&time);
5583         snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
5584                   tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
5585                   tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
5586         printf ("Time Stamp: %s\n", timebuf);
5587       }
5588       break;
5589
5590     case DT_MIPS_RLD_VERSION:
5591     case DT_MIPS_LOCAL_GOTNO:
5592     case DT_MIPS_CONFLICTNO:
5593     case DT_MIPS_LIBLISTNO:
5594     case DT_MIPS_SYMTABNO:
5595     case DT_MIPS_UNREFEXTNO:
5596     case DT_MIPS_HIPAGENO:
5597     case DT_MIPS_DELTA_CLASS_NO:
5598     case DT_MIPS_DELTA_INSTANCE_NO:
5599     case DT_MIPS_DELTA_RELOC_NO:
5600     case DT_MIPS_DELTA_SYM_NO:
5601     case DT_MIPS_DELTA_CLASSSYM_NO:
5602     case DT_MIPS_COMPACT_SIZE:
5603       printf ("%ld\n", (long) entry->d_un.d_ptr);
5604       break;
5605
5606     default:
5607       printf ("%#lx\n", (unsigned long) entry->d_un.d_ptr);
5608     }
5609 }
5610
5611
5612 static void
5613 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
5614 {
5615   switch (entry->d_tag)
5616     {
5617     case DT_HP_DLD_FLAGS:
5618       {
5619         static struct
5620         {
5621           long int bit;
5622           const char * str;
5623         }
5624         flags[] =
5625         {
5626           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
5627           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
5628           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
5629           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
5630           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
5631           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
5632           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
5633           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
5634           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
5635           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
5636           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
5637           { DT_HP_GST, "HP_GST" },
5638           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
5639           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
5640           { DT_HP_NODELETE, "HP_NODELETE" },
5641           { DT_HP_GROUP, "HP_GROUP" },
5642           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5643         };
5644         int first = 1;
5645         size_t cnt;
5646         bfd_vma val = entry->d_un.d_val;
5647
5648         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
5649           if (val & flags[cnt].bit)
5650             {
5651               if (! first)
5652                 putchar (' ');
5653               fputs (flags[cnt].str, stdout);
5654               first = 0;
5655               val ^= flags[cnt].bit;
5656             }
5657
5658         if (val != 0 || first)
5659           {
5660             if (! first)
5661               putchar (' ');
5662             print_vma (val, HEX);
5663           }
5664       }
5665       break;
5666
5667     default:
5668       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5669       break;
5670     }
5671   putchar ('\n');
5672 }
5673
5674 static void
5675 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
5676 {
5677   switch (entry->d_tag)
5678     {
5679     case DT_IA_64_PLT_RESERVE:
5680       /* First 3 slots reserved.  */
5681       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5682       printf (" -- ");
5683       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
5684       break;
5685
5686     default:
5687       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5688       break;
5689     }
5690   putchar ('\n');
5691 }
5692
5693 static int
5694 get_32bit_dynamic_section (FILE * file)
5695 {
5696   Elf32_External_Dyn * edyn;
5697   Elf32_External_Dyn * ext;
5698   Elf_Internal_Dyn * entry;
5699
5700   edyn = get_data (NULL, file, dynamic_addr, 1, dynamic_size,
5701                    _("dynamic section"));
5702   if (!edyn)
5703     return 0;
5704
5705 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5706    might not have the luxury of section headers.  Look for the DT_NULL
5707    terminator to determine the number of entries.  */
5708   for (ext = edyn, dynamic_nent = 0;
5709        (char *) ext < (char *) edyn + dynamic_size;
5710        ext++)
5711     {
5712       dynamic_nent++;
5713       if (BYTE_GET (ext->d_tag) == DT_NULL)
5714         break;
5715     }
5716
5717   dynamic_section = cmalloc (dynamic_nent, sizeof (* entry));
5718   if (dynamic_section == NULL)
5719     {
5720       error (_("Out of memory\n"));
5721       free (edyn);
5722       return 0;
5723     }
5724
5725   for (ext = edyn, entry = dynamic_section;
5726        entry < dynamic_section + dynamic_nent;
5727        ext++, entry++)
5728     {
5729       entry->d_tag      = BYTE_GET (ext->d_tag);
5730       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
5731     }
5732
5733   free (edyn);
5734
5735   return 1;
5736 }
5737
5738 static int
5739 get_64bit_dynamic_section (FILE * file)
5740 {
5741   Elf64_External_Dyn * edyn;
5742   Elf64_External_Dyn * ext;
5743   Elf_Internal_Dyn * entry;
5744
5745   edyn = get_data (NULL, file, dynamic_addr, 1, dynamic_size,
5746                    _("dynamic section"));
5747   if (!edyn)
5748     return 0;
5749
5750 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5751    might not have the luxury of section headers.  Look for the DT_NULL
5752    terminator to determine the number of entries.  */
5753   for (ext = edyn, dynamic_nent = 0;
5754        (char *) ext < (char *) edyn + dynamic_size;
5755        ext++)
5756     {
5757       dynamic_nent++;
5758       if (BYTE_GET (ext->d_tag) == DT_NULL)
5759         break;
5760     }
5761
5762   dynamic_section = cmalloc (dynamic_nent, sizeof (* entry));
5763   if (dynamic_section == NULL)
5764     {
5765       error (_("Out of memory\n"));
5766       free (edyn);
5767       return 0;
5768     }
5769
5770   for (ext = edyn, entry = dynamic_section;
5771        entry < dynamic_section + dynamic_nent;
5772        ext++, entry++)
5773     {
5774       entry->d_tag      = BYTE_GET (ext->d_tag);
5775       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
5776     }
5777
5778   free (edyn);
5779
5780   return 1;
5781 }
5782
5783 static void
5784 print_dynamic_flags (bfd_vma flags)
5785 {
5786   int first = 1;
5787
5788   while (flags)
5789     {
5790       bfd_vma flag;
5791
5792       flag = flags & - flags;
5793       flags &= ~ flag;
5794
5795       if (first)
5796         first = 0;
5797       else
5798         putc (' ', stdout);
5799
5800       switch (flag)
5801         {
5802         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
5803         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
5804         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
5805         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
5806         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
5807         default:                fputs ("unknown", stdout); break;
5808         }
5809     }
5810   puts ("");
5811 }
5812
5813 /* Parse and display the contents of the dynamic section.  */
5814
5815 static int
5816 process_dynamic_section (FILE * file)
5817 {
5818   Elf_Internal_Dyn * entry;
5819
5820   if (dynamic_size == 0)
5821     {
5822       if (do_dynamic)
5823         printf (_("\nThere is no dynamic section in this file.\n"));
5824
5825       return 1;
5826     }
5827
5828   if (is_32bit_elf)
5829     {
5830       if (! get_32bit_dynamic_section (file))
5831         return 0;
5832     }
5833   else if (! get_64bit_dynamic_section (file))
5834     return 0;
5835
5836   /* Find the appropriate symbol table.  */
5837   if (dynamic_symbols == NULL)
5838     {
5839       for (entry = dynamic_section;
5840            entry < dynamic_section + dynamic_nent;
5841            ++entry)
5842         {
5843           Elf_Internal_Shdr section;
5844
5845           if (entry->d_tag != DT_SYMTAB)
5846             continue;
5847
5848           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
5849
5850           /* Since we do not know how big the symbol table is,
5851              we default to reading in the entire file (!) and
5852              processing that.  This is overkill, I know, but it
5853              should work.  */
5854           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
5855
5856           if (archive_file_offset != 0)
5857             section.sh_size = archive_file_size - section.sh_offset;
5858           else
5859             {
5860               if (fseek (file, 0, SEEK_END))
5861                 error (_("Unable to seek to end of file!\n"));
5862
5863               section.sh_size = ftell (file) - section.sh_offset;
5864             }
5865
5866           if (is_32bit_elf)
5867             section.sh_entsize = sizeof (Elf32_External_Sym);
5868           else
5869             section.sh_entsize = sizeof (Elf64_External_Sym);
5870
5871           num_dynamic_syms = section.sh_size / section.sh_entsize;
5872           if (num_dynamic_syms < 1)
5873             {
5874               error (_("Unable to determine the number of symbols to load\n"));
5875               continue;
5876             }
5877
5878           dynamic_symbols = GET_ELF_SYMBOLS (file, &section);
5879         }
5880     }
5881
5882   /* Similarly find a string table.  */
5883   if (dynamic_strings == NULL)
5884     {
5885       for (entry = dynamic_section;
5886            entry < dynamic_section + dynamic_nent;
5887            ++entry)
5888         {
5889           unsigned long offset;
5890           long str_tab_len;
5891
5892           if (entry->d_tag != DT_STRTAB)
5893             continue;
5894
5895           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
5896
5897           /* Since we do not know how big the string table is,
5898              we default to reading in the entire file (!) and
5899              processing that.  This is overkill, I know, but it
5900              should work.  */
5901
5902           offset = offset_from_vma (file, entry->d_un.d_val, 0);
5903
5904           if (archive_file_offset != 0)
5905             str_tab_len = archive_file_size - offset;
5906           else
5907             {
5908               if (fseek (file, 0, SEEK_END))
5909                 error (_("Unable to seek to end of file\n"));
5910               str_tab_len = ftell (file) - offset;
5911             }
5912
5913           if (str_tab_len < 1)
5914             {
5915               error
5916                 (_("Unable to determine the length of the dynamic string table\n"));
5917               continue;
5918             }
5919
5920           dynamic_strings = get_data (NULL, file, offset, 1, str_tab_len,
5921                                       _("dynamic string table"));
5922           dynamic_strings_length = str_tab_len;
5923           break;
5924         }
5925     }
5926
5927   /* And find the syminfo section if available.  */
5928   if (dynamic_syminfo == NULL)
5929     {
5930       unsigned long syminsz = 0;
5931
5932       for (entry = dynamic_section;
5933            entry < dynamic_section + dynamic_nent;
5934            ++entry)
5935         {
5936           if (entry->d_tag == DT_SYMINENT)
5937             {
5938               /* Note: these braces are necessary to avoid a syntax
5939                  error from the SunOS4 C compiler.  */
5940               assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
5941             }
5942           else if (entry->d_tag == DT_SYMINSZ)
5943             syminsz = entry->d_un.d_val;
5944           else if (entry->d_tag == DT_SYMINFO)
5945             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
5946                                                       syminsz);
5947         }
5948
5949       if (dynamic_syminfo_offset != 0 && syminsz != 0)
5950         {
5951           Elf_External_Syminfo * extsyminfo;
5952           Elf_External_Syminfo * extsym;
5953           Elf_Internal_Syminfo * syminfo;
5954
5955           /* There is a syminfo section.  Read the data.  */
5956           extsyminfo = get_data (NULL, file, dynamic_syminfo_offset, 1,
5957                                  syminsz, _("symbol information"));
5958           if (!extsyminfo)
5959             return 0;
5960
5961           dynamic_syminfo = malloc (syminsz);
5962           if (dynamic_syminfo == NULL)
5963             {
5964               error (_("Out of memory\n"));
5965               return 0;
5966             }
5967
5968           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
5969           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
5970                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
5971                ++syminfo, ++extsym)
5972             {
5973               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
5974               syminfo->si_flags = BYTE_GET (extsym->si_flags);
5975             }
5976
5977           free (extsyminfo);
5978         }
5979     }
5980
5981   if (do_dynamic && dynamic_addr)
5982     printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5983             dynamic_addr, dynamic_nent);
5984   if (do_dynamic)
5985     printf (_("  Tag        Type                         Name/Value\n"));
5986
5987   for (entry = dynamic_section;
5988        entry < dynamic_section + dynamic_nent;
5989        entry++)
5990     {
5991       if (do_dynamic)
5992         {
5993           const char * dtype;
5994
5995           putchar (' ');
5996           print_vma (entry->d_tag, FULL_HEX);
5997           dtype = get_dynamic_type (entry->d_tag);
5998           printf (" (%s)%*s", dtype,
5999                   ((is_32bit_elf ? 27 : 19)
6000                    - (int) strlen (dtype)),
6001                   " ");
6002         }
6003
6004       switch (entry->d_tag)
6005         {
6006         case DT_FLAGS:
6007           if (do_dynamic)
6008             print_dynamic_flags (entry->d_un.d_val);
6009           break;
6010
6011         case DT_AUXILIARY:
6012         case DT_FILTER:
6013         case DT_CONFIG:
6014         case DT_DEPAUDIT:
6015         case DT_AUDIT:
6016           if (do_dynamic)
6017             {
6018               switch (entry->d_tag)
6019                 {
6020                 case DT_AUXILIARY:
6021                   printf (_("Auxiliary library"));
6022                   break;
6023
6024                 case DT_FILTER:
6025                   printf (_("Filter library"));
6026                   break;
6027
6028                 case DT_CONFIG:
6029                   printf (_("Configuration file"));
6030                   break;
6031
6032                 case DT_DEPAUDIT:
6033                   printf (_("Dependency audit library"));
6034                   break;
6035
6036                 case DT_AUDIT:
6037                   printf (_("Audit library"));
6038                   break;
6039                 }
6040
6041               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6042                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
6043               else
6044                 {
6045                   printf (": ");
6046                   print_vma (entry->d_un.d_val, PREFIX_HEX);
6047                   putchar ('\n');
6048                 }
6049             }
6050           break;
6051
6052         case DT_FEATURE:
6053           if (do_dynamic)
6054             {
6055               printf (_("Flags:"));
6056
6057               if (entry->d_un.d_val == 0)
6058                 printf (_(" None\n"));
6059               else
6060                 {
6061                   unsigned long int val = entry->d_un.d_val;
6062
6063                   if (val & DTF_1_PARINIT)
6064                     {
6065                       printf (" PARINIT");
6066                       val ^= DTF_1_PARINIT;
6067                     }
6068                   if (val & DTF_1_CONFEXP)
6069                     {
6070                       printf (" CONFEXP");
6071                       val ^= DTF_1_CONFEXP;
6072                     }
6073                   if (val != 0)
6074                     printf (" %lx", val);
6075                   puts ("");
6076                 }
6077             }
6078           break;
6079
6080         case DT_POSFLAG_1:
6081           if (do_dynamic)
6082             {
6083               printf (_("Flags:"));
6084
6085               if (entry->d_un.d_val == 0)
6086                 printf (_(" None\n"));
6087               else
6088                 {
6089                   unsigned long int val = entry->d_un.d_val;
6090
6091                   if (val & DF_P1_LAZYLOAD)
6092                     {
6093                       printf (" LAZYLOAD");
6094                       val ^= DF_P1_LAZYLOAD;
6095                     }
6096                   if (val & DF_P1_GROUPPERM)
6097                     {
6098                       printf (" GROUPPERM");
6099                       val ^= DF_P1_GROUPPERM;
6100                     }
6101                   if (val != 0)
6102                     printf (" %lx", val);
6103                   puts ("");
6104                 }
6105             }
6106           break;
6107
6108         case DT_FLAGS_1:
6109           if (do_dynamic)
6110             {
6111               printf (_("Flags:"));
6112               if (entry->d_un.d_val == 0)
6113                 printf (_(" None\n"));
6114               else
6115                 {
6116                   unsigned long int val = entry->d_un.d_val;
6117
6118                   if (val & DF_1_NOW)
6119                     {
6120                       printf (" NOW");
6121                       val ^= DF_1_NOW;
6122                     }
6123                   if (val & DF_1_GLOBAL)
6124                     {
6125                       printf (" GLOBAL");
6126                       val ^= DF_1_GLOBAL;
6127                     }
6128                   if (val & DF_1_GROUP)
6129                     {
6130                       printf (" GROUP");
6131                       val ^= DF_1_GROUP;
6132                     }
6133                   if (val & DF_1_NODELETE)
6134                     {
6135                       printf (" NODELETE");
6136                       val ^= DF_1_NODELETE;
6137                     }
6138                   if (val & DF_1_LOADFLTR)
6139                     {
6140                       printf (" LOADFLTR");
6141                       val ^= DF_1_LOADFLTR;
6142                     }
6143                   if (val & DF_1_INITFIRST)
6144                     {
6145                       printf (" INITFIRST");
6146                       val ^= DF_1_INITFIRST;
6147                     }
6148                   if (val & DF_1_NOOPEN)
6149                     {
6150                       printf (" NOOPEN");
6151                       val ^= DF_1_NOOPEN;
6152                     }
6153                   if (val & DF_1_ORIGIN)
6154                     {
6155                       printf (" ORIGIN");
6156                       val ^= DF_1_ORIGIN;
6157                     }
6158                   if (val & DF_1_DIRECT)
6159                     {
6160                       printf (" DIRECT");
6161                       val ^= DF_1_DIRECT;
6162                     }
6163                   if (val & DF_1_TRANS)
6164                     {
6165                       printf (" TRANS");
6166                       val ^= DF_1_TRANS;
6167                     }
6168                   if (val & DF_1_INTERPOSE)
6169                     {
6170                       printf (" INTERPOSE");
6171                       val ^= DF_1_INTERPOSE;
6172                     }
6173                   if (val & DF_1_NODEFLIB)
6174                     {
6175                       printf (" NODEFLIB");
6176                       val ^= DF_1_NODEFLIB;
6177                     }
6178                   if (val & DF_1_NODUMP)
6179                     {
6180                       printf (" NODUMP");
6181                       val ^= DF_1_NODUMP;
6182                     }
6183                   if (val & DF_1_CONLFAT)
6184                     {
6185                       printf (" CONLFAT");
6186                       val ^= DF_1_CONLFAT;
6187                     }
6188                   if (val != 0)
6189                     printf (" %lx", val);
6190                   puts ("");
6191                 }
6192             }
6193           break;
6194
6195         case DT_PLTREL:
6196           dynamic_info[entry->d_tag] = entry->d_un.d_val;
6197           if (do_dynamic)
6198             puts (get_dynamic_type (entry->d_un.d_val));
6199           break;
6200
6201         case DT_NULL    :
6202         case DT_NEEDED  :
6203         case DT_PLTGOT  :
6204         case DT_HASH    :
6205         case DT_STRTAB  :
6206         case DT_SYMTAB  :
6207         case DT_RELA    :
6208         case DT_INIT    :
6209         case DT_FINI    :
6210         case DT_SONAME  :
6211         case DT_RPATH   :
6212         case DT_SYMBOLIC:
6213         case DT_REL     :
6214         case DT_DEBUG   :
6215         case DT_TEXTREL :
6216         case DT_JMPREL  :
6217         case DT_RUNPATH :
6218           dynamic_info[entry->d_tag] = entry->d_un.d_val;
6219
6220           if (do_dynamic)
6221             {
6222               char * name;
6223
6224               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6225                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
6226               else
6227                 name = NULL;
6228
6229               if (name)
6230                 {
6231                   switch (entry->d_tag)
6232                     {
6233                     case DT_NEEDED:
6234                       printf (_("Shared library: [%s]"), name);
6235
6236                       if (streq (name, program_interpreter))
6237                         printf (_(" program interpreter"));
6238                       break;
6239
6240                     case DT_SONAME:
6241                       printf (_("Library soname: [%s]"), name);
6242                       break;
6243
6244                     case DT_RPATH:
6245                       printf (_("Library rpath: [%s]"), name);
6246                       break;
6247
6248                     case DT_RUNPATH:
6249                       printf (_("Library runpath: [%s]"), name);
6250                       break;
6251
6252                     default:
6253                       print_vma (entry->d_un.d_val, PREFIX_HEX);
6254                       break;
6255                     }
6256                 }
6257               else
6258                 print_vma (entry->d_un.d_val, PREFIX_HEX);
6259
6260               putchar ('\n');
6261             }
6262           break;
6263
6264         case DT_PLTRELSZ:
6265         case DT_RELASZ  :
6266         case DT_STRSZ   :
6267         case DT_RELSZ   :
6268         case DT_RELAENT :
6269         case DT_SYMENT  :
6270         case DT_RELENT  :
6271           dynamic_info[entry->d_tag] = entry->d_un.d_val;
6272         case DT_PLTPADSZ:
6273         case DT_MOVEENT :
6274         case DT_MOVESZ  :
6275         case DT_INIT_ARRAYSZ:
6276         case DT_FINI_ARRAYSZ:
6277         case DT_GNU_CONFLICTSZ:
6278         case DT_GNU_LIBLISTSZ:
6279           if (do_dynamic)
6280             {
6281               print_vma (entry->d_un.d_val, UNSIGNED);
6282               printf (" (bytes)\n");
6283             }
6284           break;
6285
6286         case DT_VERDEFNUM:
6287         case DT_VERNEEDNUM:
6288         case DT_RELACOUNT:
6289         case DT_RELCOUNT:
6290           if (do_dynamic)
6291             {
6292               print_vma (entry->d_un.d_val, UNSIGNED);
6293               putchar ('\n');
6294             }
6295           break;
6296
6297         case DT_SYMINSZ:
6298         case DT_SYMINENT:
6299         case DT_SYMINFO:
6300         case DT_USED:
6301         case DT_INIT_ARRAY:
6302         case DT_FINI_ARRAY:
6303           if (do_dynamic)
6304             {
6305               if (entry->d_tag == DT_USED
6306                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
6307                 {
6308                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
6309
6310                   if (*name)
6311                     {
6312                       printf (_("Not needed object: [%s]\n"), name);
6313                       break;
6314                     }
6315                 }
6316
6317               print_vma (entry->d_un.d_val, PREFIX_HEX);
6318               putchar ('\n');
6319             }
6320           break;
6321
6322         case DT_BIND_NOW:
6323           /* The value of this entry is ignored.  */
6324           if (do_dynamic)
6325             putchar ('\n');
6326           break;
6327
6328         case DT_GNU_PRELINKED:
6329           if (do_dynamic)
6330             {
6331               struct tm * tmp;
6332               time_t time = entry->d_un.d_val;
6333
6334               tmp = gmtime (&time);
6335               printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6336                       tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
6337                       tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
6338
6339             }
6340           break;
6341
6342         case DT_GNU_HASH:
6343           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
6344           if (do_dynamic)
6345             {
6346               print_vma (entry->d_un.d_val, PREFIX_HEX);
6347               putchar ('\n');
6348             }
6349           break;
6350
6351         default:
6352           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
6353             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
6354               entry->d_un.d_val;
6355
6356           if (do_dynamic)
6357             {
6358               switch (elf_header.e_machine)
6359                 {
6360                 case EM_MIPS:
6361                 case EM_MIPS_RS3_LE:
6362                   dynamic_section_mips_val (entry);
6363                   break;
6364                 case EM_PARISC:
6365                   dynamic_section_parisc_val (entry);
6366                   break;
6367                 case EM_IA_64:
6368                   dynamic_section_ia64_val (entry);
6369                   break;
6370                 default:
6371                   print_vma (entry->d_un.d_val, PREFIX_HEX);
6372                   putchar ('\n');
6373                 }
6374             }
6375           break;
6376         }
6377     }
6378
6379   return 1;
6380 }
6381
6382 static char *
6383 get_ver_flags (unsigned int flags)
6384 {
6385   static char buff[32];
6386
6387   buff[0] = 0;
6388
6389   if (flags == 0)
6390     return _("none");
6391
6392   if (flags & VER_FLG_BASE)
6393     strcat (buff, "BASE ");
6394
6395   if (flags & VER_FLG_WEAK)
6396     {
6397       if (flags & VER_FLG_BASE)
6398         strcat (buff, "| ");
6399
6400       strcat (buff, "WEAK ");
6401     }
6402
6403   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
6404     strcat (buff, "| <unknown>");
6405
6406   return buff;
6407 }
6408
6409 /* Display the contents of the version sections.  */
6410 static int
6411 process_version_sections (FILE * file)
6412 {
6413   Elf_Internal_Shdr * section;
6414   unsigned i;
6415   int found = 0;
6416
6417   if (! do_version)
6418     return 1;
6419
6420   for (i = 0, section = section_headers;
6421        i < elf_header.e_shnum;
6422        i++, section++)
6423     {
6424       switch (section->sh_type)
6425         {
6426         case SHT_GNU_verdef:
6427           {
6428             Elf_External_Verdef * edefs;
6429             unsigned int idx;
6430             unsigned int cnt;
6431             char * endbuf;
6432
6433             found = 1;
6434
6435             printf
6436               (_("\nVersion definition section '%s' contains %u entries:\n"),
6437                SECTION_NAME (section), section->sh_info);
6438
6439             printf (_("  Addr: 0x"));
6440             printf_vma (section->sh_addr);
6441             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
6442                     (unsigned long) section->sh_offset, section->sh_link,
6443                     section->sh_link < elf_header.e_shnum
6444                     ? SECTION_NAME (section_headers + section->sh_link)
6445                     : "<corrupt>");
6446
6447             edefs = get_data (NULL, file, section->sh_offset, 1,
6448                               section->sh_size,
6449                               _("version definition section"));
6450             endbuf = (char *) edefs + section->sh_size;
6451             if (!edefs)
6452               break;
6453
6454             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6455               {
6456                 char * vstart;
6457                 Elf_External_Verdef * edef;
6458                 Elf_Internal_Verdef ent;
6459                 Elf_External_Verdaux * eaux;
6460                 Elf_Internal_Verdaux aux;
6461                 int j;
6462                 int isum;
6463
6464                 vstart = ((char *) edefs) + idx;
6465                 if (vstart + sizeof (*edef) > endbuf)
6466                   break;
6467
6468                 edef = (Elf_External_Verdef *) vstart;
6469
6470                 ent.vd_version = BYTE_GET (edef->vd_version);
6471                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
6472                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
6473                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
6474                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
6475                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
6476                 ent.vd_next    = BYTE_GET (edef->vd_next);
6477
6478                 printf (_("  %#06x: Rev: %d  Flags: %s"),
6479                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
6480
6481                 printf (_("  Index: %d  Cnt: %d  "),
6482                         ent.vd_ndx, ent.vd_cnt);
6483
6484                 vstart += ent.vd_aux;
6485
6486                 eaux = (Elf_External_Verdaux *) vstart;
6487
6488                 aux.vda_name = BYTE_GET (eaux->vda_name);
6489                 aux.vda_next = BYTE_GET (eaux->vda_next);
6490
6491                 if (VALID_DYNAMIC_NAME (aux.vda_name))
6492                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
6493                 else
6494                   printf (_("Name index: %ld\n"), aux.vda_name);
6495
6496                 isum = idx + ent.vd_aux;
6497
6498                 for (j = 1; j < ent.vd_cnt; j++)
6499                   {
6500                     isum   += aux.vda_next;
6501                     vstart += aux.vda_next;
6502
6503                     eaux = (Elf_External_Verdaux *) vstart;
6504                     if (vstart + sizeof (*eaux) > endbuf)
6505                       break;
6506
6507                     aux.vda_name = BYTE_GET (eaux->vda_name);
6508                     aux.vda_next = BYTE_GET (eaux->vda_next);
6509
6510                     if (VALID_DYNAMIC_NAME (aux.vda_name))
6511                       printf (_("  %#06x: Parent %d: %s\n"),
6512                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
6513                     else
6514                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
6515                               isum, j, aux.vda_name);
6516                   }
6517                 if (j < ent.vd_cnt)
6518                   printf (_("  Version def aux past end of section\n"));
6519
6520                 idx += ent.vd_next;
6521               }
6522             if (cnt < section->sh_info)
6523               printf (_("  Version definition past end of section\n"));
6524
6525             free (edefs);
6526           }
6527           break;
6528
6529         case SHT_GNU_verneed:
6530           {
6531             Elf_External_Verneed * eneed;
6532             unsigned int idx;
6533             unsigned int cnt;
6534             char * endbuf;
6535
6536             found = 1;
6537
6538             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6539                     SECTION_NAME (section), section->sh_info);
6540
6541             printf (_(" Addr: 0x"));
6542             printf_vma (section->sh_addr);
6543             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
6544                     (unsigned long) section->sh_offset, section->sh_link,
6545                     section->sh_link < elf_header.e_shnum
6546                     ? SECTION_NAME (section_headers + section->sh_link)
6547                     : "<corrupt>");
6548
6549             eneed = get_data (NULL, file, section->sh_offset, 1,
6550                               section->sh_size,
6551                               _("version need section"));
6552             endbuf = (char *) eneed + section->sh_size;
6553             if (!eneed)
6554               break;
6555
6556             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6557               {
6558                 Elf_External_Verneed * entry;
6559                 Elf_Internal_Verneed ent;
6560                 int j;
6561                 int isum;
6562                 char * vstart;
6563
6564                 vstart = ((char *) eneed) + idx;
6565                 if (vstart + sizeof (*entry) > endbuf)
6566                   break;
6567
6568                 entry = (Elf_External_Verneed *) vstart;
6569
6570                 ent.vn_version = BYTE_GET (entry->vn_version);
6571                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
6572                 ent.vn_file    = BYTE_GET (entry->vn_file);
6573                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
6574                 ent.vn_next    = BYTE_GET (entry->vn_next);
6575
6576                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
6577
6578                 if (VALID_DYNAMIC_NAME (ent.vn_file))
6579                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
6580                 else
6581                   printf (_("  File: %lx"), ent.vn_file);
6582
6583                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
6584
6585                 vstart += ent.vn_aux;
6586
6587                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
6588                   {
6589                     Elf_External_Vernaux * eaux;
6590                     Elf_Internal_Vernaux aux;
6591
6592                     if (vstart + sizeof (*eaux) > endbuf)
6593                       break;
6594                     eaux = (Elf_External_Vernaux *) vstart;
6595
6596                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
6597                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
6598                     aux.vna_other = BYTE_GET (eaux->vna_other);
6599                     aux.vna_name  = BYTE_GET (eaux->vna_name);
6600                     aux.vna_next  = BYTE_GET (eaux->vna_next);
6601
6602                     if (VALID_DYNAMIC_NAME (aux.vna_name))
6603                       printf (_("  %#06x:   Name: %s"),
6604                               isum, GET_DYNAMIC_NAME (aux.vna_name));
6605                     else
6606                       printf (_("  %#06x:   Name index: %lx"),
6607                               isum, aux.vna_name);
6608
6609                     printf (_("  Flags: %s  Version: %d\n"),
6610                             get_ver_flags (aux.vna_flags), aux.vna_other);
6611
6612                     isum   += aux.vna_next;
6613                     vstart += aux.vna_next;
6614                   }
6615                 if (j < ent.vn_cnt)
6616                   printf (_("  Version need aux past end of section\n"));
6617
6618                 idx += ent.vn_next;
6619               }
6620             if (cnt < section->sh_info)
6621               printf (_("  Version need past end of section\n"));
6622
6623             free (eneed);
6624           }
6625           break;
6626
6627         case SHT_GNU_versym:
6628           {
6629             Elf_Internal_Shdr * link_section;
6630             int total;
6631             int cnt;
6632             unsigned char * edata;
6633             unsigned short * data;
6634             char * strtab;
6635             Elf_Internal_Sym * symbols;
6636             Elf_Internal_Shdr * string_sec;
6637             long off;
6638
6639             if (section->sh_link >= elf_header.e_shnum)
6640               break;
6641
6642             link_section = section_headers + section->sh_link;
6643             total = section->sh_size / sizeof (Elf_External_Versym);
6644
6645             if (link_section->sh_link >= elf_header.e_shnum)
6646               break;
6647
6648             found = 1;
6649
6650             symbols = GET_ELF_SYMBOLS (file, link_section);
6651
6652             string_sec = section_headers + link_section->sh_link;
6653
6654             strtab = get_data (NULL, file, string_sec->sh_offset, 1,
6655                                string_sec->sh_size, _("version string table"));
6656             if (!strtab)
6657               break;
6658
6659             printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6660                     SECTION_NAME (section), total);
6661
6662             printf (_(" Addr: "));
6663             printf_vma (section->sh_addr);
6664             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
6665                     (unsigned long) section->sh_offset, section->sh_link,
6666                     SECTION_NAME (link_section));
6667
6668             off = offset_from_vma (file,
6669                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
6670                                    total * sizeof (short));
6671             edata = get_data (NULL, file, off, total, sizeof (short),
6672                               _("version symbol data"));
6673             if (!edata)
6674               {
6675                 free (strtab);
6676                 break;
6677               }
6678
6679             data = cmalloc (total, sizeof (short));
6680
6681             for (cnt = total; cnt --;)
6682               data[cnt] = byte_get (edata + cnt * sizeof (short),
6683                                     sizeof (short));
6684
6685             free (edata);
6686
6687             for (cnt = 0; cnt < total; cnt += 4)
6688               {
6689                 int j, nn;
6690                 int check_def, check_need;
6691                 char * name;
6692
6693                 printf ("  %03x:", cnt);
6694
6695                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
6696                   switch (data[cnt + j])
6697                     {
6698                     case 0:
6699                       fputs (_("   0 (*local*)    "), stdout);
6700                       break;
6701
6702                     case 1:
6703                       fputs (_("   1 (*global*)   "), stdout);
6704                       break;
6705
6706                     default:
6707                       nn = printf ("%4x%c", data[cnt + j] & 0x7fff,
6708                                    data[cnt + j] & 0x8000 ? 'h' : ' ');
6709
6710                       check_def = 1;
6711                       check_need = 1;
6712                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
6713                           || section_headers[symbols[cnt + j].st_shndx].sh_type
6714                              != SHT_NOBITS)
6715                         {
6716                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
6717                             check_def = 0;
6718                           else
6719                             check_need = 0;
6720                         }
6721
6722                       if (check_need
6723                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
6724                         {
6725                           Elf_Internal_Verneed ivn;
6726                           unsigned long offset;
6727
6728                           offset = offset_from_vma
6729                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
6730                              sizeof (Elf_External_Verneed));
6731
6732                           do
6733                             {
6734                               Elf_Internal_Vernaux ivna;
6735                               Elf_External_Verneed evn;
6736                               Elf_External_Vernaux evna;
6737                               unsigned long a_off;
6738
6739                               get_data (&evn, file, offset, sizeof (evn), 1,
6740                                         _("version need"));
6741
6742                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
6743                               ivn.vn_next = BYTE_GET (evn.vn_next);
6744
6745                               a_off = offset + ivn.vn_aux;
6746
6747                               do
6748                                 {
6749                                   get_data (&evna, file, a_off, sizeof (evna),
6750                                             1, _("version need aux (2)"));
6751
6752                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
6753                                   ivna.vna_other = BYTE_GET (evna.vna_other);
6754
6755                                   a_off += ivna.vna_next;
6756                                 }
6757                               while (ivna.vna_other != data[cnt + j]
6758                                      && ivna.vna_next != 0);
6759
6760                               if (ivna.vna_other == data[cnt + j])
6761                                 {
6762                                   ivna.vna_name = BYTE_GET (evna.vna_name);
6763
6764                                   if (ivna.vna_name >= string_sec->sh_size)
6765                                     name = _("*invalid*");
6766                                   else
6767                                     name = strtab + ivna.vna_name;
6768                                   nn += printf ("(%s%-*s",
6769                                                 name,
6770                                                 12 - (int) strlen (name),
6771                                                 ")");
6772                                   check_def = 0;
6773                                   break;
6774                                 }
6775
6776                               offset += ivn.vn_next;
6777                             }
6778                           while (ivn.vn_next);
6779                         }
6780
6781                       if (check_def && data[cnt + j] != 0x8001
6782                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
6783                         {
6784                           Elf_Internal_Verdef ivd;
6785                           Elf_External_Verdef evd;
6786                           unsigned long offset;
6787
6788                           offset = offset_from_vma
6789                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
6790                              sizeof evd);
6791
6792                           do
6793                             {
6794                               get_data (&evd, file, offset, sizeof (evd), 1,
6795                                         _("version def"));
6796
6797                               ivd.vd_next = BYTE_GET (evd.vd_next);
6798                               ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
6799
6800                               offset += ivd.vd_next;
6801                             }
6802                           while (ivd.vd_ndx != (data[cnt + j] & 0x7fff)
6803                                  && ivd.vd_next != 0);
6804
6805                           if (ivd.vd_ndx == (data[cnt + j] & 0x7fff))
6806                             {
6807                               Elf_External_Verdaux evda;
6808                               Elf_Internal_Verdaux ivda;
6809
6810                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
6811
6812                               get_data (&evda, file,
6813                                         offset - ivd.vd_next + ivd.vd_aux,
6814                                         sizeof (evda), 1,
6815                                         _("version def aux"));
6816
6817                               ivda.vda_name = BYTE_GET (evda.vda_name);
6818
6819                               if (ivda.vda_name >= string_sec->sh_size)
6820                                 name = _("*invalid*");
6821                               else
6822                                 name = strtab + ivda.vda_name;
6823                               nn += printf ("(%s%-*s",
6824                                             name,
6825                                             12 - (int) strlen (name),
6826                                             ")");
6827                             }
6828                         }
6829
6830                       if (nn < 18)
6831                         printf ("%*c", 18 - nn, ' ');
6832                     }
6833
6834                 putchar ('\n');
6835               }
6836
6837             free (data);
6838             free (strtab);
6839             free (symbols);
6840           }
6841           break;
6842
6843         default:
6844           break;
6845         }
6846     }
6847
6848   if (! found)
6849     printf (_("\nNo version information found in this file.\n"));
6850
6851   return 1;
6852 }
6853
6854 static const char *
6855 get_symbol_binding (unsigned int binding)
6856 {
6857   static char buff[32];
6858
6859   switch (binding)
6860     {
6861     case STB_LOCAL:     return "LOCAL";
6862     case STB_GLOBAL:    return "GLOBAL";
6863     case STB_WEAK:      return "WEAK";
6864     default:
6865       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
6866         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
6867                   binding);
6868       else if (binding >= STB_LOOS && binding <= STB_HIOS)
6869         snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
6870       else
6871         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
6872       return buff;
6873     }
6874 }
6875
6876 static const char *
6877 get_symbol_type (unsigned int type)
6878 {
6879   static char buff[32];
6880
6881   switch (type)
6882     {
6883     case STT_NOTYPE:    return "NOTYPE";
6884     case STT_OBJECT:    return "OBJECT";
6885     case STT_FUNC:      return "FUNC";
6886     case STT_SECTION:   return "SECTION";
6887     case STT_FILE:      return "FILE";
6888     case STT_COMMON:    return "COMMON";
6889     case STT_TLS:       return "TLS";
6890     case STT_RELC:      return "RELC";
6891     case STT_SRELC:     return "SRELC";
6892     default:
6893       if (type >= STT_LOPROC && type <= STT_HIPROC)
6894         {
6895           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
6896             return "THUMB_FUNC";
6897
6898           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
6899             return "REGISTER";
6900
6901           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
6902             return "PARISC_MILLI";
6903
6904           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
6905         }
6906       else if (type >= STT_LOOS && type <= STT_HIOS)
6907         {
6908           if (elf_header.e_machine == EM_PARISC)
6909             {
6910               if (type == STT_HP_OPAQUE)
6911                 return "HP_OPAQUE";
6912               if (type == STT_HP_STUB)
6913                 return "HP_STUB";
6914             }
6915
6916           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
6917         }
6918       else
6919         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
6920       return buff;
6921     }
6922 }
6923
6924 static const char *
6925 get_symbol_visibility (unsigned int visibility)
6926 {
6927   switch (visibility)
6928     {
6929     case STV_DEFAULT:   return "DEFAULT";
6930     case STV_INTERNAL:  return "INTERNAL";
6931     case STV_HIDDEN:    return "HIDDEN";
6932     case STV_PROTECTED: return "PROTECTED";
6933     default: abort ();
6934     }
6935 }
6936
6937 static const char *
6938 get_mips_symbol_other (unsigned int other)
6939 {
6940   switch (other)
6941     {
6942     case STO_OPTIONAL:  return "OPTIONAL";
6943     case STO_MIPS16:    return "MIPS16";
6944     case STO_MIPS_PLT:  return "MIPS PLT";
6945     case STO_MIPS_PIC:  return "MIPS PIC";
6946     default:            return NULL;
6947     }
6948 }
6949
6950 static const char *
6951 get_symbol_other (unsigned int other)
6952 {
6953   const char * result = NULL;
6954   static char buff [32];
6955
6956   if (other == 0)
6957     return "";
6958
6959   switch (elf_header.e_machine)
6960     {
6961     case EM_MIPS:
6962       result = get_mips_symbol_other (other);
6963     default:
6964       break;
6965     }
6966
6967   if (result)
6968     return result;
6969
6970   snprintf (buff, sizeof buff, _("<other>: %x"), other);
6971   return buff;
6972 }
6973
6974 static const char *
6975 get_symbol_index_type (unsigned int type)
6976 {
6977   static char buff[32];
6978
6979   switch (type)
6980     {
6981     case SHN_UNDEF:     return "UND";
6982     case SHN_ABS:       return "ABS";
6983     case SHN_COMMON:    return "COM";
6984     default:
6985       if (type == SHN_IA_64_ANSI_COMMON
6986           && elf_header.e_machine == EM_IA_64
6987           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
6988         return "ANSI_COM";
6989       else if (elf_header.e_machine == EM_X86_64
6990                && type == SHN_X86_64_LCOMMON)
6991         return "LARGE_COM";
6992       else if (type == SHN_MIPS_SCOMMON
6993                && elf_header.e_machine == EM_MIPS)
6994         return "SCOM";
6995       else if (type == SHN_MIPS_SUNDEFINED
6996                && elf_header.e_machine == EM_MIPS)
6997         return "SUND";
6998       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
6999         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
7000       else if (type >= SHN_LOOS && type <= SHN_HIOS)
7001         sprintf (buff, "OS [0x%04x]", type & 0xffff);
7002       else if (type >= SHN_LORESERVE)
7003         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
7004       else
7005         sprintf (buff, "%3d", type);
7006       break;
7007     }
7008
7009   return buff;
7010 }
7011
7012 static bfd_vma *
7013 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
7014 {
7015   unsigned char * e_data;
7016   bfd_vma * i_data;
7017
7018   e_data = cmalloc (number, ent_size);
7019
7020   if (e_data == NULL)
7021     {
7022       error (_("Out of memory\n"));
7023       return NULL;
7024     }
7025
7026   if (fread (e_data, ent_size, number, file) != number)
7027     {
7028       error (_("Unable to read in dynamic data\n"));
7029       return NULL;
7030     }
7031
7032   i_data = cmalloc (number, sizeof (*i_data));
7033
7034   if (i_data == NULL)
7035     {
7036       error (_("Out of memory\n"));
7037       free (e_data);
7038       return NULL;
7039     }
7040
7041   while (number--)
7042     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
7043
7044   free (e_data);
7045
7046   return i_data;
7047 }
7048
7049 static void
7050 print_dynamic_symbol (bfd_vma si, unsigned long hn)
7051 {
7052   Elf_Internal_Sym * psym;
7053   int n;
7054
7055   psym = dynamic_symbols + si;
7056
7057   n = print_vma (si, DEC_5);
7058   if (n < 5)
7059     fputs ("     " + n, stdout);
7060   printf (" %3lu: ", hn);
7061   print_vma (psym->st_value, LONG_HEX);
7062   putchar (' ');
7063   print_vma (psym->st_size, DEC_5);
7064
7065   printf ("  %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
7066   printf (" %6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
7067   printf (" %3s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
7068   /* Check to see if any other bits in the st_other field are set.
7069      Note - displaying this information disrupts the layout of the
7070      table being generated, but for the moment this case is very
7071      rare.  */
7072   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
7073     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
7074   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
7075   if (VALID_DYNAMIC_NAME (psym->st_name))
7076     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
7077   else
7078     printf (" <corrupt: %14ld>", psym->st_name);
7079   putchar ('\n');
7080 }
7081
7082 /* Dump the symbol table.  */
7083 static int
7084 process_symbol_table (FILE * file)
7085 {
7086   Elf_Internal_Shdr * section;
7087   bfd_vma nbuckets = 0;
7088   bfd_vma nchains = 0;
7089   bfd_vma * buckets = NULL;
7090   bfd_vma * chains = NULL;
7091   bfd_vma ngnubuckets = 0;
7092   bfd_vma * gnubuckets = NULL;
7093   bfd_vma * gnuchains = NULL;
7094   bfd_vma gnusymidx = 0;
7095
7096   if (! do_syms && !do_histogram)
7097     return 1;
7098
7099   if (dynamic_info[DT_HASH]
7100       && (do_histogram
7101           || (do_using_dynamic && dynamic_strings != NULL)))
7102     {
7103       unsigned char nb[8];
7104       unsigned char nc[8];
7105       int hash_ent_size = 4;
7106
7107       if ((elf_header.e_machine == EM_ALPHA
7108            || elf_header.e_machine == EM_S390
7109            || elf_header.e_machine == EM_S390_OLD)
7110           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
7111         hash_ent_size = 8;
7112
7113       if (fseek (file,
7114                  (archive_file_offset
7115                   + offset_from_vma (file, dynamic_info[DT_HASH],
7116                                      sizeof nb + sizeof nc)),
7117                  SEEK_SET))
7118         {
7119           error (_("Unable to seek to start of dynamic information\n"));
7120           return 0;
7121         }
7122
7123       if (fread (nb, hash_ent_size, 1, file) != 1)
7124         {
7125           error (_("Failed to read in number of buckets\n"));
7126           return 0;
7127         }
7128
7129       if (fread (nc, hash_ent_size, 1, file) != 1)
7130         {
7131           error (_("Failed to read in number of chains\n"));
7132           return 0;
7133         }
7134
7135       nbuckets = byte_get (nb, hash_ent_size);
7136       nchains  = byte_get (nc, hash_ent_size);
7137
7138       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
7139       chains  = get_dynamic_data (file, nchains, hash_ent_size);
7140
7141       if (buckets == NULL || chains == NULL)
7142         return 0;
7143     }
7144
7145   if (dynamic_info_DT_GNU_HASH
7146       && (do_histogram
7147           || (do_using_dynamic && dynamic_strings != NULL)))
7148     {
7149       unsigned char nb[16];
7150       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
7151       bfd_vma buckets_vma;
7152
7153       if (fseek (file,
7154                  (archive_file_offset
7155                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
7156                                      sizeof nb)),
7157                  SEEK_SET))
7158         {
7159           error (_("Unable to seek to start of dynamic information\n"));
7160           return 0;
7161         }
7162
7163       if (fread (nb, 16, 1, file) != 1)
7164         {
7165           error (_("Failed to read in number of buckets\n"));
7166           return 0;
7167         }
7168
7169       ngnubuckets = byte_get (nb, 4);
7170       gnusymidx = byte_get (nb + 4, 4);
7171       bitmaskwords = byte_get (nb + 8, 4);
7172       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
7173       if (is_32bit_elf)
7174         buckets_vma += bitmaskwords * 4;
7175       else
7176         buckets_vma += bitmaskwords * 8;
7177
7178       if (fseek (file,
7179                  (archive_file_offset
7180                   + offset_from_vma (file, buckets_vma, 4)),
7181                  SEEK_SET))
7182         {
7183           error (_("Unable to seek to start of dynamic information\n"));
7184           return 0;
7185         }
7186
7187       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
7188
7189       if (gnubuckets == NULL)
7190         return 0;
7191
7192       for (i = 0; i < ngnubuckets; i++)
7193         if (gnubuckets[i] != 0)
7194           {
7195             if (gnubuckets[i] < gnusymidx)
7196               return 0;
7197
7198             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
7199               maxchain = gnubuckets[i];
7200           }
7201
7202       if (maxchain == 0xffffffff)
7203         return 0;
7204
7205       maxchain -= gnusymidx;
7206
7207       if (fseek (file,
7208                  (archive_file_offset
7209                   + offset_from_vma (file, buckets_vma
7210                                            + 4 * (ngnubuckets + maxchain), 4)),
7211                  SEEK_SET))
7212         {
7213           error (_("Unable to seek to start of dynamic information\n"));
7214           return 0;
7215         }
7216
7217       do
7218         {
7219           if (fread (nb, 4, 1, file) != 1)
7220             {
7221               error (_("Failed to determine last chain length\n"));
7222               return 0;
7223             }
7224
7225           if (maxchain + 1 == 0)
7226             return 0;
7227
7228           ++maxchain;
7229         }
7230       while ((byte_get (nb, 4) & 1) == 0);
7231
7232       if (fseek (file,
7233                  (archive_file_offset
7234                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
7235                  SEEK_SET))
7236         {
7237           error (_("Unable to seek to start of dynamic information\n"));
7238           return 0;
7239         }
7240
7241       gnuchains = get_dynamic_data (file, maxchain, 4);
7242
7243       if (gnuchains == NULL)
7244         return 0;
7245     }
7246
7247   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
7248       && do_syms
7249       && do_using_dynamic
7250       && dynamic_strings != NULL)
7251     {
7252       unsigned long hn;
7253
7254       if (dynamic_info[DT_HASH])
7255         {
7256           bfd_vma si;
7257
7258           printf (_("\nSymbol table for image:\n"));
7259           if (is_32bit_elf)
7260             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
7261           else
7262             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
7263
7264           for (hn = 0; hn < nbuckets; hn++)
7265             {
7266               if (! buckets[hn])
7267                 continue;
7268
7269               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
7270                 print_dynamic_symbol (si, hn);
7271             }
7272         }
7273
7274       if (dynamic_info_DT_GNU_HASH)
7275         {
7276           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7277           if (is_32bit_elf)
7278             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
7279           else
7280             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
7281
7282           for (hn = 0; hn < ngnubuckets; ++hn)
7283             if (gnubuckets[hn] != 0)
7284               {
7285                 bfd_vma si = gnubuckets[hn];
7286                 bfd_vma off = si - gnusymidx;
7287
7288                 do
7289                   {
7290                     print_dynamic_symbol (si, hn);
7291                     si++;
7292                   }
7293                 while ((gnuchains[off++] & 1) == 0);
7294               }
7295         }
7296     }
7297   else if (do_syms && !do_using_dynamic)
7298     {
7299       unsigned int i;
7300
7301       for (i = 0, section = section_headers;
7302            i < elf_header.e_shnum;
7303            i++, section++)
7304         {
7305           unsigned int si;
7306           char * strtab = NULL;
7307           unsigned long int strtab_size = 0;
7308           Elf_Internal_Sym * symtab;
7309           Elf_Internal_Sym * psym;
7310
7311           if (   section->sh_type != SHT_SYMTAB
7312               && section->sh_type != SHT_DYNSYM)
7313             continue;
7314
7315           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7316                   SECTION_NAME (section),
7317                   (unsigned long) (section->sh_size / section->sh_entsize));
7318           if (is_32bit_elf)
7319             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
7320           else
7321             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
7322
7323           symtab = GET_ELF_SYMBOLS (file, section);
7324           if (symtab == NULL)
7325             continue;
7326
7327           if (section->sh_link == elf_header.e_shstrndx)
7328             {
7329               strtab = string_table;
7330               strtab_size = string_table_length;
7331             }
7332           else if (section->sh_link < elf_header.e_shnum)
7333             {
7334               Elf_Internal_Shdr * string_sec;
7335
7336               string_sec = section_headers + section->sh_link;
7337
7338               strtab = get_data (NULL, file, string_sec->sh_offset,
7339                                  1, string_sec->sh_size, _("string table"));
7340               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
7341             }
7342
7343           for (si = 0, psym = symtab;
7344                si < section->sh_size / section->sh_entsize;
7345                si++, psym++)
7346             {
7347               printf ("%6d: ", si);
7348               print_vma (psym->st_value, LONG_HEX);
7349               putchar (' ');
7350               print_vma (psym->st_size, DEC_5);
7351               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
7352               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
7353               printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
7354               /* Check to see if any other bits in the st_other field are set.
7355                  Note - displaying this information disrupts the layout of the
7356                  table being generated, but for the moment this case is very rare.  */
7357               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
7358                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
7359               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
7360               print_symbol (25, psym->st_name < strtab_size
7361                             ? strtab + psym->st_name : "<corrupt>");
7362
7363               if (section->sh_type == SHT_DYNSYM &&
7364                   version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
7365                 {
7366                   unsigned char data[2];
7367                   unsigned short vers_data;
7368                   unsigned long offset;
7369                   int is_nobits;
7370                   int check_def;
7371
7372                   offset = offset_from_vma
7373                     (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
7374                      sizeof data + si * sizeof (vers_data));
7375
7376                   get_data (&data, file, offset + si * sizeof (vers_data),
7377                             sizeof (data), 1, _("version data"));
7378
7379                   vers_data = byte_get (data, 2);
7380
7381                   is_nobits = (psym->st_shndx < elf_header.e_shnum
7382                                && section_headers[psym->st_shndx].sh_type
7383                                   == SHT_NOBITS);
7384
7385                   check_def = (psym->st_shndx != SHN_UNDEF);
7386
7387                   if ((vers_data & 0x8000) || vers_data > 1)
7388                     {
7389                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
7390                           && (is_nobits || ! check_def))
7391                         {
7392                           Elf_External_Verneed evn;
7393                           Elf_Internal_Verneed ivn;
7394                           Elf_Internal_Vernaux ivna;
7395
7396                           /* We must test both.  */
7397                           offset = offset_from_vma
7398                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
7399                              sizeof evn);
7400
7401                           do
7402                             {
7403                               unsigned long vna_off;
7404
7405                               get_data (&evn, file, offset, sizeof (evn), 1,
7406                                         _("version need"));
7407
7408                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
7409                               ivn.vn_next = BYTE_GET (evn.vn_next);
7410
7411                               vna_off = offset + ivn.vn_aux;
7412
7413                               do
7414                                 {
7415                                   Elf_External_Vernaux evna;
7416
7417                                   get_data (&evna, file, vna_off,
7418                                             sizeof (evna), 1,
7419                                             _("version need aux (3)"));
7420
7421                                   ivna.vna_other = BYTE_GET (evna.vna_other);
7422                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
7423                                   ivna.vna_name  = BYTE_GET (evna.vna_name);
7424
7425                                   vna_off += ivna.vna_next;
7426                                 }
7427                               while (ivna.vna_other != vers_data
7428                                      && ivna.vna_next != 0);
7429
7430                               if (ivna.vna_other == vers_data)
7431                                 break;
7432
7433                               offset += ivn.vn_next;
7434                             }
7435                           while (ivn.vn_next != 0);
7436
7437                           if (ivna.vna_other == vers_data)
7438                             {
7439                               printf ("@%s (%d)",
7440                                       ivna.vna_name < strtab_size
7441                                       ? strtab + ivna.vna_name : "<corrupt>",
7442                                       ivna.vna_other);
7443                               check_def = 0;
7444                             }
7445                           else if (! is_nobits)
7446                             error (_("bad dynamic symbol\n"));
7447                           else
7448                             check_def = 1;
7449                         }
7450
7451                       if (check_def)
7452                         {
7453                           if (vers_data != 0x8001
7454                               && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
7455                             {
7456                               Elf_Internal_Verdef ivd;
7457                               Elf_Internal_Verdaux ivda;
7458                               Elf_External_Verdaux evda;
7459                               unsigned long offset;
7460
7461                               offset = offset_from_vma
7462                                 (file,
7463                                  version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
7464                                  sizeof (Elf_External_Verdef));
7465
7466                               do
7467                                 {
7468                                   Elf_External_Verdef evd;
7469
7470                                   get_data (&evd, file, offset, sizeof (evd),
7471                                             1, _("version def"));
7472
7473                                   ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
7474                                   ivd.vd_aux = BYTE_GET (evd.vd_aux);
7475                                   ivd.vd_next = BYTE_GET (evd.vd_next);
7476
7477                                   offset += ivd.vd_next;
7478                                 }
7479                               while (ivd.vd_ndx != (vers_data & 0x7fff)
7480                                      && ivd.vd_next != 0);
7481
7482                               offset -= ivd.vd_next;
7483                               offset += ivd.vd_aux;
7484
7485                               get_data (&evda, file, offset, sizeof (evda),
7486                                         1, _("version def aux"));
7487
7488                               ivda.vda_name = BYTE_GET (evda.vda_name);
7489
7490                               if (psym->st_name != ivda.vda_name)
7491                                 printf ((vers_data & 0x8000)
7492                                         ? "@%s" : "@@%s",
7493                                         ivda.vda_name < strtab_size
7494                                         ? strtab + ivda.vda_name : "<corrupt>");
7495                             }
7496                         }
7497                     }
7498                 }
7499
7500               putchar ('\n');
7501             }
7502
7503           free (symtab);
7504           if (strtab != string_table)
7505             free (strtab);
7506         }
7507     }
7508   else if (do_syms)
7509     printf
7510       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7511
7512   if (do_histogram && buckets != NULL)
7513     {
7514       unsigned long * lengths;
7515       unsigned long * counts;
7516       unsigned long hn;
7517       bfd_vma si;
7518       unsigned long maxlength = 0;
7519       unsigned long nzero_counts = 0;
7520       unsigned long nsyms = 0;
7521
7522       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7523               (unsigned long) nbuckets);
7524       printf (_(" Length  Number     %% of total  Coverage\n"));
7525
7526       lengths = calloc (nbuckets, sizeof (*lengths));
7527       if (lengths == NULL)
7528         {
7529           error (_("Out of memory\n"));
7530           return 0;
7531         }
7532       for (hn = 0; hn < nbuckets; ++hn)
7533         {
7534           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
7535             {
7536               ++nsyms;
7537               if (maxlength < ++lengths[hn])
7538                 ++maxlength;
7539             }
7540         }
7541
7542       counts = calloc (maxlength + 1, sizeof (*counts));
7543       if (counts == NULL)
7544         {
7545           error (_("Out of memory\n"));
7546           return 0;
7547         }
7548
7549       for (hn = 0; hn < nbuckets; ++hn)
7550         ++counts[lengths[hn]];
7551
7552       if (nbuckets > 0)
7553         {
7554           unsigned long i;
7555           printf ("      0  %-10lu (%5.1f%%)\n",
7556                   counts[0], (counts[0] * 100.0) / nbuckets);
7557           for (i = 1; i <= maxlength; ++i)
7558             {
7559               nzero_counts += counts[i] * i;
7560               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
7561                       i, counts[i], (counts[i] * 100.0) / nbuckets,
7562                       (nzero_counts * 100.0) / nsyms);
7563             }
7564         }
7565
7566       free (counts);
7567       free (lengths);
7568     }
7569
7570   if (buckets != NULL)
7571     {
7572       free (buckets);
7573       free (chains);
7574     }
7575
7576   if (do_histogram && dynamic_info_DT_GNU_HASH)
7577     {
7578       unsigned long * lengths;
7579       unsigned long * counts;
7580       unsigned long hn;
7581       unsigned long maxlength = 0;
7582       unsigned long nzero_counts = 0;
7583       unsigned long nsyms = 0;
7584
7585       lengths = calloc (ngnubuckets, sizeof (*lengths));
7586       if (lengths == NULL)
7587         {
7588           error (_("Out of memory\n"));
7589           return 0;
7590         }
7591
7592       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7593               (unsigned long) ngnubuckets);
7594       printf (_(" Length  Number     %% of total  Coverage\n"));
7595
7596       for (hn = 0; hn < ngnubuckets; ++hn)
7597         if (gnubuckets[hn] != 0)
7598           {
7599             bfd_vma off, length = 1;
7600
7601             for (off = gnubuckets[hn] - gnusymidx;
7602                  (gnuchains[off] & 1) == 0; ++off)
7603               ++length;
7604             lengths[hn] = length;
7605             if (length > maxlength)
7606               maxlength = length;
7607             nsyms += length;
7608           }
7609
7610       counts = calloc (maxlength + 1, sizeof (*counts));
7611       if (counts == NULL)
7612         {
7613           error (_("Out of memory\n"));
7614           return 0;
7615         }
7616
7617       for (hn = 0; hn < ngnubuckets; ++hn)
7618         ++counts[lengths[hn]];
7619
7620       if (ngnubuckets > 0)
7621         {
7622           unsigned long j;
7623           printf ("      0  %-10lu (%5.1f%%)\n",
7624                   counts[0], (counts[0] * 100.0) / ngnubuckets);
7625           for (j = 1; j <= maxlength; ++j)
7626             {
7627               nzero_counts += counts[j] * j;
7628               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
7629                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
7630                       (nzero_counts * 100.0) / nsyms);
7631             }
7632         }
7633
7634       free (counts);
7635       free (lengths);
7636       free (gnubuckets);
7637       free (gnuchains);
7638     }
7639
7640   return 1;
7641 }
7642
7643 static int
7644 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
7645 {
7646   unsigned int i;
7647
7648   if (dynamic_syminfo == NULL
7649       || !do_dynamic)
7650     /* No syminfo, this is ok.  */
7651     return 1;
7652
7653   /* There better should be a dynamic symbol section.  */
7654   if (dynamic_symbols == NULL || dynamic_strings == NULL)
7655     return 0;
7656
7657   if (dynamic_addr)
7658     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7659             dynamic_syminfo_offset, dynamic_syminfo_nent);
7660
7661   printf (_(" Num: Name                           BoundTo     Flags\n"));
7662   for (i = 0; i < dynamic_syminfo_nent; ++i)
7663     {
7664       unsigned short int flags = dynamic_syminfo[i].si_flags;
7665
7666       printf ("%4d: ", i);
7667       if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
7668         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
7669       else
7670         printf ("<corrupt: %19ld>", dynamic_symbols[i].st_name);
7671       putchar (' ');
7672
7673       switch (dynamic_syminfo[i].si_boundto)
7674         {
7675         case SYMINFO_BT_SELF:
7676           fputs ("SELF       ", stdout);
7677           break;
7678         case SYMINFO_BT_PARENT:
7679           fputs ("PARENT     ", stdout);
7680           break;
7681         default:
7682           if (dynamic_syminfo[i].si_boundto > 0
7683               && dynamic_syminfo[i].si_boundto < dynamic_nent
7684               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
7685             {
7686               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
7687               putchar (' ' );
7688             }
7689           else
7690             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
7691           break;
7692         }
7693
7694       if (flags & SYMINFO_FLG_DIRECT)
7695         printf (" DIRECT");
7696       if (flags & SYMINFO_FLG_PASSTHRU)
7697         printf (" PASSTHRU");
7698       if (flags & SYMINFO_FLG_COPY)
7699         printf (" COPY");
7700       if (flags & SYMINFO_FLG_LAZYLOAD)
7701         printf (" LAZYLOAD");
7702
7703       puts ("");
7704     }
7705
7706   return 1;
7707 }
7708
7709 #ifdef SUPPORT_DISASSEMBLY
7710 static int
7711 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
7712 {
7713   printf (_("\nAssembly dump of section %s\n"),
7714           SECTION_NAME (section));
7715
7716   /* XXX -- to be done --- XXX */
7717
7718   return 1;
7719 }
7720 #endif
7721
7722 static int
7723 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
7724 {
7725   Elf_Internal_Shdr * relsec;
7726   bfd_size_type num_bytes;
7727   bfd_vma addr;
7728   char * data;
7729   char * end;
7730   char * start;
7731   char * name = SECTION_NAME (section);
7732   bfd_boolean some_strings_shown;
7733
7734   num_bytes = section->sh_size;
7735
7736   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
7737     {
7738       printf (_("\nSection '%s' has no data to dump.\n"), name);
7739       return 0;
7740     }
7741
7742   addr = section->sh_addr;
7743
7744   start = get_data (NULL, file, section->sh_offset, 1, num_bytes,
7745                     _("section data"));
7746   if (!start)
7747     return 0;
7748
7749   printf (_("\nString dump of section '%s':\n"), name);
7750
7751   /* If the section being dumped has relocations against it the user might
7752      be expecting these relocations to have been applied.  Check for this
7753      case and issue a warning message in order to avoid confusion.
7754      FIXME: Maybe we ought to have an option that dumps a section with
7755      relocs applied ?  */
7756   for (relsec = section_headers;
7757        relsec < section_headers + elf_header.e_shnum;
7758        ++relsec)
7759     {
7760       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
7761           || relsec->sh_info >= elf_header.e_shnum
7762           || section_headers + relsec->sh_info != section
7763           || relsec->sh_size == 0
7764           || relsec->sh_link >= elf_header.e_shnum)
7765         continue;
7766
7767       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7768       break;
7769     }
7770
7771   data = start;
7772   end  = start + num_bytes;
7773   some_strings_shown = FALSE;
7774
7775   while (data < end)
7776     {
7777       while (!ISPRINT (* data))
7778         if (++ data >= end)
7779           break;
7780
7781       if (data < end)
7782         {
7783 #ifndef __MSVCRT__
7784           printf ("  [%6tx]  %s\n", data - start, data);
7785 #else
7786           printf ("  [%6Ix]  %s\n", (size_t) (data - start), data);
7787 #endif
7788           data += strlen (data);
7789           some_strings_shown = TRUE;
7790         }
7791     }
7792
7793   if (! some_strings_shown)
7794     printf (_("  No strings found in this section."));
7795
7796   free (start);
7797
7798   putchar ('\n');
7799   return 1;
7800 }
7801
7802
7803 static int
7804 dump_section_as_bytes (Elf_Internal_Shdr * section, FILE * file)
7805 {
7806   Elf_Internal_Shdr * relsec;
7807   bfd_size_type bytes;
7808   bfd_vma addr;
7809   unsigned char * data;
7810   unsigned char * start;
7811
7812   bytes = section->sh_size;
7813
7814   if (bytes == 0 || section->sh_type == SHT_NOBITS)
7815     {
7816       printf (_("\nSection '%s' has no data to dump.\n"),
7817               SECTION_NAME (section));
7818       return 0;
7819     }
7820   else
7821     printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
7822
7823   addr = section->sh_addr;
7824
7825   start = get_data (NULL, file, section->sh_offset, 1, bytes,
7826                     _("section data"));
7827   if (!start)
7828     return 0;
7829
7830   /* If the section being dumped has relocations against it the user might
7831      be expecting these relocations to have been applied.  Check for this
7832      case and issue a warning message in order to avoid confusion.
7833      FIXME: Maybe we ought to have an option that dumps a section with
7834      relocs applied ?  */
7835   for (relsec = section_headers;
7836        relsec < section_headers + elf_header.e_shnum;
7837        ++relsec)
7838     {
7839       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
7840           || relsec->sh_info >= elf_header.e_shnum
7841           || section_headers + relsec->sh_info != section
7842           || relsec->sh_size == 0
7843           || relsec->sh_link >= elf_header.e_shnum)
7844         continue;
7845
7846       printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7847       break;
7848     }
7849
7850   data = start;
7851
7852   while (bytes)
7853     {
7854       int j;
7855       int k;
7856       int lbytes;
7857
7858       lbytes = (bytes > 16 ? 16 : bytes);
7859
7860       printf ("  0x%8.8lx ", (unsigned long) addr);
7861
7862       for (j = 0; j < 16; j++)
7863         {
7864           if (j < lbytes)
7865             printf ("%2.2x", data[j]);
7866           else
7867             printf ("  ");
7868
7869           if ((j & 3) == 3)
7870             printf (" ");
7871         }
7872
7873       for (j = 0; j < lbytes; j++)
7874         {
7875           k = data[j];
7876           if (k >= ' ' && k < 0x7f)
7877             printf ("%c", k);
7878           else
7879             printf (".");
7880         }
7881
7882       putchar ('\n');
7883
7884       data  += lbytes;
7885       addr  += lbytes;
7886       bytes -= lbytes;
7887     }
7888
7889   free (start);
7890
7891   putchar ('\n');
7892   return 1;
7893 }
7894
7895 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
7896    DWARF debug sections.  This is a target specific test.  Note - we do not
7897    go through the whole including-target-headers-multiple-times route, (as
7898    we have already done with <elf/h8.h>) because this would become very
7899    messy and even then this function would have to contain target specific
7900    information (the names of the relocs instead of their numeric values).
7901    FIXME: This is not the correct way to solve this problem.  The proper way
7902    is to have target specific reloc sizing and typing functions created by
7903    the reloc-macros.h header, in the same way that it already creates the
7904    reloc naming functions.  */
7905
7906 static bfd_boolean
7907 is_32bit_abs_reloc (unsigned int reloc_type)
7908 {
7909   switch (elf_header.e_machine)
7910     {
7911     case EM_386:
7912     case EM_486:
7913       return reloc_type == 1; /* R_386_32.  */
7914     case EM_68K:
7915       return reloc_type == 1; /* R_68K_32.  */
7916     case EM_860:
7917       return reloc_type == 1; /* R_860_32.  */
7918     case EM_ALPHA:
7919       return reloc_type == 1; /* XXX Is this right ?  */
7920     case EM_ARC:
7921       return reloc_type == 1; /* R_ARC_32.  */
7922     case EM_ARM:
7923       return reloc_type == 2; /* R_ARM_ABS32 */
7924     case EM_AVR_OLD:
7925     case EM_AVR:
7926       return reloc_type == 1;
7927     case EM_BLACKFIN:
7928       return reloc_type == 0x12; /* R_byte4_data.  */
7929     case EM_CRIS:
7930       return reloc_type == 3; /* R_CRIS_32.  */
7931     case EM_CR16:
7932     case EM_CR16_OLD:
7933       return reloc_type == 3; /* R_CR16_NUM32.  */
7934     case EM_CRX:
7935       return reloc_type == 15; /* R_CRX_NUM32.  */
7936     case EM_CYGNUS_FRV:
7937       return reloc_type == 1;
7938     case EM_CYGNUS_D10V:
7939     case EM_D10V:
7940       return reloc_type == 6; /* R_D10V_32.  */
7941     case EM_CYGNUS_D30V:
7942     case EM_D30V:
7943       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
7944     case EM_DLX:
7945       return reloc_type == 3; /* R_DLX_RELOC_32.  */
7946     case EM_CYGNUS_FR30:
7947     case EM_FR30:
7948       return reloc_type == 3; /* R_FR30_32.  */
7949     case EM_H8S:
7950     case EM_H8_300:
7951     case EM_H8_300H:
7952       return reloc_type == 1; /* R_H8_DIR32.  */
7953     case EM_IA_64:
7954       return reloc_type == 0x65; /* R_IA64_SECREL32LSB.  */
7955     case EM_IP2K_OLD:
7956     case EM_IP2K:
7957       return reloc_type == 2; /* R_IP2K_32.  */
7958     case EM_IQ2000:
7959       return reloc_type == 2; /* R_IQ2000_32.  */
7960     case EM_LATTICEMICO32:
7961       return reloc_type == 3; /* R_LM32_32.  */
7962     case EM_M32C_OLD:
7963     case EM_M32C:
7964       return reloc_type == 3; /* R_M32C_32.  */
7965     case EM_M32R:
7966       return reloc_type == 34; /* R_M32R_32_RELA.  */
7967     case EM_MCORE:
7968       return reloc_type == 1; /* R_MCORE_ADDR32.  */
7969     case EM_CYGNUS_MEP:
7970       return reloc_type == 4; /* R_MEP_32.  */
7971     case EM_MIPS:
7972       return reloc_type == 2; /* R_MIPS_32.  */
7973     case EM_MMIX:
7974       return reloc_type == 4; /* R_MMIX_32.  */
7975     case EM_CYGNUS_MN10200:
7976     case EM_MN10200:
7977       return reloc_type == 1; /* R_MN10200_32.  */
7978     case EM_CYGNUS_MN10300:
7979     case EM_MN10300:
7980       return reloc_type == 1; /* R_MN10300_32.  */
7981     case EM_MSP430_OLD:
7982     case EM_MSP430:
7983       return reloc_type == 1; /* R_MSP43_32.  */
7984     case EM_MT:
7985       return reloc_type == 2; /* R_MT_32.  */
7986     case EM_ALTERA_NIOS2:
7987     case EM_NIOS32:
7988       return reloc_type == 1; /* R_NIOS_32.  */
7989     case EM_OPENRISC:
7990     case EM_OR32:
7991       return reloc_type == 1; /* R_OR32_32.  */
7992     case EM_PARISC:
7993       return reloc_type == 1; /* R_PARISC_DIR32.  */
7994     case EM_PJ:
7995     case EM_PJ_OLD:
7996       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
7997     case EM_PPC64:
7998       return reloc_type == 1; /* R_PPC64_ADDR32.  */
7999     case EM_PPC:
8000       return reloc_type == 1; /* R_PPC_ADDR32.  */
8001     case EM_S370:
8002       return reloc_type == 1; /* R_I370_ADDR31.  */
8003     case EM_S390_OLD:
8004     case EM_S390:
8005       return reloc_type == 4; /* R_S390_32.  */
8006     case EM_SCORE:
8007       return reloc_type == 8; /* R_SCORE_ABS32.  */
8008     case EM_SH:
8009       return reloc_type == 1; /* R_SH_DIR32.  */
8010     case EM_SPARC32PLUS:
8011     case EM_SPARCV9:
8012     case EM_SPARC:
8013       return reloc_type == 3 /* R_SPARC_32.  */
8014         || reloc_type == 23; /* R_SPARC_UA32.  */
8015     case EM_SPU:
8016       return reloc_type == 6; /* R_SPU_ADDR32 */
8017     case EM_CYGNUS_V850:
8018     case EM_V850:
8019       return reloc_type == 6; /* R_V850_ABS32.  */
8020     case EM_VAX:
8021       return reloc_type == 1; /* R_VAX_32.  */
8022     case EM_X86_64:
8023       return reloc_type == 10; /* R_X86_64_32.  */
8024     case EM_XSTORMY16:
8025       return reloc_type == 1; /* R_XSTROMY16_32.  */
8026     case EM_XTENSA_OLD:
8027     case EM_XTENSA:
8028       return reloc_type == 1; /* R_XTENSA_32.  */
8029
8030     default:
8031       error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8032              elf_header.e_machine);
8033       abort ();
8034     }
8035 }
8036
8037 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8038    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
8039
8040 static bfd_boolean
8041 is_32bit_pcrel_reloc (unsigned int reloc_type)
8042 {
8043   switch (elf_header.e_machine)
8044     {
8045     case EM_386:
8046     case EM_486:
8047       return reloc_type == 2;  /* R_386_PC32.  */
8048     case EM_68K:
8049       return reloc_type == 4;  /* R_68K_PC32.  */
8050     case EM_ALPHA:
8051       return reloc_type == 10; /* R_ALPHA_SREL32.  */
8052     case EM_ARM:
8053       return reloc_type == 3;  /* R_ARM_REL32 */
8054     case EM_PARISC:
8055       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
8056     case EM_PPC:
8057       return reloc_type == 26; /* R_PPC_REL32.  */
8058     case EM_PPC64:
8059       return reloc_type == 26; /* R_PPC64_REL32.  */
8060     case EM_S390_OLD:
8061     case EM_S390:
8062       return reloc_type == 5;  /* R_390_PC32.  */
8063     case EM_SH:
8064       return reloc_type == 2;  /* R_SH_REL32.  */
8065     case EM_SPARC32PLUS:
8066     case EM_SPARCV9:
8067     case EM_SPARC:
8068       return reloc_type == 6;  /* R_SPARC_DISP32.  */
8069     case EM_SPU:
8070       return reloc_type == 13; /* R_SPU_REL32.  */
8071     case EM_X86_64:
8072       return reloc_type == 2;  /* R_X86_64_PC32.  */
8073     case EM_XTENSA_OLD:
8074     case EM_XTENSA:
8075       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
8076     default:
8077       /* Do not abort or issue an error message here.  Not all targets use
8078          pc-relative 32-bit relocs in their DWARF debug information and we
8079          have already tested for target coverage in is_32bit_abs_reloc.  A
8080          more helpful warning message will be generated by
8081          debug_apply_relocations anyway, so just return.  */
8082       return FALSE;
8083     }
8084 }
8085
8086 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8087    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
8088
8089 static bfd_boolean
8090 is_64bit_abs_reloc (unsigned int reloc_type)
8091 {
8092   switch (elf_header.e_machine)
8093     {
8094     case EM_ALPHA:
8095       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
8096     case EM_IA_64:
8097       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
8098     case EM_PARISC:
8099       return reloc_type == 80; /* R_PARISC_DIR64.  */
8100     case EM_PPC64:
8101       return reloc_type == 38; /* R_PPC64_ADDR64.  */
8102     case EM_SPARC32PLUS:
8103     case EM_SPARCV9:
8104     case EM_SPARC:
8105       return reloc_type == 54; /* R_SPARC_UA64.  */
8106     case EM_X86_64:
8107       return reloc_type == 1; /* R_X86_64_64.  */
8108     case EM_S390_OLD:
8109     case EM_S390:
8110       return reloc_type == 22;  /* R_S390_64 */
8111     case EM_MIPS:
8112       return reloc_type == 18;  /* R_MIPS_64 */
8113     default:
8114       return FALSE;
8115     }
8116 }
8117
8118 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
8119    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
8120
8121 static bfd_boolean
8122 is_64bit_pcrel_reloc (unsigned int reloc_type)
8123 {
8124   switch (elf_header.e_machine)
8125     {
8126     case EM_ALPHA:
8127       return reloc_type == 11; /* R_ALPHA_SREL64 */
8128     case EM_IA_64:
8129       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB */
8130     case EM_PARISC:
8131       return reloc_type == 72; /* R_PARISC_PCREL64 */
8132     case EM_PPC64:
8133       return reloc_type == 44; /* R_PPC64_REL64 */
8134     case EM_SPARC32PLUS:
8135     case EM_SPARCV9:
8136     case EM_SPARC:
8137       return reloc_type == 46; /* R_SPARC_DISP64 */
8138     case EM_X86_64:
8139       return reloc_type == 24; /* R_X86_64_PC64 */
8140     case EM_S390_OLD:
8141     case EM_S390:
8142       return reloc_type == 23;  /* R_S390_PC64 */
8143     default:
8144       return FALSE;
8145     }
8146 }
8147
8148 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8149    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
8150
8151 static bfd_boolean
8152 is_16bit_abs_reloc (unsigned int reloc_type)
8153 {
8154   switch (elf_header.e_machine)
8155     {
8156     case EM_AVR_OLD:
8157     case EM_AVR:
8158       return reloc_type == 4; /* R_AVR_16.  */
8159     case EM_CYGNUS_D10V:
8160     case EM_D10V:
8161       return reloc_type == 3; /* R_D10V_16.  */
8162     case EM_H8S:
8163     case EM_H8_300:
8164     case EM_H8_300H:
8165       return reloc_type == R_H8_DIR16;
8166     case EM_IP2K_OLD:
8167     case EM_IP2K:
8168       return reloc_type == 1; /* R_IP2K_16.  */
8169     case EM_M32C_OLD:
8170     case EM_M32C:
8171       return reloc_type == 1; /* R_M32C_16 */
8172     case EM_MSP430_OLD:
8173     case EM_MSP430:
8174       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
8175     case EM_ALTERA_NIOS2:
8176     case EM_NIOS32:
8177       return reloc_type == 9; /* R_NIOS_16.  */
8178     default:
8179       return FALSE;
8180     }
8181 }
8182
8183 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
8184    relocation entries (possibly formerly used for SHT_GROUP sections).  */
8185
8186 static bfd_boolean
8187 is_none_reloc (unsigned int reloc_type)
8188 {
8189   switch (elf_header.e_machine)
8190     {
8191     case EM_68K:     /* R_68K_NONE.  */
8192     case EM_386:     /* R_386_NONE.  */
8193     case EM_SPARC32PLUS:
8194     case EM_SPARCV9:
8195     case EM_SPARC:   /* R_SPARC_NONE.  */
8196     case EM_MIPS:    /* R_MIPS_NONE.  */
8197     case EM_PARISC:  /* R_PARISC_NONE.  */
8198     case EM_ALPHA:   /* R_ALPHA_NONE.  */
8199     case EM_PPC:     /* R_PPC_NONE.  */
8200     case EM_PPC64:   /* R_PPC64_NONE.  */
8201     case EM_ARM:     /* R_ARM_NONE.  */
8202     case EM_IA_64:   /* R_IA64_NONE.  */
8203     case EM_SH:      /* R_SH_NONE.  */
8204     case EM_S390_OLD:
8205     case EM_S390:    /* R_390_NONE.  */
8206     case EM_CRIS:    /* R_CRIS_NONE.  */
8207     case EM_X86_64:  /* R_X86_64_NONE.  */
8208     case EM_MN10300: /* R_MN10300_NONE.  */
8209     case EM_M32R:    /* R_M32R_NONE.  */
8210       return reloc_type == 0;
8211     }
8212   return FALSE;
8213 }
8214
8215 /* Uncompresses a section that was compressed using zlib, in place.
8216    This is a copy of bfd_uncompress_section_contents, in bfd/compress.c  */
8217
8218 static int
8219 uncompress_section_contents (unsigned char ** buffer, dwarf_size_type * size)
8220 {
8221 #ifndef HAVE_ZLIB_H
8222   /* These are just to quiet gcc.  */
8223   buffer = 0;
8224   size = 0;
8225   return FALSE;
8226 #else
8227   dwarf_size_type compressed_size = *size;
8228   unsigned char * compressed_buffer = *buffer;
8229   dwarf_size_type uncompressed_size;
8230   unsigned char * uncompressed_buffer;
8231   z_stream strm;
8232   int rc;
8233   dwarf_size_type header_size = 12;
8234
8235   /* Read the zlib header.  In this case, it should be "ZLIB" followed
8236      by the uncompressed section size, 8 bytes in big-endian order.  */
8237   if (compressed_size < header_size
8238       || ! streq ((char *) compressed_buffer, "ZLIB"))
8239     return 0;
8240
8241   uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
8242   uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
8243   uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
8244   uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
8245   uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
8246   uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
8247   uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
8248   uncompressed_size += compressed_buffer[11];
8249
8250   /* It is possible the section consists of several compressed
8251      buffers concatenated together, so we uncompress in a loop.  */
8252   strm.zalloc = NULL;
8253   strm.zfree = NULL;
8254   strm.opaque = NULL;
8255   strm.avail_in = compressed_size - header_size;
8256   strm.next_in = (Bytef *) compressed_buffer + header_size;
8257   strm.avail_out = uncompressed_size;
8258   uncompressed_buffer = xmalloc (uncompressed_size);
8259
8260   rc = inflateInit (& strm);
8261   while (strm.avail_in > 0)
8262     {
8263       if (rc != Z_OK)
8264         goto fail;
8265       strm.next_out = ((Bytef *) uncompressed_buffer
8266                        + (uncompressed_size - strm.avail_out));
8267       rc = inflate (&strm, Z_FINISH);
8268       if (rc != Z_STREAM_END)
8269         goto fail;
8270       rc = inflateReset (& strm);
8271     }
8272   rc = inflateEnd (& strm);
8273   if (rc != Z_OK
8274       || strm.avail_out != 0)
8275     goto fail;
8276
8277   free (compressed_buffer);
8278   *buffer = uncompressed_buffer;
8279   *size = uncompressed_size;
8280   return 1;
8281
8282  fail:
8283   free (uncompressed_buffer);
8284   return 0;
8285 #endif  /* HAVE_ZLIB_H */
8286 }
8287
8288 /* Apply relocations to a debug section.  */
8289
8290 static void
8291 debug_apply_relocations (void * file,
8292                          Elf_Internal_Shdr * section,
8293                          unsigned char * start)
8294 {
8295   Elf_Internal_Shdr * relsec;
8296   unsigned char * end = start + section->sh_size;
8297
8298   if (elf_header.e_type != ET_REL)
8299     return;
8300
8301   /* Find the reloc section associated with the debug section.  */
8302   for (relsec = section_headers;
8303        relsec < section_headers + elf_header.e_shnum;
8304        ++relsec)
8305     {
8306       bfd_boolean is_rela;
8307       unsigned long num_relocs;
8308       Elf_Internal_Rela * relocs;
8309       Elf_Internal_Rela * rp;
8310       Elf_Internal_Shdr * symsec;
8311       Elf_Internal_Sym * symtab;
8312       Elf_Internal_Sym * sym;
8313
8314       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
8315           || relsec->sh_info >= elf_header.e_shnum
8316           || section_headers + relsec->sh_info != section
8317           || relsec->sh_size == 0
8318           || relsec->sh_link >= elf_header.e_shnum)
8319         continue;
8320
8321       is_rela = relsec->sh_type == SHT_RELA;
8322
8323       if (is_rela)
8324         {
8325           if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
8326                                   & relocs, & num_relocs))
8327             return;
8328         }
8329       else
8330         {
8331           if (!slurp_rel_relocs (file, relsec->sh_offset, relsec->sh_size,
8332                                  & relocs, & num_relocs))
8333             return;
8334         }
8335
8336       /* SH uses RELA but uses in place value instead of the addend field.  */
8337       if (elf_header.e_machine == EM_SH)
8338         is_rela = FALSE;
8339
8340       symsec = section_headers + relsec->sh_link;
8341       symtab = GET_ELF_SYMBOLS (file, symsec);
8342
8343       for (rp = relocs; rp < relocs + num_relocs; ++rp)
8344         {
8345           bfd_vma         addend;
8346           unsigned int    reloc_type;
8347           unsigned int    reloc_size;
8348           unsigned char * loc;
8349
8350           reloc_type = get_reloc_type (rp->r_info);
8351
8352           if (is_none_reloc (reloc_type))
8353             continue;
8354
8355           if (is_32bit_abs_reloc (reloc_type)
8356               || is_32bit_pcrel_reloc (reloc_type))
8357             reloc_size = 4;
8358           else if (is_64bit_abs_reloc (reloc_type)
8359                    || is_64bit_pcrel_reloc (reloc_type))
8360             reloc_size = 8;
8361           else if (is_16bit_abs_reloc (reloc_type))
8362             reloc_size = 2;
8363           else
8364             {
8365               warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8366                     reloc_type, SECTION_NAME (section));
8367               continue;
8368             }
8369
8370           loc = start + rp->r_offset;
8371           if ((loc + reloc_size) > end)
8372             {
8373               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8374                     (unsigned long) rp->r_offset,
8375                     SECTION_NAME (section));
8376               continue;
8377             }
8378
8379           sym = symtab + get_reloc_symindex (rp->r_info);
8380
8381           /* If the reloc has a symbol associated with it,
8382              make sure that it is of an appropriate type.
8383
8384              Relocations against symbols without type can happen.
8385              Gcc -feliminate-dwarf2-dups may generate symbols
8386              without type for debug info.
8387
8388              Icc generates relocations against function symbols
8389              instead of local labels.
8390
8391              Relocations against object symbols can happen, eg when
8392              referencing a global array.  For an example of this see
8393              the _clz.o binary in libgcc.a.  */
8394           if (sym != symtab
8395               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
8396             {
8397               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8398                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
8399                     (long int)(rp - relocs),
8400                     SECTION_NAME (relsec));
8401               continue;
8402             }
8403
8404           addend = is_rela ? rp->r_addend : byte_get (loc, reloc_size);
8405
8406           if (is_32bit_pcrel_reloc (reloc_type)
8407               || is_64bit_pcrel_reloc (reloc_type))
8408             {
8409               /* On HPPA, all pc-relative relocations are biased by 8.  */
8410               if (elf_header.e_machine == EM_PARISC)
8411                 addend -= 8;
8412               byte_put (loc, (addend + sym->st_value) - rp->r_offset,
8413                         reloc_size);
8414             }
8415           else
8416             byte_put (loc, addend + sym->st_value, reloc_size);
8417         }
8418
8419       free (symtab);
8420       free (relocs);
8421       break;
8422     }
8423 }
8424
8425 static int
8426 load_specific_debug_section (enum dwarf_section_display_enum debug,
8427                              Elf_Internal_Shdr * sec, void * file)
8428 {
8429   struct dwarf_section * section = &debug_displays [debug].section;
8430   char buf [64];
8431   int section_is_compressed;
8432
8433   /* If it is already loaded, do nothing.  */
8434   if (section->start != NULL)
8435     return 1;
8436
8437   section_is_compressed = section->name == section->compressed_name;
8438
8439   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
8440   section->address = sec->sh_addr;
8441   section->size = sec->sh_size;
8442   section->start = get_data (NULL, file, sec->sh_offset, 1,
8443                              sec->sh_size, buf);
8444   if (section->start == NULL)
8445     return 0;
8446
8447   if (section_is_compressed)
8448     if (! uncompress_section_contents (&section->start, &section->size))
8449       return 0;
8450
8451   if (debug_displays [debug].relocate)
8452     debug_apply_relocations (file, sec, section->start);
8453
8454   return 1;
8455 }
8456
8457 int
8458 load_debug_section (enum dwarf_section_display_enum debug, void * file)
8459 {
8460   struct dwarf_section * section = &debug_displays [debug].section;
8461   Elf_Internal_Shdr * sec;
8462
8463   /* Locate the debug section.  */
8464   sec = find_section (section->uncompressed_name);
8465   if (sec != NULL)
8466     section->name = section->uncompressed_name;
8467   else
8468     {
8469       sec = find_section (section->compressed_name);
8470       if (sec != NULL)
8471         section->name = section->compressed_name;
8472     }
8473   if (sec == NULL)
8474     return 0;
8475
8476   return load_specific_debug_section (debug, sec, file);
8477 }
8478
8479 void
8480 free_debug_section (enum dwarf_section_display_enum debug)
8481 {
8482   struct dwarf_section * section = &debug_displays [debug].section;
8483
8484   if (section->start == NULL)
8485     return;
8486
8487   free ((char *) section->start);
8488   section->start = NULL;
8489   section->address = 0;
8490   section->size = 0;
8491 }
8492
8493 static int
8494 display_debug_section (Elf_Internal_Shdr * section, FILE * file)
8495 {
8496   char * name = SECTION_NAME (section);
8497   bfd_size_type length;
8498   int result = 1;
8499   enum dwarf_section_display_enum i;
8500
8501   length = section->sh_size;
8502   if (length == 0)
8503     {
8504       printf (_("\nSection '%s' has no debugging data.\n"), name);
8505       return 0;
8506     }
8507
8508   if (const_strneq (name, ".gnu.linkonce.wi."))
8509     name = ".debug_info";
8510
8511   /* See if we know how to display the contents of this section.  */
8512   for (i = 0; i < max; i++)
8513     if (streq (debug_displays[i].section.uncompressed_name, name)
8514         || streq (debug_displays[i].section.compressed_name, name))
8515       {
8516         struct dwarf_section * sec = &debug_displays [i].section;
8517         int secondary = (section != find_section (name));
8518
8519         if (secondary)
8520           free_debug_section (i);
8521
8522         if (streq (debug_displays[i].section.uncompressed_name, name))
8523           sec->name = sec->uncompressed_name;
8524         else
8525           sec->name = sec->compressed_name;
8526         if (load_specific_debug_section (i, section, file))
8527           {
8528             result &= debug_displays[i].display (sec, file);
8529
8530             if (secondary || (i != info && i != abbrev))
8531               free_debug_section (i);
8532           }
8533
8534         break;
8535       }
8536
8537   if (i == max)
8538     {
8539       printf (_("Unrecognized debug section: %s\n"), name);
8540       result = 0;
8541     }
8542
8543   return result;
8544 }
8545
8546 /* Set DUMP_SECTS for all sections where dumps were requested
8547    based on section name.  */
8548
8549 static void
8550 initialise_dumps_byname (void)
8551 {
8552   struct dump_list_entry * cur;
8553
8554   for (cur = dump_sects_byname; cur; cur = cur->next)
8555     {
8556       unsigned int i;
8557       int any;
8558
8559       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
8560         if (streq (SECTION_NAME (section_headers + i), cur->name))
8561           {
8562             request_dump_bynumber (i, cur->type);
8563             any = 1;
8564           }
8565
8566       if (!any)
8567         warn (_("Section '%s' was not dumped because it does not exist!\n"),
8568               cur->name);
8569     }
8570 }
8571
8572 static void
8573 process_section_contents (FILE * file)
8574 {
8575   Elf_Internal_Shdr * section;
8576   unsigned int i;
8577
8578   if (! do_dump)
8579     return;
8580
8581   initialise_dumps_byname ();
8582
8583   for (i = 0, section = section_headers;
8584        i < elf_header.e_shnum && i < num_dump_sects;
8585        i++, section++)
8586     {
8587 #ifdef SUPPORT_DISASSEMBLY
8588       if (dump_sects[i] & DISASS_DUMP)
8589         disassemble_section (section, file);
8590 #endif
8591       if (dump_sects[i] & HEX_DUMP)
8592         dump_section_as_bytes (section, file);
8593
8594       if (dump_sects[i] & DEBUG_DUMP)
8595         display_debug_section (section, file);
8596
8597       if (dump_sects[i] & STRING_DUMP)
8598         dump_section_as_strings (section, file);
8599     }
8600
8601   /* Check to see if the user requested a
8602      dump of a section that does not exist.  */
8603   while (i++ < num_dump_sects)
8604     if (dump_sects[i])
8605       warn (_("Section %d was not dumped because it does not exist!\n"), i);
8606 }
8607
8608 static void
8609 process_mips_fpe_exception (int mask)
8610 {
8611   if (mask)
8612     {
8613       int first = 1;
8614       if (mask & OEX_FPU_INEX)
8615         fputs ("INEX", stdout), first = 0;
8616       if (mask & OEX_FPU_UFLO)
8617         printf ("%sUFLO", first ? "" : "|"), first = 0;
8618       if (mask & OEX_FPU_OFLO)
8619         printf ("%sOFLO", first ? "" : "|"), first = 0;
8620       if (mask & OEX_FPU_DIV0)
8621         printf ("%sDIV0", first ? "" : "|"), first = 0;
8622       if (mask & OEX_FPU_INVAL)
8623         printf ("%sINVAL", first ? "" : "|");
8624     }
8625   else
8626     fputs ("0", stdout);
8627 }
8628
8629 /* ARM EABI attributes section.  */
8630 typedef struct
8631 {
8632   int tag;
8633   const char * name;
8634   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
8635   int type;
8636   const char ** table;
8637 } arm_attr_public_tag;
8638
8639 static const char * arm_attr_tag_CPU_arch[] =
8640   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8641    "v6K", "v7", "v6-M", "v6S-M"};
8642 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
8643 static const char * arm_attr_tag_THUMB_ISA_use[] =
8644   {"No", "Thumb-1", "Thumb-2"};
8645 static const char * arm_attr_tag_VFP_arch[] =
8646   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16"};
8647 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
8648 static const char * arm_attr_tag_Advanced_SIMD_arch[] = {"No", "NEONv1"};
8649 static const char * arm_attr_tag_PCS_config[] =
8650   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8651    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8652 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
8653   {"V6", "SB", "TLS", "Unused"};
8654 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
8655   {"Absolute", "PC-relative", "SB-relative", "None"};
8656 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
8657   {"Absolute", "PC-relative", "None"};
8658 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
8659   {"None", "direct", "GOT-indirect"};
8660 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
8661   {"None", "??? 1", "2", "??? 3", "4"};
8662 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
8663 static const char * arm_attr_tag_ABI_FP_denormal[] =
8664   {"Unused", "Needed", "Sign only"};
8665 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
8666 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
8667 static const char * arm_attr_tag_ABI_FP_number_model[] =
8668   {"Unused", "Finite", "RTABI", "IEEE 754"};
8669 static const char * arm_attr_tag_ABI_align8_needed[] = {"No", "Yes", "4-byte"};
8670 static const char * arm_attr_tag_ABI_align8_preserved[] =
8671   {"No", "Yes, except leaf SP", "Yes"};
8672 static const char * arm_attr_tag_ABI_enum_size[] =
8673   {"Unused", "small", "int", "forced to int"};
8674 static const char * arm_attr_tag_ABI_HardFP_use[] =
8675   {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8676 static const char * arm_attr_tag_ABI_VFP_args[] =
8677   {"AAPCS", "VFP registers", "custom"};
8678 static const char * arm_attr_tag_ABI_WMMX_args[] =
8679   {"AAPCS", "WMMX registers", "custom"};
8680 static const char * arm_attr_tag_ABI_optimization_goals[] =
8681   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8682     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8683 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
8684   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8685     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8686 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
8687 static const char * arm_attr_tag_VFP_HP_extension[] =
8688   {"Not Allowed", "Allowed"};
8689 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
8690   {"None", "IEEE 754", "Alternative Format"};
8691 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
8692 static const char * arm_attr_tag_Virtualization_use[] =
8693   {"Not Allowed", "Allowed"};
8694 static const char * arm_attr_tag_MPextension_use[] = {"Not Allowed", "Allowed"};
8695
8696 #define LOOKUP(id, name) \
8697   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8698 static arm_attr_public_tag arm_attr_public_tags[] =
8699 {
8700   {4, "CPU_raw_name", 1, NULL},
8701   {5, "CPU_name", 1, NULL},
8702   LOOKUP(6, CPU_arch),
8703   {7, "CPU_arch_profile", 0, NULL},
8704   LOOKUP(8, ARM_ISA_use),
8705   LOOKUP(9, THUMB_ISA_use),
8706   LOOKUP(10, VFP_arch),
8707   LOOKUP(11, WMMX_arch),
8708   LOOKUP(12, Advanced_SIMD_arch),
8709   LOOKUP(13, PCS_config),
8710   LOOKUP(14, ABI_PCS_R9_use),
8711   LOOKUP(15, ABI_PCS_RW_data),
8712   LOOKUP(16, ABI_PCS_RO_data),
8713   LOOKUP(17, ABI_PCS_GOT_use),
8714   LOOKUP(18, ABI_PCS_wchar_t),
8715   LOOKUP(19, ABI_FP_rounding),
8716   LOOKUP(20, ABI_FP_denormal),
8717   LOOKUP(21, ABI_FP_exceptions),
8718   LOOKUP(22, ABI_FP_user_exceptions),
8719   LOOKUP(23, ABI_FP_number_model),
8720   LOOKUP(24, ABI_align8_needed),
8721   LOOKUP(25, ABI_align8_preserved),
8722   LOOKUP(26, ABI_enum_size),
8723   LOOKUP(27, ABI_HardFP_use),
8724   LOOKUP(28, ABI_VFP_args),
8725   LOOKUP(29, ABI_WMMX_args),
8726   LOOKUP(30, ABI_optimization_goals),
8727   LOOKUP(31, ABI_FP_optimization_goals),
8728   {32, "compatibility", 0, NULL},
8729   LOOKUP(34, CPU_unaligned_access),
8730   LOOKUP(36, VFP_HP_extension),
8731   LOOKUP(38, ABI_FP_16bit_format),
8732   {64, "nodefaults", 0, NULL},
8733   {65, "also_compatible_with", 0, NULL},
8734   LOOKUP(66, T2EE_use),
8735   {67, "conformance", 1, NULL},
8736   LOOKUP(68, Virtualization_use),
8737   LOOKUP(70, MPextension_use)
8738 };
8739 #undef LOOKUP
8740
8741 /* Read an unsigned LEB128 encoded value from p.  Set *PLEN to the number of
8742    bytes read.  */
8743
8744 static unsigned int
8745 read_uleb128 (unsigned char * p, unsigned int * plen)
8746 {
8747   unsigned char c;
8748   unsigned int val;
8749   int shift;
8750   int len;
8751
8752   val = 0;
8753   shift = 0;
8754   len = 0;
8755   do
8756     {
8757       c = *(p++);
8758       len++;
8759       val |= ((unsigned int)c & 0x7f) << shift;
8760       shift += 7;
8761     }
8762   while (c & 0x80);
8763
8764   *plen = len;
8765   return val;
8766 }
8767
8768 static unsigned char *
8769 display_arm_attribute (unsigned char * p)
8770 {
8771   int tag;
8772   unsigned int len;
8773   int val;
8774   arm_attr_public_tag * attr;
8775   unsigned i;
8776   int type;
8777
8778   tag = read_uleb128 (p, &len);
8779   p += len;
8780   attr = NULL;
8781   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
8782     {
8783       if (arm_attr_public_tags[i].tag == tag)
8784         {
8785           attr = &arm_attr_public_tags[i];
8786           break;
8787         }
8788     }
8789
8790   if (attr)
8791     {
8792       printf ("  Tag_%s: ", attr->name);
8793       switch (attr->type)
8794         {
8795         case 0:
8796           switch (tag)
8797             {
8798             case 7: /* Tag_CPU_arch_profile.  */
8799               val = read_uleb128 (p, &len);
8800               p += len;
8801               switch (val)
8802                 {
8803                 case 0: printf ("None\n"); break;
8804                 case 'A': printf ("Application\n"); break;
8805                 case 'R': printf ("Realtime\n"); break;
8806                 case 'M': printf ("Microcontroller\n"); break;
8807                 default: printf ("??? (%d)\n", val); break;
8808                 }
8809               break;
8810
8811             case 32: /* Tag_compatibility.  */
8812               val = read_uleb128 (p, &len);
8813               p += len;
8814               printf ("flag = %d, vendor = %s\n", val, p);
8815               p += strlen ((char *) p) + 1;
8816               break;
8817
8818             case 64: /* Tag_nodefaults.  */
8819               p++;
8820               printf ("True\n");
8821               break;
8822
8823             case 65: /* Tag_also_compatible_with.  */
8824               val = read_uleb128 (p, &len);
8825               p += len;
8826               if (val == 6 /* Tag_CPU_arch.  */)
8827                 {
8828                   val = read_uleb128 (p, &len);
8829                   p += len;
8830                   if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
8831                     printf ("??? (%d)\n", val);
8832                   else
8833                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
8834                 }
8835               else
8836                 printf ("???\n");
8837               while (*(p++) != '\0' /* NUL terminator.  */);
8838               break;
8839
8840             default:
8841               abort ();
8842             }
8843           return p;
8844
8845         case 1:
8846         case 2:
8847           type = attr->type;
8848           break;
8849
8850         default:
8851           assert (attr->type & 0x80);
8852           val = read_uleb128 (p, &len);
8853           p += len;
8854           type = attr->type & 0x7f;
8855           if (val >= type)
8856             printf ("??? (%d)\n", val);
8857           else
8858             printf ("%s\n", attr->table[val]);
8859           return p;
8860         }
8861     }
8862   else
8863     {
8864       if (tag & 1)
8865         type = 1; /* String.  */
8866       else
8867         type = 2; /* uleb128.  */
8868       printf ("  Tag_unknown_%d: ", tag);
8869     }
8870
8871   if (type == 1)
8872     {
8873       printf ("\"%s\"\n", p);
8874       p += strlen ((char *) p) + 1;
8875     }
8876   else
8877     {
8878       val = read_uleb128 (p, &len);
8879       p += len;
8880       printf ("%d (0x%x)\n", val, val);
8881     }
8882
8883   return p;
8884 }
8885
8886 static unsigned char *
8887 display_gnu_attribute (unsigned char * p,
8888                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
8889 {
8890   int tag;
8891   unsigned int len;
8892   int val;
8893   int type;
8894
8895   tag = read_uleb128 (p, &len);
8896   p += len;
8897
8898   /* Tag_compatibility is the only generic GNU attribute defined at
8899      present.  */
8900   if (tag == 32)
8901     {
8902       val = read_uleb128 (p, &len);
8903       p += len;
8904       printf ("flag = %d, vendor = %s\n", val, p);
8905       p += strlen ((char *) p) + 1;
8906       return p;
8907     }
8908
8909   if ((tag & 2) == 0 && display_proc_gnu_attribute)
8910     return display_proc_gnu_attribute (p, tag);
8911
8912   if (tag & 1)
8913     type = 1; /* String.  */
8914   else
8915     type = 2; /* uleb128.  */
8916   printf ("  Tag_unknown_%d: ", tag);
8917
8918   if (type == 1)
8919     {
8920       printf ("\"%s\"\n", p);
8921       p += strlen ((char *) p) + 1;
8922     }
8923   else
8924     {
8925       val = read_uleb128 (p, &len);
8926       p += len;
8927       printf ("%d (0x%x)\n", val, val);
8928     }
8929
8930   return p;
8931 }
8932
8933 static unsigned char *
8934 display_power_gnu_attribute (unsigned char * p, int tag)
8935 {
8936   int type;
8937   unsigned int len;
8938   int val;
8939
8940   if (tag == Tag_GNU_Power_ABI_FP)
8941     {
8942       val = read_uleb128 (p, &len);
8943       p += len;
8944       printf ("  Tag_GNU_Power_ABI_FP: ");
8945
8946       switch (val)
8947         {
8948         case 0:
8949           printf ("Hard or soft float\n");
8950           break;
8951         case 1:
8952           printf ("Hard float\n");
8953           break;
8954         case 2:
8955           printf ("Soft float\n");
8956           break;
8957         case 3:
8958           printf ("Single-precision hard float\n");
8959           break;
8960         default:
8961           printf ("??? (%d)\n", val);
8962           break;
8963         }
8964       return p;
8965    }
8966
8967   if (tag == Tag_GNU_Power_ABI_Vector)
8968     {
8969       val = read_uleb128 (p, &len);
8970       p += len;
8971       printf ("  Tag_GNU_Power_ABI_Vector: ");
8972       switch (val)
8973         {
8974         case 0:
8975           printf ("Any\n");
8976           break;
8977         case 1:
8978           printf ("Generic\n");
8979           break;
8980         case 2:
8981           printf ("AltiVec\n");
8982           break;
8983         case 3:
8984           printf ("SPE\n");
8985           break;
8986         default:
8987           printf ("??? (%d)\n", val);
8988           break;
8989         }
8990       return p;
8991    }
8992
8993   if (tag == Tag_GNU_Power_ABI_Struct_Return)
8994     {
8995       val = read_uleb128 (p, &len);
8996       p += len;
8997       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
8998       switch (val)
8999        {
9000        case 0:
9001          printf ("Any\n");
9002          break;
9003        case 1:
9004          printf ("r3/r4\n");
9005          break;
9006        case 2:
9007          printf ("Memory\n");
9008          break;
9009        default:
9010          printf ("??? (%d)\n", val);
9011          break;
9012        }
9013       return p;
9014     }
9015
9016   if (tag & 1)
9017     type = 1; /* String.  */
9018   else
9019     type = 2; /* uleb128.  */
9020   printf ("  Tag_unknown_%d: ", tag);
9021
9022   if (type == 1)
9023     {
9024       printf ("\"%s\"\n", p);
9025       p += strlen ((char *) p) + 1;
9026     }
9027   else
9028     {
9029       val = read_uleb128 (p, &len);
9030       p += len;
9031       printf ("%d (0x%x)\n", val, val);
9032     }
9033
9034   return p;
9035 }
9036
9037 static unsigned char *
9038 display_mips_gnu_attribute (unsigned char * p, int tag)
9039 {
9040   int type;
9041   unsigned int len;
9042   int val;
9043
9044   if (tag == Tag_GNU_MIPS_ABI_FP)
9045     {
9046       val = read_uleb128 (p, &len);
9047       p += len;
9048       printf ("  Tag_GNU_MIPS_ABI_FP: ");
9049
9050       switch (val)
9051         {
9052         case 0:
9053           printf ("Hard or soft float\n");
9054           break;
9055         case 1:
9056           printf ("Hard float (-mdouble-float)\n");
9057           break;
9058         case 2:
9059           printf ("Hard float (-msingle-float)\n");
9060           break;
9061         case 3:
9062           printf ("Soft float\n");
9063           break;
9064         case 4:
9065           printf ("64-bit float (-mips32r2 -mfp64)\n");
9066           break;
9067         default:
9068           printf ("??? (%d)\n", val);
9069           break;
9070         }
9071       return p;
9072    }
9073
9074   if (tag & 1)
9075     type = 1; /* String.  */
9076   else
9077     type = 2; /* uleb128.  */
9078   printf ("  Tag_unknown_%d: ", tag);
9079
9080   if (type == 1)
9081     {
9082       printf ("\"%s\"\n", p);
9083       p += strlen ((char *) p) + 1;
9084     }
9085   else
9086     {
9087       val = read_uleb128 (p, &len);
9088       p += len;
9089       printf ("%d (0x%x)\n", val, val);
9090     }
9091
9092   return p;
9093 }
9094
9095 static int
9096 process_attributes (FILE * file,
9097                     const char * public_name,
9098                     unsigned int proc_type,
9099                     unsigned char * (* display_pub_attribute) (unsigned char *),
9100                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
9101 {
9102   Elf_Internal_Shdr * sect;
9103   unsigned char * contents;
9104   unsigned char * p;
9105   unsigned char * end;
9106   bfd_vma section_len;
9107   bfd_vma len;
9108   unsigned i;
9109
9110   /* Find the section header so that we get the size.  */
9111   for (i = 0, sect = section_headers;
9112        i < elf_header.e_shnum;
9113        i++, sect++)
9114     {
9115       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
9116         continue;
9117
9118       contents = get_data (NULL, file, sect->sh_offset, 1, sect->sh_size,
9119                            _("attributes"));
9120       if (contents == NULL)
9121         continue;
9122
9123       p = contents;
9124       if (*p == 'A')
9125         {
9126           len = sect->sh_size - 1;
9127           p++;
9128
9129           while (len > 0)
9130             {
9131               int namelen;
9132               bfd_boolean public_section;
9133               bfd_boolean gnu_section;
9134
9135               section_len = byte_get (p, 4);
9136               p += 4;
9137
9138               if (section_len > len)
9139                 {
9140                   printf (_("ERROR: Bad section length (%d > %d)\n"),
9141                           (int) section_len, (int) len);
9142                   section_len = len;
9143                 }
9144
9145               len -= section_len;
9146               printf ("Attribute Section: %s\n", p);
9147
9148               if (public_name && streq ((char *) p, public_name))
9149                 public_section = TRUE;
9150               else
9151                 public_section = FALSE;
9152
9153               if (streq ((char *) p, "gnu"))
9154                 gnu_section = TRUE;
9155               else
9156                 gnu_section = FALSE;
9157
9158               namelen = strlen ((char *) p) + 1;
9159               p += namelen;
9160               section_len -= namelen + 4;
9161
9162               while (section_len > 0)
9163                 {
9164                   int tag = *(p++);
9165                   int val;
9166                   bfd_vma size;
9167
9168                   size = byte_get (p, 4);
9169                   if (size > section_len)
9170                     {
9171                       printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9172                               (int) size, (int) section_len);
9173                       size = section_len;
9174                     }
9175
9176                   section_len -= size;
9177                   end = p + size - 1;
9178                   p += 4;
9179
9180                   switch (tag)
9181                     {
9182                     case 1:
9183                       printf ("File Attributes\n");
9184                       break;
9185                     case 2:
9186                       printf ("Section Attributes:");
9187                       goto do_numlist;
9188                     case 3:
9189                       printf ("Symbol Attributes:");
9190                     do_numlist:
9191                       for (;;)
9192                         {
9193                           unsigned int i;
9194
9195                           val = read_uleb128 (p, &i);
9196                           p += i;
9197                           if (val == 0)
9198                             break;
9199                           printf (" %d", val);
9200                         }
9201                       printf ("\n");
9202                       break;
9203                     default:
9204                       printf ("Unknown tag: %d\n", tag);
9205                       public_section = FALSE;
9206                       break;
9207                     }
9208
9209                   if (public_section)
9210                     {
9211                       while (p < end)
9212                         p = display_pub_attribute (p);
9213                     }
9214                   else if (gnu_section)
9215                     {
9216                       while (p < end)
9217                         p = display_gnu_attribute (p,
9218                                                    display_proc_gnu_attribute);
9219                     }
9220                   else
9221                     {
9222                       /* ??? Do something sensible, like dump hex.  */
9223                       printf ("  Unknown section contexts\n");
9224                       p = end;
9225                     }
9226                 }
9227             }
9228         }
9229       else
9230         printf (_("Unknown format '%c'\n"), *p);
9231
9232       free (contents);
9233     }
9234   return 1;
9235 }
9236
9237 static int
9238 process_arm_specific (FILE * file)
9239 {
9240   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
9241                              display_arm_attribute, NULL);
9242 }
9243
9244 static int
9245 process_power_specific (FILE * file)
9246 {
9247   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
9248                              display_power_gnu_attribute);
9249 }
9250
9251 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9252    Print the Address, Access and Initial fields of an entry at VMA ADDR
9253    and return the VMA of the next entry.  */
9254
9255 static bfd_vma
9256 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
9257 {
9258   printf ("  ");
9259   print_vma (addr, LONG_HEX);
9260   printf (" ");
9261   if (addr < pltgot + 0xfff0)
9262     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
9263   else
9264     printf ("%10s", "");
9265   printf (" ");
9266   if (data == NULL)
9267     printf ("%*s", is_32bit_elf ? 8 : 16, "<unknown>");
9268   else
9269     {
9270       bfd_vma entry;
9271
9272       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
9273       print_vma (entry, LONG_HEX);
9274     }
9275   return addr + (is_32bit_elf ? 4 : 8);
9276 }
9277
9278 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9279    PLTGOT.  Print the Address and Initial fields of an entry at VMA
9280    ADDR and return the VMA of the next entry.  */
9281
9282 static bfd_vma
9283 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
9284 {
9285   printf ("  ");
9286   print_vma (addr, LONG_HEX);
9287   printf (" ");
9288   if (data == NULL)
9289     printf ("%*s", is_32bit_elf ? 8 : 16, "<unknown>");
9290   else
9291     {
9292       bfd_vma entry;
9293
9294       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
9295       print_vma (entry, LONG_HEX);
9296     }
9297   return addr + (is_32bit_elf ? 4 : 8);
9298 }
9299
9300 static int
9301 process_mips_specific (FILE * file)
9302 {
9303   Elf_Internal_Dyn * entry;
9304   size_t liblist_offset = 0;
9305   size_t liblistno = 0;
9306   size_t conflictsno = 0;
9307   size_t options_offset = 0;
9308   size_t conflicts_offset = 0;
9309   size_t pltrelsz = 0;
9310   size_t pltrel = 0;
9311   bfd_vma pltgot = 0;
9312   bfd_vma mips_pltgot = 0;
9313   bfd_vma jmprel = 0;
9314   bfd_vma local_gotno = 0;
9315   bfd_vma gotsym = 0;
9316   bfd_vma symtabno = 0;
9317
9318   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
9319                       display_mips_gnu_attribute);
9320
9321   /* We have a lot of special sections.  Thanks SGI!  */
9322   if (dynamic_section == NULL)
9323     /* No information available.  */
9324     return 0;
9325
9326   for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
9327     switch (entry->d_tag)
9328       {
9329       case DT_MIPS_LIBLIST:
9330         liblist_offset
9331           = offset_from_vma (file, entry->d_un.d_val,
9332                              liblistno * sizeof (Elf32_External_Lib));
9333         break;
9334       case DT_MIPS_LIBLISTNO:
9335         liblistno = entry->d_un.d_val;
9336         break;
9337       case DT_MIPS_OPTIONS:
9338         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
9339         break;
9340       case DT_MIPS_CONFLICT:
9341         conflicts_offset
9342           = offset_from_vma (file, entry->d_un.d_val,
9343                              conflictsno * sizeof (Elf32_External_Conflict));
9344         break;
9345       case DT_MIPS_CONFLICTNO:
9346         conflictsno = entry->d_un.d_val;
9347         break;
9348       case DT_PLTGOT:
9349         pltgot = entry->d_un.d_ptr;
9350         break;
9351       case DT_MIPS_LOCAL_GOTNO:
9352         local_gotno = entry->d_un.d_val;
9353         break;
9354       case DT_MIPS_GOTSYM:
9355         gotsym = entry->d_un.d_val;
9356         break;
9357       case DT_MIPS_SYMTABNO:
9358         symtabno = entry->d_un.d_val;
9359         break;
9360       case DT_MIPS_PLTGOT:
9361         mips_pltgot = entry->d_un.d_ptr;
9362         break;
9363       case DT_PLTREL:
9364         pltrel = entry->d_un.d_val;
9365         break;
9366       case DT_PLTRELSZ:
9367         pltrelsz = entry->d_un.d_val;
9368         break;
9369       case DT_JMPREL:
9370         jmprel = entry->d_un.d_ptr;
9371         break;
9372       default:
9373         break;
9374       }
9375
9376   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
9377     {
9378       Elf32_External_Lib * elib;
9379       size_t cnt;
9380
9381       elib = get_data (NULL, file, liblist_offset,
9382                        liblistno, sizeof (Elf32_External_Lib),
9383                        _("liblist"));
9384       if (elib)
9385         {
9386           printf ("\nSection '.liblist' contains %lu entries:\n",
9387                   (unsigned long) liblistno);
9388           fputs ("     Library              Time Stamp          Checksum   Version Flags\n",
9389                  stdout);
9390
9391           for (cnt = 0; cnt < liblistno; ++cnt)
9392             {
9393               Elf32_Lib liblist;
9394               time_t time;
9395               char timebuf[20];
9396               struct tm * tmp;
9397
9398               liblist.l_name = BYTE_GET (elib[cnt].l_name);
9399               time = BYTE_GET (elib[cnt].l_time_stamp);
9400               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9401               liblist.l_version = BYTE_GET (elib[cnt].l_version);
9402               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9403
9404               tmp = gmtime (&time);
9405               snprintf (timebuf, sizeof (timebuf),
9406                         "%04u-%02u-%02uT%02u:%02u:%02u",
9407                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9408                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9409
9410               printf ("%3lu: ", (unsigned long) cnt);
9411               if (VALID_DYNAMIC_NAME (liblist.l_name))
9412                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
9413               else
9414                 printf ("<corrupt: %9ld>", liblist.l_name);
9415               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
9416                       liblist.l_version);
9417
9418               if (liblist.l_flags == 0)
9419                 puts (" NONE");
9420               else
9421                 {
9422                   static const struct
9423                   {
9424                     const char * name;
9425                     int bit;
9426                   }
9427                   l_flags_vals[] =
9428                   {
9429                     { " EXACT_MATCH", LL_EXACT_MATCH },
9430                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
9431                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
9432                     { " EXPORTS", LL_EXPORTS },
9433                     { " DELAY_LOAD", LL_DELAY_LOAD },
9434                     { " DELTA", LL_DELTA }
9435                   };
9436                   int flags = liblist.l_flags;
9437                   size_t fcnt;
9438
9439                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
9440                     if ((flags & l_flags_vals[fcnt].bit) != 0)
9441                       {
9442                         fputs (l_flags_vals[fcnt].name, stdout);
9443                         flags ^= l_flags_vals[fcnt].bit;
9444                       }
9445                   if (flags != 0)
9446                     printf (" %#x", (unsigned int) flags);
9447
9448                   puts ("");
9449                 }
9450             }
9451
9452           free (elib);
9453         }
9454     }
9455
9456   if (options_offset != 0)
9457     {
9458       Elf_External_Options * eopt;
9459       Elf_Internal_Shdr * sect = section_headers;
9460       Elf_Internal_Options * iopt;
9461       Elf_Internal_Options * option;
9462       size_t offset;
9463       int cnt;
9464
9465       /* Find the section header so that we get the size.  */
9466       while (sect->sh_type != SHT_MIPS_OPTIONS)
9467         ++sect;
9468
9469       eopt = get_data (NULL, file, options_offset, 1, sect->sh_size,
9470                        _("options"));
9471       if (eopt)
9472         {
9473           iopt = cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
9474           if (iopt == NULL)
9475             {
9476               error (_("Out of memory\n"));
9477               return 0;
9478             }
9479
9480           offset = cnt = 0;
9481           option = iopt;
9482
9483           while (offset < sect->sh_size)
9484             {
9485               Elf_External_Options * eoption;
9486
9487               eoption = (Elf_External_Options *) ((char *) eopt + offset);
9488
9489               option->kind = BYTE_GET (eoption->kind);
9490               option->size = BYTE_GET (eoption->size);
9491               option->section = BYTE_GET (eoption->section);
9492               option->info = BYTE_GET (eoption->info);
9493
9494               offset += option->size;
9495
9496               ++option;
9497               ++cnt;
9498             }
9499
9500           printf (_("\nSection '%s' contains %d entries:\n"),
9501                   SECTION_NAME (sect), cnt);
9502
9503           option = iopt;
9504
9505           while (cnt-- > 0)
9506             {
9507               size_t len;
9508
9509               switch (option->kind)
9510                 {
9511                 case ODK_NULL:
9512                   /* This shouldn't happen.  */
9513                   printf (" NULL       %d %lx", option->section, option->info);
9514                   break;
9515                 case ODK_REGINFO:
9516                   printf (" REGINFO    ");
9517                   if (elf_header.e_machine == EM_MIPS)
9518                     {
9519                       /* 32bit form.  */
9520                       Elf32_External_RegInfo * ereg;
9521                       Elf32_RegInfo reginfo;
9522
9523                       ereg = (Elf32_External_RegInfo *) (option + 1);
9524                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9525                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9526                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9527                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9528                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9529                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
9530
9531                       printf ("GPR %08lx  GP 0x%lx\n",
9532                               reginfo.ri_gprmask,
9533                               (unsigned long) reginfo.ri_gp_value);
9534                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
9535                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9536                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9537                     }
9538                   else
9539                     {
9540                       /* 64 bit form.  */
9541                       Elf64_External_RegInfo * ereg;
9542                       Elf64_Internal_RegInfo reginfo;
9543
9544                       ereg = (Elf64_External_RegInfo *) (option + 1);
9545                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
9546                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9547                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9548                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9549                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9550                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
9551
9552                       printf ("GPR %08lx  GP 0x",
9553                               reginfo.ri_gprmask);
9554                       printf_vma (reginfo.ri_gp_value);
9555                       printf ("\n");
9556
9557                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
9558                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9559                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9560                     }
9561                   ++option;
9562                   continue;
9563                 case ODK_EXCEPTIONS:
9564                   fputs (" EXCEPTIONS fpe_min(", stdout);
9565                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
9566                   fputs (") fpe_max(", stdout);
9567                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
9568                   fputs (")", stdout);
9569
9570                   if (option->info & OEX_PAGE0)
9571                     fputs (" PAGE0", stdout);
9572                   if (option->info & OEX_SMM)
9573                     fputs (" SMM", stdout);
9574                   if (option->info & OEX_FPDBUG)
9575                     fputs (" FPDBUG", stdout);
9576                   if (option->info & OEX_DISMISS)
9577                     fputs (" DISMISS", stdout);
9578                   break;
9579                 case ODK_PAD:
9580                   fputs (" PAD       ", stdout);
9581                   if (option->info & OPAD_PREFIX)
9582                     fputs (" PREFIX", stdout);
9583                   if (option->info & OPAD_POSTFIX)
9584                     fputs (" POSTFIX", stdout);
9585                   if (option->info & OPAD_SYMBOL)
9586                     fputs (" SYMBOL", stdout);
9587                   break;
9588                 case ODK_HWPATCH:
9589                   fputs (" HWPATCH   ", stdout);
9590                   if (option->info & OHW_R4KEOP)
9591                     fputs (" R4KEOP", stdout);
9592                   if (option->info & OHW_R8KPFETCH)
9593                     fputs (" R8KPFETCH", stdout);
9594                   if (option->info & OHW_R5KEOP)
9595                     fputs (" R5KEOP", stdout);
9596                   if (option->info & OHW_R5KCVTL)
9597                     fputs (" R5KCVTL", stdout);
9598                   break;
9599                 case ODK_FILL:
9600                   fputs (" FILL       ", stdout);
9601                   /* XXX Print content of info word?  */
9602                   break;
9603                 case ODK_TAGS:
9604                   fputs (" TAGS       ", stdout);
9605                   /* XXX Print content of info word?  */
9606                   break;
9607                 case ODK_HWAND:
9608                   fputs (" HWAND     ", stdout);
9609                   if (option->info & OHWA0_R4KEOP_CHECKED)
9610                     fputs (" R4KEOP_CHECKED", stdout);
9611                   if (option->info & OHWA0_R4KEOP_CLEAN)
9612                     fputs (" R4KEOP_CLEAN", stdout);
9613                   break;
9614                 case ODK_HWOR:
9615                   fputs (" HWOR      ", stdout);
9616                   if (option->info & OHWA0_R4KEOP_CHECKED)
9617                     fputs (" R4KEOP_CHECKED", stdout);
9618                   if (option->info & OHWA0_R4KEOP_CLEAN)
9619                     fputs (" R4KEOP_CLEAN", stdout);
9620                   break;
9621                 case ODK_GP_GROUP:
9622                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
9623                           option->info & OGP_GROUP,
9624                           (option->info & OGP_SELF) >> 16);
9625                   break;
9626                 case ODK_IDENT:
9627                   printf (" IDENT     %#06lx  self-contained %#06lx",
9628                           option->info & OGP_GROUP,
9629                           (option->info & OGP_SELF) >> 16);
9630                   break;
9631                 default:
9632                   /* This shouldn't happen.  */
9633                   printf (" %3d ???     %d %lx",
9634                           option->kind, option->section, option->info);
9635                   break;
9636                 }
9637
9638               len = sizeof (* eopt);
9639               while (len < option->size)
9640                 if (((char *) option)[len] >= ' '
9641                     && ((char *) option)[len] < 0x7f)
9642                   printf ("%c", ((char *) option)[len++]);
9643                 else
9644                   printf ("\\%03o", ((char *) option)[len++]);
9645
9646               fputs ("\n", stdout);
9647               ++option;
9648             }
9649
9650           free (eopt);
9651         }
9652     }
9653
9654   if (conflicts_offset != 0 && conflictsno != 0)
9655     {
9656       Elf32_Conflict * iconf;
9657       size_t cnt;
9658
9659       if (dynamic_symbols == NULL)
9660         {
9661           error (_("conflict list found without a dynamic symbol table\n"));
9662           return 0;
9663         }
9664
9665       iconf = cmalloc (conflictsno, sizeof (* iconf));
9666       if (iconf == NULL)
9667         {
9668           error (_("Out of memory\n"));
9669           return 0;
9670         }
9671
9672       if (is_32bit_elf)
9673         {
9674           Elf32_External_Conflict * econf32;
9675
9676           econf32 = get_data (NULL, file, conflicts_offset,
9677                               conflictsno, sizeof (* econf32), _("conflict"));
9678           if (!econf32)
9679             return 0;
9680
9681           for (cnt = 0; cnt < conflictsno; ++cnt)
9682             iconf[cnt] = BYTE_GET (econf32[cnt]);
9683
9684           free (econf32);
9685         }
9686       else
9687         {
9688           Elf64_External_Conflict * econf64;
9689
9690           econf64 = get_data (NULL, file, conflicts_offset,
9691                               conflictsno, sizeof (* econf64), _("conflict"));
9692           if (!econf64)
9693             return 0;
9694
9695           for (cnt = 0; cnt < conflictsno; ++cnt)
9696             iconf[cnt] = BYTE_GET (econf64[cnt]);
9697
9698           free (econf64);
9699         }
9700
9701       printf (_("\nSection '.conflict' contains %lu entries:\n"),
9702               (unsigned long) conflictsno);
9703       puts (_("  Num:    Index       Value  Name"));
9704
9705       for (cnt = 0; cnt < conflictsno; ++cnt)
9706         {
9707           Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
9708
9709           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
9710           print_vma (psym->st_value, FULL_HEX);
9711           putchar (' ');
9712           if (VALID_DYNAMIC_NAME (psym->st_name))
9713             print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9714           else
9715             printf ("<corrupt: %14ld>", psym->st_name);
9716           putchar ('\n');
9717         }
9718
9719       free (iconf);
9720     }
9721
9722   if (pltgot != 0 && local_gotno != 0)
9723     {
9724       bfd_vma entry, local_end, global_end;
9725       size_t i, offset;
9726       unsigned char * data;
9727       int addr_size;
9728
9729       entry = pltgot;
9730       addr_size = (is_32bit_elf ? 4 : 8);
9731       local_end = pltgot + local_gotno * addr_size;
9732       global_end = local_end + (symtabno - gotsym) * addr_size;
9733
9734       offset = offset_from_vma (file, pltgot, global_end - pltgot);
9735       data = get_data (NULL, file, offset, global_end - pltgot, 1, _("GOT"));
9736       printf (_("\nPrimary GOT:\n"));
9737       printf (_(" Canonical gp value: "));
9738       print_vma (pltgot + 0x7ff0, LONG_HEX);
9739       printf ("\n\n");
9740
9741       printf (_(" Reserved entries:\n"));
9742       printf (_("  %*s %10s %*s Purpose\n"),
9743               addr_size * 2, "Address", "Access",
9744               addr_size * 2, "Initial");
9745       entry = print_mips_got_entry (data, pltgot, entry);
9746       printf (" Lazy resolver\n");
9747       if (data
9748           && (byte_get (data + entry - pltgot, addr_size)
9749               >> (addr_size * 8 - 1)) != 0)
9750         {
9751           entry = print_mips_got_entry (data, pltgot, entry);
9752           printf (" Module pointer (GNU extension)\n");
9753         }
9754       printf ("\n");
9755
9756       if (entry < local_end)
9757         {
9758           printf (_(" Local entries:\n"));
9759           printf (_("  %*s %10s %*s\n"),
9760                   addr_size * 2, "Address", "Access",
9761                   addr_size * 2, "Initial");
9762           while (entry < local_end)
9763             {
9764               entry = print_mips_got_entry (data, pltgot, entry);
9765               printf ("\n");
9766             }
9767           printf ("\n");
9768         }
9769
9770       if (gotsym < symtabno)
9771         {
9772           int sym_width;
9773
9774           printf (_(" Global entries:\n"));
9775           printf (_("  %*s %10s %*s %*s %-7s %3s %s\n"),
9776                   addr_size * 2, "Address", "Access",
9777                   addr_size * 2, "Initial",
9778                   addr_size * 2, "Sym.Val.", "Type", "Ndx", "Name");
9779           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
9780           for (i = gotsym; i < symtabno; i++)
9781             {
9782               Elf_Internal_Sym * psym;
9783
9784               psym = dynamic_symbols + i;
9785               entry = print_mips_got_entry (data, pltgot, entry);
9786               printf (" ");
9787               print_vma (psym->st_value, LONG_HEX);
9788               printf (" %-7s %3s ",
9789                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
9790                       get_symbol_index_type (psym->st_shndx));
9791               if (VALID_DYNAMIC_NAME (psym->st_name))
9792                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
9793               else
9794                 printf ("<corrupt: %14ld>", psym->st_name);
9795               printf ("\n");
9796             }
9797           printf ("\n");
9798         }
9799
9800       if (data)
9801         free (data);
9802     }
9803
9804   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
9805     {
9806       bfd_vma entry, end;
9807       size_t offset, rel_offset;
9808       unsigned long count, i;
9809       unsigned char * data;
9810       int addr_size, sym_width;
9811       Elf_Internal_Rela * rels;
9812
9813       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
9814       if (pltrel == DT_RELA)
9815         {
9816           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
9817             return 0;
9818         }
9819       else
9820         {
9821           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
9822             return 0;
9823         }
9824
9825       entry = mips_pltgot;
9826       addr_size = (is_32bit_elf ? 4 : 8);
9827       end = mips_pltgot + (2 + count) * addr_size;
9828
9829       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
9830       data = get_data (NULL, file, offset, end - mips_pltgot, 1, _("PLT GOT"));
9831       printf (_("\nPLT GOT:\n\n"));
9832       printf (_(" Reserved entries:\n"));
9833       printf (_("  %*s %*s Purpose\n"),
9834               addr_size * 2, "Address", addr_size * 2, "Initial");
9835       entry = print_mips_pltgot_entry (data, mips_pltgot, entry);
9836       printf (" PLT lazy resolver\n");
9837       entry = print_mips_pltgot_entry (data, mips_pltgot, entry);
9838       printf (" Module pointer\n");
9839       printf ("\n");
9840
9841       printf (_(" Entries:\n"));
9842       printf (_("  %*s %*s %*s %-7s %3s %s\n"),
9843               addr_size * 2, "Address",
9844               addr_size * 2, "Initial",
9845               addr_size * 2, "Sym.Val.", "Type", "Ndx", "Name");
9846       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
9847       for (i = 0; i < count; i++)
9848         {
9849           Elf_Internal_Sym * psym;
9850
9851           psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
9852           entry = print_mips_pltgot_entry (data, mips_pltgot, entry);
9853           printf (" ");
9854           print_vma (psym->st_value, LONG_HEX);
9855           printf (" %-7s %3s ",
9856                   get_symbol_type (ELF_ST_TYPE (psym->st_info)),
9857                   get_symbol_index_type (psym->st_shndx));
9858           if (VALID_DYNAMIC_NAME (psym->st_name))
9859             print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
9860           else
9861             printf ("<corrupt: %14ld>", psym->st_name);
9862           printf ("\n");
9863         }
9864       printf ("\n");
9865
9866       if (data)
9867         free (data);
9868       free (rels);
9869     }
9870
9871   return 1;
9872 }
9873
9874 static int
9875 process_gnu_liblist (FILE * file)
9876 {
9877   Elf_Internal_Shdr * section;
9878   Elf_Internal_Shdr * string_sec;
9879   Elf32_External_Lib * elib;
9880   char * strtab;
9881   size_t strtab_size;
9882   size_t cnt;
9883   unsigned i;
9884
9885   if (! do_arch)
9886     return 0;
9887
9888   for (i = 0, section = section_headers;
9889        i < elf_header.e_shnum;
9890        i++, section++)
9891     {
9892       switch (section->sh_type)
9893         {
9894         case SHT_GNU_LIBLIST:
9895           if (section->sh_link >= elf_header.e_shnum)
9896             break;
9897
9898           elib = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9899                            _("liblist"));
9900
9901           if (elib == NULL)
9902             break;
9903           string_sec = section_headers + section->sh_link;
9904
9905           strtab = get_data (NULL, file, string_sec->sh_offset, 1,
9906                              string_sec->sh_size, _("liblist string table"));
9907           strtab_size = string_sec->sh_size;
9908
9909           if (strtab == NULL
9910               || section->sh_entsize != sizeof (Elf32_External_Lib))
9911             {
9912               free (elib);
9913               break;
9914             }
9915
9916           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9917                   SECTION_NAME (section),
9918                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
9919
9920           puts ("     Library              Time Stamp          Checksum   Version Flags");
9921
9922           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
9923                ++cnt)
9924             {
9925               Elf32_Lib liblist;
9926               time_t time;
9927               char timebuf[20];
9928               struct tm * tmp;
9929
9930               liblist.l_name = BYTE_GET (elib[cnt].l_name);
9931               time = BYTE_GET (elib[cnt].l_time_stamp);
9932               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9933               liblist.l_version = BYTE_GET (elib[cnt].l_version);
9934               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9935
9936               tmp = gmtime (&time);
9937               snprintf (timebuf, sizeof (timebuf),
9938                         "%04u-%02u-%02uT%02u:%02u:%02u",
9939                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9940                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9941
9942               printf ("%3lu: ", (unsigned long) cnt);
9943               if (do_wide)
9944                 printf ("%-20s", liblist.l_name < strtab_size
9945                                  ? strtab + liblist.l_name : "<corrupt>");
9946               else
9947                 printf ("%-20.20s", liblist.l_name < strtab_size
9948                                     ? strtab + liblist.l_name : "<corrupt>");
9949               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
9950                       liblist.l_version, liblist.l_flags);
9951             }
9952
9953           free (elib);
9954         }
9955     }
9956
9957   return 1;
9958 }
9959
9960 static const char *
9961 get_note_type (unsigned e_type)
9962 {
9963   static char buff[64];
9964
9965   if (elf_header.e_type == ET_CORE)
9966     switch (e_type)
9967       {
9968       case NT_AUXV:
9969         return _("NT_AUXV (auxiliary vector)");
9970       case NT_PRSTATUS:
9971         return _("NT_PRSTATUS (prstatus structure)");
9972       case NT_FPREGSET:
9973         return _("NT_FPREGSET (floating point registers)");
9974       case NT_PRPSINFO:
9975         return _("NT_PRPSINFO (prpsinfo structure)");
9976       case NT_TASKSTRUCT:
9977         return _("NT_TASKSTRUCT (task structure)");
9978       case NT_PRXFPREG:
9979         return _("NT_PRXFPREG (user_xfpregs structure)");
9980       case NT_PPC_VMX:
9981         return _("NT_PPC_VMX (ppc Altivec registers)");
9982       case NT_PPC_VSX:
9983         return _("NT_PPC_VSX (ppc VSX registers)");
9984       case NT_PSTATUS:
9985         return _("NT_PSTATUS (pstatus structure)");
9986       case NT_FPREGS:
9987         return _("NT_FPREGS (floating point registers)");
9988       case NT_PSINFO:
9989         return _("NT_PSINFO (psinfo structure)");
9990       case NT_LWPSTATUS:
9991         return _("NT_LWPSTATUS (lwpstatus_t structure)");
9992       case NT_LWPSINFO:
9993         return _("NT_LWPSINFO (lwpsinfo_t structure)");
9994       case NT_WIN32PSTATUS:
9995         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9996       default:
9997         break;
9998       }
9999   else
10000     switch (e_type)
10001       {
10002       case NT_VERSION:
10003         return _("NT_VERSION (version)");
10004       case NT_ARCH:
10005         return _("NT_ARCH (architecture)");
10006       default:
10007         break;
10008       }
10009
10010   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
10011   return buff;
10012 }
10013
10014 static const char *
10015 get_gnu_elf_note_type (unsigned e_type)
10016 {
10017   static char buff[64];
10018
10019   switch (e_type)
10020     {
10021     case NT_GNU_ABI_TAG:
10022       return _("NT_GNU_ABI_TAG (ABI version tag)");
10023     case NT_GNU_HWCAP:
10024       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10025     case NT_GNU_BUILD_ID:
10026       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
10027     case NT_GNU_GOLD_VERSION:
10028       return _("NT_GNU_GOLD_VERSION (gold version)");
10029     default:
10030       break;
10031     }
10032
10033   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
10034   return buff;
10035 }
10036
10037 static const char *
10038 get_netbsd_elfcore_note_type (unsigned e_type)
10039 {
10040   static char buff[64];
10041
10042   if (e_type == NT_NETBSDCORE_PROCINFO)
10043     {
10044       /* NetBSD core "procinfo" structure.  */
10045       return _("NetBSD procinfo structure");
10046     }
10047
10048   /* As of Jan 2002 there are no other machine-independent notes
10049      defined for NetBSD core files.  If the note type is less
10050      than the start of the machine-dependent note types, we don't
10051      understand it.  */
10052
10053   if (e_type < NT_NETBSDCORE_FIRSTMACH)
10054     {
10055       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
10056       return buff;
10057     }
10058
10059   switch (elf_header.e_machine)
10060     {
10061     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10062        and PT_GETFPREGS == mach+2.  */
10063
10064     case EM_OLD_ALPHA:
10065     case EM_ALPHA:
10066     case EM_SPARC:
10067     case EM_SPARC32PLUS:
10068     case EM_SPARCV9:
10069       switch (e_type)
10070         {
10071         case NT_NETBSDCORE_FIRSTMACH+0:
10072           return _("PT_GETREGS (reg structure)");
10073         case NT_NETBSDCORE_FIRSTMACH+2:
10074           return _("PT_GETFPREGS (fpreg structure)");
10075         default:
10076           break;
10077         }
10078       break;
10079
10080     /* On all other arch's, PT_GETREGS == mach+1 and
10081        PT_GETFPREGS == mach+3.  */
10082     default:
10083       switch (e_type)
10084         {
10085         case NT_NETBSDCORE_FIRSTMACH+1:
10086           return _("PT_GETREGS (reg structure)");
10087         case NT_NETBSDCORE_FIRSTMACH+3:
10088           return _("PT_GETFPREGS (fpreg structure)");
10089         default:
10090           break;
10091         }
10092     }
10093
10094   snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
10095             e_type - NT_NETBSDCORE_FIRSTMACH);
10096   return buff;
10097 }
10098
10099 /* Note that by the ELF standard, the name field is already null byte
10100    terminated, and namesz includes the terminating null byte.
10101    I.E. the value of namesz for the name "FSF" is 4.
10102
10103    If the value of namesz is zero, there is no name present.  */
10104 static int
10105 process_note (Elf_Internal_Note * pnote)
10106 {
10107   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
10108   const char * nt;
10109
10110   if (pnote->namesz == 0)
10111     /* If there is no note name, then use the default set of
10112        note type strings.  */
10113     nt = get_note_type (pnote->type);
10114
10115   else if (const_strneq (pnote->namedata, "GNU"))
10116     /* GNU-specific object file notes.  */
10117     nt = get_gnu_elf_note_type (pnote->type);
10118
10119   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
10120     /* NetBSD-specific core file notes.  */
10121     nt = get_netbsd_elfcore_note_type (pnote->type);
10122
10123   else if (strneq (pnote->namedata, "SPU/", 4))
10124     {
10125       /* SPU-specific core file notes.  */
10126       nt = pnote->namedata + 4;
10127       name = "SPU";
10128     }
10129
10130   else
10131     /* Don't recognize this note name; just use the default set of
10132        note type strings.  */
10133       nt = get_note_type (pnote->type);
10134
10135   printf ("  %s\t\t0x%08lx\t%s\n", name, pnote->descsz, nt);
10136   return 1;
10137 }
10138
10139
10140 static int
10141 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
10142 {
10143   Elf_External_Note * pnotes;
10144   Elf_External_Note * external;
10145   int res = 1;
10146
10147   if (length <= 0)
10148     return 0;
10149
10150   pnotes = get_data (NULL, file, offset, 1, length, _("notes"));
10151   if (!pnotes)
10152     return 0;
10153
10154   external = pnotes;
10155
10156   printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10157           (unsigned long) offset, (unsigned long) length);
10158   printf (_("  Owner\t\tData size\tDescription\n"));
10159
10160   while (external < (Elf_External_Note *) ((char *) pnotes + length))
10161     {
10162       Elf_External_Note * next;
10163       Elf_Internal_Note inote;
10164       char * temp = NULL;
10165
10166       inote.type     = BYTE_GET (external->type);
10167       inote.namesz   = BYTE_GET (external->namesz);
10168       inote.namedata = external->name;
10169       inote.descsz   = BYTE_GET (external->descsz);
10170       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
10171       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
10172
10173       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
10174
10175       if (((char *) next) > (((char *) pnotes) + length))
10176         {
10177           warn (_("corrupt note found at offset %lx into core notes\n"),
10178                 (unsigned long) ((char *) external - (char *) pnotes));
10179           warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10180                 inote.type, inote.namesz, inote.descsz);
10181           break;
10182         }
10183
10184       external = next;
10185
10186       /* Verify that name is null terminated.  It appears that at least
10187          one version of Linux (RedHat 6.0) generates corefiles that don't
10188          comply with the ELF spec by failing to include the null byte in
10189          namesz.  */
10190       if (inote.namedata[inote.namesz] != '\0')
10191         {
10192           temp = malloc (inote.namesz + 1);
10193
10194           if (temp == NULL)
10195             {
10196               error (_("Out of memory\n"));
10197               res = 0;
10198               break;
10199             }
10200
10201           strncpy (temp, inote.namedata, inote.namesz);
10202           temp[inote.namesz] = 0;
10203
10204           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
10205           inote.namedata = temp;
10206         }
10207
10208       res &= process_note (& inote);
10209
10210       if (temp != NULL)
10211         {
10212           free (temp);
10213           temp = NULL;
10214         }
10215     }
10216
10217   free (pnotes);
10218
10219   return res;
10220 }
10221
10222 static int
10223 process_corefile_note_segments (FILE * file)
10224 {
10225   Elf_Internal_Phdr * segment;
10226   unsigned int i;
10227   int res = 1;
10228
10229   if (! get_program_headers (file))
10230       return 0;
10231
10232   for (i = 0, segment = program_headers;
10233        i < elf_header.e_phnum;
10234        i++, segment++)
10235     {
10236       if (segment->p_type == PT_NOTE)
10237         res &= process_corefile_note_segment (file,
10238                                               (bfd_vma) segment->p_offset,
10239                                               (bfd_vma) segment->p_filesz);
10240     }
10241
10242   return res;
10243 }
10244
10245 static int
10246 process_note_sections (FILE * file)
10247 {
10248   Elf_Internal_Shdr * section;
10249   unsigned long i;
10250   int res = 1;
10251
10252   for (i = 0, section = section_headers;
10253        i < elf_header.e_shnum;
10254        i++, section++)
10255     if (section->sh_type == SHT_NOTE)
10256       res &= process_corefile_note_segment (file,
10257                                             (bfd_vma) section->sh_offset,
10258                                             (bfd_vma) section->sh_size);
10259
10260   return res;
10261 }
10262
10263 static int
10264 process_notes (FILE * file)
10265 {
10266   /* If we have not been asked to display the notes then do nothing.  */
10267   if (! do_notes)
10268     return 1;
10269
10270   if (elf_header.e_type != ET_CORE)
10271     return process_note_sections (file);
10272
10273   /* No program headers means no NOTE segment.  */
10274   if (elf_header.e_phnum > 0)
10275     return process_corefile_note_segments (file);
10276
10277   printf (_("No note segments present in the core file.\n"));
10278   return 1;
10279 }
10280
10281 static int
10282 process_arch_specific (FILE * file)
10283 {
10284   if (! do_arch)
10285     return 1;
10286
10287   switch (elf_header.e_machine)
10288     {
10289     case EM_ARM:
10290       return process_arm_specific (file);
10291     case EM_MIPS:
10292     case EM_MIPS_RS3_LE:
10293       return process_mips_specific (file);
10294       break;
10295     case EM_PPC:
10296       return process_power_specific (file);
10297       break;
10298     default:
10299       break;
10300     }
10301   return 1;
10302 }
10303
10304 static int
10305 get_file_header (FILE * file)
10306 {
10307   /* Read in the identity array.  */
10308   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
10309     return 0;
10310
10311   /* Determine how to read the rest of the header.  */
10312   switch (elf_header.e_ident[EI_DATA])
10313     {
10314     default: /* fall through */
10315     case ELFDATANONE: /* fall through */
10316     case ELFDATA2LSB:
10317       byte_get = byte_get_little_endian;
10318       byte_put = byte_put_little_endian;
10319       break;
10320     case ELFDATA2MSB:
10321       byte_get = byte_get_big_endian;
10322       byte_put = byte_put_big_endian;
10323       break;
10324     }
10325
10326   /* For now we only support 32 bit and 64 bit ELF files.  */
10327   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
10328
10329   /* Read in the rest of the header.  */
10330   if (is_32bit_elf)
10331     {
10332       Elf32_External_Ehdr ehdr32;
10333
10334       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
10335         return 0;
10336
10337       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
10338       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
10339       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
10340       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
10341       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
10342       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
10343       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
10344       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
10345       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
10346       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
10347       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
10348       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
10349       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
10350     }
10351   else
10352     {
10353       Elf64_External_Ehdr ehdr64;
10354
10355       /* If we have been compiled with sizeof (bfd_vma) == 4, then
10356          we will not be able to cope with the 64bit data found in
10357          64 ELF files.  Detect this now and abort before we start
10358          overwriting things.  */
10359       if (sizeof (bfd_vma) < 8)
10360         {
10361           error (_("This instance of readelf has been built without support for a\n\
10362 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10363           return 0;
10364         }
10365
10366       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
10367         return 0;
10368
10369       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
10370       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
10371       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
10372       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
10373       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
10374       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
10375       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
10376       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
10377       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
10378       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
10379       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
10380       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
10381       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
10382     }
10383
10384   if (elf_header.e_shoff)
10385     {
10386       /* There may be some extensions in the first section header.  Don't
10387          bomb if we can't read it.  */
10388       if (is_32bit_elf)
10389         get_32bit_section_headers (file, 1);
10390       else
10391         get_64bit_section_headers (file, 1);
10392     }
10393
10394   return 1;
10395 }
10396
10397 /* Process one ELF object file according to the command line options.
10398    This file may actually be stored in an archive.  The file is
10399    positioned at the start of the ELF object.  */
10400
10401 static int
10402 process_object (char * file_name, FILE * file)
10403 {
10404   unsigned int i;
10405
10406   if (! get_file_header (file))
10407     {
10408       error (_("%s: Failed to read file header\n"), file_name);
10409       return 1;
10410     }
10411
10412   /* Initialise per file variables.  */
10413   for (i = ARRAY_SIZE (version_info); i--;)
10414     version_info[i] = 0;
10415
10416   for (i = ARRAY_SIZE (dynamic_info); i--;)
10417     dynamic_info[i] = 0;
10418
10419   /* Process the file.  */
10420   if (show_name)
10421     printf (_("\nFile: %s\n"), file_name);
10422
10423   /* Initialise the dump_sects array from the cmdline_dump_sects array.
10424      Note we do this even if cmdline_dump_sects is empty because we
10425      must make sure that the dump_sets array is zeroed out before each
10426      object file is processed.  */
10427   if (num_dump_sects > num_cmdline_dump_sects)
10428     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
10429
10430   if (num_cmdline_dump_sects > 0)
10431     {
10432       if (num_dump_sects == 0)
10433         /* A sneaky way of allocating the dump_sects array.  */
10434         request_dump_bynumber (num_cmdline_dump_sects, 0);
10435
10436       assert (num_dump_sects >= num_cmdline_dump_sects);
10437       memcpy (dump_sects, cmdline_dump_sects,
10438               num_cmdline_dump_sects * sizeof (* dump_sects));
10439     }
10440
10441   if (! process_file_header ())
10442     return 1;
10443
10444   if (! process_section_headers (file))
10445     {
10446       /* Without loaded section headers we cannot process lots of
10447          things.  */
10448       do_unwind = do_version = do_dump = do_arch = 0;
10449
10450       if (! do_using_dynamic)
10451         do_syms = do_reloc = 0;
10452     }
10453
10454   if (! process_section_groups (file))
10455     {
10456       /* Without loaded section groups we cannot process unwind.  */
10457       do_unwind = 0;
10458     }
10459
10460   if (process_program_headers (file))
10461     process_dynamic_section (file);
10462
10463   process_relocs (file);
10464
10465   process_unwind (file);
10466
10467   process_symbol_table (file);
10468
10469   process_syminfo (file);
10470
10471   process_version_sections (file);
10472
10473   process_section_contents (file);
10474
10475   process_notes (file);
10476
10477   process_gnu_liblist (file);
10478
10479   process_arch_specific (file);
10480
10481   if (program_headers)
10482     {
10483       free (program_headers);
10484       program_headers = NULL;
10485     }
10486
10487   if (section_headers)
10488     {
10489       free (section_headers);
10490       section_headers = NULL;
10491     }
10492
10493   if (string_table)
10494     {
10495       free (string_table);
10496       string_table = NULL;
10497       string_table_length = 0;
10498     }
10499
10500   if (dynamic_strings)
10501     {
10502       free (dynamic_strings);
10503       dynamic_strings = NULL;
10504       dynamic_strings_length = 0;
10505     }
10506
10507   if (dynamic_symbols)
10508     {
10509       free (dynamic_symbols);
10510       dynamic_symbols = NULL;
10511       num_dynamic_syms = 0;
10512     }
10513
10514   if (dynamic_syminfo)
10515     {
10516       free (dynamic_syminfo);
10517       dynamic_syminfo = NULL;
10518     }
10519
10520   if (section_headers_groups)
10521     {
10522       free (section_headers_groups);
10523       section_headers_groups = NULL;
10524     }
10525
10526   if (section_groups)
10527     {
10528       struct group_list * g;
10529       struct group_list * next;
10530
10531       for (i = 0; i < group_count; i++)
10532         {
10533           for (g = section_groups [i].root; g != NULL; g = next)
10534             {
10535               next = g->next;
10536               free (g);
10537             }
10538         }
10539
10540       free (section_groups);
10541       section_groups = NULL;
10542     }
10543
10544   free_debug_memory ();
10545
10546   return 0;
10547 }
10548
10549 /* Return the path name for a proxy entry in a thin archive, adjusted relative
10550    to the path name of the thin archive itself if necessary.  Always returns
10551    a pointer to malloc'ed memory.  */
10552
10553 static char *
10554 adjust_relative_path (char * file_name, char * name, int name_len)
10555 {
10556   char * member_file_name;
10557   const char * base_name = lbasename (file_name);
10558
10559   /* This is a proxy entry for a thin archive member.
10560      If the extended name table contains an absolute path
10561      name, or if the archive is in the current directory,
10562      use the path name as given.  Otherwise, we need to
10563      find the member relative to the directory where the
10564      archive is located.  */
10565   if (IS_ABSOLUTE_PATH (name) || base_name == file_name)
10566     {
10567       member_file_name = malloc (name_len + 1);
10568       if (member_file_name == NULL)
10569         {
10570           error (_("Out of memory\n"));
10571           return NULL;
10572         }
10573       memcpy (member_file_name, name, name_len);
10574       member_file_name[name_len] = '\0';
10575     }
10576   else
10577     {
10578       /* Concatenate the path components of the archive file name
10579          to the relative path name from the extended name table.  */
10580       size_t prefix_len = base_name - file_name;
10581       member_file_name = malloc (prefix_len + name_len + 1);
10582       if (member_file_name == NULL)
10583         {
10584           error (_("Out of memory\n"));
10585           return NULL;
10586         }
10587       memcpy (member_file_name, file_name, prefix_len);
10588       memcpy (member_file_name + prefix_len, name, name_len);
10589       member_file_name[prefix_len + name_len] = '\0';
10590     }
10591   return member_file_name;
10592 }
10593
10594 /* Structure to hold information about an archive file.  */
10595
10596 struct archive_info
10597 {
10598   char * file_name;                     /* Archive file name.  */
10599   FILE * file;                          /* Open file descriptor.  */
10600   unsigned long index_num;              /* Number of symbols in table.  */
10601   unsigned long * index_array;          /* The array of member offsets.  */
10602   char * sym_table;                     /* The symbol table.  */
10603   unsigned long sym_size;               /* Size of the symbol table.  */
10604   char * longnames;                     /* The long file names table.  */
10605   unsigned long longnames_size;         /* Size of the long file names table.  */
10606   unsigned long nested_member_origin;   /* Origin in the nested archive of the current member.  */
10607   unsigned long next_arhdr_offset;      /* Offset of the next archive header.  */
10608   bfd_boolean is_thin_archive;          /* TRUE if this is a thin archive.  */
10609   struct ar_hdr arhdr;                  /* Current archive header.  */
10610 };
10611
10612 /* Read the symbol table and long-name table from an archive.  */
10613
10614 static int
10615 setup_archive (struct archive_info * arch, char * file_name, FILE * file,
10616                bfd_boolean is_thin_archive, bfd_boolean read_symbols)
10617 {
10618   size_t got;
10619   unsigned long size;
10620
10621   arch->file_name = strdup (file_name);
10622   arch->file = file;
10623   arch->index_num = 0;
10624   arch->index_array = NULL;
10625   arch->sym_table = NULL;
10626   arch->sym_size = 0;
10627   arch->longnames = NULL;
10628   arch->longnames_size = 0;
10629   arch->nested_member_origin = 0;
10630   arch->is_thin_archive = is_thin_archive;
10631   arch->next_arhdr_offset = SARMAG;
10632
10633   /* Read the first archive member header.  */
10634   if (fseek (file, SARMAG, SEEK_SET) != 0)
10635     {
10636       error (_("%s: failed to seek to first archive header\n"), file_name);
10637       return 1;
10638     }
10639   got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
10640   if (got != sizeof arch->arhdr)
10641     {
10642       if (got == 0)
10643         return 0;
10644
10645       error (_("%s: failed to read archive header\n"), file_name);
10646       return 1;
10647     }
10648
10649   /* See if this is the archive symbol table.  */
10650   if (const_strneq (arch->arhdr.ar_name, "/               ")
10651       || const_strneq (arch->arhdr.ar_name, "/SYM64/         "))
10652     {
10653       size = strtoul (arch->arhdr.ar_size, NULL, 10);
10654       size = size + (size & 1);
10655
10656       arch->next_arhdr_offset += sizeof arch->arhdr + size;
10657
10658       if (read_symbols)
10659         {
10660           unsigned long i;
10661           /* A buffer used to hold numbers read in from an archive index.
10662              These are always 4 bytes long and stored in big-endian format.  */
10663 #define SIZEOF_AR_INDEX_NUMBERS 4
10664           unsigned char integer_buffer[SIZEOF_AR_INDEX_NUMBERS];
10665           unsigned char * index_buffer;
10666
10667           /* Check the size of the archive index.  */
10668           if (size < SIZEOF_AR_INDEX_NUMBERS)
10669             {
10670               error (_("%s: the archive index is empty\n"), file_name);
10671               return 1;
10672             }
10673
10674           /* Read the numer of entries in the archive index.  */
10675           got = fread (integer_buffer, 1, sizeof integer_buffer, file);
10676           if (got != sizeof (integer_buffer))
10677             {
10678               error (_("%s: failed to read archive index\n"), file_name);
10679               return 1;
10680             }
10681           arch->index_num = byte_get_big_endian (integer_buffer, sizeof integer_buffer);
10682           size -= SIZEOF_AR_INDEX_NUMBERS;
10683
10684           /* Read in the archive index.  */
10685           if (size < arch->index_num * SIZEOF_AR_INDEX_NUMBERS)
10686             {
10687               error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
10688                      file_name, arch->index_num);
10689               return 1;
10690             }
10691           index_buffer = malloc (arch->index_num * SIZEOF_AR_INDEX_NUMBERS);
10692           if (index_buffer == NULL)
10693             {
10694               error (_("Out of memory whilst trying to read archive symbol index\n"));
10695               return 1;
10696             }
10697           got = fread (index_buffer, SIZEOF_AR_INDEX_NUMBERS, arch->index_num, file);
10698           if (got != arch->index_num)
10699             {
10700               free (index_buffer);
10701               error (_("%s: failed to read archive index\n"), file_name);
10702               return 1;
10703             }
10704           size -= arch->index_num * SIZEOF_AR_INDEX_NUMBERS;
10705
10706           /* Convert the index numbers into the host's numeric format.  */
10707           arch->index_array = malloc (arch->index_num * sizeof (* arch->index_array));
10708           if (arch->index_array == NULL)
10709             {
10710               free (index_buffer);
10711               error (_("Out of memory whilst trying to convert the archive symbol index\n"));
10712               return 1;
10713             }
10714
10715           for (i = 0; i < arch->index_num; i++)
10716             arch->index_array[i] = byte_get_big_endian ((unsigned char *) (index_buffer + (i * SIZEOF_AR_INDEX_NUMBERS)),
10717                                                         SIZEOF_AR_INDEX_NUMBERS);
10718           free (index_buffer);
10719
10720           /* The remaining space in the header is taken up by the symbol table.  */
10721           if (size < 1)
10722             {
10723               error (_("%s: the archive has an index but no symbols\n"), file_name);
10724               return 1;
10725             }
10726           arch->sym_table = malloc (size);
10727           arch->sym_size = size;
10728           if (arch->sym_table == NULL)
10729             {
10730               error (_("Out of memory whilst trying to read archive index symbol table\n"));
10731               return 1;
10732             }
10733           got = fread (arch->sym_table, 1, size, file);
10734           if (got != size)
10735             {
10736               error (_("%s: failed to read archive index symbol table\n"), file_name);
10737               return 1;
10738             }
10739         }
10740       else
10741         {
10742           if (fseek (file, size, SEEK_CUR) != 0)
10743             {
10744               error (_("%s: failed to skip archive symbol table\n"), file_name);
10745               return 1;
10746             }
10747         }
10748
10749       /* Read the next archive header.  */
10750       got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
10751       if (got != sizeof arch->arhdr)
10752         {
10753           if (got == 0)
10754             return 0;
10755           error (_("%s: failed to read archive header following archive index\n"), file_name);
10756           return 1;
10757         }
10758     }
10759   else if (read_symbols)
10760     printf (_("%s has no archive index\n"), file_name);
10761
10762   if (const_strneq (arch->arhdr.ar_name, "//              "))
10763     {
10764       /* This is the archive string table holding long member names.  */
10765       arch->longnames_size = strtoul (arch->arhdr.ar_size, NULL, 10);
10766       arch->next_arhdr_offset += sizeof arch->arhdr + arch->longnames_size;
10767
10768       arch->longnames = malloc (arch->longnames_size);
10769       if (arch->longnames == NULL)
10770         {
10771           error (_("Out of memory reading long symbol names in archive\n"));
10772           return 1;
10773         }
10774
10775       if (fread (arch->longnames, arch->longnames_size, 1, file) != 1)
10776         {
10777           free (arch->longnames);
10778           arch->longnames = NULL;
10779           error (_("%s: failed to read long symbol name string table\n"), file_name);
10780           return 1;
10781         }
10782
10783       if ((arch->longnames_size & 1) != 0)
10784         getc (file);
10785     }
10786
10787   return 0;
10788 }
10789
10790 /* Release the memory used for the archive information.  */
10791
10792 static void
10793 release_archive (struct archive_info * arch)
10794 {
10795   if (arch->file_name != NULL)
10796     free (arch->file_name);
10797   if (arch->index_array != NULL)
10798     free (arch->index_array);
10799   if (arch->sym_table != NULL)
10800     free (arch->sym_table);
10801   if (arch->longnames != NULL)
10802     free (arch->longnames);
10803 }
10804
10805 /* Open and setup a nested archive, if not already open.  */
10806
10807 static int
10808 setup_nested_archive (struct archive_info * nested_arch, char * member_file_name)
10809 {
10810   FILE * member_file;
10811
10812   /* Have we already setup this archive?  */
10813   if (nested_arch->file_name != NULL
10814       && streq (nested_arch->file_name, member_file_name))
10815     return 0;
10816
10817   /* Close previous file and discard cached information.  */
10818   if (nested_arch->file != NULL)
10819     fclose (nested_arch->file);
10820   release_archive (nested_arch);
10821
10822   member_file = fopen (member_file_name, "rb");
10823   if (member_file == NULL)
10824     return 1;
10825   return setup_archive (nested_arch, member_file_name, member_file, FALSE, FALSE);
10826 }
10827
10828 static char *
10829 get_archive_member_name_at (struct archive_info *  arch,
10830                             unsigned long          offset,
10831                             struct archive_info *  nested_arch);
10832
10833 /* Get the name of an archive member from the current archive header.
10834    For simple names, this will modify the ar_name field of the current
10835    archive header.  For long names, it will return a pointer to the
10836    longnames table.  For nested archives, it will open the nested archive
10837    and get the name recursively.  NESTED_ARCH is a single-entry cache so
10838    we don't keep rereading the same information from a nested archive.  */
10839
10840 static char *
10841 get_archive_member_name (struct archive_info *  arch,
10842                          struct archive_info *  nested_arch)
10843 {
10844   unsigned long j, k;
10845
10846   if (arch->arhdr.ar_name[0] == '/')
10847     {
10848       /* We have a long name.  */
10849       char * endp;
10850       char * member_file_name;
10851       char * member_name;
10852
10853       arch->nested_member_origin = 0;
10854       k = j = strtoul (arch->arhdr.ar_name + 1, &endp, 10);
10855       if (arch->is_thin_archive && endp != NULL && * endp == ':')
10856         arch->nested_member_origin = strtoul (endp + 1, NULL, 10);
10857
10858       while ((j < arch->longnames_size)
10859              && (arch->longnames[j] != '\n')
10860              && (arch->longnames[j] != '\0'))
10861         j++;
10862       if (arch->longnames[j-1] == '/')
10863         j--;
10864       arch->longnames[j] = '\0';
10865
10866       if (!arch->is_thin_archive || arch->nested_member_origin == 0)
10867         return arch->longnames + k;
10868
10869       /* This is a proxy for a member of a nested archive.
10870          Find the name of the member in that archive.  */
10871       member_file_name = adjust_relative_path (arch->file_name, arch->longnames + k, j - k);
10872       if (member_file_name != NULL
10873           && setup_nested_archive (nested_arch, member_file_name) == 0
10874           && (member_name = get_archive_member_name_at (nested_arch, arch->nested_member_origin, NULL)) != NULL)
10875         {
10876           free (member_file_name);
10877           return member_name;
10878         }
10879       free (member_file_name);
10880
10881       /* Last resort: just return the name of the nested archive.  */
10882       return arch->longnames + k;
10883     }
10884
10885   /* We have a normal (short) name.  */
10886   j = 0;
10887   while ((arch->arhdr.ar_name[j] != '/') && (j < 16))
10888     j++;
10889   arch->arhdr.ar_name[j] = '\0';
10890   return arch->arhdr.ar_name;
10891 }
10892
10893 /* Get the name of an archive member at a given OFFSET within an archive ARCH.  */
10894
10895 static char *
10896 get_archive_member_name_at (struct archive_info * arch,
10897                             unsigned long         offset,
10898                             struct archive_info * nested_arch)
10899 {
10900   size_t got;
10901
10902   if (fseek (arch->file, offset, SEEK_SET) != 0)
10903     {
10904       error (_("%s: failed to seek to next file name\n"), arch->file_name);
10905       return NULL;
10906     }
10907   got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file);
10908   if (got != sizeof arch->arhdr)
10909     {
10910       error (_("%s: failed to read archive header\n"), arch->file_name);
10911       return NULL;
10912     }
10913   if (memcmp (arch->arhdr.ar_fmag, ARFMAG, 2) != 0)
10914     {
10915       error (_("%s: did not find a valid archive header\n"), arch->file_name);
10916       return NULL;
10917     }
10918
10919   return get_archive_member_name (arch, nested_arch);
10920 }
10921
10922 /* Construct a string showing the name of the archive member, qualified
10923    with the name of the containing archive file.  For thin archives, we
10924    use square brackets to denote the indirection.  For nested archives,
10925    we show the qualified name of the external member inside the square
10926    brackets (e.g., "thin.a[normal.a(foo.o)]").  */
10927
10928 static char *
10929 make_qualified_name (struct archive_info * arch,
10930                      struct archive_info * nested_arch,
10931                      char * member_name)
10932 {
10933   size_t len;
10934   char * name;
10935
10936   len = strlen (arch->file_name) + strlen (member_name) + 3;
10937   if (arch->is_thin_archive && arch->nested_member_origin != 0)
10938     len += strlen (nested_arch->file_name) + 2;
10939
10940   name = malloc (len);
10941   if (name == NULL)
10942     {
10943       error (_("Out of memory\n"));
10944       return NULL;
10945     }
10946
10947   if (arch->is_thin_archive && arch->nested_member_origin != 0)
10948     snprintf (name, len, "%s[%s(%s)]", arch->file_name, nested_arch->file_name, member_name);
10949   else if (arch->is_thin_archive)
10950     snprintf (name, len, "%s[%s]", arch->file_name, member_name);
10951   else
10952     snprintf (name, len, "%s(%s)", arch->file_name, member_name);
10953
10954   return name;
10955 }
10956
10957 /* Process an ELF archive.
10958    On entry the file is positioned just after the ARMAG string.  */
10959
10960 static int
10961 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
10962 {
10963   struct archive_info arch;
10964   struct archive_info nested_arch;
10965   size_t got;
10966   size_t file_name_size;
10967   int ret;
10968
10969   show_name = 1;
10970
10971   /* The ARCH structure is used to hold information about this archive.  */
10972   arch.file_name = NULL;
10973   arch.file = NULL;
10974   arch.index_array = NULL;
10975   arch.sym_table = NULL;
10976   arch.longnames = NULL;
10977
10978   /* The NESTED_ARCH structure is used as a single-item cache of information
10979      about a nested archive (when members of a thin archive reside within
10980      another regular archive file).  */
10981   nested_arch.file_name = NULL;
10982   nested_arch.file = NULL;
10983   nested_arch.index_array = NULL;
10984   nested_arch.sym_table = NULL;
10985   nested_arch.longnames = NULL;
10986
10987   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
10988     {
10989       ret = 1;
10990       goto out;
10991     }
10992
10993   if (do_archive_index)
10994     {
10995       if (arch.sym_table == NULL)
10996         error (_("%s: unable to dump the index as none was found\n"), file_name);
10997       else
10998         {
10999           unsigned int i, l;
11000           unsigned long current_pos;
11001
11002           printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
11003                   file_name, arch.index_num, arch.sym_size);
11004           current_pos = ftell (file);
11005
11006           for (i = l = 0; i < arch.index_num; i++)
11007             {
11008               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
11009                 {
11010                   char * member_name;
11011
11012                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
11013
11014                   if (member_name != NULL)
11015                     {
11016                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
11017
11018                       if (qualified_name != NULL)
11019                         {
11020                           printf (_("Binary %s contains:\n"), qualified_name);
11021                           free (qualified_name);
11022                         }
11023                     }
11024                 }
11025
11026               if (l >= arch.sym_size)
11027                 {
11028                   error (_("%s: end of the symbol table reached before the end of the index\n"),
11029                          file_name);
11030                   break;
11031                 }
11032               printf ("\t%s\n", arch.sym_table + l);
11033               l += strlen (arch.sym_table + l) + 1;
11034             }
11035
11036           if (l & 01)
11037             ++l;
11038           if (l < arch.sym_size)
11039             error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
11040                    file_name);
11041
11042           if (fseek (file, current_pos, SEEK_SET) != 0)
11043             {
11044               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
11045               ret = 1;
11046               goto out;
11047             }
11048         }
11049
11050       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
11051           && !do_segments && !do_header && !do_dump && !do_version
11052           && !do_histogram && !do_debugging && !do_arch && !do_notes
11053           && !do_section_groups)
11054         {
11055           ret = 0; /* Archive index only.  */
11056           goto out;
11057         }
11058     }
11059
11060   file_name_size = strlen (file_name);
11061   ret = 0;
11062
11063   while (1)
11064     {
11065       char * name;
11066       size_t namelen;
11067       char * qualified_name;
11068
11069       /* Read the next archive header.  */
11070       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
11071         {
11072           error (_("%s: failed to seek to next archive header\n"), file_name);
11073           return 1;
11074         }
11075       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
11076       if (got != sizeof arch.arhdr)
11077         {
11078           if (got == 0)
11079             break;
11080           error (_("%s: failed to read archive header\n"), file_name);
11081           ret = 1;
11082           break;
11083         }
11084       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
11085         {
11086           error (_("%s: did not find a valid archive header\n"), arch.file_name);
11087           ret = 1;
11088           break;
11089         }
11090
11091       arch.next_arhdr_offset += sizeof arch.arhdr;
11092
11093       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
11094       if (archive_file_size & 01)
11095         ++archive_file_size;
11096
11097       name = get_archive_member_name (&arch, &nested_arch);
11098       if (name == NULL)
11099         {
11100           error (_("%s: bad archive file name\n"), file_name);
11101           ret = 1;
11102           break;
11103         }
11104       namelen = strlen (name);
11105
11106       qualified_name = make_qualified_name (&arch, &nested_arch, name);
11107       if (qualified_name == NULL)
11108         {
11109           error (_("%s: bad archive file name\n"), file_name);
11110           ret = 1;
11111           break;
11112         }
11113
11114       if (is_thin_archive && arch.nested_member_origin == 0)
11115         {
11116           /* This is a proxy for an external member of a thin archive.  */
11117           FILE * member_file;
11118           char * member_file_name = adjust_relative_path (file_name, name, namelen);
11119           if (member_file_name == NULL)
11120             {
11121               ret = 1;
11122               break;
11123             }
11124
11125           member_file = fopen (member_file_name, "rb");
11126           if (member_file == NULL)
11127             {
11128               error (_("Input file '%s' is not readable.\n"), member_file_name);
11129               free (member_file_name);
11130               ret = 1;
11131               break;
11132             }
11133
11134           archive_file_offset = arch.nested_member_origin;
11135
11136           ret |= process_object (qualified_name, member_file);
11137
11138           fclose (member_file);
11139           free (member_file_name);
11140         }
11141       else if (is_thin_archive)
11142         {
11143           /* This is a proxy for a member of a nested archive.  */
11144           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
11145
11146           /* The nested archive file will have been opened and setup by
11147              get_archive_member_name.  */
11148           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
11149             {
11150               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
11151               ret = 1;
11152               break;
11153             }
11154
11155           ret |= process_object (qualified_name, nested_arch.file);
11156         }
11157       else
11158         {
11159           archive_file_offset = arch.next_arhdr_offset;
11160           arch.next_arhdr_offset += archive_file_size;
11161
11162           ret |= process_object (qualified_name, file);
11163         }
11164
11165       free (qualified_name);
11166     }
11167
11168  out:
11169   if (nested_arch.file != NULL)
11170     fclose (nested_arch.file);
11171   release_archive (&nested_arch);
11172   release_archive (&arch);
11173
11174   return ret;
11175 }
11176
11177 static int
11178 process_file (char * file_name)
11179 {
11180   FILE * file;
11181   struct stat statbuf;
11182   char armag[SARMAG];
11183   int ret;
11184
11185   if (stat (file_name, &statbuf) < 0)
11186     {
11187       if (errno == ENOENT)
11188         error (_("'%s': No such file\n"), file_name);
11189       else
11190         error (_("Could not locate '%s'.  System error message: %s\n"),
11191                file_name, strerror (errno));
11192       return 1;
11193     }
11194
11195   if (! S_ISREG (statbuf.st_mode))
11196     {
11197       error (_("'%s' is not an ordinary file\n"), file_name);
11198       return 1;
11199     }
11200
11201   file = fopen (file_name, "rb");
11202   if (file == NULL)
11203     {
11204       error (_("Input file '%s' is not readable.\n"), file_name);
11205       return 1;
11206     }
11207
11208   if (fread (armag, SARMAG, 1, file) != 1)
11209     {
11210       error (_("%s: Failed to read file's magic number\n"), file_name);
11211       fclose (file);
11212       return 1;
11213     }
11214
11215   if (memcmp (armag, ARMAG, SARMAG) == 0)
11216     ret = process_archive (file_name, file, FALSE);
11217   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
11218     ret = process_archive (file_name, file, TRUE);
11219   else
11220     {
11221       if (do_archive_index)
11222         error (_("File %s is not an archive so its index cannot be displayed.\n"),
11223                file_name);
11224
11225       rewind (file);
11226       archive_file_size = archive_file_offset = 0;
11227       ret = process_object (file_name, file);
11228     }
11229
11230   fclose (file);
11231
11232   return ret;
11233 }
11234
11235 #ifdef SUPPORT_DISASSEMBLY
11236 /* Needed by the i386 disassembler.  For extra credit, someone could
11237    fix this so that we insert symbolic addresses here, esp for GOT/PLT
11238    symbols.  */
11239
11240 void
11241 print_address (unsigned int addr, FILE * outfile)
11242 {
11243   fprintf (outfile,"0x%8.8x", addr);
11244 }
11245
11246 /* Needed by the i386 disassembler.  */
11247 void
11248 db_task_printsym (unsigned int addr)
11249 {
11250   print_address (addr, stderr);
11251 }
11252 #endif
11253
11254 int
11255 main (int argc, char ** argv)
11256 {
11257   int err;
11258
11259 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11260   setlocale (LC_MESSAGES, "");
11261 #endif
11262 #if defined (HAVE_SETLOCALE)
11263   setlocale (LC_CTYPE, "");
11264 #endif
11265   bindtextdomain (PACKAGE, LOCALEDIR);
11266   textdomain (PACKAGE);
11267
11268   expandargv (&argc, &argv);
11269
11270   parse_args (argc, argv);
11271
11272   if (num_dump_sects > 0)
11273     {
11274       /* Make a copy of the dump_sects array.  */
11275       cmdline_dump_sects = malloc (num_dump_sects * sizeof (* dump_sects));
11276       if (cmdline_dump_sects == NULL)
11277         error (_("Out of memory allocating dump request table.\n"));
11278       else
11279         {
11280           memcpy (cmdline_dump_sects, dump_sects,
11281                   num_dump_sects * sizeof (* dump_sects));
11282           num_cmdline_dump_sects = num_dump_sects;
11283         }
11284     }
11285
11286   if (optind < (argc - 1))
11287     show_name = 1;
11288
11289   err = 0;
11290   while (optind < argc)
11291     err |= process_file (argv[optind++]);
11292
11293   if (dump_sects != NULL)
11294     free (dump_sects);
11295   if (cmdline_dump_sects != NULL)
11296     free (cmdline_dump_sects);
11297
11298   return err;
11299 }