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