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