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