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