binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright 1998-2013 Free Software Foundation, Inc.
   3
   4    Originally developed by Eric Youngdale <eric@andante.jic.com>
   5    Modifications by Nick Clifton <nickc@redhat.com>
   6
   7    This file is part of GNU Binutils.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  22    02110-1301, USA.  */
  23 \f
  24 /* The difference between readelf and objdump:
  25
  26   Both programs are capable of displaying the contents of ELF format files,
  27   so why does the binutils project have two file dumpers ?
  28
  29   The reason is that objdump sees an ELF file through a BFD filter of the
  30   world; if BFD has a bug where, say, it disagrees about a machine constant
  31   in e_flags, then the odds are good that it will remain internally
  32   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
  33   GAS sees it the BFD way.  There was need for a tool to go find out what
  34   the file actually says.
  35
  36   This is why the readelf program does not link against the BFD library - it
  37   exists as an independent program to help verify the correct working of BFD.
  38
  39   There is also the case that readelf can provide more information about an
  40   ELF file than is provided by objdump.  In particular it can display DWARF
  41   debugging information which (at the moment) objdump cannot.  */
  42 \f
  43 #include "sysdep.h"
  44 #include <assert.h>
  45 #include <time.h>
  46 #ifdef HAVE_ZLIB_H
  47 #include <zlib.h>
  48 #endif
  49 #ifdef HAVE_WCHAR_H
  50 #include <wchar.h>
  51 #endif
  52
  53 #if __GNUC__ >= 2
  54 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  55    as this will allow us to read in and parse 64bit and 32bit ELF files.
  56    Only do this if we believe that the compiler can support a 64 bit
  57    data type.  For now we only rely on GCC being able to do this.  */
  58 #define BFD64
  59 #endif
  60
  61 #include "bfd.h"
  62 #include "bucomm.h"
  63 #include "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/aarch64.h"
  95 #include "elf/alpha.h"
  96 #include "elf/arc.h"
  97 #include "elf/arm.h"
  98 #include "elf/avr.h"
  99 #include "elf/bfin.h"
 100 #include "elf/cr16.h"
 101 #include "elf/cris.h"
 102 #include "elf/crx.h"
 103 #include "elf/d10v.h"
 104 #include "elf/d30v.h"
 105 #include "elf/dlx.h"
 106 #include "elf/epiphany.h"
 107 #include "elf/fr30.h"
 108 #include "elf/frv.h"
 109 #include "elf/h8.h"
 110 #include "elf/hppa.h"
 111 #include "elf/i386.h"
 112 #include "elf/i370.h"
 113 #include "elf/i860.h"
 114 #include "elf/i960.h"
 115 #include "elf/ia64.h"
 116 #include "elf/ip2k.h"
 117 #include "elf/lm32.h"
 118 #include "elf/iq2000.h"
 119 #include "elf/m32c.h"
 120 #include "elf/m32r.h"
 121 #include "elf/m68k.h"
 122 #include "elf/m68hc11.h"
 123 #include "elf/mcore.h"
 124 #include "elf/mep.h"
 125 #include "elf/metag.h"
 126 #include "elf/microblaze.h"
 127 #include "elf/mips.h"
 128 #include "elf/mmix.h"
 129 #include "elf/mn10200.h"
 130 #include "elf/mn10300.h"
 131 #include "elf/moxie.h"
 132 #include "elf/mt.h"
 133 #include "elf/msp430.h"
 134 #include "elf/or32.h"
 135 #include "elf/pj.h"
 136 #include "elf/ppc.h"
 137 #include "elf/ppc64.h"
 138 #include "elf/rl78.h"
 139 #include "elf/rx.h"
 140 #include "elf/s390.h"
 141 #include "elf/score.h"
 142 #include "elf/sh.h"
 143 #include "elf/sparc.h"
 144 #include "elf/spu.h"
 145 #include "elf/tic6x.h"
 146 #include "elf/tilegx.h"
 147 #include "elf/tilepro.h"
 148 #include "elf/v850.h"
 149 #include "elf/vax.h"
 150 #include "elf/x86-64.h"
 151 #include "elf/xc16x.h"
 152 #include "elf/xgate.h"
 153 #include "elf/xstormy16.h"
 154 #include "elf/xtensa.h"
 155
 156 #include "elf/nios2.h"
 157
 158 #include "getopt.h"
 159 #include "libiberty.h"
 160 #include "safe-ctype.h"
 161 #include "filenames.h"
 162
 163 char * program_name = "readelf";
 164 static long archive_file_offset;
 165 static unsigned long archive_file_size;
 166 static unsigned long dynamic_addr;
 167 static bfd_size_type dynamic_size;
 168 static unsigned int dynamic_nent;
 169 static char * dynamic_strings;
 170 static unsigned long dynamic_strings_length;
 171 static char * string_table;
 172 static unsigned long string_table_length;
 173 static unsigned long num_dynamic_syms;
 174 static Elf_Internal_Sym * dynamic_symbols;
 175 static Elf_Internal_Syminfo * dynamic_syminfo;
 176 static unsigned long dynamic_syminfo_offset;
 177 static unsigned int dynamic_syminfo_nent;
 178 static char program_interpreter[PATH_MAX];
 179 static bfd_vma dynamic_info[DT_ENCODING];
 180 static bfd_vma dynamic_info_DT_GNU_HASH;
 181 static bfd_vma version_info[16];
 182 static Elf_Internal_Ehdr elf_header;
 183 static Elf_Internal_Shdr * section_headers;
 184 static Elf_Internal_Phdr * program_headers;
 185 static Elf_Internal_Dyn *  dynamic_section;
 186 static Elf_Internal_Shdr * symtab_shndx_hdr;
 187 static int show_name;
 188 static int do_dynamic;
 189 static int do_syms;
 190 static int do_dyn_syms;
 191 static int do_reloc;
 192 static int do_sections;
 193 static int do_section_groups;
 194 static int do_section_details;
 195 static int do_segments;
 196 static int do_unwind;
 197 static int do_using_dynamic;
 198 static int do_header;
 199 static int do_dump;
 200 static int do_version;
 201 static int do_histogram;
 202 static int do_debugging;
 203 static int do_arch;
 204 static int do_notes;
 205 static int do_archive_index;
 206 static int is_32bit_elf;
 207
 208 struct group_list
 209 {
 210   struct group_list * next;
 211   unsigned int section_index;
 212 };
 213
 214 struct group
 215 {
 216   struct group_list * root;
 217   unsigned int group_index;
 218 };
 219
 220 static size_t group_count;
 221 static struct group * section_groups;
 222 static struct group ** section_headers_groups;
 223
 224
 225 /* Flag bits indicating particular types of dump.  */
 226 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 227 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 228 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 229 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 230 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 231
 232 typedef unsigned char dump_type;
 233
 234 /* A linked list of the section names for which dumps were requested.  */
 235 struct dump_list_entry
 236 {
 237   char * name;
 238   dump_type type;
 239   struct dump_list_entry * next;
 240 };
 241 static struct dump_list_entry * dump_sects_byname;
 242
 243 /* A dynamic array of flags indicating for which sections a dump
 244    has been requested via command line switches.  */
 245 static dump_type *   cmdline_dump_sects = NULL;
 246 static unsigned int  num_cmdline_dump_sects = 0;
 247
 248 /* A dynamic array of flags indicating for which sections a dump of
 249    some kind has been requested.  It is reset on a per-object file
 250    basis and then initialised from the cmdline_dump_sects array,
 251    the results of interpreting the -w switch, and the
 252    dump_sects_byname list.  */
 253 static dump_type *   dump_sects = NULL;
 254 static unsigned int  num_dump_sects = 0;
 255
 256
 257 /* How to print a vma value.  */
 258 typedef enum print_mode
 259 {
 260   HEX,
 261   DEC,
 262   DEC_5,
 263   UNSIGNED,
 264   PREFIX_HEX,
 265   FULL_HEX,
 266   LONG_HEX
 267 }
 268 print_mode;
 269
 270 #define UNKNOWN -1
 271
 272 #define SECTION_NAME(X)                                         \
 273   ((X) == NULL ? _("<none>")                                    \
 274    : string_table == NULL ? _("<no-name>")                      \
 275    : ((X)->sh_name >= string_table_length ? _("<corrupt>")      \
 276   : string_table + (X)->sh_name))
 277
 278 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 279
 280 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 281   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 282    : get_64bit_elf_symbols (file, section, sym_count))
 283
 284 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 285 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 286    already been called and verified that the string exists.  */
 287 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 288
 289 #define REMOVE_ARCH_BITS(ADDR)                  \
 290   do                                            \
 291     {                                           \
 292       if (elf_header.e_machine == EM_ARM)       \
 293         (ADDR) &= ~1;                           \
 294     }                                           \
 295   while (0)
 296 \f
 297 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
 298    Put the retrieved data into VAR, if it is not NULL.  Otherwise allocate a buffer
 299    using malloc and fill that.  In either case return the pointer to the start of
 300    the retrieved data or NULL if something went wrong.  If something does go wrong
 301    emit an error message using REASON as part of the context.  */
 302
 303 static void *
 304 get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
 305           const char * reason)
 306 {
 307   void * mvar;
 308
 309   if (size == 0 || nmemb == 0)
 310     return NULL;
 311
 312   if (fseek (file, archive_file_offset + offset, SEEK_SET))
 313     {
 314       error (_("Unable to seek to 0x%lx for %s\n"),
 315              (unsigned long) archive_file_offset + offset, reason);
 316       return NULL;
 317     }
 318
 319   mvar = var;
 320   if (mvar == NULL)
 321     {
 322       /* Check for overflow.  */
 323       if (nmemb < (~(size_t) 0 - 1) / size)
 324         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 325         mvar = malloc (size * nmemb + 1);
 326
 327       if (mvar == NULL)
 328         {
 329           error (_("Out of memory allocating 0x%lx bytes for %s\n"),
 330                  (unsigned long)(size * nmemb), reason);
 331           return NULL;
 332         }
 333
 334       ((char *) mvar)[size * nmemb] = '\0';
 335     }
 336
 337   if (fread (mvar, size, nmemb, file) != nmemb)
 338     {
 339       error (_("Unable to read in 0x%lx bytes of %s\n"),
 340              (unsigned long)(size * nmemb), reason);
 341       if (mvar != var)
 342         free (mvar);
 343       return NULL;
 344     }
 345
 346   return mvar;
 347 }
 348
 349 /* Print a VMA value.  */
 350
 351 static int
 352 print_vma (bfd_vma vma, print_mode mode)
 353 {
 354   int nc = 0;
 355
 356   switch (mode)
 357     {
 358     case FULL_HEX:
 359       nc = printf ("0x");
 360       /* Drop through.  */
 361
 362     case LONG_HEX:
 363 #ifdef BFD64
 364       if (is_32bit_elf)
 365         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 366 #endif
 367       printf_vma (vma);
 368       return nc + 16;
 369
 370     case DEC_5:
 371       if (vma <= 99999)
 372         return printf ("%5" BFD_VMA_FMT "d", vma);
 373       /* Drop through.  */
 374
 375     case PREFIX_HEX:
 376       nc = printf ("0x");
 377       /* Drop through.  */
 378
 379     case HEX:
 380       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 381
 382     case DEC:
 383       return printf ("%" BFD_VMA_FMT "d", vma);
 384
 385     case UNSIGNED:
 386       return printf ("%" BFD_VMA_FMT "u", vma);
 387     }
 388   return 0;
 389 }
 390
 391 /* Display a symbol on stdout.  Handles the display of control characters and
 392    multibye characters (assuming the host environment supports them).
 393
 394    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 395
 396    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 397    padding as necessary.
 398
 399    Returns the number of emitted characters.  */
 400
 401 static unsigned int
 402 print_symbol (int width, const char *symbol)
 403 {
 404   bfd_boolean extra_padding = FALSE;
 405   int num_printed = 0;
 406 #ifdef HAVE_MBSTATE_T
 407   mbstate_t state;
 408 #endif
 409   int width_remaining;
 410
 411   if (width < 0)
 412     {
 413       /* Keep the width positive.  This also helps.  */
 414       width = - width;
 415       extra_padding = TRUE;
 416     }
 417
 418   if (do_wide)
 419     /* Set the remaining width to a very large value.
 420        This simplifies the code below.  */
 421     width_remaining = INT_MAX;
 422   else
 423     width_remaining = width;
 424
 425 #ifdef HAVE_MBSTATE_T
 426   /* Initialise the multibyte conversion state.  */
 427   memset (& state, 0, sizeof (state));
 428 #endif
 429
 430   while (width_remaining)
 431     {
 432       size_t  n;
 433       const char c = *symbol++;
 434
 435       if (c == 0)
 436         break;
 437
 438       /* Do not print control characters directly as they can affect terminal
 439          settings.  Such characters usually appear in the names generated
 440          by the assembler for local labels.  */
 441       if (ISCNTRL (c))
 442         {
 443           if (width_remaining < 2)
 444             break;
 445
 446           printf ("^%c", c + 0x40);
 447           width_remaining -= 2;
 448           num_printed += 2;
 449         }
 450       else if (ISPRINT (c))
 451         {
 452           putchar (c);
 453           width_remaining --;
 454           num_printed ++;
 455         }
 456       else
 457         {
 458 #ifdef HAVE_MBSTATE_T
 459           wchar_t w;
 460 #endif
 461           /* Let printf do the hard work of displaying multibyte characters.  */
 462           printf ("%.1s", symbol - 1);
 463           width_remaining --;
 464           num_printed ++;
 465
 466 #ifdef HAVE_MBSTATE_T
 467           /* Try to find out how many bytes made up the character that was
 468              just printed.  Advance the symbol pointer past the bytes that
 469              were displayed.  */
 470           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 471 #else
 472           n = 1;
 473 #endif
 474           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 475             symbol += (n - 1);
 476         }
 477     }
 478
 479   if (extra_padding && num_printed < width)
 480     {
 481       /* Fill in the remaining spaces.  */
 482       printf ("%-*s", width - num_printed, " ");
 483       num_printed = width;
 484     }
 485
 486   return num_printed;
 487 }
 488
 489 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 490
 491 static Elf_Internal_Shdr *
 492 find_section (const char * name)
 493 {
 494   unsigned int i;
 495
 496   for (i = 0; i < elf_header.e_shnum; i++)
 497     if (streq (SECTION_NAME (section_headers + i), name))
 498       return section_headers + i;
 499
 500   return NULL;
 501 }
 502
 503 /* Return a pointer to a section containing ADDR, or NULL if no such
 504    section exists.  */
 505
 506 static Elf_Internal_Shdr *
 507 find_section_by_address (bfd_vma addr)
 508 {
 509   unsigned int i;
 510
 511   for (i = 0; i < elf_header.e_shnum; i++)
 512     {
 513       Elf_Internal_Shdr *sec = section_headers + i;
 514       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 515         return sec;
 516     }
 517
 518   return NULL;
 519 }
 520
 521 /* Return a pointer to section NAME, or NULL if no such section exists,
 522    restricted to the list of sections given in SET.  */
 523
 524 static Elf_Internal_Shdr *
 525 find_section_in_set (const char * name, unsigned int * set)
 526 {
 527   unsigned int i;
 528
 529   if (set != NULL)
 530     {
 531       while ((i = *set++) > 0)
 532         if (streq (SECTION_NAME (section_headers + i), name))
 533           return section_headers + i;
 534     }
 535
 536   return find_section (name);
 537 }
 538
 539 /* Read an unsigned LEB128 encoded value from p.  Set *PLEN to the number of
 540    bytes read.  */
 541
 542 static unsigned long
 543 read_uleb128 (unsigned char *data, unsigned int *length_return)
 544 {
 545   return read_leb128 (data, length_return, 0);
 546 }
 547
 548 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
 549    This OS has so many departures from the ELF standard that we test it at
 550    many places.  */
 551
 552 static inline int
 553 is_ia64_vms (void)
 554 {
 555   return elf_header.e_machine == EM_IA_64
 556     && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 557 }
 558
 559 /* Guess the relocation size commonly used by the specific machines.  */
 560
 561 static int
 562 guess_is_rela (unsigned int e_machine)
 563 {
 564   switch (e_machine)
 565     {
 566       /* Targets that use REL relocations.  */
 567     case EM_386:
 568     case EM_486:
 569     case EM_960:
 570     case EM_ARM:
 571     case EM_D10V:
 572     case EM_CYGNUS_D10V:
 573     case EM_DLX:
 574     case EM_MIPS:
 575     case EM_MIPS_RS3_LE:
 576     case EM_CYGNUS_M32R:
 577     case EM_OPENRISC:
 578     case EM_OR32:
 579     case EM_SCORE:
 580     case EM_XGATE:
 581       return FALSE;
 582
 583       /* Targets that use RELA relocations.  */
 584     case EM_68K:
 585     case EM_860:
 586     case EM_AARCH64:
 587     case EM_ADAPTEVA_EPIPHANY:
 588     case EM_ALPHA:
 589     case EM_ALTERA_NIOS2:
 590     case EM_AVR:
 591     case EM_AVR_OLD:
 592     case EM_BLACKFIN:
 593     case EM_CR16:
 594     case EM_CRIS:
 595     case EM_CRX:
 596     case EM_D30V:
 597     case EM_CYGNUS_D30V:
 598     case EM_FR30:
 599     case EM_CYGNUS_FR30:
 600     case EM_CYGNUS_FRV:
 601     case EM_H8S:
 602     case EM_H8_300:
 603     case EM_H8_300H:
 604     case EM_IA_64:
 605     case EM_IP2K:
 606     case EM_IP2K_OLD:
 607     case EM_IQ2000:
 608     case EM_LATTICEMICO32:
 609     case EM_M32C_OLD:
 610     case EM_M32C:
 611     case EM_M32R:
 612     case EM_MCORE:
 613     case EM_CYGNUS_MEP:
 614     case EM_METAG:
 615     case EM_MMIX:
 616     case EM_MN10200:
 617     case EM_CYGNUS_MN10200:
 618     case EM_MN10300:
 619     case EM_CYGNUS_MN10300:
 620     case EM_MOXIE:
 621     case EM_MSP430:
 622     case EM_MSP430_OLD:
 623     case EM_MT:
 624     case EM_NIOS32:
 625     case EM_PPC64:
 626     case EM_PPC:
 627     case EM_RL78:
 628     case EM_RX:
 629     case EM_S390:
 630     case EM_S390_OLD:
 631     case EM_SH:
 632     case EM_SPARC:
 633     case EM_SPARC32PLUS:
 634     case EM_SPARCV9:
 635     case EM_SPU:
 636     case EM_TI_C6000:
 637     case EM_TILEGX:
 638     case EM_TILEPRO:
 639     case EM_V800:
 640     case EM_V850:
 641     case EM_CYGNUS_V850:
 642     case EM_VAX:
 643     case EM_X86_64:
 644     case EM_L1OM:
 645     case EM_K1OM:
 646     case EM_XSTORMY16:
 647     case EM_XTENSA:
 648     case EM_XTENSA_OLD:
 649     case EM_MICROBLAZE:
 650     case EM_MICROBLAZE_OLD:
 651       return TRUE;
 652
 653     case EM_68HC05:
 654     case EM_68HC08:
 655     case EM_68HC11:
 656     case EM_68HC16:
 657     case EM_FX66:
 658     case EM_ME16:
 659     case EM_MMA:
 660     case EM_NCPU:
 661     case EM_NDR1:
 662     case EM_PCP:
 663     case EM_ST100:
 664     case EM_ST19:
 665     case EM_ST7:
 666     case EM_ST9PLUS:
 667     case EM_STARCORE:
 668     case EM_SVX:
 669     case EM_TINYJ:
 670     default:
 671       warn (_("Don't know about relocations on this machine architecture\n"));
 672       return FALSE;
 673     }
 674 }
 675
 676 static int
 677 slurp_rela_relocs (FILE * file,
 678                    unsigned long rel_offset,
 679                    unsigned long rel_size,
 680                    Elf_Internal_Rela ** relasp,
 681                    unsigned long * nrelasp)
 682 {
 683   Elf_Internal_Rela * relas;
 684   unsigned long nrelas;
 685   unsigned int i;
 686
 687   if (is_32bit_elf)
 688     {
 689       Elf32_External_Rela * erelas;
 690
 691       erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
 692                                                  rel_size, _("32-bit relocation data"));
 693       if (!erelas)
 694         return 0;
 695
 696       nrelas = rel_size / sizeof (Elf32_External_Rela);
 697
 698       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 699                                              sizeof (Elf_Internal_Rela));
 700
 701       if (relas == NULL)
 702         {
 703           free (erelas);
 704           error (_("out of memory parsing relocs\n"));
 705           return 0;
 706         }
 707
 708       for (i = 0; i < nrelas; i++)
 709         {
 710           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 711           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 712           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 713         }
 714
 715       free (erelas);
 716     }
 717   else
 718     {
 719       Elf64_External_Rela * erelas;
 720
 721       erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
 722                                                  rel_size, _("64-bit relocation data"));
 723       if (!erelas)
 724         return 0;
 725
 726       nrelas = rel_size / sizeof (Elf64_External_Rela);
 727
 728       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 729                                              sizeof (Elf_Internal_Rela));
 730
 731       if (relas == NULL)
 732         {
 733           free (erelas);
 734           error (_("out of memory parsing relocs\n"));
 735           return 0;
 736         }
 737
 738       for (i = 0; i < nrelas; i++)
 739         {
 740           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 741           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 742           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 743
 744           /* The #ifdef BFD64 below is to prevent a compile time
 745              warning.  We know that if we do not have a 64 bit data
 746              type that we will never execute this code anyway.  */
 747 #ifdef BFD64
 748           if (elf_header.e_machine == EM_MIPS
 749               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 750             {
 751               /* In little-endian objects, r_info isn't really a
 752                  64-bit little-endian value: it has a 32-bit
 753                  little-endian symbol index followed by four
 754                  individual byte fields.  Reorder INFO
 755                  accordingly.  */
 756               bfd_vma inf = relas[i].r_info;
 757               inf = (((inf & 0xffffffff) << 32)
 758                       | ((inf >> 56) & 0xff)
 759                       | ((inf >> 40) & 0xff00)
 760                       | ((inf >> 24) & 0xff0000)
 761                       | ((inf >> 8) & 0xff000000));
 762               relas[i].r_info = inf;
 763             }
 764 #endif /* BFD64 */
 765         }
 766
 767       free (erelas);
 768     }
 769   *relasp = relas;
 770   *nrelasp = nrelas;
 771   return 1;
 772 }
 773
 774 static int
 775 slurp_rel_relocs (FILE * file,
 776                   unsigned long rel_offset,
 777                   unsigned long rel_size,
 778                   Elf_Internal_Rela ** relsp,
 779                   unsigned long * nrelsp)
 780 {
 781   Elf_Internal_Rela * rels;
 782   unsigned long nrels;
 783   unsigned int i;
 784
 785   if (is_32bit_elf)
 786     {
 787       Elf32_External_Rel * erels;
 788
 789       erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
 790                                                rel_size, _("32-bit relocation data"));
 791       if (!erels)
 792         return 0;
 793
 794       nrels = rel_size / sizeof (Elf32_External_Rel);
 795
 796       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 797
 798       if (rels == NULL)
 799         {
 800           free (erels);
 801           error (_("out of memory parsing relocs\n"));
 802           return 0;
 803         }
 804
 805       for (i = 0; i < nrels; i++)
 806         {
 807           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 808           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 809           rels[i].r_addend = 0;
 810         }
 811
 812       free (erels);
 813     }
 814   else
 815     {
 816       Elf64_External_Rel * erels;
 817
 818       erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
 819                                                rel_size, _("64-bit relocation data"));
 820       if (!erels)
 821         return 0;
 822
 823       nrels = rel_size / sizeof (Elf64_External_Rel);
 824
 825       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 826
 827       if (rels == NULL)
 828         {
 829           free (erels);
 830           error (_("out of memory parsing relocs\n"));
 831           return 0;
 832         }
 833
 834       for (i = 0; i < nrels; i++)
 835         {
 836           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 837           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 838           rels[i].r_addend = 0;
 839
 840           /* The #ifdef BFD64 below is to prevent a compile time
 841              warning.  We know that if we do not have a 64 bit data
 842              type that we will never execute this code anyway.  */
 843 #ifdef BFD64
 844           if (elf_header.e_machine == EM_MIPS
 845               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 846             {
 847               /* In little-endian objects, r_info isn't really a
 848                  64-bit little-endian value: it has a 32-bit
 849                  little-endian symbol index followed by four
 850                  individual byte fields.  Reorder INFO
 851                  accordingly.  */
 852               bfd_vma inf = rels[i].r_info;
 853               inf = (((inf & 0xffffffff) << 32)
 854                      | ((inf >> 56) & 0xff)
 855                      | ((inf >> 40) & 0xff00)
 856                      | ((inf >> 24) & 0xff0000)
 857                      | ((inf >> 8) & 0xff000000));
 858               rels[i].r_info = inf;
 859             }
 860 #endif /* BFD64 */
 861         }
 862
 863       free (erels);
 864     }
 865   *relsp = rels;
 866   *nrelsp = nrels;
 867   return 1;
 868 }
 869
 870 /* Returns the reloc type extracted from the reloc info field.  */
 871
 872 static unsigned int
 873 get_reloc_type (bfd_vma reloc_info)
 874 {
 875   if (is_32bit_elf)
 876     return ELF32_R_TYPE (reloc_info);
 877
 878   switch (elf_header.e_machine)
 879     {
 880     case EM_MIPS:
 881       /* Note: We assume that reloc_info has already been adjusted for us.  */
 882       return ELF64_MIPS_R_TYPE (reloc_info);
 883
 884     case EM_SPARCV9:
 885       return ELF64_R_TYPE_ID (reloc_info);
 886
 887     default:
 888       return ELF64_R_TYPE (reloc_info);
 889     }
 890 }
 891
 892 /* Return the symbol index extracted from the reloc info field.  */
 893
 894 static bfd_vma
 895 get_reloc_symindex (bfd_vma reloc_info)
 896 {
 897   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
 898 }
 899
 900 /* Display the contents of the relocation data found at the specified
 901    offset.  */
 902
 903 static void
 904 dump_relocations (FILE * file,
 905                   unsigned long rel_offset,
 906                   unsigned long rel_size,
 907                   Elf_Internal_Sym * symtab,
 908                   unsigned long nsyms,
 909                   char * strtab,
 910                   unsigned long strtablen,
 911                   int is_rela)
 912 {
 913   unsigned int i;
 914   Elf_Internal_Rela * rels;
 915
 916   if (is_rela == UNKNOWN)
 917     is_rela = guess_is_rela (elf_header.e_machine);
 918
 919   if (is_rela)
 920     {
 921       if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
 922         return;
 923     }
 924   else
 925     {
 926       if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
 927         return;
 928     }
 929
 930   if (is_32bit_elf)
 931     {
 932       if (is_rela)
 933         {
 934           if (do_wide)
 935             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
 936           else
 937             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
 938         }
 939       else
 940         {
 941           if (do_wide)
 942             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
 943           else
 944             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
 945         }
 946     }
 947   else
 948     {
 949       if (is_rela)
 950         {
 951           if (do_wide)
 952             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
 953           else
 954             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
 955         }
 956       else
 957         {
 958           if (do_wide)
 959             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
 960           else
 961             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
 962         }
 963     }
 964
 965   for (i = 0; i < rel_size; i++)
 966     {
 967       const char * rtype;
 968       bfd_vma offset;
 969       bfd_vma inf;
 970       bfd_vma symtab_index;
 971       bfd_vma type;
 972
 973       offset = rels[i].r_offset;
 974       inf    = rels[i].r_info;
 975
 976       type = get_reloc_type (inf);
 977       symtab_index = get_reloc_symindex  (inf);
 978
 979       if (is_32bit_elf)
 980         {
 981           printf ("%8.8lx  %8.8lx ",
 982                   (unsigned long) offset & 0xffffffff,
 983                   (unsigned long) inf & 0xffffffff);
 984         }
 985       else
 986         {
 987 #if BFD_HOST_64BIT_LONG
 988           printf (do_wide
 989                   ? "%16.16lx  %16.16lx "
 990                   : "%12.12lx  %12.12lx ",
 991                   offset, inf);
 992 #elif BFD_HOST_64BIT_LONG_LONG
 993 #ifndef __MSVCRT__
 994           printf (do_wide
 995                   ? "%16.16llx  %16.16llx "
 996                   : "%12.12llx  %12.12llx ",
 997                   offset, inf);
 998 #else
 999           printf (do_wide
1000                   ? "%16.16I64x  %16.16I64x "
1001                   : "%12.12I64x  %12.12I64x ",
1002                   offset, inf);
1003 #endif
1004 #else
1005           printf (do_wide
1006                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1007                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1008                   _bfd_int64_high (offset),
1009                   _bfd_int64_low (offset),
1010                   _bfd_int64_high (inf),
1011                   _bfd_int64_low (inf));
1012 #endif
1013         }
1014
1015       switch (elf_header.e_machine)
1016         {
1017         default:
1018           rtype = NULL;
1019           break;
1020
1021         case EM_AARCH64:
1022           rtype = elf_aarch64_reloc_type (type);
1023           break;
1024
1025         case EM_M32R:
1026         case EM_CYGNUS_M32R:
1027           rtype = elf_m32r_reloc_type (type);
1028           break;
1029
1030         case EM_386:
1031         case EM_486:
1032           rtype = elf_i386_reloc_type (type);
1033           break;
1034
1035         case EM_68HC11:
1036         case EM_68HC12:
1037           rtype = elf_m68hc11_reloc_type (type);
1038           break;
1039
1040         case EM_68K:
1041           rtype = elf_m68k_reloc_type (type);
1042           break;
1043
1044         case EM_960:
1045           rtype = elf_i960_reloc_type (type);
1046           break;
1047
1048         case EM_AVR:
1049         case EM_AVR_OLD:
1050           rtype = elf_avr_reloc_type (type);
1051           break;
1052
1053         case EM_OLD_SPARCV9:
1054         case EM_SPARC32PLUS:
1055         case EM_SPARCV9:
1056         case EM_SPARC:
1057           rtype = elf_sparc_reloc_type (type);
1058           break;
1059
1060         case EM_SPU:
1061           rtype = elf_spu_reloc_type (type);
1062           break;
1063
1064         case EM_V800:
1065           rtype = v800_reloc_type (type);
1066           break;
1067         case EM_V850:
1068         case EM_CYGNUS_V850:
1069           rtype = v850_reloc_type (type);
1070           break;
1071
1072         case EM_D10V:
1073         case EM_CYGNUS_D10V:
1074           rtype = elf_d10v_reloc_type (type);
1075           break;
1076
1077         case EM_D30V:
1078         case EM_CYGNUS_D30V:
1079           rtype = elf_d30v_reloc_type (type);
1080           break;
1081
1082         case EM_DLX:
1083           rtype = elf_dlx_reloc_type (type);
1084           break;
1085
1086         case EM_SH:
1087           rtype = elf_sh_reloc_type (type);
1088           break;
1089
1090         case EM_MN10300:
1091         case EM_CYGNUS_MN10300:
1092           rtype = elf_mn10300_reloc_type (type);
1093           break;
1094
1095         case EM_MN10200:
1096         case EM_CYGNUS_MN10200:
1097           rtype = elf_mn10200_reloc_type (type);
1098           break;
1099
1100         case EM_FR30:
1101         case EM_CYGNUS_FR30:
1102           rtype = elf_fr30_reloc_type (type);
1103           break;
1104
1105         case EM_CYGNUS_FRV:
1106           rtype = elf_frv_reloc_type (type);
1107           break;
1108
1109         case EM_MCORE:
1110           rtype = elf_mcore_reloc_type (type);
1111           break;
1112
1113         case EM_MMIX:
1114           rtype = elf_mmix_reloc_type (type);
1115           break;
1116
1117         case EM_MOXIE:
1118           rtype = elf_moxie_reloc_type (type);
1119           break;
1120
1121         case EM_MSP430:
1122         case EM_MSP430_OLD:
1123           rtype = elf_msp430_reloc_type (type);
1124           break;
1125
1126         case EM_PPC:
1127           rtype = elf_ppc_reloc_type (type);
1128           break;
1129
1130         case EM_PPC64:
1131           rtype = elf_ppc64_reloc_type (type);
1132           break;
1133
1134         case EM_MIPS:
1135         case EM_MIPS_RS3_LE:
1136           rtype = elf_mips_reloc_type (type);
1137           break;
1138
1139         case EM_ALPHA:
1140           rtype = elf_alpha_reloc_type (type);
1141           break;
1142
1143         case EM_ARM:
1144           rtype = elf_arm_reloc_type (type);
1145           break;
1146
1147         case EM_ARC:
1148           rtype = elf_arc_reloc_type (type);
1149           break;
1150
1151         case EM_PARISC:
1152           rtype = elf_hppa_reloc_type (type);
1153           break;
1154
1155         case EM_H8_300:
1156         case EM_H8_300H:
1157         case EM_H8S:
1158           rtype = elf_h8_reloc_type (type);
1159           break;
1160
1161         case EM_OPENRISC:
1162         case EM_OR32:
1163           rtype = elf_or32_reloc_type (type);
1164           break;
1165
1166         case EM_PJ:
1167         case EM_PJ_OLD:
1168           rtype = elf_pj_reloc_type (type);
1169           break;
1170         case EM_IA_64:
1171           rtype = elf_ia64_reloc_type (type);
1172           break;
1173
1174         case EM_CRIS:
1175           rtype = elf_cris_reloc_type (type);
1176           break;
1177
1178         case EM_860:
1179           rtype = elf_i860_reloc_type (type);
1180           break;
1181
1182         case EM_X86_64:
1183         case EM_L1OM:
1184         case EM_K1OM:
1185           rtype = elf_x86_64_reloc_type (type);
1186           break;
1187
1188         case EM_S370:
1189           rtype = i370_reloc_type (type);
1190           break;
1191
1192         case EM_S390_OLD:
1193         case EM_S390:
1194           rtype = elf_s390_reloc_type (type);
1195           break;
1196
1197         case EM_SCORE:
1198           rtype = elf_score_reloc_type (type);
1199           break;
1200
1201         case EM_XSTORMY16:
1202           rtype = elf_xstormy16_reloc_type (type);
1203           break;
1204
1205         case EM_CRX:
1206           rtype = elf_crx_reloc_type (type);
1207           break;
1208
1209         case EM_VAX:
1210           rtype = elf_vax_reloc_type (type);
1211           break;
1212
1213         case EM_ADAPTEVA_EPIPHANY:
1214           rtype = elf_epiphany_reloc_type (type);
1215           break;
1216
1217         case EM_IP2K:
1218         case EM_IP2K_OLD:
1219           rtype = elf_ip2k_reloc_type (type);
1220           break;
1221
1222         case EM_IQ2000:
1223           rtype = elf_iq2000_reloc_type (type);
1224           break;
1225
1226         case EM_XTENSA_OLD:
1227         case EM_XTENSA:
1228           rtype = elf_xtensa_reloc_type (type);
1229           break;
1230
1231         case EM_LATTICEMICO32:
1232           rtype = elf_lm32_reloc_type (type);
1233           break;
1234
1235         case EM_M32C_OLD:
1236         case EM_M32C:
1237           rtype = elf_m32c_reloc_type (type);
1238           break;
1239
1240         case EM_MT:
1241           rtype = elf_mt_reloc_type (type);
1242           break;
1243
1244         case EM_BLACKFIN:
1245           rtype = elf_bfin_reloc_type (type);
1246           break;
1247
1248         case EM_CYGNUS_MEP:
1249           rtype = elf_mep_reloc_type (type);
1250           break;
1251
1252         case EM_CR16:
1253           rtype = elf_cr16_reloc_type (type);
1254           break;
1255
1256         case EM_MICROBLAZE:
1257         case EM_MICROBLAZE_OLD:
1258           rtype = elf_microblaze_reloc_type (type);
1259           break;
1260
1261         case EM_RL78:
1262           rtype = elf_rl78_reloc_type (type);
1263           break;
1264
1265         case EM_RX:
1266           rtype = elf_rx_reloc_type (type);
1267           break;
1268
1269         case EM_METAG:
1270           rtype = elf_metag_reloc_type (type);
1271           break;
1272
1273         case EM_XC16X:
1274         case EM_C166:
1275           rtype = elf_xc16x_reloc_type (type);
1276           break;
1277
1278         case EM_TI_C6000:
1279           rtype = elf_tic6x_reloc_type (type);
1280           break;
1281
1282         case EM_TILEGX:
1283           rtype = elf_tilegx_reloc_type (type);
1284           break;
1285
1286         case EM_TILEPRO:
1287           rtype = elf_tilepro_reloc_type (type);
1288           break;
1289
1290         case EM_XGATE:
1291           rtype = elf_xgate_reloc_type (type);
1292           break;
1293
1294         case EM_ALTERA_NIOS2:
1295           rtype = elf_nios2_reloc_type (type);
1296           break;
1297         }
1298
1299       if (rtype == NULL)
1300         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1301       else
1302         printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1303
1304       if (elf_header.e_machine == EM_ALPHA
1305           && rtype != NULL
1306           && streq (rtype, "R_ALPHA_LITUSE")
1307           && is_rela)
1308         {
1309           switch (rels[i].r_addend)
1310             {
1311             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1312             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1313             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1314             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1315             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1316             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1317             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1318             default: rtype = NULL;
1319             }
1320           if (rtype)
1321             printf (" (%s)", rtype);
1322           else
1323             {
1324               putchar (' ');
1325               printf (_("<unknown addend: %lx>"),
1326                       (unsigned long) rels[i].r_addend);
1327             }
1328         }
1329       else if (symtab_index)
1330         {
1331           if (symtab == NULL || symtab_index >= nsyms)
1332             printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1333           else
1334             {
1335               Elf_Internal_Sym * psym;
1336
1337               psym = symtab + symtab_index;
1338
1339               printf (" ");
1340
1341               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1342                 {
1343                   const char * name;
1344                   unsigned int len;
1345                   unsigned int width = is_32bit_elf ? 8 : 14;
1346
1347                   /* Relocations against GNU_IFUNC symbols do not use the value
1348                      of the symbol as the address to relocate against.  Instead
1349                      they invoke the function named by the symbol and use its
1350                      result as the address for relocation.
1351
1352                      To indicate this to the user, do not display the value of
1353                      the symbol in the "Symbols's Value" field.  Instead show
1354                      its name followed by () as a hint that the symbol is
1355                      invoked.  */
1356
1357                   if (strtab == NULL
1358                       || psym->st_name == 0
1359                       || psym->st_name >= strtablen)
1360                     name = "??";
1361                   else
1362                     name = strtab + psym->st_name;
1363
1364                   len = print_symbol (width, name);
1365                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1366                 }
1367               else
1368                 {
1369                   print_vma (psym->st_value, LONG_HEX);
1370
1371                   printf (is_32bit_elf ? "   " : " ");
1372                 }
1373
1374               if (psym->st_name == 0)
1375                 {
1376                   const char * sec_name = "<null>";
1377                   char name_buf[40];
1378
1379                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1380                     {
1381                       if (psym->st_shndx < elf_header.e_shnum)
1382                         sec_name
1383                           = SECTION_NAME (section_headers + psym->st_shndx);
1384                       else if (psym->st_shndx == SHN_ABS)
1385                         sec_name = "ABS";
1386                       else if (psym->st_shndx == SHN_COMMON)
1387                         sec_name = "COMMON";
1388                       else if ((elf_header.e_machine == EM_MIPS
1389                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1390                                || (elf_header.e_machine == EM_TI_C6000
1391                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1392                         sec_name = "SCOMMON";
1393                       else if (elf_header.e_machine == EM_MIPS
1394                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1395                         sec_name = "SUNDEF";
1396                       else if ((elf_header.e_machine == EM_X86_64
1397                                 || elf_header.e_machine == EM_L1OM
1398                                 || elf_header.e_machine == EM_K1OM)
1399                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1400                         sec_name = "LARGE_COMMON";
1401                       else if (elf_header.e_machine == EM_IA_64
1402                                && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1403                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1404                         sec_name = "ANSI_COM";
1405                       else if (is_ia64_vms ()
1406                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1407                         sec_name = "VMS_SYMVEC";
1408                       else
1409                         {
1410                           sprintf (name_buf, "<section 0x%x>",
1411                                    (unsigned int) psym->st_shndx);
1412                           sec_name = name_buf;
1413                         }
1414                     }
1415                   print_symbol (22, sec_name);
1416                 }
1417               else if (strtab == NULL)
1418                 printf (_("<string table index: %3ld>"), psym->st_name);
1419               else if (psym->st_name >= strtablen)
1420                 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1421               else
1422                 print_symbol (22, strtab + psym->st_name);
1423
1424               if (is_rela)
1425                 {
1426                   bfd_signed_vma off = rels[i].r_addend;
1427
1428                   if (off < 0)
1429                     printf (" - %" BFD_VMA_FMT "x", - off);
1430                   else
1431                     printf (" + %" BFD_VMA_FMT "x", off);
1432                 }
1433             }
1434         }
1435       else if (is_rela)
1436         {
1437           bfd_signed_vma off = rels[i].r_addend;
1438
1439           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1440           if (off < 0)
1441             printf ("-%" BFD_VMA_FMT "x", - off);
1442           else
1443             printf ("%" BFD_VMA_FMT "x", off);
1444         }
1445
1446       if (elf_header.e_machine == EM_SPARCV9
1447           && rtype != NULL
1448           && streq (rtype, "R_SPARC_OLO10"))
1449         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1450
1451       putchar ('\n');
1452
1453 #ifdef BFD64
1454       if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1455         {
1456           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1457           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1458           const char * rtype2 = elf_mips_reloc_type (type2);
1459           const char * rtype3 = elf_mips_reloc_type (type3);
1460
1461           printf ("                    Type2: ");
1462
1463           if (rtype2 == NULL)
1464             printf (_("unrecognized: %-7lx"),
1465                     (unsigned long) type2 & 0xffffffff);
1466           else
1467             printf ("%-17.17s", rtype2);
1468
1469           printf ("\n                    Type3: ");
1470
1471           if (rtype3 == NULL)
1472             printf (_("unrecognized: %-7lx"),
1473                     (unsigned long) type3 & 0xffffffff);
1474           else
1475             printf ("%-17.17s", rtype3);
1476
1477           putchar ('\n');
1478         }
1479 #endif /* BFD64 */
1480     }
1481
1482   free (rels);
1483 }
1484
1485 static const char *
1486 get_mips_dynamic_type (unsigned long type)
1487 {
1488   switch (type)
1489     {
1490     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1491     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1492     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1493     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1494     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1495     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1496     case DT_MIPS_MSYM: return "MIPS_MSYM";
1497     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1498     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1499     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1500     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1501     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1502     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1503     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1504     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1505     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1506     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1507     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1508     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1509     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1510     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1511     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1512     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1513     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1514     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1515     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1516     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1517     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1518     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1519     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1520     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1521     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1522     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1523     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1524     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1525     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1526     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1527     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1528     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1529     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1530     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1531     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1532     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1533     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1534     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1535     default:
1536       return NULL;
1537     }
1538 }
1539
1540 static const char *
1541 get_sparc64_dynamic_type (unsigned long type)
1542 {
1543   switch (type)
1544     {
1545     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1546     default:
1547       return NULL;
1548     }
1549 }
1550
1551 static const char *
1552 get_ppc_dynamic_type (unsigned long type)
1553 {
1554   switch (type)
1555     {
1556     case DT_PPC_GOT:    return "PPC_GOT";
1557     case DT_PPC_TLSOPT: return "PPC_TLSOPT";
1558     default:
1559       return NULL;
1560     }
1561 }
1562
1563 static const char *
1564 get_ppc64_dynamic_type (unsigned long type)
1565 {
1566   switch (type)
1567     {
1568     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1569     case DT_PPC64_OPD:    return "PPC64_OPD";
1570     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1571     case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
1572     default:
1573       return NULL;
1574     }
1575 }
1576
1577 static const char *
1578 get_parisc_dynamic_type (unsigned long type)
1579 {
1580   switch (type)
1581     {
1582     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1583     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1584     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1585     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1586     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1587     case DT_HP_PREINIT:         return "HP_PREINIT";
1588     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1589     case DT_HP_NEEDED:          return "HP_NEEDED";
1590     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1591     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1592     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1593     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1594     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1595     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1596     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1597     case DT_HP_FILTERED:        return "HP_FILTERED";
1598     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1599     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1600     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1601     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1602     case DT_PLT:                return "PLT";
1603     case DT_PLT_SIZE:           return "PLT_SIZE";
1604     case DT_DLT:                return "DLT";
1605     case DT_DLT_SIZE:           return "DLT_SIZE";
1606     default:
1607       return NULL;
1608     }
1609 }
1610
1611 static const char *
1612 get_ia64_dynamic_type (unsigned long type)
1613 {
1614   switch (type)
1615     {
1616     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1617     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1618     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1619     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1620     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1621     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1622     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1623     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1624     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1625     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1626     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1627     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1628     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1629     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1630     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1631     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1632     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1633     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1634     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1635     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1636     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1637     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1638     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1639     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1640     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1641     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1642     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1643     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1644     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1645     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1646     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1647     default:
1648       return NULL;
1649     }
1650 }
1651
1652 static const char *
1653 get_alpha_dynamic_type (unsigned long type)
1654 {
1655   switch (type)
1656     {
1657     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1658     default:
1659       return NULL;
1660     }
1661 }
1662
1663 static const char *
1664 get_score_dynamic_type (unsigned long type)
1665 {
1666   switch (type)
1667     {
1668     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1669     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1670     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1671     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1672     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1673     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1674     default:
1675       return NULL;
1676     }
1677 }
1678
1679 static const char *
1680 get_tic6x_dynamic_type (unsigned long type)
1681 {
1682   switch (type)
1683     {
1684     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1685     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1686     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
1687     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
1688     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
1689     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
1690     default:
1691       return NULL;
1692     }
1693 }
1694
1695 static const char *
1696 get_nios2_dynamic_type (unsigned long type)
1697 {
1698   switch (type)
1699     {
1700     case DT_NIOS2_GP: return "NIOS2_GP";
1701     default:
1702       return NULL;
1703     }
1704 }
1705
1706 static const char *
1707 get_dynamic_type (unsigned long type)
1708 {
1709   static char buff[64];
1710
1711   switch (type)
1712     {
1713     case DT_NULL:       return "NULL";
1714     case DT_NEEDED:     return "NEEDED";
1715     case DT_PLTRELSZ:   return "PLTRELSZ";
1716     case DT_PLTGOT:     return "PLTGOT";
1717     case DT_HASH:       return "HASH";
1718     case DT_STRTAB:     return "STRTAB";
1719     case DT_SYMTAB:     return "SYMTAB";
1720     case DT_RELA:       return "RELA";
1721     case DT_RELASZ:     return "RELASZ";
1722     case DT_RELAENT:    return "RELAENT";
1723     case DT_STRSZ:      return "STRSZ";
1724     case DT_SYMENT:     return "SYMENT";
1725     case DT_INIT:       return "INIT";
1726     case DT_FINI:       return "FINI";
1727     case DT_SONAME:     return "SONAME";
1728     case DT_RPATH:      return "RPATH";
1729     case DT_SYMBOLIC:   return "SYMBOLIC";
1730     case DT_REL:        return "REL";
1731     case DT_RELSZ:      return "RELSZ";
1732     case DT_RELENT:     return "RELENT";
1733     case DT_PLTREL:     return "PLTREL";
1734     case DT_DEBUG:      return "DEBUG";
1735     case DT_TEXTREL:    return "TEXTREL";
1736     case DT_JMPREL:     return "JMPREL";
1737     case DT_BIND_NOW:   return "BIND_NOW";
1738     case DT_INIT_ARRAY: return "INIT_ARRAY";
1739     case DT_FINI_ARRAY: return "FINI_ARRAY";
1740     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1741     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1742     case DT_RUNPATH:    return "RUNPATH";
1743     case DT_FLAGS:      return "FLAGS";
1744
1745     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1746     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1747
1748     case DT_CHECKSUM:   return "CHECKSUM";
1749     case DT_PLTPADSZ:   return "PLTPADSZ";
1750     case DT_MOVEENT:    return "MOVEENT";
1751     case DT_MOVESZ:     return "MOVESZ";
1752     case DT_FEATURE:    return "FEATURE";
1753     case DT_POSFLAG_1:  return "POSFLAG_1";
1754     case DT_SYMINSZ:    return "SYMINSZ";
1755     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
1756
1757     case DT_ADDRRNGLO:  return "ADDRRNGLO";
1758     case DT_CONFIG:     return "CONFIG";
1759     case DT_DEPAUDIT:   return "DEPAUDIT";
1760     case DT_AUDIT:      return "AUDIT";
1761     case DT_PLTPAD:     return "PLTPAD";
1762     case DT_MOVETAB:    return "MOVETAB";
1763     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
1764
1765     case DT_VERSYM:     return "VERSYM";
1766
1767     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1768     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1769     case DT_RELACOUNT:  return "RELACOUNT";
1770     case DT_RELCOUNT:   return "RELCOUNT";
1771     case DT_FLAGS_1:    return "FLAGS_1";
1772     case DT_VERDEF:     return "VERDEF";
1773     case DT_VERDEFNUM:  return "VERDEFNUM";
1774     case DT_VERNEED:    return "VERNEED";
1775     case DT_VERNEEDNUM: return "VERNEEDNUM";
1776
1777     case DT_AUXILIARY:  return "AUXILIARY";
1778     case DT_USED:       return "USED";
1779     case DT_FILTER:     return "FILTER";
1780
1781     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1782     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1783     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1784     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1785     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1786     case DT_GNU_HASH:   return "GNU_HASH";
1787
1788     default:
1789       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1790         {
1791           const char * result;
1792
1793           switch (elf_header.e_machine)
1794             {
1795             case EM_MIPS:
1796             case EM_MIPS_RS3_LE:
1797               result = get_mips_dynamic_type (type);
1798               break;
1799             case EM_SPARCV9:
1800               result = get_sparc64_dynamic_type (type);
1801               break;
1802             case EM_PPC:
1803               result = get_ppc_dynamic_type (type);
1804               break;
1805             case EM_PPC64:
1806               result = get_ppc64_dynamic_type (type);
1807               break;
1808             case EM_IA_64:
1809               result = get_ia64_dynamic_type (type);
1810               break;
1811             case EM_ALPHA:
1812               result = get_alpha_dynamic_type (type);
1813               break;
1814             case EM_SCORE:
1815               result = get_score_dynamic_type (type);
1816               break;
1817             case EM_TI_C6000:
1818               result = get_tic6x_dynamic_type (type);
1819               break;
1820             case EM_ALTERA_NIOS2:
1821               result = get_nios2_dynamic_type (type);
1822               break;
1823             default:
1824               result = NULL;
1825               break;
1826             }
1827
1828           if (result != NULL)
1829             return result;
1830
1831           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1832         }
1833       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1834                || (elf_header.e_machine == EM_PARISC
1835                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1836         {
1837           const char * result;
1838
1839           switch (elf_header.e_machine)
1840             {
1841             case EM_PARISC:
1842               result = get_parisc_dynamic_type (type);
1843               break;
1844             case EM_IA_64:
1845               result = get_ia64_dynamic_type (type);
1846               break;
1847             default:
1848               result = NULL;
1849               break;
1850             }
1851
1852           if (result != NULL)
1853             return result;
1854
1855           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1856                     type);
1857         }
1858       else
1859         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1860
1861       return buff;
1862     }
1863 }
1864
1865 static char *
1866 get_file_type (unsigned e_type)
1867 {
1868   static char buff[32];
1869
1870   switch (e_type)
1871     {
1872     case ET_NONE:       return _("NONE (None)");
1873     case ET_REL:        return _("REL (Relocatable file)");
1874     case ET_EXEC:       return _("EXEC (Executable file)");
1875     case ET_DYN:        return _("DYN (Shared object file)");
1876     case ET_CORE:       return _("CORE (Core file)");
1877
1878     default:
1879       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1880         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1881       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1882         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1883       else
1884         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1885       return buff;
1886     }
1887 }
1888
1889 static char *
1890 get_machine_name (unsigned e_machine)
1891 {
1892   static char buff[64]; /* XXX */
1893
1894   switch (e_machine)
1895     {
1896     case EM_NONE:               return _("None");
1897     case EM_AARCH64:            return "AArch64";
1898     case EM_M32:                return "WE32100";
1899     case EM_SPARC:              return "Sparc";
1900     case EM_SPU:                return "SPU";
1901     case EM_386:                return "Intel 80386";
1902     case EM_68K:                return "MC68000";
1903     case EM_88K:                return "MC88000";
1904     case EM_486:                return "Intel 80486";
1905     case EM_860:                return "Intel 80860";
1906     case EM_MIPS:               return "MIPS R3000";
1907     case EM_S370:               return "IBM System/370";
1908     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
1909     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
1910     case EM_PARISC:             return "HPPA";
1911     case EM_PPC_OLD:            return "Power PC (old)";
1912     case EM_SPARC32PLUS:        return "Sparc v8+" ;
1913     case EM_960:                return "Intel 90860";
1914     case EM_PPC:                return "PowerPC";
1915     case EM_PPC64:              return "PowerPC64";
1916     case EM_FR20:               return "Fujitsu FR20";
1917     case EM_RH32:               return "TRW RH32";
1918     case EM_MCORE:              return "MCORE";
1919     case EM_ARM:                return "ARM";
1920     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
1921     case EM_SH:                 return "Renesas / SuperH SH";
1922     case EM_SPARCV9:            return "Sparc v9";
1923     case EM_TRICORE:            return "Siemens Tricore";
1924     case EM_ARC:                return "ARC";
1925     case EM_H8_300:             return "Renesas H8/300";
1926     case EM_H8_300H:            return "Renesas H8/300H";
1927     case EM_H8S:                return "Renesas H8S";
1928     case EM_H8_500:             return "Renesas H8/500";
1929     case EM_IA_64:              return "Intel IA-64";
1930     case EM_MIPS_X:             return "Stanford MIPS-X";
1931     case EM_COLDFIRE:           return "Motorola Coldfire";
1932     case EM_ALPHA:              return "Alpha";
1933     case EM_CYGNUS_D10V:
1934     case EM_D10V:               return "d10v";
1935     case EM_CYGNUS_D30V:
1936     case EM_D30V:               return "d30v";
1937     case EM_CYGNUS_M32R:
1938     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
1939     case EM_CYGNUS_V850:
1940     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
1941     case EM_V850:               return "Renesas V850";
1942     case EM_CYGNUS_MN10300:
1943     case EM_MN10300:            return "mn10300";
1944     case EM_CYGNUS_MN10200:
1945     case EM_MN10200:            return "mn10200";
1946     case EM_MOXIE:              return "Moxie";
1947     case EM_CYGNUS_FR30:
1948     case EM_FR30:               return "Fujitsu FR30";
1949     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
1950     case EM_PJ_OLD:
1951     case EM_PJ:                 return "picoJava";
1952     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
1953     case EM_PCP:                return "Siemens PCP";
1954     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
1955     case EM_NDR1:               return "Denso NDR1 microprocesspr";
1956     case EM_STARCORE:           return "Motorola Star*Core processor";
1957     case EM_ME16:               return "Toyota ME16 processor";
1958     case EM_ST100:              return "STMicroelectronics ST100 processor";
1959     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
1960     case EM_PDSP:               return "Sony DSP processor";
1961     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
1962     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
1963     case EM_FX66:               return "Siemens FX66 microcontroller";
1964     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1965     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
1966     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
1967     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
1968     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
1969     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
1970     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
1971     case EM_SVX:                return "Silicon Graphics SVx";
1972     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
1973     case EM_VAX:                return "Digital VAX";
1974     case EM_AVR_OLD:
1975     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
1976     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
1977     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
1978     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
1979     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
1980     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
1981     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
1982     case EM_PRISM:              return "Vitesse Prism";
1983     case EM_X86_64:             return "Advanced Micro Devices X86-64";
1984     case EM_L1OM:               return "Intel L1OM";
1985     case EM_K1OM:               return "Intel K1OM";
1986     case EM_S390_OLD:
1987     case EM_S390:               return "IBM S/390";
1988     case EM_SCORE:              return "SUNPLUS S+Core";
1989     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
1990     case EM_OPENRISC:
1991     case EM_OR32:               return "OpenRISC";
1992     case EM_ARC_A5:             return "ARC International ARCompact processor";
1993     case EM_CRX:                return "National Semiconductor CRX microprocessor";
1994     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
1995     case EM_DLX:                return "OpenDLX";
1996     case EM_IP2K_OLD:
1997     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
1998     case EM_IQ2000:             return "Vitesse IQ2000";
1999     case EM_XTENSA_OLD:
2000     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2001     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2002     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2003     case EM_NS32K:              return "National Semiconductor 32000 series";
2004     case EM_TPC:                return "Tenor Network TPC processor";
2005     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2006     case EM_MAX:                return "MAX Processor";
2007     case EM_CR:                 return "National Semiconductor CompactRISC";
2008     case EM_F2MC16:             return "Fujitsu F2MC16";
2009     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2010     case EM_LATTICEMICO32:      return "Lattice Mico32";
2011     case EM_M32C_OLD:
2012     case EM_M32C:               return "Renesas M32c";
2013     case EM_MT:                 return "Morpho Techologies MT processor";
2014     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2015     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2016     case EM_SEP:                return "Sharp embedded microprocessor";
2017     case EM_ARCA:               return "Arca RISC microprocessor";
2018     case EM_UNICORE:            return "Unicore";
2019     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2020     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2021     case EM_NIOS32:             return "Altera Nios";
2022     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2023     case EM_C166:
2024     case EM_XC16X:              return "Infineon Technologies xc16x";
2025     case EM_M16C:               return "Renesas M16C series microprocessors";
2026     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2027     case EM_CE:                 return "Freescale Communication Engine RISC core";
2028     case EM_TSK3000:            return "Altium TSK3000 core";
2029     case EM_RS08:               return "Freescale RS08 embedded processor";
2030     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2031     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2032     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2033     case EM_SE_C17:             return "Seiko Epson C17 family";
2034     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2035     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2036     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2037     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2038     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2039     case EM_R32C:               return "Renesas R32C series microprocessors";
2040     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2041     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2042     case EM_8051:               return "Intel 8051 and variants";
2043     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2044     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2045     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2046     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2047     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2048     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2049     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2050     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2051     case EM_CR16:
2052     case EM_MICROBLAZE:
2053     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2054     case EM_RL78:               return "Renesas RL78";
2055     case EM_RX:                 return "Renesas RX";
2056     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2057     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2058     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2059     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2060     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2061     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor family";
2062     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2063     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2064     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2065     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2066     case EM_CUDA:               return "NVIDIA CUDA architecture";
2067     case EM_XGATE:              return "Motorola XGATE embedded processor";
2068     default:
2069       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2070       return buff;
2071     }
2072 }
2073
2074 static void
2075 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2076 {
2077   unsigned eabi;
2078   int unknown = 0;
2079
2080   eabi = EF_ARM_EABI_VERSION (e_flags);
2081   e_flags &= ~ EF_ARM_EABIMASK;
2082
2083   /* Handle "generic" ARM flags.  */
2084   if (e_flags & EF_ARM_RELEXEC)
2085     {
2086       strcat (buf, ", relocatable executable");
2087       e_flags &= ~ EF_ARM_RELEXEC;
2088     }
2089
2090   if (e_flags & EF_ARM_HASENTRY)
2091     {
2092       strcat (buf, ", has entry point");
2093       e_flags &= ~ EF_ARM_HASENTRY;
2094     }
2095
2096   /* Now handle EABI specific flags.  */
2097   switch (eabi)
2098     {
2099     default:
2100       strcat (buf, ", <unrecognized EABI>");
2101       if (e_flags)
2102         unknown = 1;
2103       break;
2104
2105     case EF_ARM_EABI_VER1:
2106       strcat (buf, ", Version1 EABI");
2107       while (e_flags)
2108         {
2109           unsigned flag;
2110
2111           /* Process flags one bit at a time.  */
2112           flag = e_flags & - e_flags;
2113           e_flags &= ~ flag;
2114
2115           switch (flag)
2116             {
2117             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2118               strcat (buf, ", sorted symbol tables");
2119               break;
2120
2121             default:
2122               unknown = 1;
2123               break;
2124             }
2125         }
2126       break;
2127
2128     case EF_ARM_EABI_VER2:
2129       strcat (buf, ", Version2 EABI");
2130       while (e_flags)
2131         {
2132           unsigned flag;
2133
2134           /* Process flags one bit at a time.  */
2135           flag = e_flags & - e_flags;
2136           e_flags &= ~ flag;
2137
2138           switch (flag)
2139             {
2140             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2141               strcat (buf, ", sorted symbol tables");
2142               break;
2143
2144             case EF_ARM_DYNSYMSUSESEGIDX:
2145               strcat (buf, ", dynamic symbols use segment index");
2146               break;
2147
2148             case EF_ARM_MAPSYMSFIRST:
2149               strcat (buf, ", mapping symbols precede others");
2150               break;
2151
2152             default:
2153               unknown = 1;
2154               break;
2155             }
2156         }
2157       break;
2158
2159     case EF_ARM_EABI_VER3:
2160       strcat (buf, ", Version3 EABI");
2161       break;
2162
2163     case EF_ARM_EABI_VER4:
2164       strcat (buf, ", Version4 EABI");
2165       while (e_flags)
2166         {
2167           unsigned flag;
2168
2169           /* Process flags one bit at a time.  */
2170           flag = e_flags & - e_flags;
2171           e_flags &= ~ flag;
2172
2173           switch (flag)
2174             {
2175             case EF_ARM_BE8:
2176               strcat (buf, ", BE8");
2177               break;
2178
2179             case EF_ARM_LE8:
2180               strcat (buf, ", LE8");
2181               break;
2182
2183             default:
2184               unknown = 1;
2185               break;
2186             }
2187       break;
2188         }
2189       break;
2190
2191     case EF_ARM_EABI_VER5:
2192       strcat (buf, ", Version5 EABI");
2193       while (e_flags)
2194         {
2195           unsigned flag;
2196
2197           /* Process flags one bit at a time.  */
2198           flag = e_flags & - e_flags;
2199           e_flags &= ~ flag;
2200
2201           switch (flag)
2202             {
2203             case EF_ARM_BE8:
2204               strcat (buf, ", BE8");
2205               break;
2206
2207             case EF_ARM_LE8:
2208               strcat (buf, ", LE8");
2209               break;
2210
2211             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2212               strcat (buf, ", soft-float ABI");
2213               break;
2214
2215             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2216               strcat (buf, ", hard-float ABI");
2217               break;
2218
2219             default:
2220               unknown = 1;
2221               break;
2222             }
2223         }
2224       break;
2225
2226     case EF_ARM_EABI_UNKNOWN:
2227       strcat (buf, ", GNU EABI");
2228       while (e_flags)
2229         {
2230           unsigned flag;
2231
2232           /* Process flags one bit at a time.  */
2233           flag = e_flags & - e_flags;
2234           e_flags &= ~ flag;
2235
2236           switch (flag)
2237             {
2238             case EF_ARM_INTERWORK:
2239               strcat (buf, ", interworking enabled");
2240               break;
2241
2242             case EF_ARM_APCS_26:
2243               strcat (buf, ", uses APCS/26");
2244               break;
2245
2246             case EF_ARM_APCS_FLOAT:
2247               strcat (buf, ", uses APCS/float");
2248               break;
2249
2250             case EF_ARM_PIC:
2251               strcat (buf, ", position independent");
2252               break;
2253
2254             case EF_ARM_ALIGN8:
2255               strcat (buf, ", 8 bit structure alignment");
2256               break;
2257
2258             case EF_ARM_NEW_ABI:
2259               strcat (buf, ", uses new ABI");
2260               break;
2261
2262             case EF_ARM_OLD_ABI:
2263               strcat (buf, ", uses old ABI");
2264               break;
2265
2266             case EF_ARM_SOFT_FLOAT:
2267               strcat (buf, ", software FP");
2268               break;
2269
2270             case EF_ARM_VFP_FLOAT:
2271               strcat (buf, ", VFP");
2272               break;
2273
2274             case EF_ARM_MAVERICK_FLOAT:
2275               strcat (buf, ", Maverick FP");
2276               break;
2277
2278             default:
2279               unknown = 1;
2280               break;
2281             }
2282         }
2283     }
2284
2285   if (unknown)
2286     strcat (buf,_(", <unknown>"));
2287 }
2288
2289 static char *
2290 get_machine_flags (unsigned e_flags, unsigned e_machine)
2291 {
2292   static char buf[1024];
2293
2294   buf[0] = '\0';
2295
2296   if (e_flags)
2297     {
2298       switch (e_machine)
2299         {
2300         default:
2301           break;
2302
2303         case EM_ARM:
2304           decode_ARM_machine_flags (e_flags, buf);
2305           break;
2306
2307         case EM_BLACKFIN:
2308           if (e_flags & EF_BFIN_PIC)
2309             strcat (buf, ", PIC");
2310
2311           if (e_flags & EF_BFIN_FDPIC)
2312             strcat (buf, ", FDPIC");
2313
2314           if (e_flags & EF_BFIN_CODE_IN_L1)
2315             strcat (buf, ", code in L1");
2316
2317           if (e_flags & EF_BFIN_DATA_IN_L1)
2318             strcat (buf, ", data in L1");
2319
2320           break;
2321
2322         case EM_CYGNUS_FRV:
2323           switch (e_flags & EF_FRV_CPU_MASK)
2324             {
2325             case EF_FRV_CPU_GENERIC:
2326               break;
2327
2328             default:
2329               strcat (buf, ", fr???");
2330               break;
2331
2332             case EF_FRV_CPU_FR300:
2333               strcat (buf, ", fr300");
2334               break;
2335
2336             case EF_FRV_CPU_FR400:
2337               strcat (buf, ", fr400");
2338               break;
2339             case EF_FRV_CPU_FR405:
2340               strcat (buf, ", fr405");
2341               break;
2342
2343             case EF_FRV_CPU_FR450:
2344               strcat (buf, ", fr450");
2345               break;
2346
2347             case EF_FRV_CPU_FR500:
2348               strcat (buf, ", fr500");
2349               break;
2350             case EF_FRV_CPU_FR550:
2351               strcat (buf, ", fr550");
2352               break;
2353
2354             case EF_FRV_CPU_SIMPLE:
2355               strcat (buf, ", simple");
2356               break;
2357             case EF_FRV_CPU_TOMCAT:
2358               strcat (buf, ", tomcat");
2359               break;
2360             }
2361           break;
2362
2363         case EM_68K:
2364           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2365             strcat (buf, ", m68000");
2366           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2367             strcat (buf, ", cpu32");
2368           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2369             strcat (buf, ", fido_a");
2370           else
2371             {
2372               char const * isa = _("unknown");
2373               char const * mac = _("unknown mac");
2374               char const * additional = NULL;
2375
2376               switch (e_flags & EF_M68K_CF_ISA_MASK)
2377                 {
2378                 case EF_M68K_CF_ISA_A_NODIV:
2379                   isa = "A";
2380                   additional = ", nodiv";
2381                   break;
2382                 case EF_M68K_CF_ISA_A:
2383                   isa = "A";
2384                   break;
2385                 case EF_M68K_CF_ISA_A_PLUS:
2386                   isa = "A+";
2387                   break;
2388                 case EF_M68K_CF_ISA_B_NOUSP:
2389                   isa = "B";
2390                   additional = ", nousp";
2391                   break;
2392                 case EF_M68K_CF_ISA_B:
2393                   isa = "B";
2394                   break;
2395                 case EF_M68K_CF_ISA_C:
2396                   isa = "C";
2397                   break;
2398                 case EF_M68K_CF_ISA_C_NODIV:
2399                   isa = "C";
2400                   additional = ", nodiv";
2401                   break;
2402                 }
2403               strcat (buf, ", cf, isa ");
2404               strcat (buf, isa);
2405               if (additional)
2406                 strcat (buf, additional);
2407               if (e_flags & EF_M68K_CF_FLOAT)
2408                 strcat (buf, ", float");
2409               switch (e_flags & EF_M68K_CF_MAC_MASK)
2410                 {
2411                 case 0:
2412                   mac = NULL;
2413                   break;
2414                 case EF_M68K_CF_MAC:
2415                   mac = "mac";
2416                   break;
2417                 case EF_M68K_CF_EMAC:
2418                   mac = "emac";
2419                   break;
2420                 case EF_M68K_CF_EMAC_B:
2421                   mac = "emac_b";
2422                   break;
2423                 }
2424               if (mac)
2425                 {
2426                   strcat (buf, ", ");
2427                   strcat (buf, mac);
2428                 }
2429             }
2430           break;
2431
2432         case EM_PPC:
2433           if (e_flags & EF_PPC_EMB)
2434             strcat (buf, ", emb");
2435
2436           if (e_flags & EF_PPC_RELOCATABLE)
2437             strcat (buf, _(", relocatable"));
2438
2439           if (e_flags & EF_PPC_RELOCATABLE_LIB)
2440             strcat (buf, _(", relocatable-lib"));
2441           break;
2442
2443         case EM_V800:
2444           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2445             strcat (buf, ", RH850 ABI");
2446
2447           if (e_flags & EF_V800_850E3)
2448             strcat (buf, ", V3 architecture");
2449
2450           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2451             strcat (buf, ", FPU not used");
2452
2453           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2454             strcat (buf, ", regmode: COMMON");
2455
2456           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2457             strcat (buf, ", r4 not used");
2458
2459           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2460             strcat (buf, ", r30 not used");
2461
2462           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2463             strcat (buf, ", r5 not used");
2464
2465           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2466             strcat (buf, ", r2 not used");
2467
2468           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2469             {
2470               switch (e_flags & - e_flags)
2471                 {
2472                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2473                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2474                 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2475                 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2476                 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2477                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2478                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2479                 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2480                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2481                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2482                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2483                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2484                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2485                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2486                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2487                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2488                 default: break;
2489                 }
2490             }
2491           break;
2492
2493         case EM_V850:
2494         case EM_CYGNUS_V850:
2495           switch (e_flags & EF_V850_ARCH)
2496             {
2497             case E_V850E3V5_ARCH:
2498               strcat (buf, ", v850e3v5");
2499               break;
2500             case E_V850E2V3_ARCH:
2501               strcat (buf, ", v850e2v3");
2502               break;
2503             case E_V850E2_ARCH:
2504               strcat (buf, ", v850e2");
2505               break;
2506             case E_V850E1_ARCH:
2507               strcat (buf, ", v850e1");
2508               break;
2509             case E_V850E_ARCH:
2510               strcat (buf, ", v850e");
2511               break;
2512             case E_V850_ARCH:
2513               strcat (buf, ", v850");
2514               break;
2515             default:
2516               strcat (buf, _(", unknown v850 architecture variant"));
2517               break;
2518             }
2519           break;
2520
2521         case EM_M32R:
2522         case EM_CYGNUS_M32R:
2523           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2524             strcat (buf, ", m32r");
2525           break;
2526
2527         case EM_MIPS:
2528         case EM_MIPS_RS3_LE:
2529           if (e_flags & EF_MIPS_NOREORDER)
2530             strcat (buf, ", noreorder");
2531
2532           if (e_flags & EF_MIPS_PIC)
2533             strcat (buf, ", pic");
2534
2535           if (e_flags & EF_MIPS_CPIC)
2536             strcat (buf, ", cpic");
2537
2538           if (e_flags & EF_MIPS_UCODE)
2539             strcat (buf, ", ugen_reserved");
2540
2541           if (e_flags & EF_MIPS_ABI2)
2542             strcat (buf, ", abi2");
2543
2544           if (e_flags & EF_MIPS_OPTIONS_FIRST)
2545             strcat (buf, ", odk first");
2546
2547           if (e_flags & EF_MIPS_32BITMODE)
2548             strcat (buf, ", 32bitmode");
2549
2550           switch ((e_flags & EF_MIPS_MACH))
2551             {
2552             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2553             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2554             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2555             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2556             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2557             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2558             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2559             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2560             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
2561             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2562             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2563             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2564             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
2565             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2566             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2567             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
2568             case 0:
2569             /* We simply ignore the field in this case to avoid confusion:
2570                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2571                extension.  */
2572               break;
2573             default: strcat (buf, _(", unknown CPU")); break;
2574             }
2575
2576           switch ((e_flags & EF_MIPS_ABI))
2577             {
2578             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2579             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2580             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2581             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2582             case 0:
2583             /* We simply ignore the field in this case to avoid confusion:
2584                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2585                This means it is likely to be an o32 file, but not for
2586                sure.  */
2587               break;
2588             default: strcat (buf, _(", unknown ABI")); break;
2589             }
2590
2591           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2592             strcat (buf, ", mdmx");
2593
2594           if (e_flags & EF_MIPS_ARCH_ASE_M16)
2595             strcat (buf, ", mips16");
2596
2597           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2598             strcat (buf, ", micromips");
2599
2600           switch ((e_flags & EF_MIPS_ARCH))
2601             {
2602             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2603             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2604             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2605             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2606             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2607             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2608             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2609             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2610             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2611             default: strcat (buf, _(", unknown ISA")); break;
2612             }
2613           break;
2614
2615         case EM_SH:
2616           switch ((e_flags & EF_SH_MACH_MASK))
2617             {
2618             case EF_SH1: strcat (buf, ", sh1"); break;
2619             case EF_SH2: strcat (buf, ", sh2"); break;
2620             case EF_SH3: strcat (buf, ", sh3"); break;
2621             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2622             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2623             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2624             case EF_SH3E: strcat (buf, ", sh3e"); break;
2625             case EF_SH4: strcat (buf, ", sh4"); break;
2626             case EF_SH5: strcat (buf, ", sh5"); break;
2627             case EF_SH2E: strcat (buf, ", sh2e"); break;
2628             case EF_SH4A: strcat (buf, ", sh4a"); break;
2629             case EF_SH2A: strcat (buf, ", sh2a"); break;
2630             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2631             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2632             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2633             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2634             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2635             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2636             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2637             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2638             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2639             default: strcat (buf, _(", unknown ISA")); break;
2640             }
2641
2642           if (e_flags & EF_SH_PIC)
2643             strcat (buf, ", pic");
2644
2645           if (e_flags & EF_SH_FDPIC)
2646             strcat (buf, ", fdpic");
2647           break;
2648
2649         case EM_SPARCV9:
2650           if (e_flags & EF_SPARC_32PLUS)
2651             strcat (buf, ", v8+");
2652
2653           if (e_flags & EF_SPARC_SUN_US1)
2654             strcat (buf, ", ultrasparcI");
2655
2656           if (e_flags & EF_SPARC_SUN_US3)
2657             strcat (buf, ", ultrasparcIII");
2658
2659           if (e_flags & EF_SPARC_HAL_R1)
2660             strcat (buf, ", halr1");
2661
2662           if (e_flags & EF_SPARC_LEDATA)
2663             strcat (buf, ", ledata");
2664
2665           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2666             strcat (buf, ", tso");
2667
2668           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2669             strcat (buf, ", pso");
2670
2671           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2672             strcat (buf, ", rmo");
2673           break;
2674
2675         case EM_PARISC:
2676           switch (e_flags & EF_PARISC_ARCH)
2677             {
2678             case EFA_PARISC_1_0:
2679               strcpy (buf, ", PA-RISC 1.0");
2680               break;
2681             case EFA_PARISC_1_1:
2682               strcpy (buf, ", PA-RISC 1.1");
2683               break;
2684             case EFA_PARISC_2_0:
2685               strcpy (buf, ", PA-RISC 2.0");
2686               break;
2687             default:
2688               break;
2689             }
2690           if (e_flags & EF_PARISC_TRAPNIL)
2691             strcat (buf, ", trapnil");
2692           if (e_flags & EF_PARISC_EXT)
2693             strcat (buf, ", ext");
2694           if (e_flags & EF_PARISC_LSB)
2695             strcat (buf, ", lsb");
2696           if (e_flags & EF_PARISC_WIDE)
2697             strcat (buf, ", wide");
2698           if (e_flags & EF_PARISC_NO_KABP)
2699             strcat (buf, ", no kabp");
2700           if (e_flags & EF_PARISC_LAZYSWAP)
2701             strcat (buf, ", lazyswap");
2702           break;
2703
2704         case EM_PJ:
2705         case EM_PJ_OLD:
2706           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2707             strcat (buf, ", new calling convention");
2708
2709           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2710             strcat (buf, ", gnu calling convention");
2711           break;
2712
2713         case EM_IA_64:
2714           if ((e_flags & EF_IA_64_ABI64))
2715             strcat (buf, ", 64-bit");
2716           else
2717             strcat (buf, ", 32-bit");
2718           if ((e_flags & EF_IA_64_REDUCEDFP))
2719             strcat (buf, ", reduced fp model");
2720           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2721             strcat (buf, ", no function descriptors, constant gp");
2722           else if ((e_flags & EF_IA_64_CONS_GP))
2723             strcat (buf, ", constant gp");
2724           if ((e_flags & EF_IA_64_ABSOLUTE))
2725             strcat (buf, ", absolute");
2726           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2727             {
2728               if ((e_flags & EF_IA_64_VMS_LINKAGES))
2729                 strcat (buf, ", vms_linkages");
2730               switch ((e_flags & EF_IA_64_VMS_COMCOD))
2731                 {
2732                 case EF_IA_64_VMS_COMCOD_SUCCESS:
2733                   break;
2734                 case EF_IA_64_VMS_COMCOD_WARNING:
2735                   strcat (buf, ", warning");
2736                   break;
2737                 case EF_IA_64_VMS_COMCOD_ERROR:
2738                   strcat (buf, ", error");
2739                   break;
2740                 case EF_IA_64_VMS_COMCOD_ABORT:
2741                   strcat (buf, ", abort");
2742                   break;
2743                 default:
2744                   abort ();
2745                 }
2746             }
2747           break;
2748
2749         case EM_VAX:
2750           if ((e_flags & EF_VAX_NONPIC))
2751             strcat (buf, ", non-PIC");
2752           if ((e_flags & EF_VAX_DFLOAT))
2753             strcat (buf, ", D-Float");
2754           if ((e_flags & EF_VAX_GFLOAT))
2755             strcat (buf, ", G-Float");
2756           break;
2757
2758         case EM_RX:
2759           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2760             strcat (buf, ", 64-bit doubles");
2761           if (e_flags & E_FLAG_RX_DSP)
2762             strcat (buf, ", dsp");
2763           if (e_flags & E_FLAG_RX_PID)
2764             strcat (buf, ", pid");
2765           if (e_flags & E_FLAG_RX_ABI)
2766             strcat (buf, ", RX ABI");
2767           break;
2768
2769         case EM_S390:
2770           if (e_flags & EF_S390_HIGH_GPRS)
2771             strcat (buf, ", highgprs");
2772           break;
2773
2774         case EM_TI_C6000:
2775           if ((e_flags & EF_C6000_REL))
2776             strcat (buf, ", relocatable module");
2777           break;
2778         }
2779     }
2780
2781   return buf;
2782 }
2783
2784 static const char *
2785 get_osabi_name (unsigned int osabi)
2786 {
2787   static char buff[32];
2788
2789   switch (osabi)
2790     {
2791     case ELFOSABI_NONE:         return "UNIX - System V";
2792     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
2793     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
2794     case ELFOSABI_GNU:          return "UNIX - GNU";
2795     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
2796     case ELFOSABI_AIX:          return "UNIX - AIX";
2797     case ELFOSABI_IRIX:         return "UNIX - IRIX";
2798     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
2799     case ELFOSABI_TRU64:        return "UNIX - TRU64";
2800     case ELFOSABI_MODESTO:      return "Novell - Modesto";
2801     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
2802     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
2803     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
2804     case ELFOSABI_AROS:         return "AROS";
2805     case ELFOSABI_FENIXOS:      return "FenixOS";
2806     default:
2807       if (osabi >= 64)
2808         switch (elf_header.e_machine)
2809           {
2810           case EM_ARM:
2811             switch (osabi)
2812               {
2813               case ELFOSABI_ARM:        return "ARM";
2814               default:
2815                 break;
2816               }
2817             break;
2818
2819           case EM_MSP430:
2820           case EM_MSP430_OLD:
2821             switch (osabi)
2822               {
2823               case ELFOSABI_STANDALONE: return _("Standalone App");
2824               default:
2825                 break;
2826               }
2827             break;
2828
2829           case EM_TI_C6000:
2830             switch (osabi)
2831               {
2832               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
2833               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
2834               default:
2835                 break;
2836               }
2837             break;
2838
2839           default:
2840             break;
2841           }
2842       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2843       return buff;
2844     }
2845 }
2846
2847 static const char *
2848 get_aarch64_segment_type (unsigned long type)
2849 {
2850   switch (type)
2851     {
2852     case PT_AARCH64_ARCHEXT:
2853       return "AARCH64_ARCHEXT";
2854     default:
2855       break;
2856     }
2857
2858   return NULL;
2859 }
2860
2861 static const char *
2862 get_arm_segment_type (unsigned long type)
2863 {
2864   switch (type)
2865     {
2866     case PT_ARM_EXIDX:
2867       return "EXIDX";
2868     default:
2869       break;
2870     }
2871
2872   return NULL;
2873 }
2874
2875 static const char *
2876 get_mips_segment_type (unsigned long type)
2877 {
2878   switch (type)
2879     {
2880     case PT_MIPS_REGINFO:
2881       return "REGINFO";
2882     case PT_MIPS_RTPROC:
2883       return "RTPROC";
2884     case PT_MIPS_OPTIONS:
2885       return "OPTIONS";
2886     default:
2887       break;
2888     }
2889
2890   return NULL;
2891 }
2892
2893 static const char *
2894 get_parisc_segment_type (unsigned long type)
2895 {
2896   switch (type)
2897     {
2898     case PT_HP_TLS:             return "HP_TLS";
2899     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
2900     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
2901     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
2902     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
2903     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
2904     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
2905     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
2906     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
2907     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
2908     case PT_HP_PARALLEL:        return "HP_PARALLEL";
2909     case PT_HP_FASTBIND:        return "HP_FASTBIND";
2910     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
2911     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
2912     case PT_HP_STACK:           return "HP_STACK";
2913     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
2914     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
2915     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
2916     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
2917     default:
2918       break;
2919     }
2920
2921   return NULL;
2922 }
2923
2924 static const char *
2925 get_ia64_segment_type (unsigned long type)
2926 {
2927   switch (type)
2928     {
2929     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
2930     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
2931     case PT_HP_TLS:             return "HP_TLS";
2932     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
2933     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
2934     case PT_IA_64_HP_STACK:     return "HP_STACK";
2935     default:
2936       break;
2937     }
2938
2939   return NULL;
2940 }
2941
2942 static const char *
2943 get_tic6x_segment_type (unsigned long type)
2944 {
2945   switch (type)
2946     {
2947     case PT_C6000_PHATTR:       return "C6000_PHATTR";
2948     default:
2949       break;
2950     }
2951
2952   return NULL;
2953 }
2954
2955 static const char *
2956 get_segment_type (unsigned long p_type)
2957 {
2958   static char buff[32];
2959
2960   switch (p_type)
2961     {
2962     case PT_NULL:       return "NULL";
2963     case PT_LOAD:       return "LOAD";
2964     case PT_DYNAMIC:    return "DYNAMIC";
2965     case PT_INTERP:     return "INTERP";
2966     case PT_NOTE:       return "NOTE";
2967     case PT_SHLIB:      return "SHLIB";
2968     case PT_PHDR:       return "PHDR";
2969     case PT_TLS:        return "TLS";
2970
2971     case PT_GNU_EH_FRAME:
2972                         return "GNU_EH_FRAME";
2973     case PT_GNU_STACK:  return "GNU_STACK";
2974     case PT_GNU_RELRO:  return "GNU_RELRO";
2975
2976     default:
2977       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2978         {
2979           const char * result;
2980
2981           switch (elf_header.e_machine)
2982             {
2983             case EM_AARCH64:
2984               result = get_aarch64_segment_type (p_type);
2985               break;
2986             case EM_ARM:
2987               result = get_arm_segment_type (p_type);
2988               break;
2989             case EM_MIPS:
2990             case EM_MIPS_RS3_LE:
2991               result = get_mips_segment_type (p_type);
2992               break;
2993             case EM_PARISC:
2994               result = get_parisc_segment_type (p_type);
2995               break;
2996             case EM_IA_64:
2997               result = get_ia64_segment_type (p_type);
2998               break;
2999             case EM_TI_C6000:
3000               result = get_tic6x_segment_type (p_type);
3001               break;
3002             default:
3003               result = NULL;
3004               break;
3005             }
3006
3007           if (result != NULL)
3008             return result;
3009
3010           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3011         }
3012       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3013         {
3014           const char * result;
3015
3016           switch (elf_header.e_machine)
3017             {
3018             case EM_PARISC:
3019               result = get_parisc_segment_type (p_type);
3020               break;
3021             case EM_IA_64:
3022               result = get_ia64_segment_type (p_type);
3023               break;
3024             default:
3025               result = NULL;
3026               break;
3027             }
3028
3029           if (result != NULL)
3030             return result;
3031
3032           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3033         }
3034       else
3035         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3036
3037       return buff;
3038     }
3039 }
3040
3041 static const char *
3042 get_mips_section_type_name (unsigned int sh_type)
3043 {
3044   switch (sh_type)
3045     {
3046     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3047     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3048     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3049     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3050     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3051     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3052     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3053     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3054     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3055     case SHT_MIPS_RELD:          return "MIPS_RELD";
3056     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3057     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3058     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3059     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3060     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3061     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3062     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3063     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3064     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3065     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3066     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3067     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3068     case SHT_MIPS_LINE:          return "MIPS_LINE";
3069     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3070     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3071     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3072     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3073     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3074     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3075     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3076     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3077     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3078     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3079     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3080     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3081     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3082     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3083     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3084     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3085     default:
3086       break;
3087     }
3088   return NULL;
3089 }
3090
3091 static const char *
3092 get_parisc_section_type_name (unsigned int sh_type)
3093 {
3094   switch (sh_type)
3095     {
3096     case SHT_PARISC_EXT:        return "PARISC_EXT";
3097     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
3098     case SHT_PARISC_DOC:        return "PARISC_DOC";
3099     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
3100     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
3101     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
3102     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
3103     default:
3104       break;
3105     }
3106   return NULL;
3107 }
3108
3109 static const char *
3110 get_ia64_section_type_name (unsigned int sh_type)
3111 {
3112   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
3113   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3114     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3115
3116   switch (sh_type)
3117     {
3118     case SHT_IA_64_EXT:                return "IA_64_EXT";
3119     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
3120     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
3121     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
3122     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3123     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
3124     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
3125     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
3126     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
3127     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
3128     default:
3129       break;
3130     }
3131   return NULL;
3132 }
3133
3134 static const char *
3135 get_x86_64_section_type_name (unsigned int sh_type)
3136 {
3137   switch (sh_type)
3138     {
3139     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
3140     default:
3141       break;
3142     }
3143   return NULL;
3144 }
3145
3146 static const char *
3147 get_aarch64_section_type_name (unsigned int sh_type)
3148 {
3149   switch (sh_type)
3150     {
3151     case SHT_AARCH64_ATTRIBUTES:
3152       return "AARCH64_ATTRIBUTES";
3153     default:
3154       break;
3155     }
3156   return NULL;
3157 }
3158
3159 static const char *
3160 get_arm_section_type_name (unsigned int sh_type)
3161 {
3162   switch (sh_type)
3163     {
3164     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
3165     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
3166     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
3167     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
3168     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
3169     default:
3170       break;
3171     }
3172   return NULL;
3173 }
3174
3175 static const char *
3176 get_tic6x_section_type_name (unsigned int sh_type)
3177 {
3178   switch (sh_type)
3179     {
3180     case SHT_C6000_UNWIND:
3181       return "C6000_UNWIND";
3182     case SHT_C6000_PREEMPTMAP:
3183       return "C6000_PREEMPTMAP";
3184     case SHT_C6000_ATTRIBUTES:
3185       return "C6000_ATTRIBUTES";
3186     case SHT_TI_ICODE:
3187       return "TI_ICODE";
3188     case SHT_TI_XREF:
3189       return "TI_XREF";
3190     case SHT_TI_HANDLER:
3191       return "TI_HANDLER";
3192     case SHT_TI_INITINFO:
3193       return "TI_INITINFO";
3194     case SHT_TI_PHATTRS:
3195       return "TI_PHATTRS";
3196     default:
3197       break;
3198     }
3199   return NULL;
3200 }
3201
3202 static const char *
3203 get_section_type_name (unsigned int sh_type)
3204 {
3205   static char buff[32];
3206
3207   switch (sh_type)
3208     {
3209     case SHT_NULL:              return "NULL";
3210     case SHT_PROGBITS:          return "PROGBITS";
3211     case SHT_SYMTAB:            return "SYMTAB";
3212     case SHT_STRTAB:            return "STRTAB";
3213     case SHT_RELA:              return "RELA";
3214     case SHT_HASH:              return "HASH";
3215     case SHT_DYNAMIC:           return "DYNAMIC";
3216     case SHT_NOTE:              return "NOTE";
3217     case SHT_NOBITS:            return "NOBITS";
3218     case SHT_REL:               return "REL";
3219     case SHT_SHLIB:             return "SHLIB";
3220     case SHT_DYNSYM:            return "DYNSYM";
3221     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
3222     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
3223     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
3224     case SHT_GNU_HASH:          return "GNU_HASH";
3225     case SHT_GROUP:             return "GROUP";
3226     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
3227     case SHT_GNU_verdef:        return "VERDEF";
3228     case SHT_GNU_verneed:       return "VERNEED";
3229     case SHT_GNU_versym:        return "VERSYM";
3230     case 0x6ffffff0:            return "VERSYM";
3231     case 0x6ffffffc:            return "VERDEF";
3232     case 0x7ffffffd:            return "AUXILIARY";
3233     case 0x7fffffff:            return "FILTER";
3234     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
3235
3236     default:
3237       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3238         {
3239           const char * result;
3240
3241           switch (elf_header.e_machine)
3242             {
3243             case EM_MIPS:
3244             case EM_MIPS_RS3_LE:
3245               result = get_mips_section_type_name (sh_type);
3246               break;
3247             case EM_PARISC:
3248               result = get_parisc_section_type_name (sh_type);
3249               break;
3250             case EM_IA_64:
3251               result = get_ia64_section_type_name (sh_type);
3252               break;
3253             case EM_X86_64:
3254             case EM_L1OM:
3255             case EM_K1OM:
3256               result = get_x86_64_section_type_name (sh_type);
3257               break;
3258             case EM_AARCH64:
3259               result = get_aarch64_section_type_name (sh_type);
3260               break;
3261             case EM_ARM:
3262               result = get_arm_section_type_name (sh_type);
3263               break;
3264             case EM_TI_C6000:
3265               result = get_tic6x_section_type_name (sh_type);
3266               break;
3267             default:
3268               result = NULL;
3269               break;
3270             }
3271
3272           if (result != NULL)
3273             return result;
3274
3275           sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3276         }
3277       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3278         {
3279           const char * result;
3280
3281           switch (elf_header.e_machine)
3282             {
3283             case EM_IA_64:
3284               result = get_ia64_section_type_name (sh_type);
3285               break;
3286             default:
3287               result = NULL;
3288               break;
3289             }
3290
3291           if (result != NULL)
3292             return result;
3293
3294           sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3295         }
3296       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3297         sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3298       else
3299         /* This message is probably going to be displayed in a 15
3300            character wide field, so put the hex value first.  */
3301         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3302
3303       return buff;
3304     }
3305 }
3306
3307 #define OPTION_DEBUG_DUMP       512
3308 #define OPTION_DYN_SYMS         513
3309 #define OPTION_DWARF_DEPTH      514
3310 #define OPTION_DWARF_START      515
3311 #define OPTION_DWARF_CHECK      516
3312
3313 static struct option options[] =
3314 {
3315   {"all",              no_argument, 0, 'a'},
3316   {"file-header",      no_argument, 0, 'h'},
3317   {"program-headers",  no_argument, 0, 'l'},
3318   {"headers",          no_argument, 0, 'e'},
3319   {"histogram",        no_argument, 0, 'I'},
3320   {"segments",         no_argument, 0, 'l'},
3321   {"sections",         no_argument, 0, 'S'},
3322   {"section-headers",  no_argument, 0, 'S'},
3323   {"section-groups",   no_argument, 0, 'g'},
3324   {"section-details",  no_argument, 0, 't'},
3325   {"full-section-name",no_argument, 0, 'N'},
3326   {"symbols",          no_argument, 0, 's'},
3327   {"syms",             no_argument, 0, 's'},
3328   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
3329   {"relocs",           no_argument, 0, 'r'},
3330   {"notes",            no_argument, 0, 'n'},
3331   {"dynamic",          no_argument, 0, 'd'},
3332   {"arch-specific",    no_argument, 0, 'A'},
3333   {"version-info",     no_argument, 0, 'V'},
3334   {"use-dynamic",      no_argument, 0, 'D'},
3335   {"unwind",           no_argument, 0, 'u'},
3336   {"archive-index",    no_argument, 0, 'c'},
3337   {"hex-dump",         required_argument, 0, 'x'},
3338   {"relocated-dump",   required_argument, 0, 'R'},
3339   {"string-dump",      required_argument, 0, 'p'},
3340 #ifdef SUPPORT_DISASSEMBLY
3341   {"instruction-dump", required_argument, 0, 'i'},
3342 #endif
3343   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
3344
3345   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
3346   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
3347   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
3348
3349   {"version",          no_argument, 0, 'v'},
3350   {"wide",             no_argument, 0, 'W'},
3351   {"help",             no_argument, 0, 'H'},
3352   {0,                  no_argument, 0, 0}
3353 };
3354
3355 static void
3356 usage (FILE * stream)
3357 {
3358   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3359   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3360   fprintf (stream, _(" Options are:\n\
3361   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3362   -h --file-header       Display the ELF file header\n\
3363   -l --program-headers   Display the program headers\n\
3364      --segments          An alias for --program-headers\n\
3365   -S --section-headers   Display the sections' header\n\
3366      --sections          An alias for --section-headers\n\
3367   -g --section-groups    Display the section groups\n\
3368   -t --section-details   Display the section details\n\
3369   -e --headers           Equivalent to: -h -l -S\n\
3370   -s --syms              Display the symbol table\n\
3371      --symbols           An alias for --syms\n\
3372   --dyn-syms             Display the dynamic symbol table\n\
3373   -n --notes             Display the core notes (if present)\n\
3374   -r --relocs            Display the relocations (if present)\n\
3375   -u --unwind            Display the unwind info (if present)\n\
3376   -d --dynamic           Display the dynamic section (if present)\n\
3377   -V --version-info      Display the version sections (if present)\n\
3378   -A --arch-specific     Display architecture specific information (if any)\n\
3379   -c --archive-index     Display the symbol/file index in an archive\n\
3380   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
3381   -x --hex-dump=<number|name>\n\
3382                          Dump the contents of section <number|name> as bytes\n\
3383   -p --string-dump=<number|name>\n\
3384                          Dump the contents of section <number|name> as strings\n\
3385   -R --relocated-dump=<number|name>\n\
3386                          Dump the contents of section <number|name> as relocated bytes\n\
3387   -w[lLiaprmfFsoRt] or\n\
3388   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3389                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3390                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3391                =addr,=cu_index]\n\
3392                          Display the contents of DWARF2 debug sections\n"));
3393   fprintf (stream, _("\
3394   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
3395   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
3396                          or deeper\n"));
3397 #ifdef SUPPORT_DISASSEMBLY
3398   fprintf (stream, _("\
3399   -i --instruction-dump=<number|name>\n\
3400                          Disassemble the contents of section <number|name>\n"));
3401 #endif
3402   fprintf (stream, _("\
3403   -I --histogram         Display histogram of bucket list lengths\n\
3404   -W --wide              Allow output width to exceed 80 characters\n\
3405   @<file>                Read options from <file>\n\
3406   -H --help              Display this information\n\
3407   -v --version           Display the version number of readelf\n"));
3408
3409   if (REPORT_BUGS_TO[0] && stream == stdout)
3410     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3411
3412   exit (stream == stdout ? 0 : 1);
3413 }
3414
3415 /* Record the fact that the user wants the contents of section number
3416    SECTION to be displayed using the method(s) encoded as flags bits
3417    in TYPE.  Note, TYPE can be zero if we are creating the array for
3418    the first time.  */
3419
3420 static void
3421 request_dump_bynumber (unsigned int section, dump_type type)
3422 {
3423   if (section >= num_dump_sects)
3424     {
3425       dump_type * new_dump_sects;
3426
3427       new_dump_sects = (dump_type *) calloc (section + 1,
3428                                              sizeof (* dump_sects));
3429
3430       if (new_dump_sects == NULL)
3431         error (_("Out of memory allocating dump request table.\n"));
3432       else
3433         {
3434           /* Copy current flag settings.  */
3435           memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3436
3437           free (dump_sects);
3438
3439           dump_sects = new_dump_sects;
3440           num_dump_sects = section + 1;
3441         }
3442     }
3443
3444   if (dump_sects)
3445     dump_sects[section] |= type;
3446
3447   return;
3448 }
3449
3450 /* Request a dump by section name.  */
3451
3452 static void
3453 request_dump_byname (const char * section, dump_type type)
3454 {
3455   struct dump_list_entry * new_request;
3456
3457   new_request = (struct dump_list_entry *)
3458       malloc (sizeof (struct dump_list_entry));
3459   if (!new_request)
3460     error (_("Out of memory allocating dump request table.\n"));
3461
3462   new_request->name = strdup (section);
3463   if (!new_request->name)
3464     error (_("Out of memory allocating dump request table.\n"));
3465
3466   new_request->type = type;
3467
3468   new_request->next = dump_sects_byname;
3469   dump_sects_byname = new_request;
3470 }
3471
3472 static inline void
3473 request_dump (dump_type type)
3474 {
3475   int section;
3476   char * cp;
3477
3478   do_dump++;
3479   section = strtoul (optarg, & cp, 0);
3480
3481   if (! *cp && section >= 0)
3482     request_dump_bynumber (section, type);
3483   else
3484     request_dump_byname (optarg, type);
3485 }
3486
3487
3488 static void
3489 parse_args (int argc, char ** argv)
3490 {
3491   int c;
3492
3493   if (argc < 2)
3494     usage (stderr);
3495
3496   while ((c = getopt_long
3497           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3498     {
3499       switch (c)
3500         {
3501         case 0:
3502           /* Long options.  */
3503           break;
3504         case 'H':
3505           usage (stdout);
3506           break;
3507
3508         case 'a':
3509           do_syms++;
3510           do_reloc++;
3511           do_unwind++;
3512           do_dynamic++;
3513           do_header++;
3514           do_sections++;
3515           do_section_groups++;
3516           do_segments++;
3517           do_version++;
3518           do_histogram++;
3519           do_arch++;
3520           do_notes++;
3521           break;
3522         case 'g':
3523           do_section_groups++;
3524           break;
3525         case 't':
3526         case 'N':
3527           do_sections++;
3528           do_section_details++;
3529           break;
3530         case 'e':
3531           do_header++;
3532           do_sections++;
3533           do_segments++;
3534           break;
3535         case 'A':
3536           do_arch++;
3537           break;
3538         case 'D':
3539           do_using_dynamic++;
3540           break;
3541         case 'r':
3542           do_reloc++;
3543           break;
3544         case 'u':
3545           do_unwind++;
3546           break;
3547         case 'h':
3548           do_header++;
3549           break;
3550         case 'l':
3551           do_segments++;
3552           break;
3553         case 's':
3554           do_syms++;
3555           break;
3556         case 'S':
3557           do_sections++;
3558           break;
3559         case 'd':
3560           do_dynamic++;
3561           break;
3562         case 'I':
3563           do_histogram++;
3564           break;
3565         case 'n':
3566           do_notes++;
3567           break;
3568         case 'c':
3569           do_archive_index++;
3570           break;
3571         case 'x':
3572           request_dump (HEX_DUMP);
3573           break;
3574         case 'p':
3575           request_dump (STRING_DUMP);
3576           break;
3577         case 'R':
3578           request_dump (RELOC_DUMP);
3579           break;
3580         case 'w':
3581           do_dump++;
3582           if (optarg == 0)
3583             {
3584               do_debugging = 1;
3585               dwarf_select_sections_all ();
3586             }
3587           else
3588             {
3589               do_debugging = 0;
3590               dwarf_select_sections_by_letters (optarg);
3591             }
3592           break;
3593         case OPTION_DEBUG_DUMP:
3594           do_dump++;
3595           if (optarg == 0)
3596             do_debugging = 1;
3597           else
3598             {
3599               do_debugging = 0;
3600               dwarf_select_sections_by_names (optarg);
3601             }
3602           break;
3603         case OPTION_DWARF_DEPTH:
3604           {
3605             char *cp;
3606
3607             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3608           }
3609           break;
3610         case OPTION_DWARF_START:
3611           {
3612             char *cp;
3613
3614             dwarf_start_die = strtoul (optarg, & cp, 0);
3615           }
3616           break;
3617         case OPTION_DWARF_CHECK:
3618           dwarf_check = 1;
3619           break;
3620         case OPTION_DYN_SYMS:
3621           do_dyn_syms++;
3622           break;
3623 #ifdef SUPPORT_DISASSEMBLY
3624         case 'i':
3625           request_dump (DISASS_DUMP);
3626           break;
3627 #endif
3628         case 'v':
3629           print_version (program_name);
3630           break;
3631         case 'V':
3632           do_version++;
3633           break;
3634         case 'W':
3635           do_wide++;
3636           break;
3637         default:
3638           /* xgettext:c-format */
3639           error (_("Invalid option '-%c'\n"), c);
3640           /* Drop through.  */
3641         case '?':
3642           usage (stderr);
3643         }
3644     }
3645
3646   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3647       && !do_segments && !do_header && !do_dump && !do_version
3648       && !do_histogram && !do_debugging && !do_arch && !do_notes
3649       && !do_section_groups && !do_archive_index
3650       && !do_dyn_syms)
3651     usage (stderr);
3652   else if (argc < 3)
3653     {
3654       warn (_("Nothing to do.\n"));
3655       usage (stderr);
3656     }
3657 }
3658
3659 static const char *
3660 get_elf_class (unsigned int elf_class)
3661 {
3662   static char buff[32];
3663
3664   switch (elf_class)
3665     {
3666     case ELFCLASSNONE: return _("none");
3667     case ELFCLASS32:   return "ELF32";
3668     case ELFCLASS64:   return "ELF64";
3669     default:
3670       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3671       return buff;
3672     }
3673 }
3674
3675 static const char *
3676 get_data_encoding (unsigned int encoding)
3677 {
3678   static char buff[32];
3679
3680   switch (encoding)
3681     {
3682     case ELFDATANONE: return _("none");
3683     case ELFDATA2LSB: return _("2's complement, little endian");
3684     case ELFDATA2MSB: return _("2's complement, big endian");
3685     default:
3686       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3687       return buff;
3688     }
3689 }
3690
3691 /* Decode the data held in 'elf_header'.  */
3692
3693 static int
3694 process_file_header (void)
3695 {
3696   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
3697       || elf_header.e_ident[EI_MAG1] != ELFMAG1
3698       || elf_header.e_ident[EI_MAG2] != ELFMAG2
3699       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3700     {
3701       error
3702         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3703       return 0;
3704     }
3705
3706   init_dwarf_regnames (elf_header.e_machine);
3707
3708   if (do_header)
3709     {
3710       int i;
3711
3712       printf (_("ELF Header:\n"));
3713       printf (_("  Magic:   "));
3714       for (i = 0; i < EI_NIDENT; i++)
3715         printf ("%2.2x ", elf_header.e_ident[i]);
3716       printf ("\n");
3717       printf (_("  Class:                             %s\n"),
3718               get_elf_class (elf_header.e_ident[EI_CLASS]));
3719       printf (_("  Data:                              %s\n"),
3720               get_data_encoding (elf_header.e_ident[EI_DATA]));
3721       printf (_("  Version:                           %d %s\n"),
3722               elf_header.e_ident[EI_VERSION],
3723               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3724                ? "(current)"
3725                : (elf_header.e_ident[EI_VERSION] != EV_NONE
3726                   ? _("<unknown: %lx>")
3727                   : "")));
3728       printf (_("  OS/ABI:                            %s\n"),
3729               get_osabi_name (elf_header.e_ident[EI_OSABI]));
3730       printf (_("  ABI Version:                       %d\n"),
3731               elf_header.e_ident[EI_ABIVERSION]);
3732       printf (_("  Type:                              %s\n"),
3733               get_file_type (elf_header.e_type));
3734       printf (_("  Machine:                           %s\n"),
3735               get_machine_name (elf_header.e_machine));
3736       printf (_("  Version:                           0x%lx\n"),
3737               (unsigned long) elf_header.e_version);
3738
3739       printf (_("  Entry point address:               "));
3740       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3741       printf (_("\n  Start of program headers:          "));
3742       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3743       printf (_(" (bytes into file)\n  Start of section headers:          "));
3744       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3745       printf (_(" (bytes into file)\n"));
3746
3747       printf (_("  Flags:                             0x%lx%s\n"),
3748               (unsigned long) elf_header.e_flags,
3749               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3750       printf (_("  Size of this header:               %ld (bytes)\n"),
3751               (long) elf_header.e_ehsize);
3752       printf (_("  Size of program headers:           %ld (bytes)\n"),
3753               (long) elf_header.e_phentsize);
3754       printf (_("  Number of program headers:         %ld"),
3755               (long) elf_header.e_phnum);
3756       if (section_headers != NULL
3757           && elf_header.e_phnum == PN_XNUM
3758           && section_headers[0].sh_info != 0)
3759         printf (" (%ld)", (long) section_headers[0].sh_info);
3760       putc ('\n', stdout);
3761       printf (_("  Size of section headers:           %ld (bytes)\n"),
3762               (long) elf_header.e_shentsize);
3763       printf (_("  Number of section headers:         %ld"),
3764               (long) elf_header.e_shnum);
3765       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
3766         printf (" (%ld)", (long) section_headers[0].sh_size);
3767       putc ('\n', stdout);
3768       printf (_("  Section header string table index: %ld"),
3769               (long) elf_header.e_shstrndx);
3770       if (section_headers != NULL
3771           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3772         printf (" (%u)", section_headers[0].sh_link);
3773       else if (elf_header.e_shstrndx != SHN_UNDEF
3774                && elf_header.e_shstrndx >= elf_header.e_shnum)
3775         printf (_(" <corrupt: out of range>"));
3776       putc ('\n', stdout);
3777     }
3778
3779   if (section_headers != NULL)
3780     {
3781       if (elf_header.e_phnum == PN_XNUM
3782           && section_headers[0].sh_info != 0)
3783         elf_header.e_phnum = section_headers[0].sh_info;
3784       if (elf_header.e_shnum == SHN_UNDEF)
3785         elf_header.e_shnum = section_headers[0].sh_size;
3786       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3787         elf_header.e_shstrndx = section_headers[0].sh_link;
3788       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3789         elf_header.e_shstrndx = SHN_UNDEF;
3790       free (section_headers);
3791       section_headers = NULL;
3792     }
3793
3794   return 1;
3795 }
3796
3797
3798 static int
3799 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3800 {
3801   Elf32_External_Phdr * phdrs;
3802   Elf32_External_Phdr * external;
3803   Elf_Internal_Phdr *   internal;
3804   unsigned int i;
3805
3806   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3807                                             elf_header.e_phentsize,
3808                                             elf_header.e_phnum,
3809                                             _("program headers"));
3810   if (!phdrs)
3811     return 0;
3812
3813   for (i = 0, internal = pheaders, external = phdrs;
3814        i < elf_header.e_phnum;
3815        i++, internal++, external++)
3816     {
3817       internal->p_type   = BYTE_GET (external->p_type);
3818       internal->p_offset = BYTE_GET (external->p_offset);
3819       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
3820       internal->p_paddr  = BYTE_GET (external->p_paddr);
3821       internal->p_filesz = BYTE_GET (external->p_filesz);
3822       internal->p_memsz  = BYTE_GET (external->p_memsz);
3823       internal->p_flags  = BYTE_GET (external->p_flags);
3824       internal->p_align  = BYTE_GET (external->p_align);
3825     }
3826
3827   free (phdrs);
3828
3829   return 1;
3830 }
3831
3832 static int
3833 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3834 {
3835   Elf64_External_Phdr * phdrs;
3836   Elf64_External_Phdr * external;
3837   Elf_Internal_Phdr *   internal;
3838   unsigned int i;
3839
3840   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3841                                             elf_header.e_phentsize,
3842                                             elf_header.e_phnum,
3843                                             _("program headers"));
3844   if (!phdrs)
3845     return 0;
3846
3847   for (i = 0, internal = pheaders, external = phdrs;
3848        i < elf_header.e_phnum;
3849        i++, internal++, external++)
3850     {
3851       internal->p_type   = BYTE_GET (external->p_type);
3852       internal->p_flags  = BYTE_GET (external->p_flags);
3853       internal->p_offset = BYTE_GET (external->p_offset);
3854       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
3855       internal->p_paddr  = BYTE_GET (external->p_paddr);
3856       internal->p_filesz = BYTE_GET (external->p_filesz);
3857       internal->p_memsz  = BYTE_GET (external->p_memsz);
3858       internal->p_align  = BYTE_GET (external->p_align);
3859     }
3860
3861   free (phdrs);
3862
3863   return 1;
3864 }
3865
3866 /* Returns 1 if the program headers were read into `program_headers'.  */
3867
3868 static int
3869 get_program_headers (FILE * file)
3870 {
3871   Elf_Internal_Phdr * phdrs;
3872
3873   /* Check cache of prior read.  */
3874   if (program_headers != NULL)
3875     return 1;
3876
3877   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3878                                          sizeof (Elf_Internal_Phdr));
3879
3880   if (phdrs == NULL)
3881     {
3882       error (_("Out of memory\n"));
3883       return 0;
3884     }
3885
3886   if (is_32bit_elf
3887       ? get_32bit_program_headers (file, phdrs)
3888       : get_64bit_program_headers (file, phdrs))
3889     {
3890       program_headers = phdrs;
3891       return 1;
3892     }
3893
3894   free (phdrs);
3895   return 0;
3896 }
3897
3898 /* Returns 1 if the program headers were loaded.  */
3899
3900 static int
3901 process_program_headers (FILE * file)
3902 {
3903   Elf_Internal_Phdr * segment;
3904   unsigned int i;
3905
3906   if (elf_header.e_phnum == 0)
3907     {
3908       /* PR binutils/12467.  */
3909       if (elf_header.e_phoff != 0)
3910         warn (_("possibly corrupt ELF header - it has a non-zero program"
3911                 " header offset, but no program headers"));
3912       else if (do_segments)
3913         printf (_("\nThere are no program headers in this file.\n"));
3914       return 0;
3915     }
3916
3917   if (do_segments && !do_header)
3918     {
3919       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3920       printf (_("Entry point "));
3921       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3922       printf (_("\nThere are %d program headers, starting at offset "),
3923               elf_header.e_phnum);
3924       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3925       printf ("\n");
3926     }
3927
3928   if (! get_program_headers (file))
3929       return 0;
3930
3931   if (do_segments)
3932     {
3933       if (elf_header.e_phnum > 1)
3934         printf (_("\nProgram Headers:\n"));
3935       else
3936         printf (_("\nProgram Headers:\n"));
3937
3938       if (is_32bit_elf)
3939         printf
3940           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
3941       else if (do_wide)
3942         printf
3943           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
3944       else
3945         {
3946           printf
3947             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
3948           printf
3949             (_("                 FileSiz            MemSiz              Flags  Align\n"));
3950         }
3951     }
3952
3953   dynamic_addr = 0;
3954   dynamic_size = 0;
3955
3956   for (i = 0, segment = program_headers;
3957        i < elf_header.e_phnum;
3958        i++, segment++)
3959     {
3960       if (do_segments)
3961         {
3962           printf ("  %-14.14s ", get_segment_type (segment->p_type));
3963
3964           if (is_32bit_elf)
3965             {
3966               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3967               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3968               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3969               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3970               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3971               printf ("%c%c%c ",
3972                       (segment->p_flags & PF_R ? 'R' : ' '),
3973                       (segment->p_flags & PF_W ? 'W' : ' '),
3974                       (segment->p_flags & PF_X ? 'E' : ' '));
3975               printf ("%#lx", (unsigned long) segment->p_align);
3976             }
3977           else if (do_wide)
3978             {
3979               if ((unsigned long) segment->p_offset == segment->p_offset)
3980                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3981               else
3982                 {
3983                   print_vma (segment->p_offset, FULL_HEX);
3984                   putchar (' ');
3985                 }
3986
3987               print_vma (segment->p_vaddr, FULL_HEX);
3988               putchar (' ');
3989               print_vma (segment->p_paddr, FULL_HEX);
3990               putchar (' ');
3991
3992               if ((unsigned long) segment->p_filesz == segment->p_filesz)
3993                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3994               else
3995                 {
3996                   print_vma (segment->p_filesz, FULL_HEX);
3997                   putchar (' ');
3998                 }
3999
4000               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4001                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4002               else
4003                 {
4004                   print_vma (segment->p_memsz, FULL_HEX);
4005                 }
4006
4007               printf (" %c%c%c ",
4008                       (segment->p_flags & PF_R ? 'R' : ' '),
4009                       (segment->p_flags & PF_W ? 'W' : ' '),
4010                       (segment->p_flags & PF_X ? 'E' : ' '));
4011
4012               if ((unsigned long) segment->p_align == segment->p_align)
4013                 printf ("%#lx", (unsigned long) segment->p_align);
4014               else
4015                 {
4016                   print_vma (segment->p_align, PREFIX_HEX);
4017                 }
4018             }
4019           else
4020             {
4021               print_vma (segment->p_offset, FULL_HEX);
4022               putchar (' ');
4023               print_vma (segment->p_vaddr, FULL_HEX);
4024               putchar (' ');
4025               print_vma (segment->p_paddr, FULL_HEX);
4026               printf ("\n                 ");
4027               print_vma (segment->p_filesz, FULL_HEX);
4028               putchar (' ');
4029               print_vma (segment->p_memsz, FULL_HEX);
4030               printf ("  %c%c%c    ",
4031                       (segment->p_flags & PF_R ? 'R' : ' '),
4032                       (segment->p_flags & PF_W ? 'W' : ' '),
4033                       (segment->p_flags & PF_X ? 'E' : ' '));
4034               print_vma (segment->p_align, HEX);
4035             }
4036         }
4037
4038       switch (segment->p_type)
4039         {
4040         case PT_DYNAMIC:
4041           if (dynamic_addr)
4042             error (_("more than one dynamic segment\n"));
4043
4044           /* By default, assume that the .dynamic section is the first
4045              section in the DYNAMIC segment.  */
4046           dynamic_addr = segment->p_offset;
4047           dynamic_size = segment->p_filesz;
4048
4049           /* Try to locate the .dynamic section. If there is
4050              a section header table, we can easily locate it.  */
4051           if (section_headers != NULL)
4052             {
4053               Elf_Internal_Shdr * sec;
4054
4055               sec = find_section (".dynamic");
4056               if (sec == NULL || sec->sh_size == 0)
4057                 {
4058                   /* A corresponding .dynamic section is expected, but on
4059                      IA-64/OpenVMS it is OK for it to be missing.  */
4060                   if (!is_ia64_vms ())
4061                     error (_("no .dynamic section in the dynamic segment\n"));
4062                   break;
4063                 }
4064
4065               if (sec->sh_type == SHT_NOBITS)
4066                 {
4067                   dynamic_size = 0;
4068                   break;
4069                 }
4070
4071               dynamic_addr = sec->sh_offset;
4072               dynamic_size = sec->sh_size;
4073
4074               if (dynamic_addr < segment->p_offset
4075                   || dynamic_addr > segment->p_offset + segment->p_filesz)
4076                 warn (_("the .dynamic section is not contained"
4077                         " within the dynamic segment\n"));
4078               else if (dynamic_addr > segment->p_offset)
4079                 warn (_("the .dynamic section is not the first section"
4080                         " in the dynamic segment.\n"));
4081             }
4082           break;
4083
4084         case PT_INTERP:
4085           if (fseek (file, archive_file_offset + (long) segment->p_offset,
4086                      SEEK_SET))
4087             error (_("Unable to find program interpreter name\n"));
4088           else
4089             {
4090               char fmt [32];
4091               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
4092
4093               if (ret >= (int) sizeof (fmt) || ret < 0)
4094                 error (_("Internal error: failed to create format string to display program interpreter\n"));
4095
4096               program_interpreter[0] = 0;
4097               if (fscanf (file, fmt, program_interpreter) <= 0)
4098                 error (_("Unable to read program interpreter name\n"));
4099
4100               if (do_segments)
4101                 printf (_("\n      [Requesting program interpreter: %s]"),
4102                     program_interpreter);
4103             }
4104           break;
4105         }
4106
4107       if (do_segments)
4108         putc ('\n', stdout);
4109     }
4110
4111   if (do_segments && section_headers != NULL && string_table != NULL)
4112     {
4113       printf (_("\n Section to Segment mapping:\n"));
4114       printf (_("  Segment Sections...\n"));
4115
4116       for (i = 0; i < elf_header.e_phnum; i++)
4117         {
4118           unsigned int j;
4119           Elf_Internal_Shdr * section;
4120
4121           segment = program_headers + i;
4122           section = section_headers + 1;
4123
4124           printf ("   %2.2d     ", i);
4125
4126           for (j = 1; j < elf_header.e_shnum; j++, section++)
4127             {
4128               if (!ELF_TBSS_SPECIAL (section, segment)
4129                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4130                 printf ("%s ", SECTION_NAME (section));
4131             }
4132
4133           putc ('\n',stdout);
4134         }
4135     }
4136
4137   return 1;
4138 }
4139
4140
4141 /* Find the file offset corresponding to VMA by using the program headers.  */
4142
4143 static long
4144 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4145 {
4146   Elf_Internal_Phdr * seg;
4147
4148   if (! get_program_headers (file))
4149     {
4150       warn (_("Cannot interpret virtual addresses without program headers.\n"));
4151       return (long) vma;
4152     }
4153
4154   for (seg = program_headers;
4155        seg < program_headers + elf_header.e_phnum;
4156        ++seg)
4157     {
4158       if (seg->p_type != PT_LOAD)
4159         continue;
4160
4161       if (vma >= (seg->p_vaddr & -seg->p_align)
4162           && vma + size <= seg->p_vaddr + seg->p_filesz)
4163         return vma - seg->p_vaddr + seg->p_offset;
4164     }
4165
4166   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4167         (unsigned long) vma);
4168   return (long) vma;
4169 }
4170
4171
4172 static int
4173 get_32bit_section_headers (FILE * file, unsigned int num)
4174 {
4175   Elf32_External_Shdr * shdrs;
4176   Elf_Internal_Shdr *   internal;
4177   unsigned int i;
4178
4179   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4180                                             elf_header.e_shentsize, num,
4181                                             _("section headers"));
4182   if (!shdrs)
4183     return 0;
4184
4185   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4186                                                    sizeof (Elf_Internal_Shdr));
4187
4188   if (section_headers == NULL)
4189     {
4190       error (_("Out of memory\n"));
4191       return 0;
4192     }
4193
4194   for (i = 0, internal = section_headers;
4195        i < num;
4196        i++, internal++)
4197     {
4198       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4199       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4200       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4201       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4202       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4203       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4204       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4205       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4206       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4207       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4208     }
4209
4210   free (shdrs);
4211
4212   return 1;
4213 }
4214
4215 static int
4216 get_64bit_section_headers (FILE * file, unsigned int num)
4217 {
4218   Elf64_External_Shdr * shdrs;
4219   Elf_Internal_Shdr *   internal;
4220   unsigned int i;
4221
4222   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4223                                             elf_header.e_shentsize, num,
4224                                             _("section headers"));
4225   if (!shdrs)
4226     return 0;
4227
4228   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4229                                                    sizeof (Elf_Internal_Shdr));
4230
4231   if (section_headers == NULL)
4232     {
4233       error (_("Out of memory\n"));
4234       return 0;
4235     }
4236
4237   for (i = 0, internal = section_headers;
4238        i < num;
4239        i++, internal++)
4240     {
4241       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4242       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4243       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4244       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4245       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4246       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4247       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4248       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4249       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4250       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4251     }
4252
4253   free (shdrs);
4254
4255   return 1;
4256 }
4257
4258 static Elf_Internal_Sym *
4259 get_32bit_elf_symbols (FILE * file,
4260                        Elf_Internal_Shdr * section,
4261                        unsigned long * num_syms_return)
4262 {
4263   unsigned long number = 0;
4264   Elf32_External_Sym * esyms = NULL;
4265   Elf_External_Sym_Shndx * shndx = NULL;
4266   Elf_Internal_Sym * isyms = NULL;
4267   Elf_Internal_Sym * psym;
4268   unsigned int j;
4269
4270   /* Run some sanity checks first.  */
4271   if (section->sh_entsize == 0)
4272     {
4273       error (_("sh_entsize is zero\n"));
4274       goto exit_point;
4275     }
4276
4277   number = section->sh_size / section->sh_entsize;
4278
4279   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4280     {
4281       error (_("Invalid sh_entsize\n"));
4282       goto exit_point;
4283     }
4284
4285   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4286                                            section->sh_size, _("symbols"));
4287   if (esyms == NULL)
4288     goto exit_point;
4289
4290   shndx = NULL;
4291   if (symtab_shndx_hdr != NULL
4292       && (symtab_shndx_hdr->sh_link
4293           == (unsigned long) (section - section_headers)))
4294     {
4295       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4296                                                    symtab_shndx_hdr->sh_offset,
4297                                                    1, symtab_shndx_hdr->sh_size,
4298                                                    _("symbol table section indicies"));
4299       if (shndx == NULL)
4300         goto exit_point;
4301     }
4302
4303   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4304
4305   if (isyms == NULL)
4306     {
4307       error (_("Out of memory\n"));
4308       goto exit_point;
4309     }
4310
4311   for (j = 0, psym = isyms; j < number; j++, psym++)
4312     {
4313       psym->st_name  = BYTE_GET (esyms[j].st_name);
4314       psym->st_value = BYTE_GET (esyms[j].st_value);
4315       psym->st_size  = BYTE_GET (esyms[j].st_size);
4316       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4317       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4318         psym->st_shndx
4319           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4320       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4321         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4322       psym->st_info  = BYTE_GET (esyms[j].st_info);
4323       psym->st_other = BYTE_GET (esyms[j].st_other);
4324     }
4325
4326  exit_point:
4327   if (shndx != NULL)
4328     free (shndx);
4329   if (esyms != NULL)
4330     free (esyms);
4331
4332   if (num_syms_return != NULL)
4333     * num_syms_return = isyms == NULL ? 0 : number;
4334
4335   return isyms;
4336 }
4337
4338 static Elf_Internal_Sym *
4339 get_64bit_elf_symbols (FILE * file,
4340                        Elf_Internal_Shdr * section,
4341                        unsigned long * num_syms_return)
4342 {
4343   unsigned long number = 0;
4344   Elf64_External_Sym * esyms = NULL;
4345   Elf_External_Sym_Shndx * shndx = NULL;
4346   Elf_Internal_Sym * isyms = NULL;
4347   Elf_Internal_Sym * psym;
4348   unsigned int j;
4349
4350   /* Run some sanity checks first.  */
4351   if (section->sh_entsize == 0)
4352     {
4353       error (_("sh_entsize is zero\n"));
4354       goto exit_point;
4355     }
4356
4357   number = section->sh_size / section->sh_entsize;
4358
4359   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4360     {
4361       error (_("Invalid sh_entsize\n"));
4362       goto exit_point;
4363     }
4364
4365   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4366                                            section->sh_size, _("symbols"));
4367   if (!esyms)
4368     goto exit_point;
4369
4370   if (symtab_shndx_hdr != NULL
4371       && (symtab_shndx_hdr->sh_link
4372           == (unsigned long) (section - section_headers)))
4373     {
4374       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4375                                                    symtab_shndx_hdr->sh_offset,
4376                                                    1, symtab_shndx_hdr->sh_size,
4377                                                    _("symbol table section indicies"));
4378       if (shndx == NULL)
4379         goto exit_point;
4380     }
4381
4382   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4383
4384   if (isyms == NULL)
4385     {
4386       error (_("Out of memory\n"));
4387       goto exit_point;
4388     }
4389
4390   for (j = 0, psym = isyms; j < number; j++, psym++)
4391     {
4392       psym->st_name  = BYTE_GET (esyms[j].st_name);
4393       psym->st_info  = BYTE_GET (esyms[j].st_info);
4394       psym->st_other = BYTE_GET (esyms[j].st_other);
4395       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4396
4397       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4398         psym->st_shndx
4399           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4400       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4401         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4402
4403       psym->st_value = BYTE_GET (esyms[j].st_value);
4404       psym->st_size  = BYTE_GET (esyms[j].st_size);
4405     }
4406
4407  exit_point:
4408   if (shndx != NULL)
4409     free (shndx);
4410   if (esyms != NULL)
4411     free (esyms);
4412
4413   if (num_syms_return != NULL)
4414     * num_syms_return = isyms == NULL ? 0 : number;
4415
4416   return isyms;
4417 }
4418
4419 static const char *
4420 get_elf_section_flags (bfd_vma sh_flags)
4421 {
4422   static char buff[1024];
4423   char * p = buff;
4424   int field_size = is_32bit_elf ? 8 : 16;
4425   int sindex;
4426   int size = sizeof (buff) - (field_size + 4 + 1);
4427   bfd_vma os_flags = 0;
4428   bfd_vma proc_flags = 0;
4429   bfd_vma unknown_flags = 0;
4430   static const struct
4431     {
4432       const char * str;
4433       int len;
4434     }
4435   flags [] =
4436     {
4437       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
4438       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
4439       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
4440       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
4441       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
4442       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
4443       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4444       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4445       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
4446       /*  9 */ { STRING_COMMA_LEN ("TLS") },
4447       /* IA-64 specific.  */
4448       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4449       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4450       /* IA-64 OpenVMS specific.  */
4451       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4452       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4453       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4454       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4455       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4456       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4457       /* Generic.  */
4458       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4459       /* SPARC specific.  */
4460       /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4461     };
4462
4463   if (do_section_details)
4464     {
4465       sprintf (buff, "[%*.*lx]: ",
4466                field_size, field_size, (unsigned long) sh_flags);
4467       p += field_size + 4;
4468     }
4469
4470   while (sh_flags)
4471     {
4472       bfd_vma flag;
4473
4474       flag = sh_flags & - sh_flags;
4475       sh_flags &= ~ flag;
4476
4477       if (do_section_details)
4478         {
4479           switch (flag)
4480             {
4481             case SHF_WRITE:             sindex = 0; break;
4482             case SHF_ALLOC:             sindex = 1; break;
4483             case SHF_EXECINSTR:         sindex = 2; break;
4484             case SHF_MERGE:             sindex = 3; break;
4485             case SHF_STRINGS:           sindex = 4; break;
4486             case SHF_INFO_LINK:         sindex = 5; break;
4487             case SHF_LINK_ORDER:        sindex = 6; break;
4488             case SHF_OS_NONCONFORMING:  sindex = 7; break;
4489             case SHF_GROUP:             sindex = 8; break;
4490             case SHF_TLS:               sindex = 9; break;
4491             case SHF_EXCLUDE:           sindex = 18; break;
4492
4493             default:
4494               sindex = -1;
4495               switch (elf_header.e_machine)
4496                 {
4497                 case EM_IA_64:
4498                   if (flag == SHF_IA_64_SHORT)
4499                     sindex = 10;
4500                   else if (flag == SHF_IA_64_NORECOV)
4501                     sindex = 11;
4502 #ifdef BFD64
4503                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4504                     switch (flag)
4505                       {
4506                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
4507                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
4508                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
4509                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
4510                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4511                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
4512                       default:                        break;
4513                       }
4514 #endif
4515                   break;
4516
4517                 case EM_386:
4518                 case EM_486:
4519                 case EM_X86_64:
4520                 case EM_L1OM:
4521                 case EM_K1OM:
4522                 case EM_OLD_SPARCV9:
4523                 case EM_SPARC32PLUS:
4524                 case EM_SPARCV9:
4525                 case EM_SPARC:
4526                   if (flag == SHF_ORDERED)
4527                     sindex = 19;
4528                   break;
4529                 default:
4530                   break;
4531                 }
4532             }
4533
4534           if (sindex != -1)
4535             {
4536               if (p != buff + field_size + 4)
4537                 {
4538                   if (size < (10 + 2))
4539                     abort ();
4540                   size -= 2;
4541                   *p++ = ',';
4542                   *p++ = ' ';
4543                 }
4544
4545               size -= flags [sindex].len;
4546               p = stpcpy (p, flags [sindex].str);
4547             }
4548           else if (flag & SHF_MASKOS)
4549             os_flags |= flag;
4550           else if (flag & SHF_MASKPROC)
4551             proc_flags |= flag;
4552           else
4553             unknown_flags |= flag;
4554         }
4555       else
4556         {
4557           switch (flag)
4558             {
4559             case SHF_WRITE:             *p = 'W'; break;
4560             case SHF_ALLOC:             *p = 'A'; break;
4561             case SHF_EXECINSTR:         *p = 'X'; break;
4562             case SHF_MERGE:             *p = 'M'; break;
4563             case SHF_STRINGS:           *p = 'S'; break;
4564             case SHF_INFO_LINK:         *p = 'I'; break;
4565             case SHF_LINK_ORDER:        *p = 'L'; break;
4566             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
4567             case SHF_GROUP:             *p = 'G'; break;
4568             case SHF_TLS:               *p = 'T'; break;
4569             case SHF_EXCLUDE:           *p = 'E'; break;
4570
4571             default:
4572               if ((elf_header.e_machine == EM_X86_64
4573                    || elf_header.e_machine == EM_L1OM
4574                    || elf_header.e_machine == EM_K1OM)
4575                   && flag == SHF_X86_64_LARGE)
4576                 *p = 'l';
4577               else if (flag & SHF_MASKOS)
4578                 {
4579                   *p = 'o';
4580                   sh_flags &= ~ SHF_MASKOS;
4581                 }
4582               else if (flag & SHF_MASKPROC)
4583                 {
4584                   *p = 'p';
4585                   sh_flags &= ~ SHF_MASKPROC;
4586                 }
4587               else
4588                 *p = 'x';
4589               break;
4590             }
4591           p++;
4592         }
4593     }
4594
4595   if (do_section_details)
4596     {
4597       if (os_flags)
4598         {
4599           size -= 5 + field_size;
4600           if (p != buff + field_size + 4)
4601             {
4602               if (size < (2 + 1))
4603                 abort ();
4604               size -= 2;
4605               *p++ = ',';
4606               *p++ = ' ';
4607             }
4608           sprintf (p, "OS (%*.*lx)", field_size, field_size,
4609                    (unsigned long) os_flags);
4610           p += 5 + field_size;
4611         }
4612       if (proc_flags)
4613         {
4614           size -= 7 + field_size;
4615           if (p != buff + field_size + 4)
4616             {
4617               if (size < (2 + 1))
4618                 abort ();
4619               size -= 2;
4620               *p++ = ',';
4621               *p++ = ' ';
4622             }
4623           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4624                    (unsigned long) proc_flags);
4625           p += 7 + field_size;
4626         }
4627       if (unknown_flags)
4628         {
4629           size -= 10 + field_size;
4630           if (p != buff + field_size + 4)
4631             {
4632               if (size < (2 + 1))
4633                 abort ();
4634               size -= 2;
4635               *p++ = ',';
4636               *p++ = ' ';
4637             }
4638           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
4639                    (unsigned long) unknown_flags);
4640           p += 10 + field_size;
4641         }
4642     }
4643
4644   *p = '\0';
4645   return buff;
4646 }
4647
4648 static int
4649 process_section_headers (FILE * file)
4650 {
4651   Elf_Internal_Shdr * section;
4652   unsigned int i;
4653
4654   section_headers = NULL;
4655
4656   if (elf_header.e_shnum == 0)
4657     {
4658       /* PR binutils/12467.  */
4659       if (elf_header.e_shoff != 0)
4660         warn (_("possibly corrupt ELF file header - it has a non-zero"
4661                 " section header offset, but no section headers\n"));
4662       else if (do_sections)
4663         printf (_("\nThere are no sections in this file.\n"));
4664
4665       return 1;
4666     }
4667
4668   if (do_sections && !do_header)
4669     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4670             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4671
4672   if (is_32bit_elf)
4673     {
4674       if (! get_32bit_section_headers (file, elf_header.e_shnum))
4675         return 0;
4676     }
4677   else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4678     return 0;
4679
4680   /* Read in the string table, so that we have names to display.  */
4681   if (elf_header.e_shstrndx != SHN_UNDEF
4682        && elf_header.e_shstrndx < elf_header.e_shnum)
4683     {
4684       section = section_headers + elf_header.e_shstrndx;
4685
4686       if (section->sh_size != 0)
4687         {
4688           string_table = (char *) get_data (NULL, file, section->sh_offset,
4689                                             1, section->sh_size,
4690                                             _("string table"));
4691
4692           string_table_length = string_table != NULL ? section->sh_size : 0;
4693         }
4694     }
4695
4696   /* Scan the sections for the dynamic symbol table
4697      and dynamic string table and debug sections.  */
4698   dynamic_symbols = NULL;
4699   dynamic_strings = NULL;
4700   dynamic_syminfo = NULL;
4701   symtab_shndx_hdr = NULL;
4702
4703   eh_addr_size = is_32bit_elf ? 4 : 8;
4704   switch (elf_header.e_machine)
4705     {
4706     case EM_MIPS:
4707     case EM_MIPS_RS3_LE:
4708       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4709          FDE addresses.  However, the ABI also has a semi-official ILP32
4710          variant for which the normal FDE address size rules apply.
4711
4712          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4713          section, where XX is the size of longs in bits.  Unfortunately,
4714          earlier compilers provided no way of distinguishing ILP32 objects
4715          from LP64 objects, so if there's any doubt, we should assume that
4716          the official LP64 form is being used.  */
4717       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4718           && find_section (".gcc_compiled_long32") == NULL)
4719         eh_addr_size = 8;
4720       break;
4721
4722     case EM_H8_300:
4723     case EM_H8_300H:
4724       switch (elf_header.e_flags & EF_H8_MACH)
4725         {
4726         case E_H8_MACH_H8300:
4727         case E_H8_MACH_H8300HN:
4728         case E_H8_MACH_H8300SN:
4729         case E_H8_MACH_H8300SXN:
4730           eh_addr_size = 2;
4731           break;
4732         case E_H8_MACH_H8300H:
4733         case E_H8_MACH_H8300S:
4734         case E_H8_MACH_H8300SX:
4735           eh_addr_size = 4;
4736           break;
4737         }
4738       break;
4739
4740     case EM_M32C_OLD:
4741     case EM_M32C:
4742       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4743         {
4744         case EF_M32C_CPU_M16C:
4745           eh_addr_size = 2;
4746           break;
4747         }
4748       break;
4749     }
4750
4751 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4752   do                                                                        \
4753     {                                                                       \
4754       size_t expected_entsize                                               \
4755         = is_32bit_elf ? size32 : size64;                                   \
4756       if (section->sh_entsize != expected_entsize)                          \
4757         error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4758                i, (unsigned long int) section->sh_entsize,                  \
4759                (unsigned long int) expected_entsize);                       \
4760       section->sh_entsize = expected_entsize;                               \
4761     }                                                                       \
4762   while (0)
4763 #define CHECK_ENTSIZE(section, i, type) \
4764   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
4765                         sizeof (Elf64_External_##type))
4766
4767   for (i = 0, section = section_headers;
4768        i < elf_header.e_shnum;
4769        i++, section++)
4770     {
4771       char * name = SECTION_NAME (section);
4772
4773       if (section->sh_type == SHT_DYNSYM)
4774         {
4775           if (dynamic_symbols != NULL)
4776             {
4777               error (_("File contains multiple dynamic symbol tables\n"));
4778               continue;
4779             }
4780
4781           CHECK_ENTSIZE (section, i, Sym);
4782           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
4783         }
4784       else if (section->sh_type == SHT_STRTAB
4785                && streq (name, ".dynstr"))
4786         {
4787           if (dynamic_strings != NULL)
4788             {
4789               error (_("File contains multiple dynamic string tables\n"));
4790               continue;
4791             }
4792
4793           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4794                                                1, section->sh_size,
4795                                                _("dynamic strings"));
4796           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
4797         }
4798       else if (section->sh_type == SHT_SYMTAB_SHNDX)
4799         {
4800           if (symtab_shndx_hdr != NULL)
4801             {
4802               error (_("File contains multiple symtab shndx tables\n"));
4803               continue;
4804             }
4805           symtab_shndx_hdr = section;
4806         }
4807       else if (section->sh_type == SHT_SYMTAB)
4808         CHECK_ENTSIZE (section, i, Sym);
4809       else if (section->sh_type == SHT_GROUP)
4810         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4811       else if (section->sh_type == SHT_REL)
4812         CHECK_ENTSIZE (section, i, Rel);
4813       else if (section->sh_type == SHT_RELA)
4814         CHECK_ENTSIZE (section, i, Rela);
4815       else if ((do_debugging || do_debug_info || do_debug_abbrevs
4816                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
4817                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
4818                 || do_debug_str || do_debug_loc || do_debug_ranges
4819                 || do_debug_addr || do_debug_cu_index)
4820                && (const_strneq (name, ".debug_")
4821                    || const_strneq (name, ".zdebug_")))
4822         {
4823           if (name[1] == 'z')
4824             name += sizeof (".zdebug_") - 1;
4825           else
4826             name += sizeof (".debug_") - 1;
4827
4828           if (do_debugging
4829               || (do_debug_info     && const_strneq (name, "info"))
4830               || (do_debug_info     && const_strneq (name, "types"))
4831               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
4832               || (do_debug_lines    && const_strneq (name, "line"))
4833               || (do_debug_pubnames && const_strneq (name, "pubnames"))
4834               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
4835               || (do_debug_aranges  && const_strneq (name, "aranges"))
4836               || (do_debug_ranges   && const_strneq (name, "ranges"))
4837               || (do_debug_frames   && const_strneq (name, "frame"))
4838               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
4839               || (do_debug_macinfo  && const_strneq (name, "macro"))
4840               || (do_debug_str      && const_strneq (name, "str"))
4841               || (do_debug_loc      && const_strneq (name, "loc"))
4842               || (do_debug_addr     && const_strneq (name, "addr"))
4843               || (do_debug_cu_index && const_strneq (name, "cu_index"))
4844               || (do_debug_cu_index && const_strneq (name, "tu_index"))
4845               )
4846             request_dump_bynumber (i, DEBUG_DUMP);
4847         }
4848       /* Linkonce section to be combined with .debug_info at link time.  */
4849       else if ((do_debugging || do_debug_info)
4850                && const_strneq (name, ".gnu.linkonce.wi."))
4851         request_dump_bynumber (i, DEBUG_DUMP);
4852       else if (do_debug_frames && streq (name, ".eh_frame"))
4853         request_dump_bynumber (i, DEBUG_DUMP);
4854       else if (do_gdb_index && streq (name, ".gdb_index"))
4855         request_dump_bynumber (i, DEBUG_DUMP);
4856       /* Trace sections for Itanium VMS.  */
4857       else if ((do_debugging || do_trace_info || do_trace_abbrevs
4858                 || do_trace_aranges)
4859                && const_strneq (name, ".trace_"))
4860         {
4861           name += sizeof (".trace_") - 1;
4862
4863           if (do_debugging
4864               || (do_trace_info     && streq (name, "info"))
4865               || (do_trace_abbrevs  && streq (name, "abbrev"))
4866               || (do_trace_aranges  && streq (name, "aranges"))
4867               )
4868             request_dump_bynumber (i, DEBUG_DUMP);
4869         }
4870
4871     }
4872
4873   if (! do_sections)
4874     return 1;
4875
4876   if (elf_header.e_shnum > 1)
4877     printf (_("\nSection Headers:\n"));
4878   else
4879     printf (_("\nSection Header:\n"));
4880
4881   if (is_32bit_elf)
4882     {
4883       if (do_section_details)
4884         {
4885           printf (_("  [Nr] Name\n"));
4886           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
4887         }
4888       else
4889         printf
4890           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
4891     }
4892   else if (do_wide)
4893     {
4894       if (do_section_details)
4895         {
4896           printf (_("  [Nr] Name\n"));
4897           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
4898         }
4899       else
4900         printf
4901           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
4902     }
4903   else
4904     {
4905       if (do_section_details)
4906         {
4907           printf (_("  [Nr] Name\n"));
4908           printf (_("       Type              Address          Offset            Link\n"));
4909           printf (_("       Size              EntSize          Info              Align\n"));
4910         }
4911       else
4912         {
4913           printf (_("  [Nr] Name              Type             Address           Offset\n"));
4914           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
4915         }
4916     }
4917
4918   if (do_section_details)
4919     printf (_("       Flags\n"));
4920
4921   for (i = 0, section = section_headers;
4922        i < elf_header.e_shnum;
4923        i++, section++)
4924     {
4925       printf ("  [%2u] ", i);
4926       if (do_section_details)
4927         {
4928           print_symbol (INT_MAX, SECTION_NAME (section));
4929           printf ("\n      ");
4930         }
4931       else
4932         {
4933           print_symbol (-17, SECTION_NAME (section));
4934         }
4935
4936       printf (do_wide ? " %-15s " : " %-15.15s ",
4937               get_section_type_name (section->sh_type));
4938
4939       if (is_32bit_elf)
4940         {
4941           const char * link_too_big = NULL;
4942
4943           print_vma (section->sh_addr, LONG_HEX);
4944
4945           printf ( " %6.6lx %6.6lx %2.2lx",
4946                    (unsigned long) section->sh_offset,
4947                    (unsigned long) section->sh_size,
4948                    (unsigned long) section->sh_entsize);
4949
4950           if (do_section_details)
4951             fputs ("  ", stdout);
4952           else
4953             printf (" %3s ", get_elf_section_flags (section->sh_flags));
4954
4955           if (section->sh_link >= elf_header.e_shnum)
4956             {
4957               link_too_big = "";
4958               /* The sh_link value is out of range.  Normally this indicates
4959                  an error but it can have special values in Solaris binaries.  */
4960               switch (elf_header.e_machine)
4961                 {
4962                 case EM_386:
4963                 case EM_486:
4964                 case EM_X86_64:
4965                 case EM_L1OM:
4966                 case EM_K1OM:
4967                 case EM_OLD_SPARCV9:
4968                 case EM_SPARC32PLUS:
4969                 case EM_SPARCV9:
4970                 case EM_SPARC:
4971                   if (section->sh_link == (SHN_BEFORE & 0xffff))
4972                     link_too_big = "BEFORE";
4973                   else if (section->sh_link == (SHN_AFTER & 0xffff))
4974                     link_too_big = "AFTER";
4975                   break;
4976                 default:
4977                   break;
4978                 }
4979             }
4980
4981           if (do_section_details)
4982             {
4983               if (link_too_big != NULL && * link_too_big)
4984                 printf ("<%s> ", link_too_big);
4985               else
4986                 printf ("%2u ", section->sh_link);
4987               printf ("%3u %2lu\n", section->sh_info,
4988                       (unsigned long) section->sh_addralign);
4989             }
4990           else
4991             printf ("%2u %3u %2lu\n",
4992                     section->sh_link,
4993                     section->sh_info,
4994                     (unsigned long) section->sh_addralign);
4995
4996           if (link_too_big && ! * link_too_big)
4997             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4998                   i, section->sh_link);
4999         }
5000       else if (do_wide)
5001         {
5002           print_vma (section->sh_addr, LONG_HEX);
5003
5004           if ((long) section->sh_offset == section->sh_offset)
5005             printf (" %6.6lx", (unsigned long) section->sh_offset);
5006           else
5007             {
5008               putchar (' ');
5009               print_vma (section->sh_offset, LONG_HEX);
5010             }
5011
5012           if ((unsigned long) section->sh_size == section->sh_size)
5013             printf (" %6.6lx", (unsigned long) section->sh_size);
5014           else
5015             {
5016               putchar (' ');
5017               print_vma (section->sh_size, LONG_HEX);
5018             }
5019
5020           if ((unsigned long) section->sh_entsize == section->sh_entsize)
5021             printf (" %2.2lx", (unsigned long) section->sh_entsize);
5022           else
5023             {
5024               putchar (' ');
5025               print_vma (section->sh_entsize, LONG_HEX);
5026             }
5027
5028           if (do_section_details)
5029             fputs ("  ", stdout);
5030           else
5031             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5032
5033           printf ("%2u %3u ", section->sh_link, section->sh_info);
5034
5035           if ((unsigned long) section->sh_addralign == section->sh_addralign)
5036             printf ("%2lu\n", (unsigned long) section->sh_addralign);
5037           else
5038             {
5039               print_vma (section->sh_addralign, DEC);
5040               putchar ('\n');
5041             }
5042         }
5043       else if (do_section_details)
5044         {
5045           printf ("       %-15.15s  ",
5046                   get_section_type_name (section->sh_type));
5047           print_vma (section->sh_addr, LONG_HEX);
5048           if ((long) section->sh_offset == section->sh_offset)
5049             printf ("  %16.16lx", (unsigned long) section->sh_offset);
5050           else
5051             {
5052               printf ("  ");
5053               print_vma (section->sh_offset, LONG_HEX);
5054             }
5055           printf ("  %u\n       ", section->sh_link);
5056           print_vma (section->sh_size, LONG_HEX);
5057           putchar (' ');
5058           print_vma (section->sh_entsize, LONG_HEX);
5059
5060           printf ("  %-16u  %lu\n",
5061                   section->sh_info,
5062                   (unsigned long) section->sh_addralign);
5063         }
5064       else
5065         {
5066           putchar (' ');
5067           print_vma (section->sh_addr, LONG_HEX);
5068           if ((long) section->sh_offset == section->sh_offset)
5069             printf ("  %8.8lx", (unsigned long) section->sh_offset);
5070           else
5071             {
5072               printf ("  ");
5073               print_vma (section->sh_offset, LONG_HEX);
5074             }
5075           printf ("\n       ");
5076           print_vma (section->sh_size, LONG_HEX);
5077           printf ("  ");
5078           print_vma (section->sh_entsize, LONG_HEX);
5079
5080           printf (" %3s ", get_elf_section_flags (section->sh_flags));
5081
5082           printf ("     %2u   %3u     %lu\n",
5083                   section->sh_link,
5084                   section->sh_info,
5085                   (unsigned long) section->sh_addralign);
5086         }
5087
5088       if (do_section_details)
5089         printf ("       %s\n", get_elf_section_flags (section->sh_flags));
5090     }
5091
5092   if (!do_section_details)
5093     {
5094       if (elf_header.e_machine == EM_X86_64
5095           || elf_header.e_machine == EM_L1OM
5096           || elf_header.e_machine == EM_K1OM)
5097         printf (_("Key to Flags:\n\
5098   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5099   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5100   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5101       else
5102         printf (_("Key to Flags:\n\
5103   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5104   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5105   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5106     }
5107
5108   return 1;
5109 }
5110
5111 static const char *
5112 get_group_flags (unsigned int flags)
5113 {
5114   static char buff[32];
5115   switch (flags)
5116     {
5117     case 0:
5118       return "";
5119
5120     case GRP_COMDAT:
5121       return "COMDAT ";
5122
5123    default:
5124       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5125       break;
5126     }
5127   return buff;
5128 }
5129
5130 static int
5131 process_section_groups (FILE * file)
5132 {
5133   Elf_Internal_Shdr * section;
5134   unsigned int i;
5135   struct group * group;
5136   Elf_Internal_Shdr * symtab_sec;
5137   Elf_Internal_Shdr * strtab_sec;
5138   Elf_Internal_Sym * symtab;
5139   unsigned long num_syms;
5140   char * strtab;
5141   size_t strtab_size;
5142
5143   /* Don't process section groups unless needed.  */
5144   if (!do_unwind && !do_section_groups)
5145     return 1;
5146
5147   if (elf_header.e_shnum == 0)
5148     {
5149       if (do_section_groups)
5150         printf (_("\nThere are no sections to group in this file.\n"));
5151
5152       return 1;
5153     }
5154
5155   if (section_headers == NULL)
5156     {
5157       error (_("Section headers are not available!\n"));
5158       /* PR 13622: This can happen with a corrupt ELF header.  */
5159       return 0;
5160     }
5161
5162   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5163                                                      sizeof (struct group *));
5164
5165   if (section_headers_groups == NULL)
5166     {
5167       error (_("Out of memory\n"));
5168       return 0;
5169     }
5170
5171   /* Scan the sections for the group section.  */
5172   group_count = 0;
5173   for (i = 0, section = section_headers;
5174        i < elf_header.e_shnum;
5175        i++, section++)
5176     if (section->sh_type == SHT_GROUP)
5177       group_count++;
5178
5179   if (group_count == 0)
5180     {
5181       if (do_section_groups)
5182         printf (_("\nThere are no section groups in this file.\n"));
5183
5184       return 1;
5185     }
5186
5187   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5188
5189   if (section_groups == NULL)
5190     {
5191       error (_("Out of memory\n"));
5192       return 0;
5193     }
5194
5195   symtab_sec = NULL;
5196   strtab_sec = NULL;
5197   symtab = NULL;
5198   num_syms = 0;
5199   strtab = NULL;
5200   strtab_size = 0;
5201   for (i = 0, section = section_headers, group = section_groups;
5202        i < elf_header.e_shnum;
5203        i++, section++)
5204     {
5205       if (section->sh_type == SHT_GROUP)
5206         {
5207           char * name = SECTION_NAME (section);
5208           char * group_name;
5209           unsigned char * start;
5210           unsigned char * indices;
5211           unsigned int entry, j, size;
5212           Elf_Internal_Shdr * sec;
5213           Elf_Internal_Sym * sym;
5214
5215           /* Get the symbol table.  */
5216           if (section->sh_link >= elf_header.e_shnum
5217               || ((sec = section_headers + section->sh_link)->sh_type
5218                   != SHT_SYMTAB))
5219             {
5220               error (_("Bad sh_link in group section `%s'\n"), name);
5221               continue;
5222             }
5223
5224           if (symtab_sec != sec)
5225             {
5226               symtab_sec = sec;
5227               if (symtab)
5228                 free (symtab);
5229               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5230             }
5231
5232           if (symtab == NULL)
5233             {
5234               error (_("Corrupt header in group section `%s'\n"), name);
5235               continue;
5236             }
5237
5238           if (section->sh_info >= num_syms)
5239             {
5240               error (_("Bad sh_info in group section `%s'\n"), name);
5241               continue;
5242             }
5243
5244           sym = symtab + section->sh_info;
5245
5246           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5247             {
5248               if (sym->st_shndx == 0
5249                   || sym->st_shndx >= elf_header.e_shnum)
5250                 {
5251                   error (_("Bad sh_info in group section `%s'\n"), name);
5252                   continue;
5253                 }
5254
5255               group_name = SECTION_NAME (section_headers + sym->st_shndx);
5256               strtab_sec = NULL;
5257               if (strtab)
5258                 free (strtab);
5259               strtab = NULL;
5260               strtab_size = 0;
5261             }
5262           else
5263             {
5264               /* Get the string table.  */
5265               if (symtab_sec->sh_link >= elf_header.e_shnum)
5266                 {
5267                   strtab_sec = NULL;
5268                   if (strtab)
5269                     free (strtab);
5270                   strtab = NULL;
5271                   strtab_size = 0;
5272                 }
5273               else if (strtab_sec
5274                        != (sec = section_headers + symtab_sec->sh_link))
5275                 {
5276                   strtab_sec = sec;
5277                   if (strtab)
5278                     free (strtab);
5279                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5280                                               1, strtab_sec->sh_size,
5281                                               _("string table"));
5282                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5283                 }
5284               group_name = sym->st_name < strtab_size
5285                 ? strtab + sym->st_name : _("<corrupt>");
5286             }
5287
5288           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5289                                               1, section->sh_size,
5290                                               _("section data"));
5291           if (start == NULL)
5292             continue;
5293
5294           indices = start;
5295           size = (section->sh_size / section->sh_entsize) - 1;
5296           entry = byte_get (indices, 4);
5297           indices += 4;
5298
5299           if (do_section_groups)
5300             {
5301               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5302                       get_group_flags (entry), i, name, group_name, size);
5303
5304               printf (_("   [Index]    Name\n"));
5305             }
5306
5307           group->group_index = i;
5308
5309           for (j = 0; j < size; j++)
5310             {
5311               struct group_list * g;
5312
5313               entry = byte_get (indices, 4);
5314               indices += 4;
5315
5316               if (entry >= elf_header.e_shnum)
5317                 {
5318                   error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5319                          entry, i, elf_header.e_shnum - 1);
5320                   continue;
5321                 }
5322
5323               if (section_headers_groups [entry] != NULL)
5324                 {
5325                   if (entry)
5326                     {
5327                       error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5328                              entry, i,
5329                              section_headers_groups [entry]->group_index);
5330                       continue;
5331                     }
5332                   else
5333                     {
5334                       /* Intel C/C++ compiler may put section 0 in a
5335                          section group. We just warn it the first time
5336                          and ignore it afterwards.  */
5337                       static int warned = 0;
5338                       if (!warned)
5339                         {
5340                           error (_("section 0 in group section [%5u]\n"),
5341                                  section_headers_groups [entry]->group_index);
5342                           warned++;
5343                         }
5344                     }
5345                 }
5346
5347               section_headers_groups [entry] = group;
5348
5349               if (do_section_groups)
5350                 {
5351                   sec = section_headers + entry;
5352                   printf ("   [%5u]   %s\n", entry, SECTION_NAME (sec));
5353                 }
5354
5355               g = (struct group_list *) xmalloc (sizeof (struct group_list));
5356               g->section_index = entry;
5357               g->next = group->root;
5358               group->root = g;
5359             }
5360
5361           if (start)
5362             free (start);
5363
5364           group++;
5365         }
5366     }
5367
5368   if (symtab)
5369     free (symtab);
5370   if (strtab)
5371     free (strtab);
5372   return 1;
5373 }
5374
5375 /* Data used to display dynamic fixups.  */
5376
5377 struct ia64_vms_dynfixup
5378 {
5379   bfd_vma needed_ident;         /* Library ident number.  */
5380   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
5381   bfd_vma fixup_needed;         /* Index of the library.  */
5382   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
5383   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
5384 };
5385
5386 /* Data used to display dynamic relocations.  */
5387
5388 struct ia64_vms_dynimgrela
5389 {
5390   bfd_vma img_rela_cnt;         /* Number of relocations.  */
5391   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
5392 };
5393
5394 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5395    library).  */
5396
5397 static void
5398 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5399                               const char *strtab, unsigned int strtab_sz)
5400 {
5401   Elf64_External_VMS_IMAGE_FIXUP *imfs;
5402   long i;
5403   const char *lib_name;
5404
5405   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5406                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
5407                    _("dynamic section image fixups"));
5408   if (!imfs)
5409     return;
5410
5411   if (fixup->needed < strtab_sz)
5412     lib_name = strtab + fixup->needed;
5413   else
5414     {
5415       warn ("corrupt library name index of 0x%lx found in dynamic entry",
5416             (unsigned long) fixup->needed);
5417       lib_name = "???";
5418     }
5419   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5420           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5421   printf
5422     (_("Seg Offset           Type                             SymVec DataType\n"));
5423
5424   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5425     {
5426       unsigned int type;
5427       const char *rtype;
5428
5429       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5430       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5431       type = BYTE_GET (imfs [i].type);
5432       rtype = elf_ia64_reloc_type (type);
5433       if (rtype == NULL)
5434         printf (" 0x%08x                       ", type);
5435       else
5436         printf (" %-32s ", rtype);
5437       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5438       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5439     }
5440
5441   free (imfs);
5442 }
5443
5444 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
5445
5446 static void
5447 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5448 {
5449   Elf64_External_VMS_IMAGE_RELA *imrs;
5450   long i;
5451
5452   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5453                    1, imgrela->img_rela_cnt * sizeof (*imrs),
5454                    _("dynamic section image relocations"));
5455   if (!imrs)
5456     return;
5457
5458   printf (_("\nImage relocs\n"));
5459   printf
5460     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
5461
5462   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5463     {
5464       unsigned int type;
5465       const char *rtype;
5466
5467       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5468       printf ("%08" BFD_VMA_FMT "x ",
5469               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5470       type = BYTE_GET (imrs [i].type);
5471       rtype = elf_ia64_reloc_type (type);
5472       if (rtype == NULL)
5473         printf ("0x%08x                      ", type);
5474       else
5475         printf ("%-31s ", rtype);
5476       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5477       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5478       printf ("%08" BFD_VMA_FMT "x\n",
5479               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5480     }
5481
5482   free (imrs);
5483 }
5484
5485 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
5486
5487 static int
5488 process_ia64_vms_dynamic_relocs (FILE *file)
5489 {
5490   struct ia64_vms_dynfixup fixup;
5491   struct ia64_vms_dynimgrela imgrela;
5492   Elf_Internal_Dyn *entry;
5493   int res = 0;
5494   bfd_vma strtab_off = 0;
5495   bfd_vma strtab_sz = 0;
5496   char *strtab = NULL;
5497
5498   memset (&fixup, 0, sizeof (fixup));
5499   memset (&imgrela, 0, sizeof (imgrela));
5500
5501   /* Note: the order of the entries is specified by the OpenVMS specs.  */
5502   for (entry = dynamic_section;
5503        entry < dynamic_section + dynamic_nent;
5504        entry++)
5505     {
5506       switch (entry->d_tag)
5507         {
5508         case DT_IA_64_VMS_STRTAB_OFFSET:
5509           strtab_off = entry->d_un.d_val;
5510           break;
5511         case DT_STRSZ:
5512           strtab_sz = entry->d_un.d_val;
5513           if (strtab == NULL)
5514             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5515                                1, strtab_sz, _("dynamic string section"));
5516           break;
5517
5518         case DT_IA_64_VMS_NEEDED_IDENT:
5519           fixup.needed_ident = entry->d_un.d_val;
5520           break;
5521         case DT_NEEDED:
5522           fixup.needed = entry->d_un.d_val;
5523           break;
5524         case DT_IA_64_VMS_FIXUP_NEEDED:
5525           fixup.fixup_needed = entry->d_un.d_val;
5526           break;
5527         case DT_IA_64_VMS_FIXUP_RELA_CNT:
5528           fixup.fixup_rela_cnt = entry->d_un.d_val;
5529           break;
5530         case DT_IA_64_VMS_FIXUP_RELA_OFF:
5531           fixup.fixup_rela_off = entry->d_un.d_val;
5532           res++;
5533           dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5534           break;
5535
5536         case DT_IA_64_VMS_IMG_RELA_CNT:
5537           imgrela.img_rela_cnt = entry->d_un.d_val;
5538           break;
5539         case DT_IA_64_VMS_IMG_RELA_OFF:
5540           imgrela.img_rela_off = entry->d_un.d_val;
5541           res++;
5542           dump_ia64_vms_dynamic_relocs (file, &imgrela);
5543           break;
5544
5545         default:
5546           break;
5547         }
5548     }
5549
5550   if (strtab != NULL)
5551     free (strtab);
5552
5553   return res;
5554 }
5555
5556 static struct
5557 {
5558   const char * name;
5559   int reloc;
5560   int size;
5561   int rela;
5562 } dynamic_relocations [] =
5563 {
5564     { "REL", DT_REL, DT_RELSZ, FALSE },
5565     { "RELA", DT_RELA, DT_RELASZ, TRUE },
5566     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5567 };
5568
5569 /* Process the reloc section.  */
5570
5571 static int
5572 process_relocs (FILE * file)
5573 {
5574   unsigned long rel_size;
5575   unsigned long rel_offset;
5576
5577
5578   if (!do_reloc)
5579     return 1;
5580
5581   if (do_using_dynamic)
5582     {
5583       int is_rela;
5584       const char * name;
5585       int has_dynamic_reloc;
5586       unsigned int i;
5587
5588       has_dynamic_reloc = 0;
5589
5590       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5591         {
5592           is_rela = dynamic_relocations [i].rela;
5593           name = dynamic_relocations [i].name;
5594           rel_size = dynamic_info [dynamic_relocations [i].size];
5595           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5596
5597           has_dynamic_reloc |= rel_size;
5598
5599           if (is_rela == UNKNOWN)
5600             {
5601               if (dynamic_relocations [i].reloc == DT_JMPREL)
5602                 switch (dynamic_info[DT_PLTREL])
5603                   {
5604                   case DT_REL:
5605                     is_rela = FALSE;
5606                     break;
5607                   case DT_RELA:
5608                     is_rela = TRUE;
5609                     break;
5610                   }
5611             }
5612
5613           if (rel_size)
5614             {
5615               printf
5616                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5617                  name, rel_offset, rel_size);
5618
5619               dump_relocations (file,
5620                                 offset_from_vma (file, rel_offset, rel_size),
5621                                 rel_size,
5622                                 dynamic_symbols, num_dynamic_syms,
5623                                 dynamic_strings, dynamic_strings_length, is_rela);
5624             }
5625         }
5626
5627       if (is_ia64_vms ())
5628         has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5629
5630       if (! has_dynamic_reloc)
5631         printf (_("\nThere are no dynamic relocations in this file.\n"));
5632     }
5633   else
5634     {
5635       Elf_Internal_Shdr * section;
5636       unsigned long i;
5637       int found = 0;
5638
5639       for (i = 0, section = section_headers;
5640            i < elf_header.e_shnum;
5641            i++, section++)
5642         {
5643           if (   section->sh_type != SHT_RELA
5644               && section->sh_type != SHT_REL)
5645             continue;
5646
5647           rel_offset = section->sh_offset;
5648           rel_size   = section->sh_size;
5649
5650           if (rel_size)
5651             {
5652               Elf_Internal_Shdr * strsec;
5653               int is_rela;
5654
5655               printf (_("\nRelocation section "));
5656
5657               if (string_table == NULL)
5658                 printf ("%d", section->sh_name);
5659               else
5660                 printf ("'%s'", SECTION_NAME (section));
5661
5662               printf (_(" at offset 0x%lx contains %lu entries:\n"),
5663                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5664
5665               is_rela = section->sh_type == SHT_RELA;
5666
5667               if (section->sh_link != 0
5668                   && section->sh_link < elf_header.e_shnum)
5669                 {
5670                   Elf_Internal_Shdr * symsec;
5671                   Elf_Internal_Sym *  symtab;
5672                   unsigned long nsyms;
5673                   unsigned long strtablen = 0;
5674                   char * strtab = NULL;
5675
5676                   symsec = section_headers + section->sh_link;
5677                   if (symsec->sh_type != SHT_SYMTAB
5678                       && symsec->sh_type != SHT_DYNSYM)
5679                     continue;
5680
5681                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
5682
5683                   if (symtab == NULL)
5684                     continue;
5685
5686                   if (symsec->sh_link != 0
5687                       && symsec->sh_link < elf_header.e_shnum)
5688                     {
5689                       strsec = section_headers + symsec->sh_link;
5690
5691                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5692                                                   1, strsec->sh_size,
5693                                                   _("string table"));
5694                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
5695                     }
5696
5697                   dump_relocations (file, rel_offset, rel_size,
5698                                     symtab, nsyms, strtab, strtablen, is_rela);
5699                   if (strtab)
5700                     free (strtab);
5701                   free (symtab);
5702                 }
5703               else
5704                 dump_relocations (file, rel_offset, rel_size,
5705                                   NULL, 0, NULL, 0, is_rela);
5706
5707               found = 1;
5708             }
5709         }
5710
5711       if (! found)
5712         printf (_("\nThere are no relocations in this file.\n"));
5713     }
5714
5715   return 1;
5716 }
5717
5718 /* Process the unwind section.  */
5719
5720 #include "unwind-ia64.h"
5721
5722 /* An absolute address consists of a section and an offset.  If the
5723    section is NULL, the offset itself is the address, otherwise, the
5724    address equals to LOAD_ADDRESS(section) + offset.  */
5725
5726 struct absaddr
5727   {
5728     unsigned short section;
5729     bfd_vma offset;
5730   };
5731
5732 #define ABSADDR(a) \
5733   ((a).section \
5734    ? section_headers [(a).section].sh_addr + (a).offset \
5735    : (a).offset)
5736
5737 struct ia64_unw_table_entry
5738   {
5739     struct absaddr start;
5740     struct absaddr end;
5741     struct absaddr info;
5742   };
5743
5744 struct ia64_unw_aux_info
5745   {
5746
5747     struct ia64_unw_table_entry *table; /* Unwind table.  */
5748     unsigned long table_len;    /* Length of unwind table.  */
5749     unsigned char * info;       /* Unwind info.  */
5750     unsigned long info_size;    /* Size of unwind info.  */
5751     bfd_vma info_addr;          /* starting address of unwind info.  */
5752     bfd_vma seg_base;           /* Starting address of segment.  */
5753     Elf_Internal_Sym * symtab;  /* The symbol table.  */
5754     unsigned long nsyms;        /* Number of symbols.  */
5755     char * strtab;              /* The string table.  */
5756     unsigned long strtab_size;  /* Size of string table.  */
5757   };
5758
5759 static void
5760 find_symbol_for_address (Elf_Internal_Sym * symtab,
5761                          unsigned long nsyms,
5762                          const char * strtab,
5763                          unsigned long strtab_size,
5764                          struct absaddr addr,
5765                          const char ** symname,
5766                          bfd_vma * offset)
5767 {
5768   bfd_vma dist = 0x100000;
5769   Elf_Internal_Sym * sym;
5770   Elf_Internal_Sym * best = NULL;
5771   unsigned long i;
5772
5773   REMOVE_ARCH_BITS (addr.offset);
5774
5775   for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
5776     {
5777       bfd_vma value = sym->st_value;
5778
5779       REMOVE_ARCH_BITS (value);
5780
5781       if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5782           && sym->st_name != 0
5783           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
5784           && addr.offset >= value
5785           && addr.offset - value < dist)
5786         {
5787           best = sym;
5788           dist = addr.offset - value;
5789           if (!dist)
5790             break;
5791         }
5792     }
5793
5794   if (best)
5795     {
5796       *symname = (best->st_name >= strtab_size
5797                   ? _("<corrupt>") : strtab + best->st_name);
5798       *offset = dist;
5799       return;
5800     }
5801
5802   *symname = NULL;
5803   *offset = addr.offset;
5804 }
5805
5806 static void
5807 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
5808 {
5809   struct ia64_unw_table_entry * tp;
5810   int in_body;
5811
5812   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5813     {
5814       bfd_vma stamp;
5815       bfd_vma offset;
5816       const unsigned char * dp;
5817       const unsigned char * head;
5818       const char * procname;
5819
5820       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5821                                aux->strtab_size, tp->start, &procname, &offset);
5822
5823       fputs ("\n<", stdout);
5824
5825       if (procname)
5826         {
5827           fputs (procname, stdout);
5828
5829           if (offset)
5830             printf ("+%lx", (unsigned long) offset);
5831         }
5832
5833       fputs (">: [", stdout);
5834       print_vma (tp->start.offset, PREFIX_HEX);
5835       fputc ('-', stdout);
5836       print_vma (tp->end.offset, PREFIX_HEX);
5837       printf ("], info at +0x%lx\n",
5838               (unsigned long) (tp->info.offset - aux->seg_base));
5839
5840       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5841       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5842
5843       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5844               (unsigned) UNW_VER (stamp),
5845               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5846               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5847               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5848               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5849
5850       if (UNW_VER (stamp) != 1)
5851         {
5852           printf (_("\tUnknown version.\n"));
5853           continue;
5854         }
5855
5856       in_body = 0;
5857       for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5858         dp = unw_decode (dp, in_body, & in_body);
5859     }
5860 }
5861
5862 static int
5863 slurp_ia64_unwind_table (FILE * file,
5864                          struct ia64_unw_aux_info * aux,
5865                          Elf_Internal_Shdr * sec)
5866 {
5867   unsigned long size, nrelas, i;
5868   Elf_Internal_Phdr * seg;
5869   struct ia64_unw_table_entry * tep;
5870   Elf_Internal_Shdr * relsec;
5871   Elf_Internal_Rela * rela;
5872   Elf_Internal_Rela * rp;
5873   unsigned char * table;
5874   unsigned char * tp;
5875   Elf_Internal_Sym * sym;
5876   const char * relname;
5877
5878   /* First, find the starting address of the segment that includes
5879      this section: */
5880
5881   if (elf_header.e_phnum)
5882     {
5883       if (! get_program_headers (file))
5884           return 0;
5885
5886       for (seg = program_headers;
5887            seg < program_headers + elf_header.e_phnum;
5888            ++seg)
5889         {
5890           if (seg->p_type != PT_LOAD)
5891             continue;
5892
5893           if (sec->sh_addr >= seg->p_vaddr
5894               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5895             {
5896               aux->seg_base = seg->p_vaddr;
5897               break;
5898             }
5899         }
5900     }
5901
5902   /* Second, build the unwind table from the contents of the unwind section:  */
5903   size = sec->sh_size;
5904   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5905                                       _("unwind table"));
5906   if (!table)
5907     return 0;
5908
5909   aux->table = (struct ia64_unw_table_entry *)
5910       xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5911   tep = aux->table;
5912   for (tp = table; tp < table + size; ++tep)
5913     {
5914       tep->start.section = SHN_UNDEF;
5915       tep->end.section   = SHN_UNDEF;
5916       tep->info.section  = SHN_UNDEF;
5917       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5918       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5919       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5920       tep->start.offset += aux->seg_base;
5921       tep->end.offset   += aux->seg_base;
5922       tep->info.offset  += aux->seg_base;
5923     }
5924   free (table);
5925
5926   /* Third, apply any relocations to the unwind table:  */
5927   for (relsec = section_headers;
5928        relsec < section_headers + elf_header.e_shnum;
5929        ++relsec)
5930     {
5931       if (relsec->sh_type != SHT_RELA
5932           || relsec->sh_info >= elf_header.e_shnum
5933           || section_headers + relsec->sh_info != sec)
5934         continue;
5935
5936       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5937                               & rela, & nrelas))
5938         return 0;
5939
5940       for (rp = rela; rp < rela + nrelas; ++rp)
5941         {
5942           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5943           sym = aux->symtab + get_reloc_symindex (rp->r_info);
5944
5945           if (! const_strneq (relname, "R_IA64_SEGREL"))
5946             {
5947               warn (_("Skipping unexpected relocation type %s\n"), relname);
5948               continue;
5949             }
5950
5951           i = rp->r_offset / (3 * eh_addr_size);
5952
5953           switch (rp->r_offset/eh_addr_size % 3)
5954             {
5955             case 0:
5956               aux->table[i].start.section = sym->st_shndx;
5957               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
5958               break;
5959             case 1:
5960               aux->table[i].end.section   = sym->st_shndx;
5961               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
5962               break;
5963             case 2:
5964               aux->table[i].info.section  = sym->st_shndx;
5965               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
5966               break;
5967             default:
5968               break;
5969             }
5970         }
5971
5972       free (rela);
5973     }
5974
5975   aux->table_len = size / (3 * eh_addr_size);
5976   return 1;
5977 }
5978
5979 static void
5980 ia64_process_unwind (FILE * file)
5981 {
5982   Elf_Internal_Shdr * sec;
5983   Elf_Internal_Shdr * unwsec = NULL;
5984   Elf_Internal_Shdr * strsec;
5985   unsigned long i, unwcount = 0, unwstart = 0;
5986   struct ia64_unw_aux_info aux;
5987
5988   memset (& aux, 0, sizeof (aux));
5989
5990   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5991     {
5992       if (sec->sh_type == SHT_SYMTAB
5993           && sec->sh_link < elf_header.e_shnum)
5994         {
5995           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
5996
5997           strsec = section_headers + sec->sh_link;
5998           assert (aux.strtab == NULL);
5999           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6000                                           1, strsec->sh_size,
6001                                           _("string table"));
6002           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6003         }
6004       else if (sec->sh_type == SHT_IA_64_UNWIND)
6005         unwcount++;
6006     }
6007
6008   if (!unwcount)
6009     printf (_("\nThere are no unwind sections in this file.\n"));
6010
6011   while (unwcount-- > 0)
6012     {
6013       char * suffix;
6014       size_t len, len2;
6015
6016       for (i = unwstart, sec = section_headers + unwstart;
6017            i < elf_header.e_shnum; ++i, ++sec)
6018         if (sec->sh_type == SHT_IA_64_UNWIND)
6019           {
6020             unwsec = sec;
6021             break;
6022           }
6023
6024       unwstart = i + 1;
6025       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6026
6027       if ((unwsec->sh_flags & SHF_GROUP) != 0)
6028         {
6029           /* We need to find which section group it is in.  */
6030           struct group_list * g = section_headers_groups [i]->root;
6031
6032           for (; g != NULL; g = g->next)
6033             {
6034               sec = section_headers + g->section_index;
6035
6036               if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6037                 break;
6038             }
6039
6040           if (g == NULL)
6041             i = elf_header.e_shnum;
6042         }
6043       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6044         {
6045           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
6046           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6047           suffix = SECTION_NAME (unwsec) + len;
6048           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6049                ++i, ++sec)
6050             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6051                 && streq (SECTION_NAME (sec) + len2, suffix))
6052               break;
6053         }
6054       else
6055         {
6056           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6057              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
6058           len = sizeof (ELF_STRING_ia64_unwind) - 1;
6059           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6060           suffix = "";
6061           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6062             suffix = SECTION_NAME (unwsec) + len;
6063           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6064                ++i, ++sec)
6065             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6066                 && streq (SECTION_NAME (sec) + len2, suffix))
6067               break;
6068         }
6069
6070       if (i == elf_header.e_shnum)
6071         {
6072           printf (_("\nCould not find unwind info section for "));
6073
6074           if (string_table == NULL)
6075             printf ("%d", unwsec->sh_name);
6076           else
6077             printf (_("'%s'"), SECTION_NAME (unwsec));
6078         }
6079       else
6080         {
6081           aux.info_addr = sec->sh_addr;
6082           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6083                                                  sec->sh_size,
6084                                                  _("unwind info"));
6085           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6086
6087           printf (_("\nUnwind section "));
6088
6089           if (string_table == NULL)
6090             printf ("%d", unwsec->sh_name);
6091           else
6092             printf (_("'%s'"), SECTION_NAME (unwsec));
6093
6094           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6095                   (unsigned long) unwsec->sh_offset,
6096                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6097
6098           (void) slurp_ia64_unwind_table (file, & aux, unwsec);
6099
6100           if (aux.table_len > 0)
6101             dump_ia64_unwind (& aux);
6102
6103           if (aux.table)
6104             free ((char *) aux.table);
6105           if (aux.info)
6106             free ((char *) aux.info);
6107           aux.table = NULL;
6108           aux.info = NULL;
6109         }
6110     }
6111
6112   if (aux.symtab)
6113     free (aux.symtab);
6114   if (aux.strtab)
6115     free ((char *) aux.strtab);
6116 }
6117
6118 struct hppa_unw_table_entry
6119   {
6120     struct absaddr start;
6121     struct absaddr end;
6122     unsigned int Cannot_unwind:1;                       /* 0 */
6123     unsigned int Millicode:1;                   /* 1 */
6124     unsigned int Millicode_save_sr0:1;          /* 2 */
6125     unsigned int Region_description:2;          /* 3..4 */
6126     unsigned int reserved1:1;                   /* 5 */
6127     unsigned int Entry_SR:1;                    /* 6 */
6128     unsigned int Entry_FR:4;     /* number saved */     /* 7..10 */
6129     unsigned int Entry_GR:5;     /* number saved */     /* 11..15 */
6130     unsigned int Args_stored:1;                 /* 16 */
6131     unsigned int Variable_Frame:1;                      /* 17 */
6132     unsigned int Separate_Package_Body:1;               /* 18 */
6133     unsigned int Frame_Extension_Millicode:1;   /* 19 */
6134     unsigned int Stack_Overflow_Check:1;                /* 20 */
6135     unsigned int Two_Instruction_SP_Increment:1;        /* 21 */
6136     unsigned int Ada_Region:1;                  /* 22 */
6137     unsigned int cxx_info:1;                    /* 23 */
6138     unsigned int cxx_try_catch:1;                       /* 24 */
6139     unsigned int sched_entry_seq:1;                     /* 25 */
6140     unsigned int reserved2:1;                   /* 26 */
6141     unsigned int Save_SP:1;                             /* 27 */
6142     unsigned int Save_RP:1;                             /* 28 */
6143     unsigned int Save_MRP_in_frame:1;           /* 29 */
6144     unsigned int extn_ptr_defined:1;            /* 30 */
6145     unsigned int Cleanup_defined:1;                     /* 31 */
6146
6147     unsigned int MPE_XL_interrupt_marker:1;             /* 0 */
6148     unsigned int HP_UX_interrupt_marker:1;              /* 1 */
6149     unsigned int Large_frame:1;                 /* 2 */
6150     unsigned int Pseudo_SP_Set:1;                       /* 3 */
6151     unsigned int reserved4:1;                   /* 4 */
6152     unsigned int Total_frame_size:27;           /* 5..31 */
6153   };
6154
6155 struct hppa_unw_aux_info
6156   {
6157     struct hppa_unw_table_entry *table; /* Unwind table.  */
6158     unsigned long table_len;    /* Length of unwind table.  */
6159     bfd_vma seg_base;           /* Starting address of segment.  */
6160     Elf_Internal_Sym * symtab;  /* The symbol table.  */
6161     unsigned long nsyms;        /* Number of symbols.  */
6162     char * strtab;              /* The string table.  */
6163     unsigned long strtab_size;  /* Size of string table.  */
6164   };
6165
6166 static void
6167 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
6168 {
6169   struct hppa_unw_table_entry * tp;
6170
6171   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6172     {
6173       bfd_vma offset;
6174       const char * procname;
6175
6176       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6177                                aux->strtab_size, tp->start, &procname,
6178                                &offset);
6179
6180       fputs ("\n<", stdout);
6181
6182       if (procname)
6183         {
6184           fputs (procname, stdout);
6185
6186           if (offset)
6187             printf ("+%lx", (unsigned long) offset);
6188         }
6189
6190       fputs (">: [", stdout);
6191       print_vma (tp->start.offset, PREFIX_HEX);
6192       fputc ('-', stdout);
6193       print_vma (tp->end.offset, PREFIX_HEX);
6194       printf ("]\n\t");
6195
6196 #define PF(_m) if (tp->_m) printf (#_m " ");
6197 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6198       PF(Cannot_unwind);
6199       PF(Millicode);
6200       PF(Millicode_save_sr0);
6201       /* PV(Region_description);  */
6202       PF(Entry_SR);
6203       PV(Entry_FR);
6204       PV(Entry_GR);
6205       PF(Args_stored);
6206       PF(Variable_Frame);
6207       PF(Separate_Package_Body);
6208       PF(Frame_Extension_Millicode);
6209       PF(Stack_Overflow_Check);
6210       PF(Two_Instruction_SP_Increment);
6211       PF(Ada_Region);
6212       PF(cxx_info);
6213       PF(cxx_try_catch);
6214       PF(sched_entry_seq);
6215       PF(Save_SP);
6216       PF(Save_RP);
6217       PF(Save_MRP_in_frame);
6218       PF(extn_ptr_defined);
6219       PF(Cleanup_defined);
6220       PF(MPE_XL_interrupt_marker);
6221       PF(HP_UX_interrupt_marker);
6222       PF(Large_frame);
6223       PF(Pseudo_SP_Set);
6224       PV(Total_frame_size);
6225 #undef PF
6226 #undef PV
6227     }
6228
6229   printf ("\n");
6230 }
6231
6232 static int
6233 slurp_hppa_unwind_table (FILE * file,
6234                          struct hppa_unw_aux_info * aux,
6235                          Elf_Internal_Shdr * sec)
6236 {
6237   unsigned long size, unw_ent_size, nentries, nrelas, i;
6238   Elf_Internal_Phdr * seg;
6239   struct hppa_unw_table_entry * tep;
6240   Elf_Internal_Shdr * relsec;
6241   Elf_Internal_Rela * rela;
6242   Elf_Internal_Rela * rp;
6243   unsigned char * table;
6244   unsigned char * tp;
6245   Elf_Internal_Sym * sym;
6246   const char * relname;
6247
6248   /* First, find the starting address of the segment that includes
6249      this section.  */
6250
6251   if (elf_header.e_phnum)
6252     {
6253       if (! get_program_headers (file))
6254         return 0;
6255
6256       for (seg = program_headers;
6257            seg < program_headers + elf_header.e_phnum;
6258            ++seg)
6259         {
6260           if (seg->p_type != PT_LOAD)
6261             continue;
6262
6263           if (sec->sh_addr >= seg->p_vaddr
6264               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6265             {
6266               aux->seg_base = seg->p_vaddr;
6267               break;
6268             }
6269         }
6270     }
6271
6272   /* Second, build the unwind table from the contents of the unwind
6273      section.  */
6274   size = sec->sh_size;
6275   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6276                                       _("unwind table"));
6277   if (!table)
6278     return 0;
6279
6280   unw_ent_size = 16;
6281   nentries = size / unw_ent_size;
6282   size = unw_ent_size * nentries;
6283
6284   tep = aux->table = (struct hppa_unw_table_entry *)
6285       xcmalloc (nentries, sizeof (aux->table[0]));
6286
6287   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6288     {
6289       unsigned int tmp1, tmp2;
6290
6291       tep->start.section = SHN_UNDEF;
6292       tep->end.section   = SHN_UNDEF;
6293
6294       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6295       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6296       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6297       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6298
6299       tep->start.offset += aux->seg_base;
6300       tep->end.offset   += aux->seg_base;
6301
6302       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6303       tep->Millicode = (tmp1 >> 30) & 0x1;
6304       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6305       tep->Region_description = (tmp1 >> 27) & 0x3;
6306       tep->reserved1 = (tmp1 >> 26) & 0x1;
6307       tep->Entry_SR = (tmp1 >> 25) & 0x1;
6308       tep->Entry_FR = (tmp1 >> 21) & 0xf;
6309       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6310       tep->Args_stored = (tmp1 >> 15) & 0x1;
6311       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6312       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6313       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6314       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6315       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6316       tep->Ada_Region = (tmp1 >> 9) & 0x1;
6317       tep->cxx_info = (tmp1 >> 8) & 0x1;
6318       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6319       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6320       tep->reserved2 = (tmp1 >> 5) & 0x1;
6321       tep->Save_SP = (tmp1 >> 4) & 0x1;
6322       tep->Save_RP = (tmp1 >> 3) & 0x1;
6323       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6324       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6325       tep->Cleanup_defined = tmp1 & 0x1;
6326
6327       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6328       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6329       tep->Large_frame = (tmp2 >> 29) & 0x1;
6330       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6331       tep->reserved4 = (tmp2 >> 27) & 0x1;
6332       tep->Total_frame_size = tmp2 & 0x7ffffff;
6333     }
6334   free (table);
6335
6336   /* Third, apply any relocations to the unwind table.  */
6337   for (relsec = section_headers;
6338        relsec < section_headers + elf_header.e_shnum;
6339        ++relsec)
6340     {
6341       if (relsec->sh_type != SHT_RELA
6342           || relsec->sh_info >= elf_header.e_shnum
6343           || section_headers + relsec->sh_info != sec)
6344         continue;
6345
6346       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6347                               & rela, & nrelas))
6348         return 0;
6349
6350       for (rp = rela; rp < rela + nrelas; ++rp)
6351         {
6352           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6353           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6354
6355           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
6356           if (! const_strneq (relname, "R_PARISC_SEGREL"))
6357             {
6358               warn (_("Skipping unexpected relocation type %s\n"), relname);
6359               continue;
6360             }
6361
6362           i = rp->r_offset / unw_ent_size;
6363
6364           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6365             {
6366             case 0:
6367               aux->table[i].start.section = sym->st_shndx;
6368               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
6369               break;
6370             case 1:
6371               aux->table[i].end.section   = sym->st_shndx;
6372               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
6373               break;
6374             default:
6375               break;
6376             }
6377         }
6378
6379       free (rela);
6380     }
6381
6382   aux->table_len = nentries;
6383
6384   return 1;
6385 }
6386
6387 static void
6388 hppa_process_unwind (FILE * file)
6389 {
6390   struct hppa_unw_aux_info aux;
6391   Elf_Internal_Shdr * unwsec = NULL;
6392   Elf_Internal_Shdr * strsec;
6393   Elf_Internal_Shdr * sec;
6394   unsigned long i;
6395
6396   if (string_table == NULL)
6397     return;
6398
6399   memset (& aux, 0, sizeof (aux));
6400
6401   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6402     {
6403       if (sec->sh_type == SHT_SYMTAB
6404           && sec->sh_link < elf_header.e_shnum)
6405         {
6406           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6407
6408           strsec = section_headers + sec->sh_link;
6409           assert (aux.strtab == NULL);
6410           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6411                                           1, strsec->sh_size,
6412                                           _("string table"));
6413           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6414         }
6415       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6416         unwsec = sec;
6417     }
6418
6419   if (!unwsec)
6420     printf (_("\nThere are no unwind sections in this file.\n"));
6421
6422   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6423     {
6424       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6425         {
6426           printf (_("\nUnwind section "));
6427           printf (_("'%s'"), SECTION_NAME (sec));
6428
6429           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6430                   (unsigned long) sec->sh_offset,
6431                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6432
6433           slurp_hppa_unwind_table (file, &aux, sec);
6434           if (aux.table_len > 0)
6435             dump_hppa_unwind (&aux);
6436
6437           if (aux.table)
6438             free ((char *) aux.table);
6439           aux.table = NULL;
6440         }
6441     }
6442
6443   if (aux.symtab)
6444     free (aux.symtab);
6445   if (aux.strtab)
6446     free ((char *) aux.strtab);
6447 }
6448
6449 struct arm_section
6450 {
6451   unsigned char *      data;            /* The unwind data.  */
6452   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
6453   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
6454   unsigned long        nrelas;          /* The number of relocations.  */
6455   unsigned int         rel_type;        /* REL or RELA ?  */
6456   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
6457 };
6458
6459 struct arm_unw_aux_info
6460 {
6461   FILE *              file;             /* The file containing the unwind sections.  */
6462   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
6463   unsigned long       nsyms;            /* Number of symbols.  */
6464   char *              strtab;           /* The file's string table.  */
6465   unsigned long       strtab_size;      /* Size of string table.  */
6466 };
6467
6468 static const char *
6469 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6470                         bfd_vma fn, struct absaddr addr)
6471 {
6472   const char *procname;
6473   bfd_vma sym_offset;
6474
6475   if (addr.section == SHN_UNDEF)
6476     addr.offset = fn;
6477
6478   find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6479                            aux->strtab_size, addr, &procname,
6480                            &sym_offset);
6481
6482   print_vma (fn, PREFIX_HEX);
6483
6484   if (procname)
6485     {
6486       fputs (" <", stdout);
6487       fputs (procname, stdout);
6488
6489       if (sym_offset)
6490         printf ("+0x%lx", (unsigned long) sym_offset);
6491       fputc ('>', stdout);
6492     }
6493
6494   return procname;
6495 }
6496
6497 static void
6498 arm_free_section (struct arm_section *arm_sec)
6499 {
6500   if (arm_sec->data != NULL)
6501     free (arm_sec->data);
6502
6503   if (arm_sec->rela != NULL)
6504     free (arm_sec->rela);
6505 }
6506
6507 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6508       cached section and install SEC instead.
6509    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6510       and return its valued in * WORDP, relocating if necessary.
6511    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6512       relocation's offset in ADDR.
6513    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6514       into the string table of the symbol associated with the reloc.  If no
6515       reloc was applied store -1 there.
6516    5) Return TRUE upon success, FALSE otherwise.  */
6517
6518 static bfd_boolean
6519 get_unwind_section_word (struct arm_unw_aux_info *  aux,
6520                          struct arm_section *       arm_sec,
6521                          Elf_Internal_Shdr *        sec,
6522                          bfd_vma                    word_offset,
6523                          unsigned int *             wordp,
6524                          struct absaddr *           addr,
6525                          bfd_vma *                  sym_name)
6526 {
6527   Elf_Internal_Rela *rp;
6528   Elf_Internal_Sym *sym;
6529   const char * relname;
6530   unsigned int word;
6531   bfd_boolean wrapped;
6532
6533   addr->section = SHN_UNDEF;
6534   addr->offset = 0;
6535
6536   if (sym_name != NULL)
6537     *sym_name = (bfd_vma) -1;
6538
6539   /* If necessary, update the section cache.  */
6540   if (sec != arm_sec->sec)
6541     {
6542       Elf_Internal_Shdr *relsec;
6543
6544       arm_free_section (arm_sec);
6545
6546       arm_sec->sec = sec;
6547       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6548                                 sec->sh_size, _("unwind data"));
6549       arm_sec->rela = NULL;
6550       arm_sec->nrelas = 0;
6551
6552       for (relsec = section_headers;
6553            relsec < section_headers + elf_header.e_shnum;
6554            ++relsec)
6555         {
6556           if (relsec->sh_info >= elf_header.e_shnum
6557               || section_headers + relsec->sh_info != sec)
6558             continue;
6559
6560           arm_sec->rel_type = relsec->sh_type;
6561           if (relsec->sh_type == SHT_REL)
6562             {
6563               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6564                                      relsec->sh_size,
6565                                      & arm_sec->rela, & arm_sec->nrelas))
6566                 return FALSE;
6567               break;
6568             }
6569           else if (relsec->sh_type == SHT_RELA)
6570             {
6571               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6572                                       relsec->sh_size,
6573                                       & arm_sec->rela, & arm_sec->nrelas))
6574                 return FALSE;
6575               break;
6576             }
6577           else
6578             warn (_("unexpected relocation type (%d) for section %d"),
6579                   relsec->sh_type, relsec->sh_info);
6580         }
6581
6582       arm_sec->next_rela = arm_sec->rela;
6583     }
6584
6585   /* If there is no unwind data we can do nothing.  */
6586   if (arm_sec->data == NULL)
6587     return FALSE;
6588
6589   /* Get the word at the required offset.  */
6590   word = byte_get (arm_sec->data + word_offset, 4);
6591
6592   /* Look through the relocs to find the one that applies to the provided offset.  */
6593   wrapped = FALSE;
6594   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6595     {
6596       bfd_vma prelval, offset;
6597
6598       if (rp->r_offset > word_offset && !wrapped)
6599         {
6600           rp = arm_sec->rela;
6601           wrapped = TRUE;
6602         }
6603       if (rp->r_offset > word_offset)
6604         break;
6605
6606       if (rp->r_offset & 3)
6607         {
6608           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6609                 (unsigned long) rp->r_offset);
6610           continue;
6611         }
6612
6613       if (rp->r_offset < word_offset)
6614         continue;
6615
6616       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6617
6618       if (arm_sec->rel_type == SHT_REL)
6619         {
6620           offset = word & 0x7fffffff;
6621           if (offset & 0x40000000)
6622             offset |= ~ (bfd_vma) 0x7fffffff;
6623         }
6624       else if (arm_sec->rel_type == SHT_RELA)
6625         offset = rp->r_addend;
6626       else
6627         abort ();
6628
6629       offset += sym->st_value;
6630       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6631
6632       /* Check that we are processing the expected reloc type.  */
6633       if (elf_header.e_machine == EM_ARM)
6634         {
6635           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6636
6637           if (streq (relname, "R_ARM_NONE"))
6638               continue;
6639
6640           if (! streq (relname, "R_ARM_PREL31"))
6641             {
6642               warn (_("Skipping unexpected relocation type %s\n"), relname);
6643               continue;
6644             }
6645         }
6646       else if (elf_header.e_machine == EM_TI_C6000)
6647         {
6648           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6649
6650           if (streq (relname, "R_C6000_NONE"))
6651             continue;
6652
6653           if (! streq (relname, "R_C6000_PREL31"))
6654             {
6655               warn (_("Skipping unexpected relocation type %s\n"), relname);
6656               continue;
6657             }
6658
6659           prelval >>= 1;
6660         }
6661       else
6662         /* This function currently only supports ARM and TI unwinders.  */
6663         abort ();
6664
6665       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6666       addr->section = sym->st_shndx;
6667       addr->offset = offset;
6668       if (sym_name)
6669         * sym_name = sym->st_name;
6670       break;
6671     }
6672
6673   *wordp = word;
6674   arm_sec->next_rela = rp;
6675
6676   return TRUE;
6677 }
6678
6679 static const char *tic6x_unwind_regnames[16] =
6680 {
6681   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6682   "A14", "A13", "A12", "A11", "A10",
6683   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6684 };
6685
6686 static void
6687 decode_tic6x_unwind_regmask (unsigned int mask)
6688 {
6689   int i;
6690
6691   for (i = 12; mask; mask >>= 1, i--)
6692     {
6693       if (mask & 1)
6694         {
6695           fputs (tic6x_unwind_regnames[i], stdout);
6696           if (mask > 1)
6697             fputs (", ", stdout);
6698         }
6699     }
6700 }
6701
6702 #define ADVANCE                                                 \
6703   if (remaining == 0 && more_words)                             \
6704     {                                                           \
6705       data_offset += 4;                                         \
6706       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
6707                                      data_offset, & word, & addr, NULL))        \
6708         return;                                                 \
6709       remaining = 4;                                            \
6710       more_words--;                                             \
6711     }                                                           \
6712
6713 #define GET_OP(OP)                      \
6714   ADVANCE;                              \
6715   if (remaining)                        \
6716     {                                   \
6717       remaining--;                      \
6718       (OP) = word >> 24;                \
6719       word <<= 8;                       \
6720     }                                   \
6721   else                                  \
6722     {                                   \
6723       printf (_("[Truncated opcode]\n"));       \
6724       return;                           \
6725     }                                   \
6726   printf ("0x%02x ", OP)
6727
6728 static void
6729 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6730                             unsigned int word, unsigned int remaining,
6731                             unsigned int more_words,
6732                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6733                             struct arm_section *data_arm_sec)
6734 {
6735   struct absaddr addr;
6736
6737   /* Decode the unwinding instructions.  */
6738   while (1)
6739     {
6740       unsigned int op, op2;
6741
6742       ADVANCE;
6743       if (remaining == 0)
6744         break;
6745       remaining--;
6746       op = word >> 24;
6747       word <<= 8;
6748
6749       printf ("  0x%02x ", op);
6750
6751       if ((op & 0xc0) == 0x00)
6752         {
6753           int offset = ((op & 0x3f) << 2) + 4;
6754
6755           printf ("     vsp = vsp + %d", offset);
6756         }
6757       else if ((op & 0xc0) == 0x40)
6758         {
6759           int offset = ((op & 0x3f) << 2) + 4;
6760
6761           printf ("     vsp = vsp - %d", offset);
6762         }
6763       else if ((op & 0xf0) == 0x80)
6764         {
6765           GET_OP (op2);
6766           if (op == 0x80 && op2 == 0)
6767             printf (_("Refuse to unwind"));
6768           else
6769             {
6770               unsigned int mask = ((op & 0x0f) << 8) | op2;
6771               int first = 1;
6772               int i;
6773
6774               printf ("pop {");
6775               for (i = 0; i < 12; i++)
6776                 if (mask & (1 << i))
6777                   {
6778                     if (first)
6779                       first = 0;
6780                     else
6781                       printf (", ");
6782                     printf ("r%d", 4 + i);
6783                   }
6784               printf ("}");
6785             }
6786         }
6787       else if ((op & 0xf0) == 0x90)
6788         {
6789           if (op == 0x9d || op == 0x9f)
6790             printf (_("     [Reserved]"));
6791           else
6792             printf ("     vsp = r%d", op & 0x0f);
6793         }
6794       else if ((op & 0xf0) == 0xa0)
6795         {
6796           int end = 4 + (op & 0x07);
6797           int first = 1;
6798           int i;
6799
6800           printf ("     pop {");
6801           for (i = 4; i <= end; i++)
6802             {
6803               if (first)
6804                 first = 0;
6805               else
6806                 printf (", ");
6807               printf ("r%d", i);
6808             }
6809           if (op & 0x08)
6810             {
6811               if (!first)
6812                 printf (", ");
6813               printf ("r14");
6814             }
6815           printf ("}");
6816         }
6817       else if (op == 0xb0)
6818         printf (_("     finish"));
6819       else if (op == 0xb1)
6820         {
6821           GET_OP (op2);
6822           if (op2 == 0 || (op2 & 0xf0) != 0)
6823             printf (_("[Spare]"));
6824           else
6825             {
6826               unsigned int mask = op2 & 0x0f;
6827               int first = 1;
6828               int i;
6829
6830               printf ("pop {");
6831               for (i = 0; i < 12; i++)
6832                 if (mask & (1 << i))
6833                   {
6834                     if (first)
6835                       first = 0;
6836                     else
6837                       printf (", ");
6838                     printf ("r%d", i);
6839                   }
6840               printf ("}");
6841             }
6842         }
6843       else if (op == 0xb2)
6844         {
6845           unsigned char buf[9];
6846           unsigned int i, len;
6847           unsigned long offset;
6848
6849           for (i = 0; i < sizeof (buf); i++)
6850             {
6851               GET_OP (buf[i]);
6852               if ((buf[i] & 0x80) == 0)
6853                 break;
6854             }
6855           assert (i < sizeof (buf));
6856           offset = read_uleb128 (buf, &len);
6857           assert (len == i + 1);
6858           offset = offset * 4 + 0x204;
6859           printf ("vsp = vsp + %ld", offset);
6860         }
6861       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
6862         {
6863           unsigned int first, last;
6864
6865           GET_OP (op2);
6866           first = op2 >> 4;
6867           last = op2 & 0x0f;
6868           if (op == 0xc8)
6869             first = first + 16;
6870           printf ("pop {D%d", first);
6871           if (last)
6872             printf ("-D%d", first + last);
6873           printf ("}");
6874         }
6875       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6876         {
6877           unsigned int count = op & 0x07;
6878
6879           printf ("pop {D8");
6880           if (count)
6881             printf ("-D%d", 8 + count);
6882           printf ("}");
6883         }
6884       else if (op >= 0xc0 && op <= 0xc5)
6885         {
6886           unsigned int count = op & 0x07;
6887
6888           printf ("     pop {wR10");
6889           if (count)
6890             printf ("-wR%d", 10 + count);
6891           printf ("}");
6892         }
6893       else if (op == 0xc6)
6894         {
6895           unsigned int first, last;
6896
6897           GET_OP (op2);
6898           first = op2 >> 4;
6899           last = op2 & 0x0f;
6900           printf ("pop {wR%d", first);
6901           if (last)
6902             printf ("-wR%d", first + last);
6903           printf ("}");
6904         }
6905       else if (op == 0xc7)
6906         {
6907           GET_OP (op2);
6908           if (op2 == 0 || (op2 & 0xf0) != 0)
6909             printf (_("[Spare]"));
6910           else
6911             {
6912               unsigned int mask = op2 & 0x0f;
6913               int first = 1;
6914               int i;
6915
6916               printf ("pop {");
6917               for (i = 0; i < 4; i++)
6918                 if (mask & (1 << i))
6919                   {
6920                     if (first)
6921                       first = 0;
6922                     else
6923                       printf (", ");
6924                     printf ("wCGR%d", i);
6925                   }
6926               printf ("}");
6927             }
6928         }
6929       else
6930         printf (_("     [unsupported opcode]"));
6931       printf ("\n");
6932     }
6933 }
6934
6935 static void
6936 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6937                             unsigned int word, unsigned int remaining,
6938                             unsigned int more_words,
6939                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6940                             struct arm_section *data_arm_sec)
6941 {
6942   struct absaddr addr;
6943
6944   /* Decode the unwinding instructions.  */
6945   while (1)
6946     {
6947       unsigned int op, op2;
6948
6949       ADVANCE;
6950       if (remaining == 0)
6951         break;
6952       remaining--;
6953       op = word >> 24;
6954       word <<= 8;
6955
6956       printf ("  0x%02x ", op);
6957
6958       if ((op & 0xc0) == 0x00)
6959         {
6960           int offset = ((op & 0x3f) << 3) + 8;
6961           printf ("     sp = sp + %d", offset);
6962         }
6963       else if ((op & 0xc0) == 0x80)
6964         {
6965           GET_OP (op2);
6966           if (op == 0x80 && op2 == 0)
6967             printf (_("Refuse to unwind"));
6968           else
6969             {
6970               unsigned int mask = ((op & 0x1f) << 8) | op2;
6971               if (op & 0x20)
6972                 printf ("pop compact {");
6973               else
6974                 printf ("pop {");
6975
6976               decode_tic6x_unwind_regmask (mask);
6977               printf("}");
6978             }
6979         }
6980       else if ((op & 0xf0) == 0xc0)
6981         {
6982           unsigned int reg;
6983           unsigned int nregs;
6984           unsigned int i;
6985           const char *name;
6986           struct
6987           {
6988               unsigned int offset;
6989               unsigned int reg;
6990           } regpos[16];
6991
6992           /* Scan entire instruction first so that GET_OP output is not
6993              interleaved with disassembly.  */
6994           nregs = 0;
6995           for (i = 0; nregs < (op & 0xf); i++)
6996             {
6997               GET_OP (op2);
6998               reg = op2 >> 4;
6999               if (reg != 0xf)
7000                 {
7001                   regpos[nregs].offset = i * 2;
7002                   regpos[nregs].reg = reg;
7003                   nregs++;
7004                 }
7005
7006               reg = op2 & 0xf;
7007               if (reg != 0xf)
7008                 {
7009                   regpos[nregs].offset = i * 2 + 1;
7010                   regpos[nregs].reg = reg;
7011                   nregs++;
7012                 }
7013             }
7014
7015           printf (_("pop frame {"));
7016           reg = nregs - 1;
7017           for (i = i * 2; i > 0; i--)
7018             {
7019               if (regpos[reg].offset == i - 1)
7020                 {
7021                   name = tic6x_unwind_regnames[regpos[reg].reg];
7022                   if (reg > 0)
7023                     reg--;
7024                 }
7025               else
7026                 name = _("[pad]");
7027
7028               fputs (name, stdout);
7029               if (i > 1)
7030                 printf (", ");
7031             }
7032
7033           printf ("}");
7034         }
7035       else if (op == 0xd0)
7036         printf ("     MOV FP, SP");
7037       else if (op == 0xd1)
7038         printf ("     __c6xabi_pop_rts");
7039       else if (op == 0xd2)
7040         {
7041           unsigned char buf[9];
7042           unsigned int i, len;
7043           unsigned long offset;
7044
7045           for (i = 0; i < sizeof (buf); i++)
7046             {
7047               GET_OP (buf[i]);
7048               if ((buf[i] & 0x80) == 0)
7049                 break;
7050             }
7051           assert (i < sizeof (buf));
7052           offset = read_uleb128 (buf, &len);
7053           assert (len == i + 1);
7054           offset = offset * 8 + 0x408;
7055           printf (_("sp = sp + %ld"), offset);
7056         }
7057       else if ((op & 0xf0) == 0xe0)
7058         {
7059           if ((op & 0x0f) == 7)
7060             printf ("     RETURN");
7061           else
7062             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7063         }
7064       else
7065         {
7066           printf (_("     [unsupported opcode]"));
7067         }
7068       putchar ('\n');
7069     }
7070 }
7071
7072 static bfd_vma
7073 arm_expand_prel31 (bfd_vma word, bfd_vma where)
7074 {
7075   bfd_vma offset;
7076
7077   offset = word & 0x7fffffff;
7078   if (offset & 0x40000000)
7079     offset |= ~ (bfd_vma) 0x7fffffff;
7080
7081   if (elf_header.e_machine == EM_TI_C6000)
7082     offset <<= 1;
7083
7084   return offset + where;
7085 }
7086
7087 static void
7088 decode_arm_unwind (struct arm_unw_aux_info *  aux,
7089                    unsigned int               word,
7090                    unsigned int               remaining,
7091                    bfd_vma                    data_offset,
7092                    Elf_Internal_Shdr *        data_sec,
7093                    struct arm_section *       data_arm_sec)
7094 {
7095   int per_index;
7096   unsigned int more_words = 0;
7097   struct absaddr addr;
7098   bfd_vma sym_name = (bfd_vma) -1;
7099
7100   if (remaining == 0)
7101     {
7102       /* Fetch the first word.
7103          Note - when decoding an object file the address extracted
7104          here will always be 0.  So we also pass in the sym_name
7105          parameter so that we can find the symbol associated with
7106          the personality routine.  */
7107       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7108                                      & word, & addr, & sym_name))
7109         return;
7110
7111       remaining = 4;
7112     }
7113
7114   if ((word & 0x80000000) == 0)
7115     {
7116       /* Expand prel31 for personality routine.  */
7117       bfd_vma fn;
7118       const char *procname;
7119
7120       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
7121       printf (_("  Personality routine: "));
7122       if (fn == 0
7123           && addr.section == SHN_UNDEF && addr.offset == 0
7124           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7125         {
7126           procname = aux->strtab + sym_name;
7127           print_vma (fn, PREFIX_HEX);
7128           if (procname)
7129             {
7130               fputs (" <", stdout);
7131               fputs (procname, stdout);
7132               fputc ('>', stdout);
7133             }
7134         }
7135       else
7136         procname = arm_print_vma_and_name (aux, fn, addr);
7137       fputc ('\n', stdout);
7138
7139       /* The GCC personality routines use the standard compact
7140          encoding, starting with one byte giving the number of
7141          words.  */
7142       if (procname != NULL
7143           && (const_strneq (procname, "__gcc_personality_v0")
7144               || const_strneq (procname, "__gxx_personality_v0")
7145               || const_strneq (procname, "__gcj_personality_v0")
7146               || const_strneq (procname, "__gnu_objc_personality_v0")))
7147         {
7148           remaining = 0;
7149           more_words = 1;
7150           ADVANCE;
7151           if (!remaining)
7152             {
7153               printf (_("  [Truncated data]\n"));
7154               return;
7155             }
7156           more_words = word >> 24;
7157           word <<= 8;
7158           remaining--;
7159           per_index = -1;
7160         }
7161       else
7162         return;
7163     }
7164   else
7165     {
7166       /* ARM EHABI Section 6.3:
7167
7168          An exception-handling table entry for the compact model looks like:
7169
7170            31 30-28 27-24 23-0
7171            -- ----- ----- ----
7172             1   0   index Data for personalityRoutine[index]    */
7173
7174       if (elf_header.e_machine == EM_ARM
7175           && (word & 0x70000000))
7176         warn (_("Corrupt ARM compact model table entry: %x \n"), word);
7177
7178       per_index = (word >> 24) & 0x7f;
7179       printf (_("  Compact model index: %d\n"), per_index);
7180       if (per_index == 0)
7181         {
7182           more_words = 0;
7183           word <<= 8;
7184           remaining--;
7185         }
7186       else if (per_index < 3)
7187         {
7188           more_words = (word >> 16) & 0xff;
7189           word <<= 16;
7190           remaining -= 2;
7191         }
7192     }
7193
7194   switch (elf_header.e_machine)
7195     {
7196     case EM_ARM:
7197       if (per_index < 3)
7198         {
7199           decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7200                                       data_offset, data_sec, data_arm_sec);
7201         }
7202       else
7203         {
7204           warn (_("Unknown ARM compact model index encountered\n"));
7205           printf (_("  [reserved]\n"));
7206         }
7207       break;
7208
7209     case EM_TI_C6000:
7210       if (per_index < 3)
7211         {
7212           decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
7213                                         data_offset, data_sec, data_arm_sec);
7214         }
7215       else if (per_index < 5)
7216         {
7217           if (((word >> 17) & 0x7f) == 0x7f)
7218             printf (_("  Restore stack from frame pointer\n"));
7219           else
7220             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
7221           printf (_("  Registers restored: "));
7222           if (per_index == 4)
7223             printf (" (compact) ");
7224           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7225           putchar ('\n');
7226           printf (_("  Return register: %s\n"),
7227                   tic6x_unwind_regnames[word & 0xf]);
7228         }
7229       else
7230         printf (_("  [reserved (%d)]\n"), per_index);
7231       break;
7232
7233     default:
7234       error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7235              elf_header.e_machine);
7236     }
7237
7238   /* Decode the descriptors.  Not implemented.  */
7239 }
7240
7241 static void
7242 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7243 {
7244   struct arm_section exidx_arm_sec, extab_arm_sec;
7245   unsigned int i, exidx_len;
7246
7247   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7248   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7249   exidx_len = exidx_sec->sh_size / 8;
7250
7251   for (i = 0; i < exidx_len; i++)
7252     {
7253       unsigned int exidx_fn, exidx_entry;
7254       struct absaddr fn_addr, entry_addr;
7255       bfd_vma fn;
7256
7257       fputc ('\n', stdout);
7258
7259       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7260                                      8 * i, & exidx_fn, & fn_addr, NULL)
7261           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7262                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
7263         {
7264           arm_free_section (& exidx_arm_sec);
7265           arm_free_section (& extab_arm_sec);
7266           return;
7267         }
7268
7269       /* ARM EHABI, Section 5:
7270          An index table entry consists of 2 words.
7271          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
7272       if (exidx_fn & 0x80000000)
7273         warn (_("corrupt index table entry: %x\n"), exidx_fn);
7274
7275       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
7276
7277       arm_print_vma_and_name (aux, fn, fn_addr);
7278       fputs (": ", stdout);
7279
7280       if (exidx_entry == 1)
7281         {
7282           print_vma (exidx_entry, PREFIX_HEX);
7283           fputs (" [cantunwind]\n", stdout);
7284         }
7285       else if (exidx_entry & 0x80000000)
7286         {
7287           print_vma (exidx_entry, PREFIX_HEX);
7288           fputc ('\n', stdout);
7289           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7290         }
7291       else
7292         {
7293           bfd_vma table, table_offset = 0;
7294           Elf_Internal_Shdr *table_sec;
7295
7296           fputs ("@", stdout);
7297           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
7298           print_vma (table, PREFIX_HEX);
7299           printf ("\n");
7300
7301           /* Locate the matching .ARM.extab.  */
7302           if (entry_addr.section != SHN_UNDEF
7303               && entry_addr.section < elf_header.e_shnum)
7304             {
7305               table_sec = section_headers + entry_addr.section;
7306               table_offset = entry_addr.offset;
7307             }
7308           else
7309             {
7310               table_sec = find_section_by_address (table);
7311               if (table_sec != NULL)
7312                 table_offset = table - table_sec->sh_addr;
7313             }
7314           if (table_sec == NULL)
7315             {
7316               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7317                     (unsigned long) table);
7318               continue;
7319             }
7320           decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7321                              &extab_arm_sec);
7322         }
7323     }
7324
7325   printf ("\n");
7326
7327   arm_free_section (&exidx_arm_sec);
7328   arm_free_section (&extab_arm_sec);
7329 }
7330
7331 /* Used for both ARM and C6X unwinding tables.  */
7332
7333 static void
7334 arm_process_unwind (FILE *file)
7335 {
7336   struct arm_unw_aux_info aux;
7337   Elf_Internal_Shdr *unwsec = NULL;
7338   Elf_Internal_Shdr *strsec;
7339   Elf_Internal_Shdr *sec;
7340   unsigned long i;
7341   unsigned int sec_type;
7342
7343   switch (elf_header.e_machine)
7344     {
7345     case EM_ARM:
7346       sec_type = SHT_ARM_EXIDX;
7347       break;
7348
7349     case EM_TI_C6000:
7350       sec_type = SHT_C6000_UNWIND;
7351       break;
7352
7353     default:
7354       error (_("Unsupported architecture type %d encountered when processing unwind table"),
7355              elf_header.e_machine);
7356       return;
7357     }
7358
7359   if (string_table == NULL)
7360     return;
7361
7362   memset (& aux, 0, sizeof (aux));
7363   aux.file = file;
7364
7365   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7366     {
7367       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7368         {
7369           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7370
7371           strsec = section_headers + sec->sh_link;
7372           assert (aux.strtab == NULL);
7373           aux.strtab = get_data (NULL, file, strsec->sh_offset,
7374                                  1, strsec->sh_size, _("string table"));
7375           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7376         }
7377       else if (sec->sh_type == sec_type)
7378         unwsec = sec;
7379     }
7380
7381   if (unwsec == NULL)
7382     printf (_("\nThere are no unwind sections in this file.\n"));
7383   else
7384     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7385       {
7386         if (sec->sh_type == sec_type)
7387           {
7388             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7389                     SECTION_NAME (sec),
7390                     (unsigned long) sec->sh_offset,
7391                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7392
7393             dump_arm_unwind (&aux, sec);
7394           }
7395       }
7396
7397   if (aux.symtab)
7398     free (aux.symtab);
7399   if (aux.strtab)
7400     free ((char *) aux.strtab);
7401 }
7402
7403 static void
7404 process_unwind (FILE * file)
7405 {
7406   struct unwind_handler
7407   {
7408     int machtype;
7409     void (* handler)(FILE *);
7410   } handlers[] =
7411   {
7412     { EM_ARM, arm_process_unwind },
7413     { EM_IA_64, ia64_process_unwind },
7414     { EM_PARISC, hppa_process_unwind },
7415     { EM_TI_C6000, arm_process_unwind },
7416     { 0, 0 }
7417   };
7418   int i;
7419
7420   if (!do_unwind)
7421     return;
7422
7423   for (i = 0; handlers[i].handler != NULL; i++)
7424     if (elf_header.e_machine == handlers[i].machtype)
7425       return handlers[i].handler (file);
7426
7427   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7428           get_machine_name (elf_header.e_machine));
7429 }
7430
7431 static void
7432 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
7433 {
7434   switch (entry->d_tag)
7435     {
7436     case DT_MIPS_FLAGS:
7437       if (entry->d_un.d_val == 0)
7438         printf (_("NONE"));
7439       else
7440         {
7441           static const char * opts[] =
7442           {
7443             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7444             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7445             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7446             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7447             "RLD_ORDER_SAFE"
7448           };
7449           unsigned int cnt;
7450           int first = 1;
7451
7452           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
7453             if (entry->d_un.d_val & (1 << cnt))
7454               {
7455                 printf ("%s%s", first ? "" : " ", opts[cnt]);
7456                 first = 0;
7457               }
7458         }
7459       break;
7460
7461     case DT_MIPS_IVERSION:
7462       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7463         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
7464       else
7465         printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
7466       break;
7467
7468     case DT_MIPS_TIME_STAMP:
7469       {
7470         char timebuf[20];
7471         struct tm * tmp;
7472
7473         time_t atime = entry->d_un.d_val;
7474         tmp = gmtime (&atime);
7475         snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7476                   tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7477                   tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7478         printf (_("Time Stamp: %s"), timebuf);
7479       }
7480       break;
7481
7482     case DT_MIPS_RLD_VERSION:
7483     case DT_MIPS_LOCAL_GOTNO:
7484     case DT_MIPS_CONFLICTNO:
7485     case DT_MIPS_LIBLISTNO:
7486     case DT_MIPS_SYMTABNO:
7487     case DT_MIPS_UNREFEXTNO:
7488     case DT_MIPS_HIPAGENO:
7489     case DT_MIPS_DELTA_CLASS_NO:
7490     case DT_MIPS_DELTA_INSTANCE_NO:
7491     case DT_MIPS_DELTA_RELOC_NO:
7492     case DT_MIPS_DELTA_SYM_NO:
7493     case DT_MIPS_DELTA_CLASSSYM_NO:
7494     case DT_MIPS_COMPACT_SIZE:
7495       print_vma (entry->d_un.d_ptr, DEC);
7496       break;
7497
7498     default:
7499       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7500     }
7501     putchar ('\n');
7502 }
7503
7504 static void
7505 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
7506 {
7507   switch (entry->d_tag)
7508     {
7509     case DT_HP_DLD_FLAGS:
7510       {
7511         static struct
7512         {
7513           long int bit;
7514           const char * str;
7515         }
7516         flags[] =
7517         {
7518           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7519           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7520           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7521           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7522           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7523           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7524           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7525           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7526           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7527           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
7528           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7529           { DT_HP_GST, "HP_GST" },
7530           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7531           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7532           { DT_HP_NODELETE, "HP_NODELETE" },
7533           { DT_HP_GROUP, "HP_GROUP" },
7534           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
7535         };
7536         int first = 1;
7537         size_t cnt;
7538         bfd_vma val = entry->d_un.d_val;
7539
7540         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
7541           if (val & flags[cnt].bit)
7542             {
7543               if (! first)
7544                 putchar (' ');
7545               fputs (flags[cnt].str, stdout);
7546               first = 0;
7547               val ^= flags[cnt].bit;
7548             }
7549
7550         if (val != 0 || first)
7551           {
7552             if (! first)
7553               putchar (' ');
7554             print_vma (val, HEX);
7555           }
7556       }
7557       break;
7558
7559     default:
7560       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7561       break;
7562     }
7563   putchar ('\n');
7564 }
7565
7566 #ifdef BFD64
7567
7568 /* VMS vs Unix time offset and factor.  */
7569
7570 #define VMS_EPOCH_OFFSET 35067168000000000LL
7571 #define VMS_GRANULARITY_FACTOR 10000000
7572
7573 /* Display a VMS time in a human readable format.  */
7574
7575 static void
7576 print_vms_time (bfd_int64_t vmstime)
7577 {
7578   struct tm *tm;
7579   time_t unxtime;
7580
7581   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7582   tm = gmtime (&unxtime);
7583   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7584           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7585           tm->tm_hour, tm->tm_min, tm->tm_sec);
7586 }
7587 #endif /* BFD64 */
7588
7589 static void
7590 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
7591 {
7592   switch (entry->d_tag)
7593     {
7594     case DT_IA_64_PLT_RESERVE:
7595       /* First 3 slots reserved.  */
7596       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7597       printf (" -- ");
7598       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
7599       break;
7600
7601     case DT_IA_64_VMS_LINKTIME:
7602 #ifdef BFD64
7603       print_vms_time (entry->d_un.d_val);
7604 #endif
7605       break;
7606
7607     case DT_IA_64_VMS_LNKFLAGS:
7608       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7609       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7610         printf (" CALL_DEBUG");
7611       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7612         printf (" NOP0BUFS");
7613       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7614         printf (" P0IMAGE");
7615       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7616         printf (" MKTHREADS");
7617       if (entry->d_un.d_val & VMS_LF_UPCALLS)
7618         printf (" UPCALLS");
7619       if (entry->d_un.d_val & VMS_LF_IMGSTA)
7620         printf (" IMGSTA");
7621       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7622         printf (" INITIALIZE");
7623       if (entry->d_un.d_val & VMS_LF_MAIN)
7624         printf (" MAIN");
7625       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7626         printf (" EXE_INIT");
7627       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7628         printf (" TBK_IN_IMG");
7629       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7630         printf (" DBG_IN_IMG");
7631       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7632         printf (" TBK_IN_DSF");
7633       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7634         printf (" DBG_IN_DSF");
7635       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7636         printf (" SIGNATURES");
7637       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7638         printf (" REL_SEG_OFF");
7639       break;
7640
7641     default:
7642       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7643       break;
7644     }
7645   putchar ('\n');
7646 }
7647
7648 static int
7649 get_32bit_dynamic_section (FILE * file)
7650 {
7651   Elf32_External_Dyn * edyn;
7652   Elf32_External_Dyn * ext;
7653   Elf_Internal_Dyn * entry;
7654
7655   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7656                                           dynamic_size, _("dynamic section"));
7657   if (!edyn)
7658     return 0;
7659
7660 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7661    might not have the luxury of section headers.  Look for the DT_NULL
7662    terminator to determine the number of entries.  */
7663   for (ext = edyn, dynamic_nent = 0;
7664        (char *) ext < (char *) edyn + dynamic_size;
7665        ext++)
7666     {
7667       dynamic_nent++;
7668       if (BYTE_GET (ext->d_tag) == DT_NULL)
7669         break;
7670     }
7671
7672   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7673                                                   sizeof (* entry));
7674   if (dynamic_section == NULL)
7675     {
7676       error (_("Out of memory\n"));
7677       free (edyn);
7678       return 0;
7679     }
7680
7681   for (ext = edyn, entry = dynamic_section;
7682        entry < dynamic_section + dynamic_nent;
7683        ext++, entry++)
7684     {
7685       entry->d_tag      = BYTE_GET (ext->d_tag);
7686       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7687     }
7688
7689   free (edyn);
7690
7691   return 1;
7692 }
7693
7694 static int
7695 get_64bit_dynamic_section (FILE * file)
7696 {
7697   Elf64_External_Dyn * edyn;
7698   Elf64_External_Dyn * ext;
7699   Elf_Internal_Dyn * entry;
7700
7701   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7702                                           dynamic_size, _("dynamic section"));
7703   if (!edyn)
7704     return 0;
7705
7706 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7707    might not have the luxury of section headers.  Look for the DT_NULL
7708    terminator to determine the number of entries.  */
7709   for (ext = edyn, dynamic_nent = 0;
7710        (char *) ext < (char *) edyn + dynamic_size;
7711        ext++)
7712     {
7713       dynamic_nent++;
7714       if (BYTE_GET (ext->d_tag) == DT_NULL)
7715         break;
7716     }
7717
7718   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7719                                                   sizeof (* entry));
7720   if (dynamic_section == NULL)
7721     {
7722       error (_("Out of memory\n"));
7723       free (edyn);
7724       return 0;
7725     }
7726
7727   for (ext = edyn, entry = dynamic_section;
7728        entry < dynamic_section + dynamic_nent;
7729        ext++, entry++)
7730     {
7731       entry->d_tag      = BYTE_GET (ext->d_tag);
7732       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7733     }
7734
7735   free (edyn);
7736
7737   return 1;
7738 }
7739
7740 static void
7741 print_dynamic_flags (bfd_vma flags)
7742 {
7743   int first = 1;
7744
7745   while (flags)
7746     {
7747       bfd_vma flag;
7748
7749       flag = flags & - flags;
7750       flags &= ~ flag;
7751
7752       if (first)
7753         first = 0;
7754       else
7755         putc (' ', stdout);
7756
7757       switch (flag)
7758         {
7759         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
7760         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
7761         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
7762         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
7763         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
7764         default:                fputs (_("unknown"), stdout); break;
7765         }
7766     }
7767   puts ("");
7768 }
7769
7770 /* Parse and display the contents of the dynamic section.  */
7771
7772 static int
7773 process_dynamic_section (FILE * file)
7774 {
7775   Elf_Internal_Dyn * entry;
7776
7777   if (dynamic_size == 0)
7778     {
7779       if (do_dynamic)
7780         printf (_("\nThere is no dynamic section in this file.\n"));
7781
7782       return 1;
7783     }
7784
7785   if (is_32bit_elf)
7786     {
7787       if (! get_32bit_dynamic_section (file))
7788         return 0;
7789     }
7790   else if (! get_64bit_dynamic_section (file))
7791     return 0;
7792
7793   /* Find the appropriate symbol table.  */
7794   if (dynamic_symbols == NULL)
7795     {
7796       for (entry = dynamic_section;
7797            entry < dynamic_section + dynamic_nent;
7798            ++entry)
7799         {
7800           Elf_Internal_Shdr section;
7801
7802           if (entry->d_tag != DT_SYMTAB)
7803             continue;
7804
7805           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7806
7807           /* Since we do not know how big the symbol table is,
7808              we default to reading in the entire file (!) and
7809              processing that.  This is overkill, I know, but it
7810              should work.  */
7811           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
7812
7813           if (archive_file_offset != 0)
7814             section.sh_size = archive_file_size - section.sh_offset;
7815           else
7816             {
7817               if (fseek (file, 0, SEEK_END))
7818                 error (_("Unable to seek to end of file!\n"));
7819
7820               section.sh_size = ftell (file) - section.sh_offset;
7821             }
7822
7823           if (is_32bit_elf)
7824             section.sh_entsize = sizeof (Elf32_External_Sym);
7825           else
7826             section.sh_entsize = sizeof (Elf64_External_Sym);
7827
7828           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
7829           if (num_dynamic_syms < 1)
7830             {
7831               error (_("Unable to determine the number of symbols to load\n"));
7832               continue;
7833             }
7834         }
7835     }
7836
7837   /* Similarly find a string table.  */
7838   if (dynamic_strings == NULL)
7839     {
7840       for (entry = dynamic_section;
7841            entry < dynamic_section + dynamic_nent;
7842            ++entry)
7843         {
7844           unsigned long offset;
7845           long str_tab_len;
7846
7847           if (entry->d_tag != DT_STRTAB)
7848             continue;
7849
7850           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7851
7852           /* Since we do not know how big the string table is,
7853              we default to reading in the entire file (!) and
7854              processing that.  This is overkill, I know, but it
7855              should work.  */
7856
7857           offset = offset_from_vma (file, entry->d_un.d_val, 0);
7858
7859           if (archive_file_offset != 0)
7860             str_tab_len = archive_file_size - offset;
7861           else
7862             {
7863               if (fseek (file, 0, SEEK_END))
7864                 error (_("Unable to seek to end of file\n"));
7865               str_tab_len = ftell (file) - offset;
7866             }
7867
7868           if (str_tab_len < 1)
7869             {
7870               error
7871                 (_("Unable to determine the length of the dynamic string table\n"));
7872               continue;
7873             }
7874
7875           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7876                                                str_tab_len,
7877                                                _("dynamic string table"));
7878           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
7879           break;
7880         }
7881     }
7882
7883   /* And find the syminfo section if available.  */
7884   if (dynamic_syminfo == NULL)
7885     {
7886       unsigned long syminsz = 0;
7887
7888       for (entry = dynamic_section;
7889            entry < dynamic_section + dynamic_nent;
7890            ++entry)
7891         {
7892           if (entry->d_tag == DT_SYMINENT)
7893             {
7894               /* Note: these braces are necessary to avoid a syntax
7895                  error from the SunOS4 C compiler.  */
7896               assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7897             }
7898           else if (entry->d_tag == DT_SYMINSZ)
7899             syminsz = entry->d_un.d_val;
7900           else if (entry->d_tag == DT_SYMINFO)
7901             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7902                                                       syminsz);
7903         }
7904
7905       if (dynamic_syminfo_offset != 0 && syminsz != 0)
7906         {
7907           Elf_External_Syminfo * extsyminfo;
7908           Elf_External_Syminfo * extsym;
7909           Elf_Internal_Syminfo * syminfo;
7910
7911           /* There is a syminfo section.  Read the data.  */
7912           extsyminfo = (Elf_External_Syminfo *)
7913               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7914                         _("symbol information"));
7915           if (!extsyminfo)
7916             return 0;
7917
7918           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
7919           if (dynamic_syminfo == NULL)
7920             {
7921               error (_("Out of memory\n"));
7922               return 0;
7923             }
7924
7925           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
7926           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7927                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7928                ++syminfo, ++extsym)
7929             {
7930               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7931               syminfo->si_flags = BYTE_GET (extsym->si_flags);
7932             }
7933
7934           free (extsyminfo);
7935         }
7936     }
7937
7938   if (do_dynamic && dynamic_addr)
7939     printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7940             dynamic_addr, dynamic_nent);
7941   if (do_dynamic)
7942     printf (_("  Tag        Type                         Name/Value\n"));
7943
7944   for (entry = dynamic_section;
7945        entry < dynamic_section + dynamic_nent;
7946        entry++)
7947     {
7948       if (do_dynamic)
7949         {
7950           const char * dtype;
7951
7952           putchar (' ');
7953           print_vma (entry->d_tag, FULL_HEX);
7954           dtype = get_dynamic_type (entry->d_tag);
7955           printf (" (%s)%*s", dtype,
7956                   ((is_32bit_elf ? 27 : 19)
7957                    - (int) strlen (dtype)),
7958                   " ");
7959         }
7960
7961       switch (entry->d_tag)
7962         {
7963         case DT_FLAGS:
7964           if (do_dynamic)
7965             print_dynamic_flags (entry->d_un.d_val);
7966           break;
7967
7968         case DT_AUXILIARY:
7969         case DT_FILTER:
7970         case DT_CONFIG:
7971         case DT_DEPAUDIT:
7972         case DT_AUDIT:
7973           if (do_dynamic)
7974             {
7975               switch (entry->d_tag)
7976                 {
7977                 case DT_AUXILIARY:
7978                   printf (_("Auxiliary library"));
7979                   break;
7980
7981                 case DT_FILTER:
7982                   printf (_("Filter library"));
7983                   break;
7984
7985                 case DT_CONFIG:
7986                   printf (_("Configuration file"));
7987                   break;
7988
7989                 case DT_DEPAUDIT:
7990                   printf (_("Dependency audit library"));
7991                   break;
7992
7993                 case DT_AUDIT:
7994                   printf (_("Audit library"));
7995                   break;
7996                 }
7997
7998               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7999                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
8000               else
8001                 {
8002                   printf (": ");
8003                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8004                   putchar ('\n');
8005                 }
8006             }
8007           break;
8008
8009         case DT_FEATURE:
8010           if (do_dynamic)
8011             {
8012               printf (_("Flags:"));
8013
8014               if (entry->d_un.d_val == 0)
8015                 printf (_(" None\n"));
8016               else
8017                 {
8018                   unsigned long int val = entry->d_un.d_val;
8019
8020                   if (val & DTF_1_PARINIT)
8021                     {
8022                       printf (" PARINIT");
8023                       val ^= DTF_1_PARINIT;
8024                     }
8025                   if (val & DTF_1_CONFEXP)
8026                     {
8027                       printf (" CONFEXP");
8028                       val ^= DTF_1_CONFEXP;
8029                     }
8030                   if (val != 0)
8031                     printf (" %lx", val);
8032                   puts ("");
8033                 }
8034             }
8035           break;
8036
8037         case DT_POSFLAG_1:
8038           if (do_dynamic)
8039             {
8040               printf (_("Flags:"));
8041
8042               if (entry->d_un.d_val == 0)
8043                 printf (_(" None\n"));
8044               else
8045                 {
8046                   unsigned long int val = entry->d_un.d_val;
8047
8048                   if (val & DF_P1_LAZYLOAD)
8049                     {
8050                       printf (" LAZYLOAD");
8051                       val ^= DF_P1_LAZYLOAD;
8052                     }
8053                   if (val & DF_P1_GROUPPERM)
8054                     {
8055                       printf (" GROUPPERM");
8056                       val ^= DF_P1_GROUPPERM;
8057                     }
8058                   if (val != 0)
8059                     printf (" %lx", val);
8060                   puts ("");
8061                 }
8062             }
8063           break;
8064
8065         case DT_FLAGS_1:
8066           if (do_dynamic)
8067             {
8068               printf (_("Flags:"));
8069               if (entry->d_un.d_val == 0)
8070                 printf (_(" None\n"));
8071               else
8072                 {
8073                   unsigned long int val = entry->d_un.d_val;
8074
8075                   if (val & DF_1_NOW)
8076                     {
8077                       printf (" NOW");
8078                       val ^= DF_1_NOW;
8079                     }
8080                   if (val & DF_1_GLOBAL)
8081                     {
8082                       printf (" GLOBAL");
8083                       val ^= DF_1_GLOBAL;
8084                     }
8085                   if (val & DF_1_GROUP)
8086                     {
8087                       printf (" GROUP");
8088                       val ^= DF_1_GROUP;
8089                     }
8090                   if (val & DF_1_NODELETE)
8091                     {
8092                       printf (" NODELETE");
8093                       val ^= DF_1_NODELETE;
8094                     }
8095                   if (val & DF_1_LOADFLTR)
8096                     {
8097                       printf (" LOADFLTR");
8098                       val ^= DF_1_LOADFLTR;
8099                     }
8100                   if (val & DF_1_INITFIRST)
8101                     {
8102                       printf (" INITFIRST");
8103                       val ^= DF_1_INITFIRST;
8104                     }
8105                   if (val & DF_1_NOOPEN)
8106                     {
8107                       printf (" NOOPEN");
8108                       val ^= DF_1_NOOPEN;
8109                     }
8110                   if (val & DF_1_ORIGIN)
8111                     {
8112                       printf (" ORIGIN");
8113                       val ^= DF_1_ORIGIN;
8114                     }
8115                   if (val & DF_1_DIRECT)
8116                     {
8117                       printf (" DIRECT");
8118                       val ^= DF_1_DIRECT;
8119                     }
8120                   if (val & DF_1_TRANS)
8121                     {
8122                       printf (" TRANS");
8123                       val ^= DF_1_TRANS;
8124                     }
8125                   if (val & DF_1_INTERPOSE)
8126                     {
8127                       printf (" INTERPOSE");
8128                       val ^= DF_1_INTERPOSE;
8129                     }
8130                   if (val & DF_1_NODEFLIB)
8131                     {
8132                       printf (" NODEFLIB");
8133                       val ^= DF_1_NODEFLIB;
8134                     }
8135                   if (val & DF_1_NODUMP)
8136                     {
8137                       printf (" NODUMP");
8138                       val ^= DF_1_NODUMP;
8139                     }
8140                   if (val & DF_1_CONFALT)
8141                     {
8142                       printf (" CONFALT");
8143                       val ^= DF_1_CONFALT;
8144                     }
8145                   if (val & DF_1_ENDFILTEE)
8146                     {
8147                       printf (" ENDFILTEE");
8148                       val ^= DF_1_ENDFILTEE;
8149                     }
8150                   if (val & DF_1_DISPRELDNE)
8151                     {
8152                       printf (" DISPRELDNE");
8153                       val ^= DF_1_DISPRELDNE;
8154                     }
8155                   if (val & DF_1_DISPRELPND)
8156                     {
8157                       printf (" DISPRELPND");
8158                       val ^= DF_1_DISPRELPND;
8159                     }
8160                   if (val & DF_1_NODIRECT)
8161                     {
8162                       printf (" NODIRECT");
8163                       val ^= DF_1_NODIRECT;
8164                     }
8165                   if (val & DF_1_IGNMULDEF)
8166                     {
8167                       printf (" IGNMULDEF");
8168                       val ^= DF_1_IGNMULDEF;
8169                     }
8170                   if (val & DF_1_NOKSYMS)
8171                     {
8172                       printf (" NOKSYMS");
8173                       val ^= DF_1_NOKSYMS;
8174                     }
8175                   if (val & DF_1_NOHDR)
8176                     {
8177                       printf (" NOHDR");
8178                       val ^= DF_1_NOHDR;
8179                     }
8180                   if (val & DF_1_EDITED)
8181                     {
8182                       printf (" EDITED");
8183                       val ^= DF_1_EDITED;
8184                     }
8185                   if (val & DF_1_NORELOC)
8186                     {
8187                       printf (" NORELOC");
8188                       val ^= DF_1_NORELOC;
8189                     }
8190                   if (val & DF_1_SYMINTPOSE)
8191                     {
8192                       printf (" SYMINTPOSE");
8193                       val ^= DF_1_SYMINTPOSE;
8194                     }
8195                   if (val & DF_1_GLOBAUDIT)
8196                     {
8197                       printf (" GLOBAUDIT");
8198                       val ^= DF_1_GLOBAUDIT;
8199                     }
8200                   if (val & DF_1_SINGLETON)
8201                     {
8202                       printf (" SINGLETON");
8203                       val ^= DF_1_SINGLETON;
8204                     }
8205                   if (val != 0)
8206                     printf (" %lx", val);
8207                   puts ("");
8208                 }
8209             }
8210           break;
8211
8212         case DT_PLTREL:
8213           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8214           if (do_dynamic)
8215             puts (get_dynamic_type (entry->d_un.d_val));
8216           break;
8217
8218         case DT_NULL    :
8219         case DT_NEEDED  :
8220         case DT_PLTGOT  :
8221         case DT_HASH    :
8222         case DT_STRTAB  :
8223         case DT_SYMTAB  :
8224         case DT_RELA    :
8225         case DT_INIT    :
8226         case DT_FINI    :
8227         case DT_SONAME  :
8228         case DT_RPATH   :
8229         case DT_SYMBOLIC:
8230         case DT_REL     :
8231         case DT_DEBUG   :
8232         case DT_TEXTREL :
8233         case DT_JMPREL  :
8234         case DT_RUNPATH :
8235           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8236
8237           if (do_dynamic)
8238             {
8239               char * name;
8240
8241               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8242                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8243               else
8244                 name = NULL;
8245
8246               if (name)
8247                 {
8248                   switch (entry->d_tag)
8249                     {
8250                     case DT_NEEDED:
8251                       printf (_("Shared library: [%s]"), name);
8252
8253                       if (streq (name, program_interpreter))
8254                         printf (_(" program interpreter"));
8255                       break;
8256
8257                     case DT_SONAME:
8258                       printf (_("Library soname: [%s]"), name);
8259                       break;
8260
8261                     case DT_RPATH:
8262                       printf (_("Library rpath: [%s]"), name);
8263                       break;
8264
8265                     case DT_RUNPATH:
8266                       printf (_("Library runpath: [%s]"), name);
8267                       break;
8268
8269                     default:
8270                       print_vma (entry->d_un.d_val, PREFIX_HEX);
8271                       break;
8272                     }
8273                 }
8274               else
8275                 print_vma (entry->d_un.d_val, PREFIX_HEX);
8276
8277               putchar ('\n');
8278             }
8279           break;
8280
8281         case DT_PLTRELSZ:
8282         case DT_RELASZ  :
8283         case DT_STRSZ   :
8284         case DT_RELSZ   :
8285         case DT_RELAENT :
8286         case DT_SYMENT  :
8287         case DT_RELENT  :
8288           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8289         case DT_PLTPADSZ:
8290         case DT_MOVEENT :
8291         case DT_MOVESZ  :
8292         case DT_INIT_ARRAYSZ:
8293         case DT_FINI_ARRAYSZ:
8294         case DT_GNU_CONFLICTSZ:
8295         case DT_GNU_LIBLISTSZ:
8296           if (do_dynamic)
8297             {
8298               print_vma (entry->d_un.d_val, UNSIGNED);
8299               printf (_(" (bytes)\n"));
8300             }
8301           break;
8302
8303         case DT_VERDEFNUM:
8304         case DT_VERNEEDNUM:
8305         case DT_RELACOUNT:
8306         case DT_RELCOUNT:
8307           if (do_dynamic)
8308             {
8309               print_vma (entry->d_un.d_val, UNSIGNED);
8310               putchar ('\n');
8311             }
8312           break;
8313
8314         case DT_SYMINSZ:
8315         case DT_SYMINENT:
8316         case DT_SYMINFO:
8317         case DT_USED:
8318         case DT_INIT_ARRAY:
8319         case DT_FINI_ARRAY:
8320           if (do_dynamic)
8321             {
8322               if (entry->d_tag == DT_USED
8323                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
8324                 {
8325                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8326
8327                   if (*name)
8328                     {
8329                       printf (_("Not needed object: [%s]\n"), name);
8330                       break;
8331                     }
8332                 }
8333
8334               print_vma (entry->d_un.d_val, PREFIX_HEX);
8335               putchar ('\n');
8336             }
8337           break;
8338
8339         case DT_BIND_NOW:
8340           /* The value of this entry is ignored.  */
8341           if (do_dynamic)
8342             putchar ('\n');
8343           break;
8344
8345         case DT_GNU_PRELINKED:
8346           if (do_dynamic)
8347             {
8348               struct tm * tmp;
8349               time_t atime = entry->d_un.d_val;
8350
8351               tmp = gmtime (&atime);
8352               printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8353                       tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8354                       tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8355
8356             }
8357           break;
8358
8359         case DT_GNU_HASH:
8360           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8361           if (do_dynamic)
8362             {
8363               print_vma (entry->d_un.d_val, PREFIX_HEX);
8364               putchar ('\n');
8365             }
8366           break;
8367
8368         default:
8369           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
8370             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
8371               entry->d_un.d_val;
8372
8373           if (do_dynamic)
8374             {
8375               switch (elf_header.e_machine)
8376                 {
8377                 case EM_MIPS:
8378                 case EM_MIPS_RS3_LE:
8379                   dynamic_section_mips_val (entry);
8380                   break;
8381                 case EM_PARISC:
8382                   dynamic_section_parisc_val (entry);
8383                   break;
8384                 case EM_IA_64:
8385                   dynamic_section_ia64_val (entry);
8386                   break;
8387                 default:
8388                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8389                   putchar ('\n');
8390                 }
8391             }
8392           break;
8393         }
8394     }
8395
8396   return 1;
8397 }
8398
8399 static char *
8400 get_ver_flags (unsigned int flags)
8401 {
8402   static char buff[32];
8403
8404   buff[0] = 0;
8405
8406   if (flags == 0)
8407     return _("none");
8408
8409   if (flags & VER_FLG_BASE)
8410     strcat (buff, "BASE ");
8411
8412   if (flags & VER_FLG_WEAK)
8413     {
8414       if (flags & VER_FLG_BASE)
8415         strcat (buff, "| ");
8416
8417       strcat (buff, "WEAK ");
8418     }
8419
8420   if (flags & VER_FLG_INFO)
8421     {
8422       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8423         strcat (buff, "| ");
8424
8425       strcat (buff, "INFO ");
8426     }
8427
8428   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
8429     strcat (buff, _("| <unknown>"));
8430
8431   return buff;
8432 }
8433
8434 /* Display the contents of the version sections.  */
8435
8436 static int
8437 process_version_sections (FILE * file)
8438 {
8439   Elf_Internal_Shdr * section;
8440   unsigned i;
8441   int found = 0;
8442
8443   if (! do_version)
8444     return 1;
8445
8446   for (i = 0, section = section_headers;
8447        i < elf_header.e_shnum;
8448        i++, section++)
8449     {
8450       switch (section->sh_type)
8451         {
8452         case SHT_GNU_verdef:
8453           {
8454             Elf_External_Verdef * edefs;
8455             unsigned int idx;
8456             unsigned int cnt;
8457             char * endbuf;
8458
8459             found = 1;
8460
8461             printf
8462               (_("\nVersion definition section '%s' contains %u entries:\n"),
8463                SECTION_NAME (section), section->sh_info);
8464
8465             printf (_("  Addr: 0x"));
8466             printf_vma (section->sh_addr);
8467             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8468                     (unsigned long) section->sh_offset, section->sh_link,
8469                     section->sh_link < elf_header.e_shnum
8470                     ? SECTION_NAME (section_headers + section->sh_link)
8471                     : _("<corrupt>"));
8472
8473             edefs = (Elf_External_Verdef *)
8474                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8475                           _("version definition section"));
8476             if (!edefs)
8477               break;
8478             endbuf = (char *) edefs + section->sh_size;
8479
8480             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8481               {
8482                 char * vstart;
8483                 Elf_External_Verdef * edef;
8484                 Elf_Internal_Verdef ent;
8485                 Elf_External_Verdaux * eaux;
8486                 Elf_Internal_Verdaux aux;
8487                 int j;
8488                 int isum;
8489
8490                 /* Check for very large indicies.  */
8491                 if (idx > (size_t) (endbuf - (char *) edefs))
8492                   break;
8493
8494                 vstart = ((char *) edefs) + idx;
8495                 if (vstart + sizeof (*edef) > endbuf)
8496                   break;
8497
8498                 edef = (Elf_External_Verdef *) vstart;
8499
8500                 ent.vd_version = BYTE_GET (edef->vd_version);
8501                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
8502                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
8503                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
8504                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
8505                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
8506                 ent.vd_next    = BYTE_GET (edef->vd_next);
8507
8508                 printf (_("  %#06x: Rev: %d  Flags: %s"),
8509                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8510
8511                 printf (_("  Index: %d  Cnt: %d  "),
8512                         ent.vd_ndx, ent.vd_cnt);
8513
8514                 /* Check for overflow.  */
8515                 if (ent.vd_aux > (size_t) (endbuf - vstart))
8516                   break;
8517
8518                 vstart += ent.vd_aux;
8519
8520                 eaux = (Elf_External_Verdaux *) vstart;
8521
8522                 aux.vda_name = BYTE_GET (eaux->vda_name);
8523                 aux.vda_next = BYTE_GET (eaux->vda_next);
8524
8525                 if (VALID_DYNAMIC_NAME (aux.vda_name))
8526                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
8527                 else
8528                   printf (_("Name index: %ld\n"), aux.vda_name);
8529
8530                 isum = idx + ent.vd_aux;
8531
8532                 for (j = 1; j < ent.vd_cnt; j++)
8533                   {
8534                     /* Check for overflow.  */
8535                     if (aux.vda_next > (size_t) (endbuf - vstart))
8536                       break;
8537
8538                     isum   += aux.vda_next;
8539                     vstart += aux.vda_next;
8540
8541                     eaux = (Elf_External_Verdaux *) vstart;
8542                     if (vstart + sizeof (*eaux) > endbuf)
8543                       break;
8544
8545                     aux.vda_name = BYTE_GET (eaux->vda_name);
8546                     aux.vda_next = BYTE_GET (eaux->vda_next);
8547
8548                     if (VALID_DYNAMIC_NAME (aux.vda_name))
8549                       printf (_("  %#06x: Parent %d: %s\n"),
8550                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
8551                     else
8552                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
8553                               isum, j, aux.vda_name);
8554                   }
8555
8556                 if (j < ent.vd_cnt)
8557                   printf (_("  Version def aux past end of section\n"));
8558
8559                 idx += ent.vd_next;
8560               }
8561
8562             if (cnt < section->sh_info)
8563               printf (_("  Version definition past end of section\n"));
8564
8565             free (edefs);
8566           }
8567           break;
8568
8569         case SHT_GNU_verneed:
8570           {
8571             Elf_External_Verneed * eneed;
8572             unsigned int idx;
8573             unsigned int cnt;
8574             char * endbuf;
8575
8576             found = 1;
8577
8578             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8579                     SECTION_NAME (section), section->sh_info);
8580
8581             printf (_(" Addr: 0x"));
8582             printf_vma (section->sh_addr);
8583             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8584                     (unsigned long) section->sh_offset, section->sh_link,
8585                     section->sh_link < elf_header.e_shnum
8586                     ? SECTION_NAME (section_headers + section->sh_link)
8587                     : _("<corrupt>"));
8588
8589             eneed = (Elf_External_Verneed *) get_data (NULL, file,
8590                                                        section->sh_offset, 1,
8591                                                        section->sh_size,
8592                                                        _("Version Needs section"));
8593             if (!eneed)
8594               break;
8595             endbuf = (char *) eneed + section->sh_size;
8596
8597             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8598               {
8599                 Elf_External_Verneed * entry;
8600                 Elf_Internal_Verneed ent;
8601                 int j;
8602                 int isum;
8603                 char * vstart;
8604
8605                 if (idx > (size_t) (endbuf - (char *) eneed))
8606                   break;
8607
8608                 vstart = ((char *) eneed) + idx;
8609                 if (vstart + sizeof (*entry) > endbuf)
8610                   break;
8611
8612                 entry = (Elf_External_Verneed *) vstart;
8613
8614                 ent.vn_version = BYTE_GET (entry->vn_version);
8615                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
8616                 ent.vn_file    = BYTE_GET (entry->vn_file);
8617                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
8618                 ent.vn_next    = BYTE_GET (entry->vn_next);
8619
8620                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
8621
8622                 if (VALID_DYNAMIC_NAME (ent.vn_file))
8623                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
8624                 else
8625                   printf (_("  File: %lx"), ent.vn_file);
8626
8627                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
8628
8629                 /* Check for overflow.  */
8630                 if (ent.vn_aux > (size_t) (endbuf - vstart))
8631                   break;
8632
8633                 vstart += ent.vn_aux;
8634
8635                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8636                   {
8637                     Elf_External_Vernaux * eaux;
8638                     Elf_Internal_Vernaux aux;
8639
8640                     if (vstart + sizeof (*eaux) > endbuf)
8641                       break;
8642                     eaux = (Elf_External_Vernaux *) vstart;
8643
8644                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
8645                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
8646                     aux.vna_other = BYTE_GET (eaux->vna_other);
8647                     aux.vna_name  = BYTE_GET (eaux->vna_name);
8648                     aux.vna_next  = BYTE_GET (eaux->vna_next);
8649
8650                     if (VALID_DYNAMIC_NAME (aux.vna_name))
8651                       printf (_("  %#06x:   Name: %s"),
8652                               isum, GET_DYNAMIC_NAME (aux.vna_name));
8653                     else
8654                       printf (_("  %#06x:   Name index: %lx"),
8655                               isum, aux.vna_name);
8656
8657                     printf (_("  Flags: %s  Version: %d\n"),
8658                             get_ver_flags (aux.vna_flags), aux.vna_other);
8659
8660                     /* Check for overflow.  */
8661                     if (aux.vna_next > (size_t) (endbuf - vstart))
8662                       break;
8663
8664                     isum   += aux.vna_next;
8665                     vstart += aux.vna_next;
8666                   }
8667
8668                 if (j < ent.vn_cnt)
8669                   warn (_("Missing Version Needs auxillary information\n"));
8670
8671                 idx += ent.vn_next;
8672               }
8673
8674             if (cnt < section->sh_info)
8675               warn (_("Missing Version Needs information\n"));
8676
8677             free (eneed);
8678           }
8679           break;
8680
8681         case SHT_GNU_versym:
8682           {
8683             Elf_Internal_Shdr * link_section;
8684             int total;
8685             int cnt;
8686             unsigned char * edata;
8687             unsigned short * data;
8688             char * strtab;
8689             Elf_Internal_Sym * symbols;
8690             Elf_Internal_Shdr * string_sec;
8691             unsigned long num_syms;
8692             long off;
8693
8694             if (section->sh_link >= elf_header.e_shnum)
8695               break;
8696
8697             link_section = section_headers + section->sh_link;
8698             total = section->sh_size / sizeof (Elf_External_Versym);
8699
8700             if (link_section->sh_link >= elf_header.e_shnum)
8701               break;
8702
8703             found = 1;
8704
8705             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
8706             if (symbols == NULL)
8707               break;
8708
8709             string_sec = section_headers + link_section->sh_link;
8710
8711             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8712                                         string_sec->sh_size,
8713                                         _("version string table"));
8714             if (!strtab)
8715               {
8716                 free (symbols);
8717                 break;
8718               }
8719
8720             printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8721                     SECTION_NAME (section), total);
8722
8723             printf (_(" Addr: "));
8724             printf_vma (section->sh_addr);
8725             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8726                     (unsigned long) section->sh_offset, section->sh_link,
8727                     SECTION_NAME (link_section));
8728
8729             off = offset_from_vma (file,
8730                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8731                                    total * sizeof (short));
8732             edata = (unsigned char *) get_data (NULL, file, off, total,
8733                                                 sizeof (short),
8734                                                 _("version symbol data"));
8735             if (!edata)
8736               {
8737                 free (strtab);
8738                 free (symbols);
8739                 break;
8740               }
8741
8742             data = (short unsigned int *) cmalloc (total, sizeof (short));
8743
8744             for (cnt = total; cnt --;)
8745               data[cnt] = byte_get (edata + cnt * sizeof (short),
8746                                     sizeof (short));
8747
8748             free (edata);
8749
8750             for (cnt = 0; cnt < total; cnt += 4)
8751               {
8752                 int j, nn;
8753                 int check_def, check_need;
8754                 char * name;
8755
8756                 printf ("  %03x:", cnt);
8757
8758                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
8759                   switch (data[cnt + j])
8760                     {
8761                     case 0:
8762                       fputs (_("   0 (*local*)    "), stdout);
8763                       break;
8764
8765                     case 1:
8766                       fputs (_("   1 (*global*)   "), stdout);
8767                       break;
8768
8769                     default:
8770                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8771                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
8772
8773                       /* If this index value is greater than the size of the symbols
8774                          array, break to avoid an out-of-bounds read.  */
8775                       if ((unsigned long)(cnt + j) >= num_syms)
8776                         {
8777                           warn (_("invalid index into symbol array\n"));
8778                           break;
8779                         }
8780
8781                       check_def = 1;
8782                       check_need = 1;
8783                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8784                           || section_headers[symbols[cnt + j].st_shndx].sh_type
8785                              != SHT_NOBITS)
8786                         {
8787                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
8788                             check_def = 0;
8789                           else
8790                             check_need = 0;
8791                         }
8792
8793                       if (check_need
8794                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
8795                         {
8796                           Elf_Internal_Verneed ivn;
8797                           unsigned long offset;
8798
8799                           offset = offset_from_vma
8800                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8801                              sizeof (Elf_External_Verneed));
8802
8803                           do
8804                             {
8805                               Elf_Internal_Vernaux ivna;
8806                               Elf_External_Verneed evn;
8807                               Elf_External_Vernaux evna;
8808                               unsigned long a_off;
8809
8810                               if (get_data (&evn, file, offset, sizeof (evn), 1,
8811                                             _("version need")) == NULL)
8812                                 break;
8813
8814                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
8815                               ivn.vn_next = BYTE_GET (evn.vn_next);
8816
8817                               a_off = offset + ivn.vn_aux;
8818
8819                               do
8820                                 {
8821                                   if (get_data (&evna, file, a_off, sizeof (evna),
8822                                                 1, _("version need aux (2)")) == NULL)
8823                                     {
8824                                       ivna.vna_next  = 0;
8825                                       ivna.vna_other = 0;
8826                                     }
8827                                   else
8828                                     {
8829                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
8830                                       ivna.vna_other = BYTE_GET (evna.vna_other);
8831                                     }
8832
8833                                   a_off += ivna.vna_next;
8834                                 }
8835                               while (ivna.vna_other != data[cnt + j]
8836                                      && ivna.vna_next != 0);
8837
8838                               if (ivna.vna_other == data[cnt + j])
8839                                 {
8840                                   ivna.vna_name = BYTE_GET (evna.vna_name);
8841
8842                                   if (ivna.vna_name >= string_sec->sh_size)
8843                                     name = _("*invalid*");
8844                                   else
8845                                     name = strtab + ivna.vna_name;
8846                                   nn += printf ("(%s%-*s",
8847                                                 name,
8848                                                 12 - (int) strlen (name),
8849                                                 ")");
8850                                   check_def = 0;
8851                                   break;
8852                                 }
8853
8854                               offset += ivn.vn_next;
8855                             }
8856                           while (ivn.vn_next);
8857                         }
8858
8859                       if (check_def && data[cnt + j] != 0x8001
8860                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8861                         {
8862                           Elf_Internal_Verdef ivd;
8863                           Elf_External_Verdef evd;
8864                           unsigned long offset;
8865
8866                           offset = offset_from_vma
8867                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8868                              sizeof evd);
8869
8870                           do
8871                             {
8872                               if (get_data (&evd, file, offset, sizeof (evd), 1,
8873                                             _("version def")) == NULL)
8874                                 {
8875                                   ivd.vd_next = 0;
8876                                   ivd.vd_ndx  = 0;
8877                                 }
8878                               else
8879                                 {
8880                                   ivd.vd_next = BYTE_GET (evd.vd_next);
8881                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
8882                                 }
8883
8884                               offset += ivd.vd_next;
8885                             }
8886                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
8887                                  && ivd.vd_next != 0);
8888
8889                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
8890                             {
8891                               Elf_External_Verdaux evda;
8892                               Elf_Internal_Verdaux ivda;
8893
8894                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
8895
8896                               if (get_data (&evda, file,
8897                                             offset - ivd.vd_next + ivd.vd_aux,
8898                                             sizeof (evda), 1,
8899                                             _("version def aux")) == NULL)
8900                                 break;
8901
8902                               ivda.vda_name = BYTE_GET (evda.vda_name);
8903
8904                               if (ivda.vda_name >= string_sec->sh_size)
8905                                 name = _("*invalid*");
8906                               else
8907                                 name = strtab + ivda.vda_name;
8908                               nn += printf ("(%s%-*s",
8909                                             name,
8910                                             12 - (int) strlen (name),
8911                                             ")");
8912                             }
8913                         }
8914
8915                       if (nn < 18)
8916                         printf ("%*c", 18 - nn, ' ');
8917                     }
8918
8919                 putchar ('\n');
8920               }
8921
8922             free (data);
8923             free (strtab);
8924             free (symbols);
8925           }
8926           break;
8927
8928         default:
8929           break;
8930         }
8931     }
8932
8933   if (! found)
8934     printf (_("\nNo version information found in this file.\n"));
8935
8936   return 1;
8937 }
8938
8939 static const char *
8940 get_symbol_binding (unsigned int binding)
8941 {
8942   static char buff[32];
8943
8944   switch (binding)
8945     {
8946     case STB_LOCAL:     return "LOCAL";
8947     case STB_GLOBAL:    return "GLOBAL";
8948     case STB_WEAK:      return "WEAK";
8949     default:
8950       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
8951         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8952                   binding);
8953       else if (binding >= STB_LOOS && binding <= STB_HIOS)
8954         {
8955           if (binding == STB_GNU_UNIQUE
8956               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8957                   /* GNU is still using the default value 0.  */
8958                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8959             return "UNIQUE";
8960           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8961         }
8962       else
8963         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
8964       return buff;
8965     }
8966 }
8967
8968 static const char *
8969 get_symbol_type (unsigned int type)
8970 {
8971   static char buff[32];
8972
8973   switch (type)
8974     {
8975     case STT_NOTYPE:    return "NOTYPE";
8976     case STT_OBJECT:    return "OBJECT";
8977     case STT_FUNC:      return "FUNC";
8978     case STT_SECTION:   return "SECTION";
8979     case STT_FILE:      return "FILE";
8980     case STT_COMMON:    return "COMMON";
8981     case STT_TLS:       return "TLS";
8982     case STT_RELC:      return "RELC";
8983     case STT_SRELC:     return "SRELC";
8984     default:
8985       if (type >= STT_LOPROC && type <= STT_HIPROC)
8986         {
8987           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
8988             return "THUMB_FUNC";
8989
8990           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
8991             return "REGISTER";
8992
8993           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8994             return "PARISC_MILLI";
8995
8996           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
8997         }
8998       else if (type >= STT_LOOS && type <= STT_HIOS)
8999         {
9000           if (elf_header.e_machine == EM_PARISC)
9001             {
9002               if (type == STT_HP_OPAQUE)
9003                 return "HP_OPAQUE";
9004               if (type == STT_HP_STUB)
9005                 return "HP_STUB";
9006             }
9007
9008           if (type == STT_GNU_IFUNC
9009               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9010                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9011                   /* GNU is still using the default value 0.  */
9012                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9013             return "IFUNC";
9014
9015           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
9016         }
9017       else
9018         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
9019       return buff;
9020     }
9021 }
9022
9023 static const char *
9024 get_symbol_visibility (unsigned int visibility)
9025 {
9026   switch (visibility)
9027     {
9028     case STV_DEFAULT:   return "DEFAULT";
9029     case STV_INTERNAL:  return "INTERNAL";
9030     case STV_HIDDEN:    return "HIDDEN";
9031     case STV_PROTECTED: return "PROTECTED";
9032     default: abort ();
9033     }
9034 }
9035
9036 static const char *
9037 get_mips_symbol_other (unsigned int other)
9038 {
9039   switch (other)
9040     {
9041     case STO_OPTIONAL:
9042       return "OPTIONAL";
9043     case STO_MIPS_PLT:
9044       return "MIPS PLT";
9045     case STO_MIPS_PIC:
9046       return "MIPS PIC";
9047     case STO_MICROMIPS:
9048       return "MICROMIPS";
9049     case STO_MICROMIPS | STO_MIPS_PIC:
9050       return "MICROMIPS, MIPS PIC";
9051     case STO_MIPS16:
9052       return "MIPS16";
9053     default:
9054       return NULL;
9055     }
9056 }
9057
9058 static const char *
9059 get_ia64_symbol_other (unsigned int other)
9060 {
9061   if (is_ia64_vms ())
9062     {
9063       static char res[32];
9064
9065       res[0] = 0;
9066
9067       /* Function types is for images and .STB files only.  */
9068       switch (elf_header.e_type)
9069         {
9070         case ET_DYN:
9071         case ET_EXEC:
9072           switch (VMS_ST_FUNC_TYPE (other))
9073             {
9074             case VMS_SFT_CODE_ADDR:
9075               strcat (res, " CA");
9076               break;
9077             case VMS_SFT_SYMV_IDX:
9078               strcat (res, " VEC");
9079               break;
9080             case VMS_SFT_FD:
9081               strcat (res, " FD");
9082               break;
9083             case VMS_SFT_RESERVE:
9084               strcat (res, " RSV");
9085               break;
9086             default:
9087               abort ();
9088             }
9089           break;
9090         default:
9091           break;
9092         }
9093       switch (VMS_ST_LINKAGE (other))
9094         {
9095         case VMS_STL_IGNORE:
9096           strcat (res, " IGN");
9097           break;
9098         case VMS_STL_RESERVE:
9099           strcat (res, " RSV");
9100           break;
9101         case VMS_STL_STD:
9102           strcat (res, " STD");
9103           break;
9104         case VMS_STL_LNK:
9105           strcat (res, " LNK");
9106           break;
9107         default:
9108           abort ();
9109         }
9110
9111       if (res[0] != 0)
9112         return res + 1;
9113       else
9114         return res;
9115     }
9116   return NULL;
9117 }
9118
9119 static const char *
9120 get_symbol_other (unsigned int other)
9121 {
9122   const char * result = NULL;
9123   static char buff [32];
9124
9125   if (other == 0)
9126     return "";
9127
9128   switch (elf_header.e_machine)
9129     {
9130     case EM_MIPS:
9131       result = get_mips_symbol_other (other);
9132       break;
9133     case EM_IA_64:
9134       result = get_ia64_symbol_other (other);
9135       break;
9136     default:
9137       break;
9138     }
9139
9140   if (result)
9141     return result;
9142
9143   snprintf (buff, sizeof buff, _("<other>: %x"), other);
9144   return buff;
9145 }
9146
9147 static const char *
9148 get_symbol_index_type (unsigned int type)
9149 {
9150   static char buff[32];
9151
9152   switch (type)
9153     {
9154     case SHN_UNDEF:     return "UND";
9155     case SHN_ABS:       return "ABS";
9156     case SHN_COMMON:    return "COM";
9157     default:
9158       if (type == SHN_IA_64_ANSI_COMMON
9159           && elf_header.e_machine == EM_IA_64
9160           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9161         return "ANSI_COM";
9162       else if ((elf_header.e_machine == EM_X86_64
9163                 || elf_header.e_machine == EM_L1OM
9164                 || elf_header.e_machine == EM_K1OM)
9165                && type == SHN_X86_64_LCOMMON)
9166         return "LARGE_COM";
9167       else if ((type == SHN_MIPS_SCOMMON
9168                 && elf_header.e_machine == EM_MIPS)
9169                || (type == SHN_TIC6X_SCOMMON
9170                    && elf_header.e_machine == EM_TI_C6000))
9171         return "SCOM";
9172       else if (type == SHN_MIPS_SUNDEFINED
9173                && elf_header.e_machine == EM_MIPS)
9174         return "SUND";
9175       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
9176         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
9177       else if (type >= SHN_LOOS && type <= SHN_HIOS)
9178         sprintf (buff, "OS [0x%04x]", type & 0xffff);
9179       else if (type >= SHN_LORESERVE)
9180         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
9181       else if (type >= elf_header.e_shnum)
9182         sprintf (buff, "bad section index[%3d]", type);
9183       else
9184         sprintf (buff, "%3d", type);
9185       break;
9186     }
9187
9188   return buff;
9189 }
9190
9191 static bfd_vma *
9192 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
9193 {
9194   unsigned char * e_data;
9195   bfd_vma * i_data;
9196
9197   e_data = (unsigned char *) cmalloc (number, ent_size);
9198
9199   if (e_data == NULL)
9200     {
9201       error (_("Out of memory\n"));
9202       return NULL;
9203     }
9204
9205   if (fread (e_data, ent_size, number, file) != number)
9206     {
9207       error (_("Unable to read in dynamic data\n"));
9208       return NULL;
9209     }
9210
9211   i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
9212
9213   if (i_data == NULL)
9214     {
9215       error (_("Out of memory\n"));
9216       free (e_data);
9217       return NULL;
9218     }
9219
9220   while (number--)
9221     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
9222
9223   free (e_data);
9224
9225   return i_data;
9226 }
9227
9228 static void
9229 print_dynamic_symbol (bfd_vma si, unsigned long hn)
9230 {
9231   Elf_Internal_Sym * psym;
9232   int n;
9233
9234   psym = dynamic_symbols + si;
9235
9236   n = print_vma (si, DEC_5);
9237   if (n < 5)
9238     fputs ("     " + n, stdout);
9239   printf (" %3lu: ", hn);
9240   print_vma (psym->st_value, LONG_HEX);
9241   putchar (' ');
9242   print_vma (psym->st_size, DEC_5);
9243
9244   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9245   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9246   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9247   /* Check to see if any other bits in the st_other field are set.
9248      Note - displaying this information disrupts the layout of the
9249      table being generated, but for the moment this case is very
9250      rare.  */
9251   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9252     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9253   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9254   if (VALID_DYNAMIC_NAME (psym->st_name))
9255     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9256   else
9257     printf (_(" <corrupt: %14ld>"), psym->st_name);
9258   putchar ('\n');
9259 }
9260
9261 /* Dump the symbol table.  */
9262 static int
9263 process_symbol_table (FILE * file)
9264 {
9265   Elf_Internal_Shdr * section;
9266   bfd_vma nbuckets = 0;
9267   bfd_vma nchains = 0;
9268   bfd_vma * buckets = NULL;
9269   bfd_vma * chains = NULL;
9270   bfd_vma ngnubuckets = 0;
9271   bfd_vma * gnubuckets = NULL;
9272   bfd_vma * gnuchains = NULL;
9273   bfd_vma gnusymidx = 0;
9274
9275   if (!do_syms && !do_dyn_syms && !do_histogram)
9276     return 1;
9277
9278   if (dynamic_info[DT_HASH]
9279       && (do_histogram
9280           || (do_using_dynamic
9281               && !do_dyn_syms
9282               && dynamic_strings != NULL)))
9283     {
9284       unsigned char nb[8];
9285       unsigned char nc[8];
9286       int hash_ent_size = 4;
9287
9288       if ((elf_header.e_machine == EM_ALPHA
9289            || elf_header.e_machine == EM_S390
9290            || elf_header.e_machine == EM_S390_OLD)
9291           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9292         hash_ent_size = 8;
9293
9294       if (fseek (file,
9295                  (archive_file_offset
9296                   + offset_from_vma (file, dynamic_info[DT_HASH],
9297                                      sizeof nb + sizeof nc)),
9298                  SEEK_SET))
9299         {
9300           error (_("Unable to seek to start of dynamic information\n"));
9301           goto no_hash;
9302         }
9303
9304       if (fread (nb, hash_ent_size, 1, file) != 1)
9305         {
9306           error (_("Failed to read in number of buckets\n"));
9307           goto no_hash;
9308         }
9309
9310       if (fread (nc, hash_ent_size, 1, file) != 1)
9311         {
9312           error (_("Failed to read in number of chains\n"));
9313           goto no_hash;
9314         }
9315
9316       nbuckets = byte_get (nb, hash_ent_size);
9317       nchains  = byte_get (nc, hash_ent_size);
9318
9319       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9320       chains  = get_dynamic_data (file, nchains, hash_ent_size);
9321
9322     no_hash:
9323       if (buckets == NULL || chains == NULL)
9324         {
9325           if (do_using_dynamic)
9326             return 0;
9327           free (buckets);
9328           free (chains);
9329           buckets = NULL;
9330           chains = NULL;
9331           nbuckets = 0;
9332           nchains = 0;
9333         }
9334     }
9335
9336   if (dynamic_info_DT_GNU_HASH
9337       && (do_histogram
9338           || (do_using_dynamic
9339               && !do_dyn_syms
9340               && dynamic_strings != NULL)))
9341     {
9342       unsigned char nb[16];
9343       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9344       bfd_vma buckets_vma;
9345
9346       if (fseek (file,
9347                  (archive_file_offset
9348                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9349                                      sizeof nb)),
9350                  SEEK_SET))
9351         {
9352           error (_("Unable to seek to start of dynamic information\n"));
9353           goto no_gnu_hash;
9354         }
9355
9356       if (fread (nb, 16, 1, file) != 1)
9357         {
9358           error (_("Failed to read in number of buckets\n"));
9359           goto no_gnu_hash;
9360         }
9361
9362       ngnubuckets = byte_get (nb, 4);
9363       gnusymidx = byte_get (nb + 4, 4);
9364       bitmaskwords = byte_get (nb + 8, 4);
9365       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
9366       if (is_32bit_elf)
9367         buckets_vma += bitmaskwords * 4;
9368       else
9369         buckets_vma += bitmaskwords * 8;
9370
9371       if (fseek (file,
9372                  (archive_file_offset
9373                   + offset_from_vma (file, buckets_vma, 4)),
9374                  SEEK_SET))
9375         {
9376           error (_("Unable to seek to start of dynamic information\n"));
9377           goto no_gnu_hash;
9378         }
9379
9380       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
9381
9382       if (gnubuckets == NULL)
9383         goto no_gnu_hash;
9384
9385       for (i = 0; i < ngnubuckets; i++)
9386         if (gnubuckets[i] != 0)
9387           {
9388             if (gnubuckets[i] < gnusymidx)
9389               return 0;
9390
9391             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9392               maxchain = gnubuckets[i];
9393           }
9394
9395       if (maxchain == 0xffffffff)
9396         goto no_gnu_hash;
9397
9398       maxchain -= gnusymidx;
9399
9400       if (fseek (file,
9401                  (archive_file_offset
9402                   + offset_from_vma (file, buckets_vma
9403                                            + 4 * (ngnubuckets + maxchain), 4)),
9404                  SEEK_SET))
9405         {
9406           error (_("Unable to seek to start of dynamic information\n"));
9407           goto no_gnu_hash;
9408         }
9409
9410       do
9411         {
9412           if (fread (nb, 4, 1, file) != 1)
9413             {
9414               error (_("Failed to determine last chain length\n"));
9415               goto no_gnu_hash;
9416             }
9417
9418           if (maxchain + 1 == 0)
9419             goto no_gnu_hash;
9420
9421           ++maxchain;
9422         }
9423       while ((byte_get (nb, 4) & 1) == 0);
9424
9425       if (fseek (file,
9426                  (archive_file_offset
9427                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9428                  SEEK_SET))
9429         {
9430           error (_("Unable to seek to start of dynamic information\n"));
9431           goto no_gnu_hash;
9432         }
9433
9434       gnuchains = get_dynamic_data (file, maxchain, 4);
9435
9436     no_gnu_hash:
9437       if (gnuchains == NULL)
9438         {
9439           free (gnubuckets);
9440           gnubuckets = NULL;
9441           ngnubuckets = 0;
9442           if (do_using_dynamic)
9443             return 0;
9444         }
9445     }
9446
9447   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9448       && do_syms
9449       && do_using_dynamic
9450       && dynamic_strings != NULL)
9451     {
9452       unsigned long hn;
9453
9454       if (dynamic_info[DT_HASH])
9455         {
9456           bfd_vma si;
9457
9458           printf (_("\nSymbol table for image:\n"));
9459           if (is_32bit_elf)
9460             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9461           else
9462             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9463
9464           for (hn = 0; hn < nbuckets; hn++)
9465             {
9466               if (! buckets[hn])
9467                 continue;
9468
9469               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9470                 print_dynamic_symbol (si, hn);
9471             }
9472         }
9473
9474       if (dynamic_info_DT_GNU_HASH)
9475         {
9476           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9477           if (is_32bit_elf)
9478             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9479           else
9480             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9481
9482           for (hn = 0; hn < ngnubuckets; ++hn)
9483             if (gnubuckets[hn] != 0)
9484               {
9485                 bfd_vma si = gnubuckets[hn];
9486                 bfd_vma off = si - gnusymidx;
9487
9488                 do
9489                   {
9490                     print_dynamic_symbol (si, hn);
9491                     si++;
9492                   }
9493                 while ((gnuchains[off++] & 1) == 0);
9494               }
9495         }
9496     }
9497   else if (do_dyn_syms || (do_syms && !do_using_dynamic))
9498     {
9499       unsigned int i;
9500
9501       for (i = 0, section = section_headers;
9502            i < elf_header.e_shnum;
9503            i++, section++)
9504         {
9505           unsigned int si;
9506           char * strtab = NULL;
9507           unsigned long int strtab_size = 0;
9508           Elf_Internal_Sym * symtab;
9509           Elf_Internal_Sym * psym;
9510           unsigned long num_syms;
9511
9512           if ((section->sh_type != SHT_SYMTAB
9513                && section->sh_type != SHT_DYNSYM)
9514               || (!do_syms
9515                   && section->sh_type == SHT_SYMTAB))
9516             continue;
9517
9518           if (section->sh_entsize == 0)
9519             {
9520               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9521                       SECTION_NAME (section));
9522               continue;
9523             }
9524
9525           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9526                   SECTION_NAME (section),
9527                   (unsigned long) (section->sh_size / section->sh_entsize));
9528
9529           if (is_32bit_elf)
9530             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
9531           else
9532             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
9533
9534           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
9535           if (symtab == NULL)
9536             continue;
9537
9538           if (section->sh_link == elf_header.e_shstrndx)
9539             {
9540               strtab = string_table;
9541               strtab_size = string_table_length;
9542             }
9543           else if (section->sh_link < elf_header.e_shnum)
9544             {
9545               Elf_Internal_Shdr * string_sec;
9546
9547               string_sec = section_headers + section->sh_link;
9548
9549               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9550                                           1, string_sec->sh_size,
9551                                           _("string table"));
9552               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
9553             }
9554
9555           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
9556             {
9557               printf ("%6d: ", si);
9558               print_vma (psym->st_value, LONG_HEX);
9559               putchar (' ');
9560               print_vma (psym->st_size, DEC_5);
9561               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9562               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9563               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9564               /* Check to see if any other bits in the st_other field are set.
9565                  Note - displaying this information disrupts the layout of the
9566                  table being generated, but for the moment this case is very rare.  */
9567               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9568                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9569               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
9570               print_symbol (25, psym->st_name < strtab_size
9571                             ? strtab + psym->st_name : _("<corrupt>"));
9572
9573               if (section->sh_type == SHT_DYNSYM
9574                   && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9575                 {
9576                   unsigned char data[2];
9577                   unsigned short vers_data;
9578                   unsigned long offset;
9579                   int is_nobits;
9580                   int check_def;
9581
9582                   offset = offset_from_vma
9583                     (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9584                      sizeof data + si * sizeof (vers_data));
9585
9586                   if (get_data (&data, file, offset + si * sizeof (vers_data),
9587                                 sizeof (data), 1, _("version data")) == NULL)
9588                     break;
9589
9590                   vers_data = byte_get (data, 2);
9591
9592                   is_nobits = (psym->st_shndx < elf_header.e_shnum
9593                                && section_headers[psym->st_shndx].sh_type
9594                                   == SHT_NOBITS);
9595
9596                   check_def = (psym->st_shndx != SHN_UNDEF);
9597
9598                   if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
9599                     {
9600                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
9601                           && (is_nobits || ! check_def))
9602                         {
9603                           Elf_External_Verneed evn;
9604                           Elf_Internal_Verneed ivn;
9605                           Elf_Internal_Vernaux ivna;
9606
9607                           /* We must test both.  */
9608                           offset = offset_from_vma
9609                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9610                              sizeof evn);
9611
9612                           do
9613                             {
9614                               unsigned long vna_off;
9615
9616                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9617                                             _("version need")) == NULL)
9618                                 {
9619                                   ivna.vna_next = 0;
9620                                   ivna.vna_other = 0;
9621                                   ivna.vna_name = 0;
9622                                   break;
9623                                 }
9624
9625                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9626                               ivn.vn_next = BYTE_GET (evn.vn_next);
9627
9628                               vna_off = offset + ivn.vn_aux;
9629
9630                               do
9631                                 {
9632                                   Elf_External_Vernaux evna;
9633
9634                                   if (get_data (&evna, file, vna_off,
9635                                                 sizeof (evna), 1,
9636                                                 _("version need aux (3)")) == NULL)
9637                                     {
9638                                       ivna.vna_next = 0;
9639                                       ivna.vna_other = 0;
9640                                       ivna.vna_name = 0;
9641                                     }
9642                                   else
9643                                     {
9644                                       ivna.vna_other = BYTE_GET (evna.vna_other);
9645                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
9646                                       ivna.vna_name  = BYTE_GET (evna.vna_name);
9647                                     }
9648
9649                                   vna_off += ivna.vna_next;
9650                                 }
9651                               while (ivna.vna_other != vers_data
9652                                      && ivna.vna_next != 0);
9653
9654                               if (ivna.vna_other == vers_data)
9655                                 break;
9656
9657                               offset += ivn.vn_next;
9658                             }
9659                           while (ivn.vn_next != 0);
9660
9661                           if (ivna.vna_other == vers_data)
9662                             {
9663                               printf ("@%s (%d)",
9664                                       ivna.vna_name < strtab_size
9665                                       ? strtab + ivna.vna_name : _("<corrupt>"),
9666                                       ivna.vna_other);
9667                               check_def = 0;
9668                             }
9669                           else if (! is_nobits)
9670                             error (_("bad dynamic symbol\n"));
9671                           else
9672                             check_def = 1;
9673                         }
9674
9675                       if (check_def)
9676                         {
9677                           if (vers_data != 0x8001
9678                               && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9679                             {
9680                               Elf_Internal_Verdef ivd;
9681                               Elf_Internal_Verdaux ivda;
9682                               Elf_External_Verdaux evda;
9683                               unsigned long off;
9684
9685                               off = offset_from_vma
9686                                 (file,
9687                                  version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9688                                  sizeof (Elf_External_Verdef));
9689
9690                               do
9691                                 {
9692                                   Elf_External_Verdef evd;
9693
9694                                   if (get_data (&evd, file, off, sizeof (evd),
9695                                                 1, _("version def")) == NULL)
9696                                     {
9697                                       ivd.vd_ndx = 0;
9698                                       ivd.vd_aux = 0;
9699                                       ivd.vd_next = 0;
9700                                     }
9701                                   else
9702                                     {
9703                                       ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9704                                       ivd.vd_aux = BYTE_GET (evd.vd_aux);
9705                                       ivd.vd_next = BYTE_GET (evd.vd_next);
9706                                     }
9707
9708                                   off += ivd.vd_next;
9709                                 }
9710                               while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
9711                                      && ivd.vd_next != 0);
9712
9713                               off -= ivd.vd_next;
9714                               off += ivd.vd_aux;
9715
9716                               if (get_data (&evda, file, off, sizeof (evda),
9717                                             1, _("version def aux")) == NULL)
9718                                 break;
9719
9720                               ivda.vda_name = BYTE_GET (evda.vda_name);
9721
9722                               if (psym->st_name != ivda.vda_name)
9723                                 printf ((vers_data & VERSYM_HIDDEN)
9724                                         ? "@%s" : "@@%s",
9725                                         ivda.vda_name < strtab_size
9726                                         ? strtab + ivda.vda_name : _("<corrupt>"));
9727                             }
9728                         }
9729                     }
9730                 }
9731
9732               putchar ('\n');
9733             }
9734
9735           free (symtab);
9736           if (strtab != string_table)
9737             free (strtab);
9738         }
9739     }
9740   else if (do_syms)
9741     printf
9742       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9743
9744   if (do_histogram && buckets != NULL)
9745     {
9746       unsigned long * lengths;
9747       unsigned long * counts;
9748       unsigned long hn;
9749       bfd_vma si;
9750       unsigned long maxlength = 0;
9751       unsigned long nzero_counts = 0;
9752       unsigned long nsyms = 0;
9753
9754       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9755               (unsigned long) nbuckets);
9756       printf (_(" Length  Number     %% of total  Coverage\n"));
9757
9758       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
9759       if (lengths == NULL)
9760         {
9761           error (_("Out of memory\n"));
9762           return 0;
9763         }
9764       for (hn = 0; hn < nbuckets; ++hn)
9765         {
9766           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
9767             {
9768               ++nsyms;
9769               if (maxlength < ++lengths[hn])
9770                 ++maxlength;
9771             }
9772         }
9773
9774       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9775       if (counts == NULL)
9776         {
9777           error (_("Out of memory\n"));
9778           return 0;
9779         }
9780
9781       for (hn = 0; hn < nbuckets; ++hn)
9782         ++counts[lengths[hn]];
9783
9784       if (nbuckets > 0)
9785         {
9786           unsigned long i;
9787           printf ("      0  %-10lu (%5.1f%%)\n",
9788                   counts[0], (counts[0] * 100.0) / nbuckets);
9789           for (i = 1; i <= maxlength; ++i)
9790             {
9791               nzero_counts += counts[i] * i;
9792               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
9793                       i, counts[i], (counts[i] * 100.0) / nbuckets,
9794                       (nzero_counts * 100.0) / nsyms);
9795             }
9796         }
9797
9798       free (counts);
9799       free (lengths);
9800     }
9801
9802   if (buckets != NULL)
9803     {
9804       free (buckets);
9805       free (chains);
9806     }
9807
9808   if (do_histogram && gnubuckets != NULL)
9809     {
9810       unsigned long * lengths;
9811       unsigned long * counts;
9812       unsigned long hn;
9813       unsigned long maxlength = 0;
9814       unsigned long nzero_counts = 0;
9815       unsigned long nsyms = 0;
9816
9817       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
9818       if (lengths == NULL)
9819         {
9820           error (_("Out of memory\n"));
9821           return 0;
9822         }
9823
9824       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9825               (unsigned long) ngnubuckets);
9826       printf (_(" Length  Number     %% of total  Coverage\n"));
9827
9828       for (hn = 0; hn < ngnubuckets; ++hn)
9829         if (gnubuckets[hn] != 0)
9830           {
9831             bfd_vma off, length = 1;
9832
9833             for (off = gnubuckets[hn] - gnusymidx;
9834                  (gnuchains[off] & 1) == 0; ++off)
9835               ++length;
9836             lengths[hn] = length;
9837             if (length > maxlength)
9838               maxlength = length;
9839             nsyms += length;
9840           }
9841
9842       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9843       if (counts == NULL)
9844         {
9845           error (_("Out of memory\n"));
9846           return 0;
9847         }
9848
9849       for (hn = 0; hn < ngnubuckets; ++hn)
9850         ++counts[lengths[hn]];
9851
9852       if (ngnubuckets > 0)
9853         {
9854           unsigned long j;
9855           printf ("      0  %-10lu (%5.1f%%)\n",
9856                   counts[0], (counts[0] * 100.0) / ngnubuckets);
9857           for (j = 1; j <= maxlength; ++j)
9858             {
9859               nzero_counts += counts[j] * j;
9860               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
9861                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9862                       (nzero_counts * 100.0) / nsyms);
9863             }
9864         }
9865
9866       free (counts);
9867       free (lengths);
9868       free (gnubuckets);
9869       free (gnuchains);
9870     }
9871
9872   return 1;
9873 }
9874
9875 static int
9876 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
9877 {
9878   unsigned int i;
9879
9880   if (dynamic_syminfo == NULL
9881       || !do_dynamic)
9882     /* No syminfo, this is ok.  */
9883     return 1;
9884
9885   /* There better should be a dynamic symbol section.  */
9886   if (dynamic_symbols == NULL || dynamic_strings == NULL)
9887     return 0;
9888
9889   if (dynamic_addr)
9890     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9891             dynamic_syminfo_offset, dynamic_syminfo_nent);
9892
9893   printf (_(" Num: Name                           BoundTo     Flags\n"));
9894   for (i = 0; i < dynamic_syminfo_nent; ++i)
9895     {
9896       unsigned short int flags = dynamic_syminfo[i].si_flags;
9897
9898       printf ("%4d: ", i);
9899       if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9900         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9901       else
9902         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
9903       putchar (' ');
9904
9905       switch (dynamic_syminfo[i].si_boundto)
9906         {
9907         case SYMINFO_BT_SELF:
9908           fputs ("SELF       ", stdout);
9909           break;
9910         case SYMINFO_BT_PARENT:
9911           fputs ("PARENT     ", stdout);
9912           break;
9913         default:
9914           if (dynamic_syminfo[i].si_boundto > 0
9915               && dynamic_syminfo[i].si_boundto < dynamic_nent
9916               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
9917             {
9918               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
9919               putchar (' ' );
9920             }
9921           else
9922             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9923           break;
9924         }
9925
9926       if (flags & SYMINFO_FLG_DIRECT)
9927         printf (" DIRECT");
9928       if (flags & SYMINFO_FLG_PASSTHRU)
9929         printf (" PASSTHRU");
9930       if (flags & SYMINFO_FLG_COPY)
9931         printf (" COPY");
9932       if (flags & SYMINFO_FLG_LAZYLOAD)
9933         printf (" LAZYLOAD");
9934
9935       puts ("");
9936     }
9937
9938   return 1;
9939 }
9940
9941 /* Check to see if the given reloc needs to be handled in a target specific
9942    manner.  If so then process the reloc and return TRUE otherwise return
9943    FALSE.  */
9944
9945 static bfd_boolean
9946 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9947                                 unsigned char *     start,
9948                                 Elf_Internal_Sym *  symtab)
9949 {
9950   unsigned int reloc_type = get_reloc_type (reloc->r_info);
9951
9952   switch (elf_header.e_machine)
9953     {
9954     case EM_MN10300:
9955     case EM_CYGNUS_MN10300:
9956       {
9957         static Elf_Internal_Sym * saved_sym = NULL;
9958
9959         switch (reloc_type)
9960           {
9961           case 34: /* R_MN10300_ALIGN */
9962             return TRUE;
9963           case 33: /* R_MN10300_SYM_DIFF */
9964             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9965             return TRUE;
9966           case 1: /* R_MN10300_32 */
9967           case 2: /* R_MN10300_16 */
9968             if (saved_sym != NULL)
9969               {
9970                 bfd_vma value;
9971
9972                 value = reloc->r_addend
9973                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9974                      - saved_sym->st_value);
9975
9976                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
9977
9978                 saved_sym = NULL;
9979                 return TRUE;
9980               }
9981             break;
9982           default:
9983             if (saved_sym != NULL)
9984               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9985             break;
9986           }
9987         break;
9988       }
9989     }
9990
9991   return FALSE;
9992 }
9993
9994 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9995    DWARF debug sections.  This is a target specific test.  Note - we do not
9996    go through the whole including-target-headers-multiple-times route, (as
9997    we have already done with <elf/h8.h>) because this would become very
9998    messy and even then this function would have to contain target specific
9999    information (the names of the relocs instead of their numeric values).
10000    FIXME: This is not the correct way to solve this problem.  The proper way
10001    is to have target specific reloc sizing and typing functions created by
10002    the reloc-macros.h header, in the same way that it already creates the
10003    reloc naming functions.  */
10004
10005 static bfd_boolean
10006 is_32bit_abs_reloc (unsigned int reloc_type)
10007 {
10008   switch (elf_header.e_machine)
10009     {
10010     case EM_386:
10011     case EM_486:
10012       return reloc_type == 1; /* R_386_32.  */
10013     case EM_68K:
10014       return reloc_type == 1; /* R_68K_32.  */
10015     case EM_860:
10016       return reloc_type == 1; /* R_860_32.  */
10017     case EM_960:
10018       return reloc_type == 2; /* R_960_32.  */
10019     case EM_AARCH64:
10020       return reloc_type == 258; /* R_AARCH64_ABS32 */
10021     case EM_ALPHA:
10022       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
10023     case EM_ARC:
10024       return reloc_type == 1; /* R_ARC_32.  */
10025     case EM_ARM:
10026       return reloc_type == 2; /* R_ARM_ABS32 */
10027     case EM_AVR_OLD:
10028     case EM_AVR:
10029       return reloc_type == 1;
10030     case EM_ADAPTEVA_EPIPHANY:
10031       return reloc_type == 3;
10032     case EM_BLACKFIN:
10033       return reloc_type == 0x12; /* R_byte4_data.  */
10034     case EM_CRIS:
10035       return reloc_type == 3; /* R_CRIS_32.  */
10036     case EM_CR16:
10037       return reloc_type == 3; /* R_CR16_NUM32.  */
10038     case EM_CRX:
10039       return reloc_type == 15; /* R_CRX_NUM32.  */
10040     case EM_CYGNUS_FRV:
10041       return reloc_type == 1;
10042     case EM_CYGNUS_D10V:
10043     case EM_D10V:
10044       return reloc_type == 6; /* R_D10V_32.  */
10045     case EM_CYGNUS_D30V:
10046     case EM_D30V:
10047       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
10048     case EM_DLX:
10049       return reloc_type == 3; /* R_DLX_RELOC_32.  */
10050     case EM_CYGNUS_FR30:
10051     case EM_FR30:
10052       return reloc_type == 3; /* R_FR30_32.  */
10053     case EM_H8S:
10054     case EM_H8_300:
10055     case EM_H8_300H:
10056       return reloc_type == 1; /* R_H8_DIR32.  */
10057     case EM_IA_64:
10058       return reloc_type == 0x65; /* R_IA64_SECREL32LSB.  */
10059     case EM_IP2K_OLD:
10060     case EM_IP2K:
10061       return reloc_type == 2; /* R_IP2K_32.  */
10062     case EM_IQ2000:
10063       return reloc_type == 2; /* R_IQ2000_32.  */
10064     case EM_LATTICEMICO32:
10065       return reloc_type == 3; /* R_LM32_32.  */
10066     case EM_M32C_OLD:
10067     case EM_M32C:
10068       return reloc_type == 3; /* R_M32C_32.  */
10069     case EM_M32R:
10070       return reloc_type == 34; /* R_M32R_32_RELA.  */
10071     case EM_MCORE:
10072       return reloc_type == 1; /* R_MCORE_ADDR32.  */
10073     case EM_CYGNUS_MEP:
10074       return reloc_type == 4; /* R_MEP_32.  */
10075     case EM_METAG:
10076       return reloc_type == 2; /* R_METAG_ADDR32.  */
10077     case EM_MICROBLAZE:
10078       return reloc_type == 1; /* R_MICROBLAZE_32.  */
10079     case EM_MIPS:
10080       return reloc_type == 2; /* R_MIPS_32.  */
10081     case EM_MMIX:
10082       return reloc_type == 4; /* R_MMIX_32.  */
10083     case EM_CYGNUS_MN10200:
10084     case EM_MN10200:
10085       return reloc_type == 1; /* R_MN10200_32.  */
10086     case EM_CYGNUS_MN10300:
10087     case EM_MN10300:
10088       return reloc_type == 1; /* R_MN10300_32.  */
10089     case EM_MOXIE:
10090       return reloc_type == 1; /* R_MOXIE_32.  */
10091     case EM_MSP430_OLD:
10092     case EM_MSP430:
10093       return reloc_type == 1; /* R_MSP43_32.  */
10094     case EM_MT:
10095       return reloc_type == 2; /* R_MT_32.  */
10096     case EM_ALTERA_NIOS2:
10097       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
10098     case EM_NIOS32:
10099       return reloc_type == 1; /* R_NIOS_32.  */
10100     case EM_OPENRISC:
10101     case EM_OR32:
10102       return reloc_type == 1; /* R_OR32_32.  */
10103     case EM_PARISC:
10104       return (reloc_type == 1 /* R_PARISC_DIR32.  */
10105               || reloc_type == 41); /* R_PARISC_SECREL32.  */
10106     case EM_PJ:
10107     case EM_PJ_OLD:
10108       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
10109     case EM_PPC64:
10110       return reloc_type == 1; /* R_PPC64_ADDR32.  */
10111     case EM_PPC:
10112       return reloc_type == 1; /* R_PPC_ADDR32.  */
10113     case EM_RL78:
10114       return reloc_type == 1; /* R_RL78_DIR32.  */
10115     case EM_RX:
10116       return reloc_type == 1; /* R_RX_DIR32.  */
10117     case EM_S370:
10118       return reloc_type == 1; /* R_I370_ADDR31.  */
10119     case EM_S390_OLD:
10120     case EM_S390:
10121       return reloc_type == 4; /* R_S390_32.  */
10122     case EM_SCORE:
10123       return reloc_type == 8; /* R_SCORE_ABS32.  */
10124     case EM_SH:
10125       return reloc_type == 1; /* R_SH_DIR32.  */
10126     case EM_SPARC32PLUS:
10127     case EM_SPARCV9:
10128     case EM_SPARC:
10129       return reloc_type == 3 /* R_SPARC_32.  */
10130         || reloc_type == 23; /* R_SPARC_UA32.  */
10131     case EM_SPU:
10132       return reloc_type == 6; /* R_SPU_ADDR32 */
10133     case EM_TI_C6000:
10134       return reloc_type == 1; /* R_C6000_ABS32.  */
10135     case EM_TILEGX:
10136       return reloc_type == 2; /* R_TILEGX_32.  */
10137     case EM_TILEPRO:
10138       return reloc_type == 1; /* R_TILEPRO_32.  */
10139     case EM_CYGNUS_V850:
10140     case EM_V850:
10141       return reloc_type == 6; /* R_V850_ABS32.  */
10142     case EM_V800:
10143       return reloc_type == 0x33; /* R_V810_WORD.  */
10144     case EM_VAX:
10145       return reloc_type == 1; /* R_VAX_32.  */
10146     case EM_X86_64:
10147     case EM_L1OM:
10148     case EM_K1OM:
10149       return reloc_type == 10; /* R_X86_64_32.  */
10150     case EM_XC16X:
10151     case EM_C166:
10152       return reloc_type == 3; /* R_XC16C_ABS_32.  */
10153     case EM_XGATE:
10154       return reloc_type == 4; /* R_XGATE_32.  */
10155     case EM_XSTORMY16:
10156       return reloc_type == 1; /* R_XSTROMY16_32.  */
10157     case EM_XTENSA_OLD:
10158     case EM_XTENSA:
10159       return reloc_type == 1; /* R_XTENSA_32.  */
10160     default:
10161       error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10162              elf_header.e_machine);
10163       abort ();
10164     }
10165 }
10166
10167 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10168    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
10169
10170 static bfd_boolean
10171 is_32bit_pcrel_reloc (unsigned int reloc_type)
10172 {
10173   switch (elf_header.e_machine)
10174     {
10175     case EM_386:
10176     case EM_486:
10177       return reloc_type == 2;  /* R_386_PC32.  */
10178     case EM_68K:
10179       return reloc_type == 4;  /* R_68K_PC32.  */
10180     case EM_AARCH64:
10181       return reloc_type == 261; /* R_AARCH64_PREL32 */
10182     case EM_ADAPTEVA_EPIPHANY:
10183       return reloc_type == 6;
10184     case EM_ALPHA:
10185       return reloc_type == 10; /* R_ALPHA_SREL32.  */
10186     case EM_ARM:
10187       return reloc_type == 3;  /* R_ARM_REL32 */
10188     case EM_MICROBLAZE:
10189       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
10190     case EM_PARISC:
10191       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
10192     case EM_PPC:
10193       return reloc_type == 26; /* R_PPC_REL32.  */
10194     case EM_PPC64:
10195       return reloc_type == 26; /* R_PPC64_REL32.  */
10196     case EM_S390_OLD:
10197     case EM_S390:
10198       return reloc_type == 5;  /* R_390_PC32.  */
10199     case EM_SH:
10200       return reloc_type == 2;  /* R_SH_REL32.  */
10201     case EM_SPARC32PLUS:
10202     case EM_SPARCV9:
10203     case EM_SPARC:
10204       return reloc_type == 6;  /* R_SPARC_DISP32.  */
10205     case EM_SPU:
10206       return reloc_type == 13; /* R_SPU_REL32.  */
10207     case EM_TILEGX:
10208       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
10209     case EM_TILEPRO:
10210       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
10211     case EM_X86_64:
10212     case EM_L1OM:
10213     case EM_K1OM:
10214       return reloc_type == 2;  /* R_X86_64_PC32.  */
10215     case EM_XTENSA_OLD:
10216     case EM_XTENSA:
10217       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
10218     default:
10219       /* Do not abort or issue an error message here.  Not all targets use
10220          pc-relative 32-bit relocs in their DWARF debug information and we
10221          have already tested for target coverage in is_32bit_abs_reloc.  A
10222          more helpful warning message will be generated by apply_relocations
10223          anyway, so just return.  */
10224       return FALSE;
10225     }
10226 }
10227
10228 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10229    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
10230
10231 static bfd_boolean
10232 is_64bit_abs_reloc (unsigned int reloc_type)
10233 {
10234   switch (elf_header.e_machine)
10235     {
10236     case EM_AARCH64:
10237       return reloc_type == 257; /* R_AARCH64_ABS64.  */
10238     case EM_ALPHA:
10239       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
10240     case EM_IA_64:
10241       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
10242     case EM_PARISC:
10243       return reloc_type == 80; /* R_PARISC_DIR64.  */
10244     case EM_PPC64:
10245       return reloc_type == 38; /* R_PPC64_ADDR64.  */
10246     case EM_SPARC32PLUS:
10247     case EM_SPARCV9:
10248     case EM_SPARC:
10249       return reloc_type == 54; /* R_SPARC_UA64.  */
10250     case EM_X86_64:
10251     case EM_L1OM:
10252     case EM_K1OM:
10253       return reloc_type == 1; /* R_X86_64_64.  */
10254     case EM_S390_OLD:
10255     case EM_S390:
10256       return reloc_type == 22;  /* R_S390_64.  */
10257     case EM_TILEGX:
10258       return reloc_type == 1; /* R_TILEGX_64.  */
10259     case EM_MIPS:
10260       return reloc_type == 18;  /* R_MIPS_64.  */
10261     default:
10262       return FALSE;
10263     }
10264 }
10265
10266 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10267    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
10268
10269 static bfd_boolean
10270 is_64bit_pcrel_reloc (unsigned int reloc_type)
10271 {
10272   switch (elf_header.e_machine)
10273     {
10274     case EM_AARCH64:
10275       return reloc_type == 260; /* R_AARCH64_PREL64.  */
10276     case EM_ALPHA:
10277       return reloc_type == 11; /* R_ALPHA_SREL64.  */
10278     case EM_IA_64:
10279       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
10280     case EM_PARISC:
10281       return reloc_type == 72; /* R_PARISC_PCREL64.  */
10282     case EM_PPC64:
10283       return reloc_type == 44; /* R_PPC64_REL64.  */
10284     case EM_SPARC32PLUS:
10285     case EM_SPARCV9:
10286     case EM_SPARC:
10287       return reloc_type == 46; /* R_SPARC_DISP64.  */
10288     case EM_X86_64:
10289     case EM_L1OM:
10290     case EM_K1OM:
10291       return reloc_type == 24; /* R_X86_64_PC64.  */
10292     case EM_S390_OLD:
10293     case EM_S390:
10294       return reloc_type == 23;  /* R_S390_PC64.  */
10295     case EM_TILEGX:
10296       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
10297     default:
10298       return FALSE;
10299     }
10300 }
10301
10302 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10303    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
10304
10305 static bfd_boolean
10306 is_24bit_abs_reloc (unsigned int reloc_type)
10307 {
10308   switch (elf_header.e_machine)
10309     {
10310     case EM_CYGNUS_MN10200:
10311     case EM_MN10200:
10312       return reloc_type == 4; /* R_MN10200_24.  */
10313     default:
10314       return FALSE;
10315     }
10316 }
10317
10318 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10319    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
10320
10321 static bfd_boolean
10322 is_16bit_abs_reloc (unsigned int reloc_type)
10323 {
10324   switch (elf_header.e_machine)
10325     {
10326     case EM_AVR_OLD:
10327     case EM_AVR:
10328       return reloc_type == 4; /* R_AVR_16.  */
10329     case EM_ADAPTEVA_EPIPHANY:
10330       return reloc_type == 5;
10331     case EM_CYGNUS_D10V:
10332     case EM_D10V:
10333       return reloc_type == 3; /* R_D10V_16.  */
10334     case EM_H8S:
10335     case EM_H8_300:
10336     case EM_H8_300H:
10337       return reloc_type == R_H8_DIR16;
10338     case EM_IP2K_OLD:
10339     case EM_IP2K:
10340       return reloc_type == 1; /* R_IP2K_16.  */
10341     case EM_M32C_OLD:
10342     case EM_M32C:
10343       return reloc_type == 1; /* R_M32C_16 */
10344     case EM_MSP430:
10345     case EM_MSP430_OLD:
10346       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
10347     case EM_ALTERA_NIOS2:
10348       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
10349     case EM_NIOS32:
10350       return reloc_type == 9; /* R_NIOS_16.  */
10351     case EM_TI_C6000:
10352       return reloc_type == 2; /* R_C6000_ABS16.  */
10353     case EM_XC16X:
10354     case EM_C166:
10355       return reloc_type == 2; /* R_XC16C_ABS_16.  */
10356     case EM_CYGNUS_MN10200:
10357     case EM_MN10200:
10358       return reloc_type == 2; /* R_MN10200_16.  */
10359     case EM_CYGNUS_MN10300:
10360     case EM_MN10300:
10361       return reloc_type == 2; /* R_MN10300_16.  */
10362     case EM_XGATE:
10363       return reloc_type == 3; /* R_XGATE_16.  */
10364     default:
10365       return FALSE;
10366     }
10367 }
10368
10369 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10370    relocation entries (possibly formerly used for SHT_GROUP sections).  */
10371
10372 static bfd_boolean
10373 is_none_reloc (unsigned int reloc_type)
10374 {
10375   switch (elf_header.e_machine)
10376     {
10377     case EM_68K:     /* R_68K_NONE.  */
10378     case EM_386:     /* R_386_NONE.  */
10379     case EM_SPARC32PLUS:
10380     case EM_SPARCV9:
10381     case EM_SPARC:   /* R_SPARC_NONE.  */
10382     case EM_MIPS:    /* R_MIPS_NONE.  */
10383     case EM_PARISC:  /* R_PARISC_NONE.  */
10384     case EM_ALPHA:   /* R_ALPHA_NONE.  */
10385     case EM_ADAPTEVA_EPIPHANY:
10386     case EM_PPC:     /* R_PPC_NONE.  */
10387     case EM_PPC64:   /* R_PPC64_NONE.  */
10388     case EM_ARM:     /* R_ARM_NONE.  */
10389     case EM_IA_64:   /* R_IA64_NONE.  */
10390     case EM_SH:      /* R_SH_NONE.  */
10391     case EM_S390_OLD:
10392     case EM_S390:    /* R_390_NONE.  */
10393     case EM_CRIS:    /* R_CRIS_NONE.  */
10394     case EM_X86_64:  /* R_X86_64_NONE.  */
10395     case EM_L1OM:    /* R_X86_64_NONE.  */
10396     case EM_K1OM:    /* R_X86_64_NONE.  */
10397     case EM_MN10300: /* R_MN10300_NONE.  */
10398     case EM_MOXIE:   /* R_MOXIE_NONE.  */
10399     case EM_M32R:    /* R_M32R_NONE.  */
10400     case EM_TI_C6000:/* R_C6000_NONE.  */
10401     case EM_TILEGX:  /* R_TILEGX_NONE.  */
10402     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
10403     case EM_XC16X:
10404     case EM_C166:    /* R_XC16X_NONE.  */
10405     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
10406     case EM_NIOS32:  /* R_NIOS_NONE.  */
10407       return reloc_type == 0;
10408     case EM_AARCH64:
10409       return reloc_type == 0 || reloc_type == 256;
10410     case EM_XTENSA_OLD:
10411     case EM_XTENSA:
10412       return (reloc_type == 0      /* R_XTENSA_NONE.  */
10413               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
10414               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
10415               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
10416     case EM_METAG:
10417       return reloc_type == 3; /* R_METAG_NONE.  */
10418     }
10419   return FALSE;
10420 }
10421
10422 /* Apply relocations to a section.
10423    Note: So far support has been added only for those relocations
10424    which can be found in debug sections.
10425    FIXME: Add support for more relocations ?  */
10426
10427 static void
10428 apply_relocations (void * file,
10429                    Elf_Internal_Shdr * section,
10430                    unsigned char * start)
10431 {
10432   Elf_Internal_Shdr * relsec;
10433   unsigned char * end = start + section->sh_size;
10434
10435   if (elf_header.e_type != ET_REL)
10436     return;
10437
10438   /* Find the reloc section associated with the section.  */
10439   for (relsec = section_headers;
10440        relsec < section_headers + elf_header.e_shnum;
10441        ++relsec)
10442     {
10443       bfd_boolean is_rela;
10444       unsigned long num_relocs;
10445       Elf_Internal_Rela * relocs;
10446       Elf_Internal_Rela * rp;
10447       Elf_Internal_Shdr * symsec;
10448       Elf_Internal_Sym * symtab;
10449       unsigned long num_syms;
10450       Elf_Internal_Sym * sym;
10451
10452       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10453           || relsec->sh_info >= elf_header.e_shnum
10454           || section_headers + relsec->sh_info != section
10455           || relsec->sh_size == 0
10456           || relsec->sh_link >= elf_header.e_shnum)
10457         continue;
10458
10459       is_rela = relsec->sh_type == SHT_RELA;
10460
10461       if (is_rela)
10462         {
10463           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10464                                   relsec->sh_size, & relocs, & num_relocs))
10465             return;
10466         }
10467       else
10468         {
10469           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10470                                  relsec->sh_size, & relocs, & num_relocs))
10471             return;
10472         }
10473
10474       /* SH uses RELA but uses in place value instead of the addend field.  */
10475       if (elf_header.e_machine == EM_SH)
10476         is_rela = FALSE;
10477
10478       symsec = section_headers + relsec->sh_link;
10479       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
10480
10481       for (rp = relocs; rp < relocs + num_relocs; ++rp)
10482         {
10483           bfd_vma         addend;
10484           unsigned int    reloc_type;
10485           unsigned int    reloc_size;
10486           unsigned char * rloc;
10487           unsigned long   sym_index;
10488
10489           reloc_type = get_reloc_type (rp->r_info);
10490
10491           if (target_specific_reloc_handling (rp, start, symtab))
10492             continue;
10493           else if (is_none_reloc (reloc_type))
10494             continue;
10495           else if (is_32bit_abs_reloc (reloc_type)
10496                    || is_32bit_pcrel_reloc (reloc_type))
10497             reloc_size = 4;
10498           else if (is_64bit_abs_reloc (reloc_type)
10499                    || is_64bit_pcrel_reloc (reloc_type))
10500             reloc_size = 8;
10501           else if (is_24bit_abs_reloc (reloc_type))
10502             reloc_size = 3;
10503           else if (is_16bit_abs_reloc (reloc_type))
10504             reloc_size = 2;
10505           else
10506             {
10507               warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10508                     reloc_type, SECTION_NAME (section));
10509               continue;
10510             }
10511
10512           rloc = start + rp->r_offset;
10513           if ((rloc + reloc_size) > end)
10514             {
10515               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10516                     (unsigned long) rp->r_offset,
10517                     SECTION_NAME (section));
10518               continue;
10519             }
10520
10521           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10522           if (sym_index >= num_syms)
10523             {
10524               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10525                     sym_index, SECTION_NAME (section));
10526               continue;
10527             }
10528           sym = symtab + sym_index;
10529
10530           /* If the reloc has a symbol associated with it,
10531              make sure that it is of an appropriate type.
10532
10533              Relocations against symbols without type can happen.
10534              Gcc -feliminate-dwarf2-dups may generate symbols
10535              without type for debug info.
10536
10537              Icc generates relocations against function symbols
10538              instead of local labels.
10539
10540              Relocations against object symbols can happen, eg when
10541              referencing a global array.  For an example of this see
10542              the _clz.o binary in libgcc.a.  */
10543           if (sym != symtab
10544               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
10545             {
10546               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10547                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
10548                     (long int)(rp - relocs),
10549                     SECTION_NAME (relsec));
10550               continue;
10551             }
10552
10553           addend = 0;
10554           if (is_rela)
10555             addend += rp->r_addend;
10556           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10557              partial_inplace.  */
10558           if (!is_rela
10559               || (elf_header.e_machine == EM_XTENSA
10560                   && reloc_type == 1)
10561               || ((elf_header.e_machine == EM_PJ
10562                    || elf_header.e_machine == EM_PJ_OLD)
10563                   && reloc_type == 1)
10564               || ((elf_header.e_machine == EM_D30V
10565                    || elf_header.e_machine == EM_CYGNUS_D30V)
10566                   && reloc_type == 12))
10567             addend += byte_get (rloc, reloc_size);
10568
10569           if (is_32bit_pcrel_reloc (reloc_type)
10570               || is_64bit_pcrel_reloc (reloc_type))
10571             {
10572               /* On HPPA, all pc-relative relocations are biased by 8.  */
10573               if (elf_header.e_machine == EM_PARISC)
10574                 addend -= 8;
10575               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
10576                         reloc_size);
10577             }
10578           else
10579             byte_put (rloc, addend + sym->st_value, reloc_size);
10580         }
10581
10582       free (symtab);
10583       free (relocs);
10584       break;
10585     }
10586 }
10587
10588 #ifdef SUPPORT_DISASSEMBLY
10589 static int
10590 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10591 {
10592   printf (_("\nAssembly dump of section %s\n"),
10593           SECTION_NAME (section));
10594
10595   /* XXX -- to be done --- XXX */
10596
10597   return 1;
10598 }
10599 #endif
10600
10601 /* Reads in the contents of SECTION from FILE, returning a pointer
10602    to a malloc'ed buffer or NULL if something went wrong.  */
10603
10604 static char *
10605 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10606 {
10607   bfd_size_type num_bytes;
10608
10609   num_bytes = section->sh_size;
10610
10611   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10612     {
10613       printf (_("\nSection '%s' has no data to dump.\n"),
10614               SECTION_NAME (section));
10615       return NULL;
10616     }
10617
10618   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10619                              _("section contents"));
10620 }
10621
10622
10623 static void
10624 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10625 {
10626   Elf_Internal_Shdr * relsec;
10627   bfd_size_type num_bytes;
10628   char * data;
10629   char * end;
10630   char * start;
10631   char * name = SECTION_NAME (section);
10632   bfd_boolean some_strings_shown;
10633
10634   start = get_section_contents (section, file);
10635   if (start == NULL)
10636     return;
10637
10638   printf (_("\nString dump of section '%s':\n"), name);
10639
10640   /* If the section being dumped has relocations against it the user might
10641      be expecting these relocations to have been applied.  Check for this
10642      case and issue a warning message in order to avoid confusion.
10643      FIXME: Maybe we ought to have an option that dumps a section with
10644      relocs applied ?  */
10645   for (relsec = section_headers;
10646        relsec < section_headers + elf_header.e_shnum;
10647        ++relsec)
10648     {
10649       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10650           || relsec->sh_info >= elf_header.e_shnum
10651           || section_headers + relsec->sh_info != section
10652           || relsec->sh_size == 0
10653           || relsec->sh_link >= elf_header.e_shnum)
10654         continue;
10655
10656       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10657       break;
10658     }
10659
10660   num_bytes = section->sh_size;
10661   data = start;
10662   end  = start + num_bytes;
10663   some_strings_shown = FALSE;
10664
10665   while (data < end)
10666     {
10667       while (!ISPRINT (* data))
10668         if (++ data >= end)
10669           break;
10670
10671       if (data < end)
10672         {
10673 #ifndef __MSVCRT__
10674           /* PR 11128: Use two separate invocations in order to work
10675              around bugs in the Solaris 8 implementation of printf.  */
10676           printf ("  [%6tx]  ", data - start);
10677           printf ("%s\n", data);
10678 #else
10679           printf ("  [%6Ix]  %s\n", (size_t) (data - start), data);
10680 #endif
10681           data += strlen (data);
10682           some_strings_shown = TRUE;
10683         }
10684     }
10685
10686   if (! some_strings_shown)
10687     printf (_("  No strings found in this section."));
10688
10689   free (start);
10690
10691   putchar ('\n');
10692 }
10693
10694 static void
10695 dump_section_as_bytes (Elf_Internal_Shdr * section,
10696                        FILE * file,
10697                        bfd_boolean relocate)
10698 {
10699   Elf_Internal_Shdr * relsec;
10700   bfd_size_type bytes;
10701   bfd_vma addr;
10702   unsigned char * data;
10703   unsigned char * start;
10704
10705   start = (unsigned char *) get_section_contents (section, file);
10706   if (start == NULL)
10707     return;
10708
10709   printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10710
10711   if (relocate)
10712     {
10713       apply_relocations (file, section, start);
10714     }
10715   else
10716     {
10717       /* If the section being dumped has relocations against it the user might
10718          be expecting these relocations to have been applied.  Check for this
10719          case and issue a warning message in order to avoid confusion.
10720          FIXME: Maybe we ought to have an option that dumps a section with
10721          relocs applied ?  */
10722       for (relsec = section_headers;
10723            relsec < section_headers + elf_header.e_shnum;
10724            ++relsec)
10725         {
10726           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10727               || relsec->sh_info >= elf_header.e_shnum
10728               || section_headers + relsec->sh_info != section
10729               || relsec->sh_size == 0
10730               || relsec->sh_link >= elf_header.e_shnum)
10731             continue;
10732
10733           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10734           break;
10735         }
10736     }
10737
10738   addr = section->sh_addr;
10739   bytes = section->sh_size;
10740   data = start;
10741
10742   while (bytes)
10743     {
10744       int j;
10745       int k;
10746       int lbytes;
10747
10748       lbytes = (bytes > 16 ? 16 : bytes);
10749
10750       printf ("  0x%8.8lx ", (unsigned long) addr);
10751
10752       for (j = 0; j < 16; j++)
10753         {
10754           if (j < lbytes)
10755             printf ("%2.2x", data[j]);
10756           else
10757             printf ("  ");
10758
10759           if ((j & 3) == 3)
10760             printf (" ");
10761         }
10762
10763       for (j = 0; j < lbytes; j++)
10764         {
10765           k = data[j];
10766           if (k >= ' ' && k < 0x7f)
10767             printf ("%c", k);
10768           else
10769             printf (".");
10770         }
10771
10772       putchar ('\n');
10773
10774       data  += lbytes;
10775       addr  += lbytes;
10776       bytes -= lbytes;
10777     }
10778
10779   free (start);
10780
10781   putchar ('\n');
10782 }
10783
10784 /* Uncompresses a section that was compressed using zlib, in place.  */
10785
10786 static int
10787 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10788                              dwarf_size_type *size ATTRIBUTE_UNUSED)
10789 {
10790 #ifndef HAVE_ZLIB_H
10791   return FALSE;
10792 #else
10793   dwarf_size_type compressed_size = *size;
10794   unsigned char * compressed_buffer = *buffer;
10795   dwarf_size_type uncompressed_size;
10796   unsigned char * uncompressed_buffer;
10797   z_stream strm;
10798   int rc;
10799   dwarf_size_type header_size = 12;
10800
10801   /* Read the zlib header.  In this case, it should be "ZLIB" followed
10802      by the uncompressed section size, 8 bytes in big-endian order.  */
10803   if (compressed_size < header_size
10804       || ! streq ((char *) compressed_buffer, "ZLIB"))
10805     return 0;
10806
10807   uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10808   uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10809   uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10810   uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10811   uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10812   uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10813   uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10814   uncompressed_size += compressed_buffer[11];
10815
10816   /* It is possible the section consists of several compressed
10817      buffers concatenated together, so we uncompress in a loop.  */
10818   strm.zalloc = NULL;
10819   strm.zfree = NULL;
10820   strm.opaque = NULL;
10821   strm.avail_in = compressed_size - header_size;
10822   strm.next_in = (Bytef *) compressed_buffer + header_size;
10823   strm.avail_out = uncompressed_size;
10824   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
10825
10826   rc = inflateInit (& strm);
10827   while (strm.avail_in > 0)
10828     {
10829       if (rc != Z_OK)
10830         goto fail;
10831       strm.next_out = ((Bytef *) uncompressed_buffer
10832                        + (uncompressed_size - strm.avail_out));
10833       rc = inflate (&strm, Z_FINISH);
10834       if (rc != Z_STREAM_END)
10835         goto fail;
10836       rc = inflateReset (& strm);
10837     }
10838   rc = inflateEnd (& strm);
10839   if (rc != Z_OK
10840       || strm.avail_out != 0)
10841     goto fail;
10842
10843   free (compressed_buffer);
10844   *buffer = uncompressed_buffer;
10845   *size = uncompressed_size;
10846   return 1;
10847
10848  fail:
10849   free (uncompressed_buffer);
10850   /* Indicate decompression failure.  */
10851   *buffer = NULL;
10852   return 0;
10853 #endif  /* HAVE_ZLIB_H */
10854 }
10855
10856 static int
10857 load_specific_debug_section (enum dwarf_section_display_enum debug,
10858                              Elf_Internal_Shdr * sec, void * file)
10859 {
10860   struct dwarf_section * section = &debug_displays [debug].section;
10861   char buf [64];
10862
10863   /* If it is already loaded, do nothing.  */
10864   if (section->start != NULL)
10865     return 1;
10866
10867   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10868   section->address = sec->sh_addr;
10869   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10870                                                sec->sh_offset, 1,
10871                                                sec->sh_size, buf);
10872   if (section->start == NULL)
10873     section->size = 0;
10874   else
10875     {
10876       section->size = sec->sh_size;
10877       if (uncompress_section_contents (&section->start, &section->size))
10878         sec->sh_size = section->size;
10879     }
10880
10881   if (section->start == NULL)
10882     return 0;
10883
10884   if (debug_displays [debug].relocate)
10885     apply_relocations ((FILE *) file, sec, section->start);
10886
10887   return 1;
10888 }
10889
10890 /* If this is not NULL, load_debug_section will only look for sections
10891    within the list of sections given here.  */
10892 unsigned int *section_subset = NULL;
10893
10894 int
10895 load_debug_section (enum dwarf_section_display_enum debug, void * file)
10896 {
10897   struct dwarf_section * section = &debug_displays [debug].section;
10898   Elf_Internal_Shdr * sec;
10899
10900   /* Locate the debug section.  */
10901   sec = find_section_in_set (section->uncompressed_name, section_subset);
10902   if (sec != NULL)
10903     section->name = section->uncompressed_name;
10904   else
10905     {
10906       sec = find_section_in_set (section->compressed_name, section_subset);
10907       if (sec != NULL)
10908         section->name = section->compressed_name;
10909     }
10910   if (sec == NULL)
10911     return 0;
10912
10913   /* If we're loading from a subset of sections, and we've loaded
10914      a section matching this name before, it's likely that it's a
10915      different one.  */
10916   if (section_subset != NULL)
10917     free_debug_section (debug);
10918
10919   return load_specific_debug_section (debug, sec, (FILE *) file);
10920 }
10921
10922 void
10923 free_debug_section (enum dwarf_section_display_enum debug)
10924 {
10925   struct dwarf_section * section = &debug_displays [debug].section;
10926
10927   if (section->start == NULL)
10928     return;
10929
10930   free ((char *) section->start);
10931   section->start = NULL;
10932   section->address = 0;
10933   section->size = 0;
10934 }
10935
10936 static int
10937 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
10938 {
10939   char * name = SECTION_NAME (section);
10940   bfd_size_type length;
10941   int result = 1;
10942   int i;
10943
10944   length = section->sh_size;
10945   if (length == 0)
10946     {
10947       printf (_("\nSection '%s' has no debugging data.\n"), name);
10948       return 0;
10949     }
10950   if (section->sh_type == SHT_NOBITS)
10951     {
10952       /* There is no point in dumping the contents of a debugging section
10953          which has the NOBITS type - the bits in the file will be random.
10954          This can happen when a file containing a .eh_frame section is
10955          stripped with the --only-keep-debug command line option.  */
10956       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10957       return 0;
10958     }
10959
10960   if (const_strneq (name, ".gnu.linkonce.wi."))
10961     name = ".debug_info";
10962
10963   /* See if we know how to display the contents of this section.  */
10964   for (i = 0; i < max; i++)
10965     if (streq (debug_displays[i].section.uncompressed_name, name)
10966         || streq (debug_displays[i].section.compressed_name, name))
10967       {
10968         struct dwarf_section * sec = &debug_displays [i].section;
10969         int secondary = (section != find_section (name));
10970
10971         if (secondary)
10972           free_debug_section ((enum dwarf_section_display_enum) i);
10973
10974         if (streq (sec->uncompressed_name, name))
10975           sec->name = sec->uncompressed_name;
10976         else
10977           sec->name = sec->compressed_name;
10978         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10979                                          section, file))
10980           {
10981             /* If this debug section is part of a CU/TU set in a .dwp file,
10982                restrict load_debug_section to the sections in that set.  */
10983             section_subset = find_cu_tu_set (file, shndx);
10984
10985             result &= debug_displays[i].display (sec, file);
10986
10987             section_subset = NULL;
10988
10989             if (secondary || (i != info && i != abbrev))
10990               free_debug_section ((enum dwarf_section_display_enum) i);
10991           }
10992
10993         break;
10994       }
10995
10996   if (i == max)
10997     {
10998       printf (_("Unrecognized debug section: %s\n"), name);
10999       result = 0;
11000     }
11001
11002   return result;
11003 }
11004
11005 /* Set DUMP_SECTS for all sections where dumps were requested
11006    based on section name.  */
11007
11008 static void
11009 initialise_dumps_byname (void)
11010 {
11011   struct dump_list_entry * cur;
11012
11013   for (cur = dump_sects_byname; cur; cur = cur->next)
11014     {
11015       unsigned int i;
11016       int any;
11017
11018       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11019         if (streq (SECTION_NAME (section_headers + i), cur->name))
11020           {
11021             request_dump_bynumber (i, cur->type);
11022             any = 1;
11023           }
11024
11025       if (!any)
11026         warn (_("Section '%s' was not dumped because it does not exist!\n"),
11027               cur->name);
11028     }
11029 }
11030
11031 static void
11032 process_section_contents (FILE * file)
11033 {
11034   Elf_Internal_Shdr * section;
11035   unsigned int i;
11036
11037   if (! do_dump)
11038     return;
11039
11040   initialise_dumps_byname ();
11041
11042   for (i = 0, section = section_headers;
11043        i < elf_header.e_shnum && i < num_dump_sects;
11044        i++, section++)
11045     {
11046 #ifdef SUPPORT_DISASSEMBLY
11047       if (dump_sects[i] & DISASS_DUMP)
11048         disassemble_section (section, file);
11049 #endif
11050       if (dump_sects[i] & HEX_DUMP)
11051         dump_section_as_bytes (section, file, FALSE);
11052
11053       if (dump_sects[i] & RELOC_DUMP)
11054         dump_section_as_bytes (section, file, TRUE);
11055
11056       if (dump_sects[i] & STRING_DUMP)
11057         dump_section_as_strings (section, file);
11058
11059       if (dump_sects[i] & DEBUG_DUMP)
11060         display_debug_section (i, section, file);
11061     }
11062
11063   /* Check to see if the user requested a
11064      dump of a section that does not exist.  */
11065   while (i++ < num_dump_sects)
11066     if (dump_sects[i])
11067       warn (_("Section %d was not dumped because it does not exist!\n"), i);
11068 }
11069
11070 static void
11071 process_mips_fpe_exception (int mask)
11072 {
11073   if (mask)
11074     {
11075       int first = 1;
11076       if (mask & OEX_FPU_INEX)
11077         fputs ("INEX", stdout), first = 0;
11078       if (mask & OEX_FPU_UFLO)
11079         printf ("%sUFLO", first ? "" : "|"), first = 0;
11080       if (mask & OEX_FPU_OFLO)
11081         printf ("%sOFLO", first ? "" : "|"), first = 0;
11082       if (mask & OEX_FPU_DIV0)
11083         printf ("%sDIV0", first ? "" : "|"), first = 0;
11084       if (mask & OEX_FPU_INVAL)
11085         printf ("%sINVAL", first ? "" : "|");
11086     }
11087   else
11088     fputs ("0", stdout);
11089 }
11090
11091 /* ARM EABI attributes section.  */
11092 typedef struct
11093 {
11094   int tag;
11095   const char * name;
11096   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
11097   int type;
11098   const char ** table;
11099 } arm_attr_public_tag;
11100
11101 static const char * arm_attr_tag_CPU_arch[] =
11102   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11103    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11104 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11105 static const char * arm_attr_tag_THUMB_ISA_use[] =
11106   {"No", "Thumb-1", "Thumb-2"};
11107 static const char * arm_attr_tag_FP_arch[] =
11108   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11109    "FP for ARMv8"};
11110 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
11111 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
11112   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11113 static const char * arm_attr_tag_PCS_config[] =
11114   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11115    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11116 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11117   {"V6", "SB", "TLS", "Unused"};
11118 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11119   {"Absolute", "PC-relative", "SB-relative", "None"};
11120 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11121   {"Absolute", "PC-relative", "None"};
11122 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11123   {"None", "direct", "GOT-indirect"};
11124 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11125   {"None", "??? 1", "2", "??? 3", "4"};
11126 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11127 static const char * arm_attr_tag_ABI_FP_denormal[] =
11128   {"Unused", "Needed", "Sign only"};
11129 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11130 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11131 static const char * arm_attr_tag_ABI_FP_number_model[] =
11132   {"Unused", "Finite", "RTABI", "IEEE 754"};
11133 static const char * arm_attr_tag_ABI_enum_size[] =
11134   {"Unused", "small", "int", "forced to int"};
11135 static const char * arm_attr_tag_ABI_HardFP_use[] =
11136   {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11137 static const char * arm_attr_tag_ABI_VFP_args[] =
11138   {"AAPCS", "VFP registers", "custom"};
11139 static const char * arm_attr_tag_ABI_WMMX_args[] =
11140   {"AAPCS", "WMMX registers", "custom"};
11141 static const char * arm_attr_tag_ABI_optimization_goals[] =
11142   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11143     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11144 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11145   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11146     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11147 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
11148 static const char * arm_attr_tag_FP_HP_extension[] =
11149   {"Not Allowed", "Allowed"};
11150 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
11151   {"None", "IEEE 754", "Alternative Format"};
11152 static const char * arm_attr_tag_MPextension_use[] =
11153   {"Not Allowed", "Allowed"};
11154 static const char * arm_attr_tag_DIV_use[] =
11155   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11156     "Allowed in v7-A with integer division extension"};
11157 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11158 static const char * arm_attr_tag_Virtualization_use[] =
11159   {"Not Allowed", "TrustZone", "Virtualization Extensions",
11160     "TrustZone and Virtualization Extensions"};
11161 static const char * arm_attr_tag_MPextension_use_legacy[] =
11162   {"Not Allowed", "Allowed"};
11163
11164 #define LOOKUP(id, name) \
11165   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11166 static arm_attr_public_tag arm_attr_public_tags[] =
11167 {
11168   {4, "CPU_raw_name", 1, NULL},
11169   {5, "CPU_name", 1, NULL},
11170   LOOKUP(6, CPU_arch),
11171   {7, "CPU_arch_profile", 0, NULL},
11172   LOOKUP(8, ARM_ISA_use),
11173   LOOKUP(9, THUMB_ISA_use),
11174   LOOKUP(10, FP_arch),
11175   LOOKUP(11, WMMX_arch),
11176   LOOKUP(12, Advanced_SIMD_arch),
11177   LOOKUP(13, PCS_config),
11178   LOOKUP(14, ABI_PCS_R9_use),
11179   LOOKUP(15, ABI_PCS_RW_data),
11180   LOOKUP(16, ABI_PCS_RO_data),
11181   LOOKUP(17, ABI_PCS_GOT_use),
11182   LOOKUP(18, ABI_PCS_wchar_t),
11183   LOOKUP(19, ABI_FP_rounding),
11184   LOOKUP(20, ABI_FP_denormal),
11185   LOOKUP(21, ABI_FP_exceptions),
11186   LOOKUP(22, ABI_FP_user_exceptions),
11187   LOOKUP(23, ABI_FP_number_model),
11188   {24, "ABI_align_needed", 0, NULL},
11189   {25, "ABI_align_preserved", 0, NULL},
11190   LOOKUP(26, ABI_enum_size),
11191   LOOKUP(27, ABI_HardFP_use),
11192   LOOKUP(28, ABI_VFP_args),
11193   LOOKUP(29, ABI_WMMX_args),
11194   LOOKUP(30, ABI_optimization_goals),
11195   LOOKUP(31, ABI_FP_optimization_goals),
11196   {32, "compatibility", 0, NULL},
11197   LOOKUP(34, CPU_unaligned_access),
11198   LOOKUP(36, FP_HP_extension),
11199   LOOKUP(38, ABI_FP_16bit_format),
11200   LOOKUP(42, MPextension_use),
11201   LOOKUP(44, DIV_use),
11202   {64, "nodefaults", 0, NULL},
11203   {65, "also_compatible_with", 0, NULL},
11204   LOOKUP(66, T2EE_use),
11205   {67, "conformance", 1, NULL},
11206   LOOKUP(68, Virtualization_use),
11207   LOOKUP(70, MPextension_use_legacy)
11208 };
11209 #undef LOOKUP
11210
11211 static unsigned char *
11212 display_arm_attribute (unsigned char * p)
11213 {
11214   int tag;
11215   unsigned int len;
11216   int val;
11217   arm_attr_public_tag * attr;
11218   unsigned i;
11219   int type;
11220
11221   tag = read_uleb128 (p, &len);
11222   p += len;
11223   attr = NULL;
11224   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11225     {
11226       if (arm_attr_public_tags[i].tag == tag)
11227         {
11228           attr = &arm_attr_public_tags[i];
11229           break;
11230         }
11231     }
11232
11233   if (attr)
11234     {
11235       printf ("  Tag_%s: ", attr->name);
11236       switch (attr->type)
11237         {
11238         case 0:
11239           switch (tag)
11240             {
11241             case 7: /* Tag_CPU_arch_profile.  */
11242               val = read_uleb128 (p, &len);
11243               p += len;
11244               switch (val)
11245                 {
11246                 case 0: printf (_("None\n")); break;
11247                 case 'A': printf (_("Application\n")); break;
11248                 case 'R': printf (_("Realtime\n")); break;
11249                 case 'M': printf (_("Microcontroller\n")); break;
11250                 case 'S': printf (_("Application or Realtime\n")); break;
11251                 default: printf ("??? (%d)\n", val); break;
11252                 }
11253               break;
11254
11255             case 24: /* Tag_align_needed.  */
11256               val = read_uleb128 (p, &len);
11257               p += len;
11258               switch (val)
11259                 {
11260                 case 0: printf (_("None\n")); break;
11261                 case 1: printf (_("8-byte\n")); break;
11262                 case 2: printf (_("4-byte\n")); break;
11263                 case 3: printf ("??? 3\n"); break;
11264                 default:
11265                   if (val <= 12)
11266                     printf (_("8-byte and up to %d-byte extended\n"),
11267                             1 << val);
11268                   else
11269                     printf ("??? (%d)\n", val);
11270                   break;
11271                 }
11272               break;
11273
11274             case 25: /* Tag_align_preserved.  */
11275               val = read_uleb128 (p, &len);
11276               p += len;
11277               switch (val)
11278                 {
11279                 case 0: printf (_("None\n")); break;
11280                 case 1: printf (_("8-byte, except leaf SP\n")); break;
11281                 case 2: printf (_("8-byte\n")); break;
11282                 case 3: printf ("??? 3\n"); break;
11283                 default:
11284                   if (val <= 12)
11285                     printf (_("8-byte and up to %d-byte extended\n"),
11286                             1 << val);
11287                   else
11288                     printf ("??? (%d)\n", val);
11289                   break;
11290                 }
11291               break;
11292
11293             case 32: /* Tag_compatibility.  */
11294               val = read_uleb128 (p, &len);
11295               p += len;
11296               printf (_("flag = %d, vendor = %s\n"), val, p);
11297               p += strlen ((char *) p) + 1;
11298               break;
11299
11300             case 64: /* Tag_nodefaults.  */
11301               p++;
11302               printf (_("True\n"));
11303               break;
11304
11305             case 65: /* Tag_also_compatible_with.  */
11306               val = read_uleb128 (p, &len);
11307               p += len;
11308               if (val == 6 /* Tag_CPU_arch.  */)
11309                 {
11310                   val = read_uleb128 (p, &len);
11311                   p += len;
11312                   if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
11313                     printf ("??? (%d)\n", val);
11314                   else
11315                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11316                 }
11317               else
11318                 printf ("???\n");
11319               while (*(p++) != '\0' /* NUL terminator.  */);
11320               break;
11321
11322             default:
11323               abort ();
11324             }
11325           return p;
11326
11327         case 1:
11328         case 2:
11329           type = attr->type;
11330           break;
11331
11332         default:
11333           assert (attr->type & 0x80);
11334           val = read_uleb128 (p, &len);
11335           p += len;
11336           type = attr->type & 0x7f;
11337           if (val >= type)
11338             printf ("??? (%d)\n", val);
11339           else
11340             printf ("%s\n", attr->table[val]);
11341           return p;
11342         }
11343     }
11344   else
11345     {
11346       if (tag & 1)
11347         type = 1; /* String.  */
11348       else
11349         type = 2; /* uleb128.  */
11350       printf ("  Tag_unknown_%d: ", tag);
11351     }
11352
11353   if (type == 1)
11354     {
11355       printf ("\"%s\"\n", p);
11356       p += strlen ((char *) p) + 1;
11357     }
11358   else
11359     {
11360       val = read_uleb128 (p, &len);
11361       p += len;
11362       printf ("%d (0x%x)\n", val, val);
11363     }
11364
11365   return p;
11366 }
11367
11368 static unsigned char *
11369 display_gnu_attribute (unsigned char * p,
11370                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11371 {
11372   int tag;
11373   unsigned int len;
11374   int val;
11375   int type;
11376
11377   tag = read_uleb128 (p, &len);
11378   p += len;
11379
11380   /* Tag_compatibility is the only generic GNU attribute defined at
11381      present.  */
11382   if (tag == 32)
11383     {
11384       val = read_uleb128 (p, &len);
11385       p += len;
11386       printf (_("flag = %d, vendor = %s\n"), val, p);
11387       p += strlen ((char *) p) + 1;
11388       return p;
11389     }
11390
11391   if ((tag & 2) == 0 && display_proc_gnu_attribute)
11392     return display_proc_gnu_attribute (p, tag);
11393
11394   if (tag & 1)
11395     type = 1; /* String.  */
11396   else
11397     type = 2; /* uleb128.  */
11398   printf ("  Tag_unknown_%d: ", tag);
11399
11400   if (type == 1)
11401     {
11402       printf ("\"%s\"\n", p);
11403       p += strlen ((char *) p) + 1;
11404     }
11405   else
11406     {
11407       val = read_uleb128 (p, &len);
11408       p += len;
11409       printf ("%d (0x%x)\n", val, val);
11410     }
11411
11412   return p;
11413 }
11414
11415 static unsigned char *
11416 display_power_gnu_attribute (unsigned char * p, int tag)
11417 {
11418   int type;
11419   unsigned int len;
11420   int val;
11421
11422   if (tag == Tag_GNU_Power_ABI_FP)
11423     {
11424       val = read_uleb128 (p, &len);
11425       p += len;
11426       printf ("  Tag_GNU_Power_ABI_FP: ");
11427
11428       switch (val)
11429         {
11430         case 0:
11431           printf (_("Hard or soft float\n"));
11432           break;
11433         case 1:
11434           printf (_("Hard float\n"));
11435           break;
11436         case 2:
11437           printf (_("Soft float\n"));
11438           break;
11439         case 3:
11440           printf (_("Single-precision hard float\n"));
11441           break;
11442         default:
11443           printf ("??? (%d)\n", val);
11444           break;
11445         }
11446       return p;
11447    }
11448
11449   if (tag == Tag_GNU_Power_ABI_Vector)
11450     {
11451       val = read_uleb128 (p, &len);
11452       p += len;
11453       printf ("  Tag_GNU_Power_ABI_Vector: ");
11454       switch (val)
11455         {
11456         case 0:
11457           printf (_("Any\n"));
11458           break;
11459         case 1:
11460           printf (_("Generic\n"));
11461           break;
11462         case 2:
11463           printf ("AltiVec\n");
11464           break;
11465         case 3:
11466           printf ("SPE\n");
11467           break;
11468         default:
11469           printf ("??? (%d)\n", val);
11470           break;
11471         }
11472       return p;
11473    }
11474
11475   if (tag == Tag_GNU_Power_ABI_Struct_Return)
11476     {
11477       val = read_uleb128 (p, &len);
11478       p += len;
11479       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
11480       switch (val)
11481        {
11482        case 0:
11483          printf (_("Any\n"));
11484          break;
11485        case 1:
11486          printf ("r3/r4\n");
11487          break;
11488        case 2:
11489          printf (_("Memory\n"));
11490          break;
11491        default:
11492          printf ("??? (%d)\n", val);
11493          break;
11494        }
11495       return p;
11496     }
11497
11498   if (tag & 1)
11499     type = 1; /* String.  */
11500   else
11501     type = 2; /* uleb128.  */
11502   printf ("  Tag_unknown_%d: ", tag);
11503
11504   if (type == 1)
11505     {
11506       printf ("\"%s\"\n", p);
11507       p += strlen ((char *) p) + 1;
11508     }
11509   else
11510     {
11511       val = read_uleb128 (p, &len);
11512       p += len;
11513       printf ("%d (0x%x)\n", val, val);
11514     }
11515
11516   return p;
11517 }
11518
11519 static void
11520 display_sparc_hwcaps (int mask)
11521 {
11522   if (mask)
11523     {
11524       int first = 1;
11525       if (mask & ELF_SPARC_HWCAP_MUL32)
11526         fputs ("mul32", stdout), first = 0;
11527       if (mask & ELF_SPARC_HWCAP_DIV32)
11528         printf ("%sdiv32", first ? "" : "|"), first = 0;
11529       if (mask & ELF_SPARC_HWCAP_FSMULD)
11530         printf ("%sfsmuld", first ? "" : "|"), first = 0;
11531       if (mask & ELF_SPARC_HWCAP_V8PLUS)
11532         printf ("%sv8plus", first ? "" : "|"), first = 0;
11533       if (mask & ELF_SPARC_HWCAP_POPC)
11534         printf ("%spopc", first ? "" : "|"), first = 0;
11535       if (mask & ELF_SPARC_HWCAP_VIS)
11536         printf ("%svis", first ? "" : "|"), first = 0;
11537       if (mask & ELF_SPARC_HWCAP_VIS2)
11538         printf ("%svis2", first ? "" : "|"), first = 0;
11539       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11540         printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11541       if (mask & ELF_SPARC_HWCAP_FMAF)
11542         printf ("%sfmaf", first ? "" : "|"), first = 0;
11543       if (mask & ELF_SPARC_HWCAP_VIS3)
11544         printf ("%svis3", first ? "" : "|"), first = 0;
11545       if (mask & ELF_SPARC_HWCAP_HPC)
11546         printf ("%shpc", first ? "" : "|"), first = 0;
11547       if (mask & ELF_SPARC_HWCAP_RANDOM)
11548         printf ("%srandom", first ? "" : "|"), first = 0;
11549       if (mask & ELF_SPARC_HWCAP_TRANS)
11550         printf ("%strans", first ? "" : "|"), first = 0;
11551       if (mask & ELF_SPARC_HWCAP_FJFMAU)
11552         printf ("%sfjfmau", first ? "" : "|"), first = 0;
11553       if (mask & ELF_SPARC_HWCAP_IMA)
11554         printf ("%sima", first ? "" : "|"), first = 0;
11555       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11556         printf ("%scspare", first ? "" : "|"), first = 0;
11557     }
11558   else
11559     fputc('0', stdout);
11560   fputc('\n', stdout);
11561 }
11562
11563 static unsigned char *
11564 display_sparc_gnu_attribute (unsigned char * p, int tag)
11565 {
11566   int type;
11567   unsigned int len;
11568   int val;
11569
11570   if (tag == Tag_GNU_Sparc_HWCAPS)
11571     {
11572       val = read_uleb128 (p, &len);
11573       p += len;
11574       printf ("  Tag_GNU_Sparc_HWCAPS: ");
11575
11576       display_sparc_hwcaps (val);
11577       return p;
11578    }
11579
11580   if (tag & 1)
11581     type = 1; /* String.  */
11582   else
11583     type = 2; /* uleb128.  */
11584   printf ("  Tag_unknown_%d: ", tag);
11585
11586   if (type == 1)
11587     {
11588       printf ("\"%s\"\n", p);
11589       p += strlen ((char *) p) + 1;
11590     }
11591   else
11592     {
11593       val = read_uleb128 (p, &len);
11594       p += len;
11595       printf ("%d (0x%x)\n", val, val);
11596     }
11597
11598   return p;
11599 }
11600
11601 static unsigned char *
11602 display_mips_gnu_attribute (unsigned char * p, int tag)
11603 {
11604   int type;
11605   unsigned int len;
11606   int val;
11607
11608   if (tag == Tag_GNU_MIPS_ABI_FP)
11609     {
11610       val = read_uleb128 (p, &len);
11611       p += len;
11612       printf ("  Tag_GNU_MIPS_ABI_FP: ");
11613
11614       switch (val)
11615         {
11616         case 0:
11617           printf (_("Hard or soft float\n"));
11618           break;
11619         case 1:
11620           printf (_("Hard float (double precision)\n"));
11621           break;
11622         case 2:
11623           printf (_("Hard float (single precision)\n"));
11624           break;
11625         case 3:
11626           printf (_("Soft float\n"));
11627           break;
11628         case 4:
11629           printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
11630           break;
11631         default:
11632           printf ("??? (%d)\n", val);
11633           break;
11634         }
11635       return p;
11636    }
11637
11638   if (tag & 1)
11639     type = 1; /* String.  */
11640   else
11641     type = 2; /* uleb128.  */
11642   printf ("  Tag_unknown_%d: ", tag);
11643
11644   if (type == 1)
11645     {
11646       printf ("\"%s\"\n", p);
11647       p += strlen ((char *) p) + 1;
11648     }
11649   else
11650     {
11651       val = read_uleb128 (p, &len);
11652       p += len;
11653       printf ("%d (0x%x)\n", val, val);
11654     }
11655
11656   return p;
11657 }
11658
11659 static unsigned char *
11660 display_tic6x_attribute (unsigned char * p)
11661 {
11662   int tag;
11663   unsigned int len;
11664   int val;
11665
11666   tag = read_uleb128 (p, &len);
11667   p += len;
11668
11669   switch (tag)
11670     {
11671     case Tag_ISA:
11672       val = read_uleb128 (p, &len);
11673       p += len;
11674       printf ("  Tag_ISA: ");
11675
11676       switch (val)
11677         {
11678         case C6XABI_Tag_ISA_none:
11679           printf (_("None\n"));
11680           break;
11681         case C6XABI_Tag_ISA_C62X:
11682           printf ("C62x\n");
11683           break;
11684         case C6XABI_Tag_ISA_C67X:
11685           printf ("C67x\n");
11686           break;
11687         case C6XABI_Tag_ISA_C67XP:
11688           printf ("C67x+\n");
11689           break;
11690         case C6XABI_Tag_ISA_C64X:
11691           printf ("C64x\n");
11692           break;
11693         case C6XABI_Tag_ISA_C64XP:
11694           printf ("C64x+\n");
11695           break;
11696         case C6XABI_Tag_ISA_C674X:
11697           printf ("C674x\n");
11698           break;
11699         default:
11700           printf ("??? (%d)\n", val);
11701           break;
11702         }
11703       return p;
11704
11705     case Tag_ABI_wchar_t:
11706       val = read_uleb128 (p, &len);
11707       p += len;
11708       printf ("  Tag_ABI_wchar_t: ");
11709       switch (val)
11710         {
11711         case 0:
11712           printf (_("Not used\n"));
11713           break;
11714         case 1:
11715           printf (_("2 bytes\n"));
11716           break;
11717         case 2:
11718           printf (_("4 bytes\n"));
11719           break;
11720         default:
11721           printf ("??? (%d)\n", val);
11722           break;
11723         }
11724       return p;
11725
11726     case Tag_ABI_stack_align_needed:
11727       val = read_uleb128 (p, &len);
11728       p += len;
11729       printf ("  Tag_ABI_stack_align_needed: ");
11730       switch (val)
11731         {
11732         case 0:
11733           printf (_("8-byte\n"));
11734           break;
11735         case 1:
11736           printf (_("16-byte\n"));
11737           break;
11738         default:
11739           printf ("??? (%d)\n", val);
11740           break;
11741         }
11742       return p;
11743
11744     case Tag_ABI_stack_align_preserved:
11745       val = read_uleb128 (p, &len);
11746       p += len;
11747       printf ("  Tag_ABI_stack_align_preserved: ");
11748       switch (val)
11749         {
11750         case 0:
11751           printf (_("8-byte\n"));
11752           break;
11753         case 1:
11754           printf (_("16-byte\n"));
11755           break;
11756         default:
11757           printf ("??? (%d)\n", val);
11758           break;
11759         }
11760       return p;
11761
11762     case Tag_ABI_DSBT:
11763       val = read_uleb128 (p, &len);
11764       p += len;
11765       printf ("  Tag_ABI_DSBT: ");
11766       switch (val)
11767         {
11768         case 0:
11769           printf (_("DSBT addressing not used\n"));
11770           break;
11771         case 1:
11772           printf (_("DSBT addressing used\n"));
11773           break;
11774         default:
11775           printf ("??? (%d)\n", val);
11776           break;
11777         }
11778       return p;
11779
11780     case Tag_ABI_PID:
11781       val = read_uleb128 (p, &len);
11782       p += len;
11783       printf ("  Tag_ABI_PID: ");
11784       switch (val)
11785         {
11786         case 0:
11787           printf (_("Data addressing position-dependent\n"));
11788           break;
11789         case 1:
11790           printf (_("Data addressing position-independent, GOT near DP\n"));
11791           break;
11792         case 2:
11793           printf (_("Data addressing position-independent, GOT far from DP\n"));
11794           break;
11795         default:
11796           printf ("??? (%d)\n", val);
11797           break;
11798         }
11799       return p;
11800
11801     case Tag_ABI_PIC:
11802       val = read_uleb128 (p, &len);
11803       p += len;
11804       printf ("  Tag_ABI_PIC: ");
11805       switch (val)
11806         {
11807         case 0:
11808           printf (_("Code addressing position-dependent\n"));
11809           break;
11810         case 1:
11811           printf (_("Code addressing position-independent\n"));
11812           break;
11813         default:
11814           printf ("??? (%d)\n", val);
11815           break;
11816         }
11817       return p;
11818
11819     case Tag_ABI_array_object_alignment:
11820       val = read_uleb128 (p, &len);
11821       p += len;
11822       printf ("  Tag_ABI_array_object_alignment: ");
11823       switch (val)
11824         {
11825         case 0:
11826           printf (_("8-byte\n"));
11827           break;
11828         case 1:
11829           printf (_("4-byte\n"));
11830           break;
11831         case 2:
11832           printf (_("16-byte\n"));
11833           break;
11834         default:
11835           printf ("??? (%d)\n", val);
11836           break;
11837         }
11838       return p;
11839
11840     case Tag_ABI_array_object_align_expected:
11841       val = read_uleb128 (p, &len);
11842       p += len;
11843       printf ("  Tag_ABI_array_object_align_expected: ");
11844       switch (val)
11845         {
11846         case 0:
11847           printf (_("8-byte\n"));
11848           break;
11849         case 1:
11850           printf (_("4-byte\n"));
11851           break;
11852         case 2:
11853           printf (_("16-byte\n"));
11854           break;
11855         default:
11856           printf ("??? (%d)\n", val);
11857           break;
11858         }
11859       return p;
11860
11861     case Tag_ABI_compatibility:
11862       val = read_uleb128 (p, &len);
11863       p += len;
11864       printf ("  Tag_ABI_compatibility: ");
11865       printf (_("flag = %d, vendor = %s\n"), val, p);
11866       p += strlen ((char *) p) + 1;
11867       return p;
11868
11869     case Tag_ABI_conformance:
11870       printf ("  Tag_ABI_conformance: ");
11871       printf ("\"%s\"\n", p);
11872       p += strlen ((char *) p) + 1;
11873       return p;
11874     }
11875
11876   printf ("  Tag_unknown_%d: ", tag);
11877
11878   if (tag & 1)
11879     {
11880       printf ("\"%s\"\n", p);
11881       p += strlen ((char *) p) + 1;
11882     }
11883   else
11884     {
11885       val = read_uleb128 (p, &len);
11886       p += len;
11887       printf ("%d (0x%x)\n", val, val);
11888     }
11889
11890   return p;
11891 }
11892
11893 static int
11894 process_attributes (FILE * file,
11895                     const char * public_name,
11896                     unsigned int proc_type,
11897                     unsigned char * (* display_pub_attribute) (unsigned char *),
11898                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11899 {
11900   Elf_Internal_Shdr * sect;
11901   unsigned char * contents;
11902   unsigned char * p;
11903   unsigned char * end;
11904   bfd_vma section_len;
11905   bfd_vma len;
11906   unsigned i;
11907
11908   /* Find the section header so that we get the size.  */
11909   for (i = 0, sect = section_headers;
11910        i < elf_header.e_shnum;
11911        i++, sect++)
11912     {
11913       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11914         continue;
11915
11916       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11917                                              sect->sh_size, _("attributes"));
11918       if (contents == NULL)
11919         continue;
11920
11921       p = contents;
11922       if (*p == 'A')
11923         {
11924           len = sect->sh_size - 1;
11925           p++;
11926
11927           while (len > 0)
11928             {
11929               int namelen;
11930               bfd_boolean public_section;
11931               bfd_boolean gnu_section;
11932
11933               section_len = byte_get (p, 4);
11934               p += 4;
11935
11936               if (section_len > len)
11937                 {
11938                   printf (_("ERROR: Bad section length (%d > %d)\n"),
11939                           (int) section_len, (int) len);
11940                   section_len = len;
11941                 }
11942
11943               len -= section_len;
11944               printf (_("Attribute Section: %s\n"), p);
11945
11946               if (public_name && streq ((char *) p, public_name))
11947                 public_section = TRUE;
11948               else
11949                 public_section = FALSE;
11950
11951               if (streq ((char *) p, "gnu"))
11952                 gnu_section = TRUE;
11953               else
11954                 gnu_section = FALSE;
11955
11956               namelen = strlen ((char *) p) + 1;
11957               p += namelen;
11958               section_len -= namelen + 4;
11959
11960               while (section_len > 0)
11961                 {
11962                   int tag = *(p++);
11963                   int val;
11964                   bfd_vma size;
11965
11966                   size = byte_get (p, 4);
11967                   if (size > section_len)
11968                     {
11969                       printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11970                               (int) size, (int) section_len);
11971                       size = section_len;
11972                     }
11973
11974                   section_len -= size;
11975                   end = p + size - 1;
11976                   p += 4;
11977
11978                   switch (tag)
11979                     {
11980                     case 1:
11981                       printf (_("File Attributes\n"));
11982                       break;
11983                     case 2:
11984                       printf (_("Section Attributes:"));
11985                       goto do_numlist;
11986                     case 3:
11987                       printf (_("Symbol Attributes:"));
11988                     do_numlist:
11989                       for (;;)
11990                         {
11991                           unsigned int j;
11992
11993                           val = read_uleb128 (p, &j);
11994                           p += j;
11995                           if (val == 0)
11996                             break;
11997                           printf (" %d", val);
11998                         }
11999                       printf ("\n");
12000                       break;
12001                     default:
12002                       printf (_("Unknown tag: %d\n"), tag);
12003                       public_section = FALSE;
12004                       break;
12005                     }
12006
12007                   if (public_section)
12008                     {
12009                       while (p < end)
12010                         p = display_pub_attribute (p);
12011                     }
12012                   else if (gnu_section)
12013                     {
12014                       while (p < end)
12015                         p = display_gnu_attribute (p,
12016                                                    display_proc_gnu_attribute);
12017                     }
12018                   else
12019                     {
12020                       /* ??? Do something sensible, like dump hex.  */
12021                       printf (_("  Unknown section contexts\n"));
12022                       p = end;
12023                     }
12024                 }
12025             }
12026         }
12027       else
12028         printf (_("Unknown format '%c'\n"), *p);
12029
12030       free (contents);
12031     }
12032   return 1;
12033 }
12034
12035 static int
12036 process_arm_specific (FILE * file)
12037 {
12038   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
12039                              display_arm_attribute, NULL);
12040 }
12041
12042 static int
12043 process_power_specific (FILE * file)
12044 {
12045   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12046                              display_power_gnu_attribute);
12047 }
12048
12049 static int
12050 process_sparc_specific (FILE * file)
12051 {
12052   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12053                              display_sparc_gnu_attribute);
12054 }
12055
12056 static int
12057 process_tic6x_specific (FILE * file)
12058 {
12059   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
12060                              display_tic6x_attribute, NULL);
12061 }
12062
12063 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12064    Print the Address, Access and Initial fields of an entry at VMA ADDR
12065    and return the VMA of the next entry.  */
12066
12067 static bfd_vma
12068 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12069 {
12070   printf ("  ");
12071   print_vma (addr, LONG_HEX);
12072   printf (" ");
12073   if (addr < pltgot + 0xfff0)
12074     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
12075   else
12076     printf ("%10s", "");
12077   printf (" ");
12078   if (data == NULL)
12079     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12080   else
12081     {
12082       bfd_vma entry;
12083
12084       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12085       print_vma (entry, LONG_HEX);
12086     }
12087   return addr + (is_32bit_elf ? 4 : 8);
12088 }
12089
12090 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12091    PLTGOT.  Print the Address and Initial fields of an entry at VMA
12092    ADDR and return the VMA of the next entry.  */
12093
12094 static bfd_vma
12095 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12096 {
12097   printf ("  ");
12098   print_vma (addr, LONG_HEX);
12099   printf (" ");
12100   if (data == NULL)
12101     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12102   else
12103     {
12104       bfd_vma entry;
12105
12106       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12107       print_vma (entry, LONG_HEX);
12108     }
12109   return addr + (is_32bit_elf ? 4 : 8);
12110 }
12111
12112 static int
12113 process_mips_specific (FILE * file)
12114 {
12115   Elf_Internal_Dyn * entry;
12116   size_t liblist_offset = 0;
12117   size_t liblistno = 0;
12118   size_t conflictsno = 0;
12119   size_t options_offset = 0;
12120   size_t conflicts_offset = 0;
12121   size_t pltrelsz = 0;
12122   size_t pltrel = 0;
12123   bfd_vma pltgot = 0;
12124   bfd_vma mips_pltgot = 0;
12125   bfd_vma jmprel = 0;
12126   bfd_vma local_gotno = 0;
12127   bfd_vma gotsym = 0;
12128   bfd_vma symtabno = 0;
12129
12130   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12131                       display_mips_gnu_attribute);
12132
12133   /* We have a lot of special sections.  Thanks SGI!  */
12134   if (dynamic_section == NULL)
12135     /* No information available.  */
12136     return 0;
12137
12138   for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
12139     switch (entry->d_tag)
12140       {
12141       case DT_MIPS_LIBLIST:
12142         liblist_offset
12143           = offset_from_vma (file, entry->d_un.d_val,
12144                              liblistno * sizeof (Elf32_External_Lib));
12145         break;
12146       case DT_MIPS_LIBLISTNO:
12147         liblistno = entry->d_un.d_val;
12148         break;
12149       case DT_MIPS_OPTIONS:
12150         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
12151         break;
12152       case DT_MIPS_CONFLICT:
12153         conflicts_offset
12154           = offset_from_vma (file, entry->d_un.d_val,
12155                              conflictsno * sizeof (Elf32_External_Conflict));
12156         break;
12157       case DT_MIPS_CONFLICTNO:
12158         conflictsno = entry->d_un.d_val;
12159         break;
12160       case DT_PLTGOT:
12161         pltgot = entry->d_un.d_ptr;
12162         break;
12163       case DT_MIPS_LOCAL_GOTNO:
12164         local_gotno = entry->d_un.d_val;
12165         break;
12166       case DT_MIPS_GOTSYM:
12167         gotsym = entry->d_un.d_val;
12168         break;
12169       case DT_MIPS_SYMTABNO:
12170         symtabno = entry->d_un.d_val;
12171         break;
12172       case DT_MIPS_PLTGOT:
12173         mips_pltgot = entry->d_un.d_ptr;
12174         break;
12175       case DT_PLTREL:
12176         pltrel = entry->d_un.d_val;
12177         break;
12178       case DT_PLTRELSZ:
12179         pltrelsz = entry->d_un.d_val;
12180         break;
12181       case DT_JMPREL:
12182         jmprel = entry->d_un.d_ptr;
12183         break;
12184       default:
12185         break;
12186       }
12187
12188   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
12189     {
12190       Elf32_External_Lib * elib;
12191       size_t cnt;
12192
12193       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
12194                                               liblistno,
12195                                               sizeof (Elf32_External_Lib),
12196                                               _("liblist section data"));
12197       if (elib)
12198         {
12199           printf (_("\nSection '.liblist' contains %lu entries:\n"),
12200                   (unsigned long) liblistno);
12201           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
12202                  stdout);
12203
12204           for (cnt = 0; cnt < liblistno; ++cnt)
12205             {
12206               Elf32_Lib liblist;
12207               time_t atime;
12208               char timebuf[20];
12209               struct tm * tmp;
12210
12211               liblist.l_name = BYTE_GET (elib[cnt].l_name);
12212               atime = BYTE_GET (elib[cnt].l_time_stamp);
12213               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12214               liblist.l_version = BYTE_GET (elib[cnt].l_version);
12215               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12216
12217               tmp = gmtime (&atime);
12218               snprintf (timebuf, sizeof (timebuf),
12219                         "%04u-%02u-%02uT%02u:%02u:%02u",
12220                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12221                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12222
12223               printf ("%3lu: ", (unsigned long) cnt);
12224               if (VALID_DYNAMIC_NAME (liblist.l_name))
12225                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
12226               else
12227                 printf (_("<corrupt: %9ld>"), liblist.l_name);
12228               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
12229                       liblist.l_version);
12230
12231               if (liblist.l_flags == 0)
12232                 puts (_(" NONE"));
12233               else
12234                 {
12235                   static const struct
12236                   {
12237                     const char * name;
12238                     int bit;
12239                   }
12240                   l_flags_vals[] =
12241                   {
12242                     { " EXACT_MATCH", LL_EXACT_MATCH },
12243                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
12244                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
12245                     { " EXPORTS", LL_EXPORTS },
12246                     { " DELAY_LOAD", LL_DELAY_LOAD },
12247                     { " DELTA", LL_DELTA }
12248                   };
12249                   int flags = liblist.l_flags;
12250                   size_t fcnt;
12251
12252                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
12253                     if ((flags & l_flags_vals[fcnt].bit) != 0)
12254                       {
12255                         fputs (l_flags_vals[fcnt].name, stdout);
12256                         flags ^= l_flags_vals[fcnt].bit;
12257                       }
12258                   if (flags != 0)
12259                     printf (" %#x", (unsigned int) flags);
12260
12261                   puts ("");
12262                 }
12263             }
12264
12265           free (elib);
12266         }
12267     }
12268
12269   if (options_offset != 0)
12270     {
12271       Elf_External_Options * eopt;
12272       Elf_Internal_Shdr * sect = section_headers;
12273       Elf_Internal_Options * iopt;
12274       Elf_Internal_Options * option;
12275       size_t offset;
12276       int cnt;
12277
12278       /* Find the section header so that we get the size.  */
12279       while (sect->sh_type != SHT_MIPS_OPTIONS)
12280         ++sect;
12281
12282       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
12283                                                 sect->sh_size, _("options"));
12284       if (eopt)
12285         {
12286           iopt = (Elf_Internal_Options *)
12287               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
12288           if (iopt == NULL)
12289             {
12290               error (_("Out of memory\n"));
12291               return 0;
12292             }
12293
12294           offset = cnt = 0;
12295           option = iopt;
12296
12297           while (offset < sect->sh_size)
12298             {
12299               Elf_External_Options * eoption;
12300
12301               eoption = (Elf_External_Options *) ((char *) eopt + offset);
12302
12303               option->kind = BYTE_GET (eoption->kind);
12304               option->size = BYTE_GET (eoption->size);
12305               option->section = BYTE_GET (eoption->section);
12306               option->info = BYTE_GET (eoption->info);
12307
12308               offset += option->size;
12309
12310               ++option;
12311               ++cnt;
12312             }
12313
12314           printf (_("\nSection '%s' contains %d entries:\n"),
12315                   SECTION_NAME (sect), cnt);
12316
12317           option = iopt;
12318
12319           while (cnt-- > 0)
12320             {
12321               size_t len;
12322
12323               switch (option->kind)
12324                 {
12325                 case ODK_NULL:
12326                   /* This shouldn't happen.  */
12327                   printf (" NULL       %d %lx", option->section, option->info);
12328                   break;
12329                 case ODK_REGINFO:
12330                   printf (" REGINFO    ");
12331                   if (elf_header.e_machine == EM_MIPS)
12332                     {
12333                       /* 32bit form.  */
12334                       Elf32_External_RegInfo * ereg;
12335                       Elf32_RegInfo reginfo;
12336
12337                       ereg = (Elf32_External_RegInfo *) (option + 1);
12338                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12339                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12340                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12341                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12342                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12343                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12344
12345                       printf ("GPR %08lx  GP 0x%lx\n",
12346                               reginfo.ri_gprmask,
12347                               (unsigned long) reginfo.ri_gp_value);
12348                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
12349                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12350                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12351                     }
12352                   else
12353                     {
12354                       /* 64 bit form.  */
12355                       Elf64_External_RegInfo * ereg;
12356                       Elf64_Internal_RegInfo reginfo;
12357
12358                       ereg = (Elf64_External_RegInfo *) (option + 1);
12359                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
12360                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12361                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12362                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12363                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12364                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
12365
12366                       printf ("GPR %08lx  GP 0x",
12367                               reginfo.ri_gprmask);
12368                       printf_vma (reginfo.ri_gp_value);
12369                       printf ("\n");
12370
12371                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
12372                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12373                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12374                     }
12375                   ++option;
12376                   continue;
12377                 case ODK_EXCEPTIONS:
12378                   fputs (" EXCEPTIONS fpe_min(", stdout);
12379                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12380                   fputs (") fpe_max(", stdout);
12381                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12382                   fputs (")", stdout);
12383
12384                   if (option->info & OEX_PAGE0)
12385                     fputs (" PAGE0", stdout);
12386                   if (option->info & OEX_SMM)
12387                     fputs (" SMM", stdout);
12388                   if (option->info & OEX_FPDBUG)
12389                     fputs (" FPDBUG", stdout);
12390                   if (option->info & OEX_DISMISS)
12391                     fputs (" DISMISS", stdout);
12392                   break;
12393                 case ODK_PAD:
12394                   fputs (" PAD       ", stdout);
12395                   if (option->info & OPAD_PREFIX)
12396                     fputs (" PREFIX", stdout);
12397                   if (option->info & OPAD_POSTFIX)
12398                     fputs (" POSTFIX", stdout);
12399                   if (option->info & OPAD_SYMBOL)
12400                     fputs (" SYMBOL", stdout);
12401                   break;
12402                 case ODK_HWPATCH:
12403                   fputs (" HWPATCH   ", stdout);
12404                   if (option->info & OHW_R4KEOP)
12405                     fputs (" R4KEOP", stdout);
12406                   if (option->info & OHW_R8KPFETCH)
12407                     fputs (" R8KPFETCH", stdout);
12408                   if (option->info & OHW_R5KEOP)
12409                     fputs (" R5KEOP", stdout);
12410                   if (option->info & OHW_R5KCVTL)
12411                     fputs (" R5KCVTL", stdout);
12412                   break;
12413                 case ODK_FILL:
12414                   fputs (" FILL       ", stdout);
12415                   /* XXX Print content of info word?  */
12416                   break;
12417                 case ODK_TAGS:
12418                   fputs (" TAGS       ", stdout);
12419                   /* XXX Print content of info word?  */
12420                   break;
12421                 case ODK_HWAND:
12422                   fputs (" HWAND     ", stdout);
12423                   if (option->info & OHWA0_R4KEOP_CHECKED)
12424                     fputs (" R4KEOP_CHECKED", stdout);
12425                   if (option->info & OHWA0_R4KEOP_CLEAN)
12426                     fputs (" R4KEOP_CLEAN", stdout);
12427                   break;
12428                 case ODK_HWOR:
12429                   fputs (" HWOR      ", stdout);
12430                   if (option->info & OHWA0_R4KEOP_CHECKED)
12431                     fputs (" R4KEOP_CHECKED", stdout);
12432                   if (option->info & OHWA0_R4KEOP_CLEAN)
12433                     fputs (" R4KEOP_CLEAN", stdout);
12434                   break;
12435                 case ODK_GP_GROUP:
12436                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
12437                           option->info & OGP_GROUP,
12438                           (option->info & OGP_SELF) >> 16);
12439                   break;
12440                 case ODK_IDENT:
12441                   printf (" IDENT     %#06lx  self-contained %#06lx",
12442                           option->info & OGP_GROUP,
12443                           (option->info & OGP_SELF) >> 16);
12444                   break;
12445                 default:
12446                   /* This shouldn't happen.  */
12447                   printf (" %3d ???     %d %lx",
12448                           option->kind, option->section, option->info);
12449                   break;
12450                 }
12451
12452               len = sizeof (* eopt);
12453               while (len < option->size)
12454                 if (((char *) option)[len] >= ' '
12455                     && ((char *) option)[len] < 0x7f)
12456                   printf ("%c", ((char *) option)[len++]);
12457                 else
12458                   printf ("\\%03o", ((char *) option)[len++]);
12459
12460               fputs ("\n", stdout);
12461               ++option;
12462             }
12463
12464           free (eopt);
12465         }
12466     }
12467
12468   if (conflicts_offset != 0 && conflictsno != 0)
12469     {
12470       Elf32_Conflict * iconf;
12471       size_t cnt;
12472
12473       if (dynamic_symbols == NULL)
12474         {
12475           error (_("conflict list found without a dynamic symbol table\n"));
12476           return 0;
12477         }
12478
12479       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
12480       if (iconf == NULL)
12481         {
12482           error (_("Out of memory\n"));
12483           return 0;
12484         }
12485
12486       if (is_32bit_elf)
12487         {
12488           Elf32_External_Conflict * econf32;
12489
12490           econf32 = (Elf32_External_Conflict *)
12491               get_data (NULL, file, conflicts_offset, conflictsno,
12492                         sizeof (* econf32), _("conflict"));
12493           if (!econf32)
12494             return 0;
12495
12496           for (cnt = 0; cnt < conflictsno; ++cnt)
12497             iconf[cnt] = BYTE_GET (econf32[cnt]);
12498
12499           free (econf32);
12500         }
12501       else
12502         {
12503           Elf64_External_Conflict * econf64;
12504
12505           econf64 = (Elf64_External_Conflict *)
12506               get_data (NULL, file, conflicts_offset, conflictsno,
12507                         sizeof (* econf64), _("conflict"));
12508           if (!econf64)
12509             return 0;
12510
12511           for (cnt = 0; cnt < conflictsno; ++cnt)
12512             iconf[cnt] = BYTE_GET (econf64[cnt]);
12513
12514           free (econf64);
12515         }
12516
12517       printf (_("\nSection '.conflict' contains %lu entries:\n"),
12518               (unsigned long) conflictsno);
12519       puts (_("  Num:    Index       Value  Name"));
12520
12521       for (cnt = 0; cnt < conflictsno; ++cnt)
12522         {
12523           Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
12524
12525           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
12526           print_vma (psym->st_value, FULL_HEX);
12527           putchar (' ');
12528           if (VALID_DYNAMIC_NAME (psym->st_name))
12529             print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
12530           else
12531             printf (_("<corrupt: %14ld>"), psym->st_name);
12532           putchar ('\n');
12533         }
12534
12535       free (iconf);
12536     }
12537
12538   if (pltgot != 0 && local_gotno != 0)
12539     {
12540       bfd_vma ent, local_end, global_end;
12541       size_t i, offset;
12542       unsigned char * data;
12543       int addr_size;
12544
12545       ent = pltgot;
12546       addr_size = (is_32bit_elf ? 4 : 8);
12547       local_end = pltgot + local_gotno * addr_size;
12548       global_end = local_end + (symtabno - gotsym) * addr_size;
12549
12550       offset = offset_from_vma (file, pltgot, global_end - pltgot);
12551       data = (unsigned char *) get_data (NULL, file, offset,
12552                                          global_end - pltgot, 1,
12553                                          _("Global Offset Table data"));
12554       if (data == NULL)
12555         return 0;
12556
12557       printf (_("\nPrimary GOT:\n"));
12558       printf (_(" Canonical gp value: "));
12559       print_vma (pltgot + 0x7ff0, LONG_HEX);
12560       printf ("\n\n");
12561
12562       printf (_(" Reserved entries:\n"));
12563       printf (_("  %*s %10s %*s Purpose\n"),
12564               addr_size * 2, _("Address"), _("Access"),
12565               addr_size * 2, _("Initial"));
12566       ent = print_mips_got_entry (data, pltgot, ent);
12567       printf (_(" Lazy resolver\n"));
12568       if (data
12569           && (byte_get (data + ent - pltgot, addr_size)
12570               >> (addr_size * 8 - 1)) != 0)
12571         {
12572           ent = print_mips_got_entry (data, pltgot, ent);
12573           printf (_(" Module pointer (GNU extension)\n"));
12574         }
12575       printf ("\n");
12576
12577       if (ent < local_end)
12578         {
12579           printf (_(" Local entries:\n"));
12580           printf ("  %*s %10s %*s\n",
12581                   addr_size * 2, _("Address"), _("Access"),
12582                   addr_size * 2, _("Initial"));
12583           while (ent < local_end)
12584             {
12585               ent = print_mips_got_entry (data, pltgot, ent);
12586               printf ("\n");
12587             }
12588           printf ("\n");
12589         }
12590
12591       if (gotsym < symtabno)
12592         {
12593           int sym_width;
12594
12595           printf (_(" Global entries:\n"));
12596           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
12597                   addr_size * 2, _("Address"),
12598                   _("Access"),
12599                   addr_size * 2, _("Initial"),
12600                   addr_size * 2, _("Sym.Val."),
12601                   _("Type"),
12602                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
12603                   _("Ndx"), _("Name"));
12604
12605           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12606           for (i = gotsym; i < symtabno; i++)
12607             {
12608               Elf_Internal_Sym * psym;
12609
12610               psym = dynamic_symbols + i;
12611               ent = print_mips_got_entry (data, pltgot, ent);
12612               printf (" ");
12613               print_vma (psym->st_value, LONG_HEX);
12614               printf (" %-7s %3s ",
12615                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12616                       get_symbol_index_type (psym->st_shndx));
12617               if (VALID_DYNAMIC_NAME (psym->st_name))
12618                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12619               else
12620                 printf (_("<corrupt: %14ld>"), psym->st_name);
12621               printf ("\n");
12622             }
12623           printf ("\n");
12624         }
12625
12626       if (data)
12627         free (data);
12628     }
12629
12630   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12631     {
12632       bfd_vma ent, end;
12633       size_t offset, rel_offset;
12634       unsigned long count, i;
12635       unsigned char * data;
12636       int addr_size, sym_width;
12637       Elf_Internal_Rela * rels;
12638
12639       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12640       if (pltrel == DT_RELA)
12641         {
12642           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12643             return 0;
12644         }
12645       else
12646         {
12647           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12648             return 0;
12649         }
12650
12651       ent = mips_pltgot;
12652       addr_size = (is_32bit_elf ? 4 : 8);
12653       end = mips_pltgot + (2 + count) * addr_size;
12654
12655       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
12656       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
12657                                          1, _("Procedure Linkage Table data"));
12658       if (data == NULL)
12659         return 0;
12660
12661       printf ("\nPLT GOT:\n\n");
12662       printf (_(" Reserved entries:\n"));
12663       printf (_("  %*s %*s Purpose\n"),
12664               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
12665       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12666       printf (_(" PLT lazy resolver\n"));
12667       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12668       printf (_(" Module pointer\n"));
12669       printf ("\n");
12670
12671       printf (_(" Entries:\n"));
12672       printf ("  %*s %*s %*s %-7s %3s %s\n",
12673               addr_size * 2, _("Address"),
12674               addr_size * 2, _("Initial"),
12675               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12676       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12677       for (i = 0; i < count; i++)
12678         {
12679           Elf_Internal_Sym * psym;
12680
12681           psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
12682           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12683           printf (" ");
12684           print_vma (psym->st_value, LONG_HEX);
12685           printf (" %-7s %3s ",
12686                   get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12687                   get_symbol_index_type (psym->st_shndx));
12688           if (VALID_DYNAMIC_NAME (psym->st_name))
12689             print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12690           else
12691             printf (_("<corrupt: %14ld>"), psym->st_name);
12692           printf ("\n");
12693         }
12694       printf ("\n");
12695
12696       if (data)
12697         free (data);
12698       free (rels);
12699     }
12700
12701   return 1;
12702 }
12703
12704 static int
12705 process_gnu_liblist (FILE * file)
12706 {
12707   Elf_Internal_Shdr * section;
12708   Elf_Internal_Shdr * string_sec;
12709   Elf32_External_Lib * elib;
12710   char * strtab;
12711   size_t strtab_size;
12712   size_t cnt;
12713   unsigned i;
12714
12715   if (! do_arch)
12716     return 0;
12717
12718   for (i = 0, section = section_headers;
12719        i < elf_header.e_shnum;
12720        i++, section++)
12721     {
12722       switch (section->sh_type)
12723         {
12724         case SHT_GNU_LIBLIST:
12725           if (section->sh_link >= elf_header.e_shnum)
12726             break;
12727
12728           elib = (Elf32_External_Lib *)
12729               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
12730                         _("liblist section data"));
12731
12732           if (elib == NULL)
12733             break;
12734           string_sec = section_headers + section->sh_link;
12735
12736           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12737                                       string_sec->sh_size,
12738                                       _("liblist string table"));
12739           if (strtab == NULL
12740               || section->sh_entsize != sizeof (Elf32_External_Lib))
12741             {
12742               free (elib);
12743               free (strtab);
12744               break;
12745             }
12746           strtab_size = string_sec->sh_size;
12747
12748           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12749                   SECTION_NAME (section),
12750                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
12751
12752           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
12753
12754           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12755                ++cnt)
12756             {
12757               Elf32_Lib liblist;
12758               time_t atime;
12759               char timebuf[20];
12760               struct tm * tmp;
12761
12762               liblist.l_name = BYTE_GET (elib[cnt].l_name);
12763               atime = BYTE_GET (elib[cnt].l_time_stamp);
12764               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12765               liblist.l_version = BYTE_GET (elib[cnt].l_version);
12766               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12767
12768               tmp = gmtime (&atime);
12769               snprintf (timebuf, sizeof (timebuf),
12770                         "%04u-%02u-%02uT%02u:%02u:%02u",
12771                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12772                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12773
12774               printf ("%3lu: ", (unsigned long) cnt);
12775               if (do_wide)
12776                 printf ("%-20s", liblist.l_name < strtab_size
12777                         ? strtab + liblist.l_name : _("<corrupt>"));
12778               else
12779                 printf ("%-20.20s", liblist.l_name < strtab_size
12780                         ? strtab + liblist.l_name : _("<corrupt>"));
12781               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12782                       liblist.l_version, liblist.l_flags);
12783             }
12784
12785           free (elib);
12786           free (strtab);
12787         }
12788     }
12789
12790   return 1;
12791 }
12792
12793 static const char *
12794 get_note_type (unsigned e_type)
12795 {
12796   static char buff[64];
12797
12798   if (elf_header.e_type == ET_CORE)
12799     switch (e_type)
12800       {
12801       case NT_AUXV:
12802         return _("NT_AUXV (auxiliary vector)");
12803       case NT_PRSTATUS:
12804         return _("NT_PRSTATUS (prstatus structure)");
12805       case NT_FPREGSET:
12806         return _("NT_FPREGSET (floating point registers)");
12807       case NT_PRPSINFO:
12808         return _("NT_PRPSINFO (prpsinfo structure)");
12809       case NT_TASKSTRUCT:
12810         return _("NT_TASKSTRUCT (task structure)");
12811       case NT_PRXFPREG:
12812         return _("NT_PRXFPREG (user_xfpregs structure)");
12813       case NT_PPC_VMX:
12814         return _("NT_PPC_VMX (ppc Altivec registers)");
12815       case NT_PPC_VSX:
12816         return _("NT_PPC_VSX (ppc VSX registers)");
12817       case NT_386_TLS:
12818         return _("NT_386_TLS (x86 TLS information)");
12819       case NT_386_IOPERM:
12820         return _("NT_386_IOPERM (x86 I/O permissions)");
12821       case NT_X86_XSTATE:
12822         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
12823       case NT_S390_HIGH_GPRS:
12824         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
12825       case NT_S390_TIMER:
12826         return _("NT_S390_TIMER (s390 timer register)");
12827       case NT_S390_TODCMP:
12828         return _("NT_S390_TODCMP (s390 TOD comparator register)");
12829       case NT_S390_TODPREG:
12830         return _("NT_S390_TODPREG (s390 TOD programmable register)");
12831       case NT_S390_CTRS:
12832         return _("NT_S390_CTRS (s390 control registers)");
12833       case NT_S390_PREFIX:
12834         return _("NT_S390_PREFIX (s390 prefix register)");
12835       case NT_S390_LAST_BREAK:
12836         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
12837       case NT_S390_SYSTEM_CALL:
12838         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
12839       case NT_ARM_VFP:
12840         return _("NT_ARM_VFP (arm VFP registers)");
12841       case NT_ARM_TLS:
12842         return _("NT_ARM_TLS (AArch TLS registers)");
12843       case NT_ARM_HW_BREAK:
12844         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
12845       case NT_ARM_HW_WATCH:
12846         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
12847       case NT_PSTATUS:
12848         return _("NT_PSTATUS (pstatus structure)");
12849       case NT_FPREGS:
12850         return _("NT_FPREGS (floating point registers)");
12851       case NT_PSINFO:
12852         return _("NT_PSINFO (psinfo structure)");
12853       case NT_LWPSTATUS:
12854         return _("NT_LWPSTATUS (lwpstatus_t structure)");
12855       case NT_LWPSINFO:
12856         return _("NT_LWPSINFO (lwpsinfo_t structure)");
12857       case NT_WIN32PSTATUS:
12858         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12859       case NT_SIGINFO:
12860         return _("NT_SIGINFO (siginfo_t data)");
12861       case NT_FILE:
12862         return _("NT_FILE (mapped files)");
12863       default:
12864         break;
12865       }
12866   else
12867     switch (e_type)
12868       {
12869       case NT_VERSION:
12870         return _("NT_VERSION (version)");
12871       case NT_ARCH:
12872         return _("NT_ARCH (architecture)");
12873       default:
12874         break;
12875       }
12876
12877   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12878   return buff;
12879 }
12880
12881 static int
12882 print_core_note (Elf_Internal_Note *pnote)
12883 {
12884   unsigned int addr_size = is_32bit_elf ? 4 : 8;
12885   bfd_vma count, page_size;
12886   unsigned char *descdata, *filenames, *descend;
12887
12888   if (pnote->type != NT_FILE)
12889     return 1;
12890
12891 #ifndef BFD64
12892   if (!is_32bit_elf)
12893     {
12894       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
12895       /* Still "successful".  */
12896       return 1;
12897     }
12898 #endif
12899
12900   if (pnote->descsz < 2 * addr_size)
12901     {
12902       printf (_("    Malformed note - too short for header\n"));
12903       return 0;
12904     }
12905
12906   descdata = (unsigned char *) pnote->descdata;
12907   descend = descdata + pnote->descsz;
12908
12909   if (descdata[pnote->descsz - 1] != '\0')
12910     {
12911       printf (_("    Malformed note - does not end with \\0\n"));
12912       return 0;
12913     }
12914
12915   count = byte_get (descdata, addr_size);
12916   descdata += addr_size;
12917
12918   page_size = byte_get (descdata, addr_size);
12919   descdata += addr_size;
12920
12921   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
12922     {
12923       printf (_("    Malformed note - too short for supplied file count\n"));
12924       return 0;
12925     }
12926
12927   printf (_("    Page size: "));
12928   print_vma (page_size, DEC);
12929   printf ("\n");
12930
12931   printf (_("    %*s%*s%*s\n"),
12932           (int) (2 + 2 * addr_size), _("Start"),
12933           (int) (4 + 2 * addr_size), _("End"),
12934           (int) (4 + 2 * addr_size), _("Page Offset"));
12935   filenames = descdata + count * 3 * addr_size;
12936   while (--count > 0)
12937     {
12938       bfd_vma start, end, file_ofs;
12939
12940       if (filenames == descend)
12941         {
12942           printf (_("    Malformed note - filenames end too early\n"));
12943           return 0;
12944         }
12945
12946       start = byte_get (descdata, addr_size);
12947       descdata += addr_size;
12948       end = byte_get (descdata, addr_size);
12949       descdata += addr_size;
12950       file_ofs = byte_get (descdata, addr_size);
12951       descdata += addr_size;
12952
12953       printf ("    ");
12954       print_vma (start, FULL_HEX);
12955       printf ("  ");
12956       print_vma (end, FULL_HEX);
12957       printf ("  ");
12958       print_vma (file_ofs, FULL_HEX);
12959       printf ("\n        %s\n", filenames);
12960
12961       filenames += 1 + strlen ((char *) filenames);
12962     }
12963
12964   return 1;
12965 }
12966
12967 static const char *
12968 get_gnu_elf_note_type (unsigned e_type)
12969 {
12970   static char buff[64];
12971
12972   switch (e_type)
12973     {
12974     case NT_GNU_ABI_TAG:
12975       return _("NT_GNU_ABI_TAG (ABI version tag)");
12976     case NT_GNU_HWCAP:
12977       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12978     case NT_GNU_BUILD_ID:
12979       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
12980     case NT_GNU_GOLD_VERSION:
12981       return _("NT_GNU_GOLD_VERSION (gold version)");
12982     default:
12983       break;
12984     }
12985
12986   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12987   return buff;
12988 }
12989
12990 static int
12991 print_gnu_note (Elf_Internal_Note *pnote)
12992 {
12993   switch (pnote->type)
12994     {
12995     case NT_GNU_BUILD_ID:
12996       {
12997         unsigned long i;
12998
12999         printf (_("    Build ID: "));
13000         for (i = 0; i < pnote->descsz; ++i)
13001           printf ("%02x", pnote->descdata[i] & 0xff);
13002         printf ("\n");
13003       }
13004       break;
13005
13006     case NT_GNU_ABI_TAG:
13007       {
13008         unsigned long os, major, minor, subminor;
13009         const char *osname;
13010
13011         os = byte_get ((unsigned char *) pnote->descdata, 4);
13012         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
13013         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
13014         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
13015
13016         switch (os)
13017           {
13018           case GNU_ABI_TAG_LINUX:
13019             osname = "Linux";
13020             break;
13021           case GNU_ABI_TAG_HURD:
13022             osname = "Hurd";
13023             break;
13024           case GNU_ABI_TAG_SOLARIS:
13025             osname = "Solaris";
13026             break;
13027           case GNU_ABI_TAG_FREEBSD:
13028             osname = "FreeBSD";
13029             break;
13030           case GNU_ABI_TAG_NETBSD:
13031             osname = "NetBSD";
13032             break;
13033           default:
13034             osname = "Unknown";
13035             break;
13036           }
13037
13038         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
13039                 major, minor, subminor);
13040       }
13041       break;
13042     }
13043
13044   return 1;
13045 }
13046
13047 static const char *
13048 get_netbsd_elfcore_note_type (unsigned e_type)
13049 {
13050   static char buff[64];
13051
13052   if (e_type == NT_NETBSDCORE_PROCINFO)
13053     {
13054       /* NetBSD core "procinfo" structure.  */
13055       return _("NetBSD procinfo structure");
13056     }
13057
13058   /* As of Jan 2002 there are no other machine-independent notes
13059      defined for NetBSD core files.  If the note type is less
13060      than the start of the machine-dependent note types, we don't
13061      understand it.  */
13062
13063   if (e_type < NT_NETBSDCORE_FIRSTMACH)
13064     {
13065       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13066       return buff;
13067     }
13068
13069   switch (elf_header.e_machine)
13070     {
13071     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13072        and PT_GETFPREGS == mach+2.  */
13073
13074     case EM_OLD_ALPHA:
13075     case EM_ALPHA:
13076     case EM_SPARC:
13077     case EM_SPARC32PLUS:
13078     case EM_SPARCV9:
13079       switch (e_type)
13080         {
13081         case NT_NETBSDCORE_FIRSTMACH + 0:
13082           return _("PT_GETREGS (reg structure)");
13083         case NT_NETBSDCORE_FIRSTMACH + 2:
13084           return _("PT_GETFPREGS (fpreg structure)");
13085         default:
13086           break;
13087         }
13088       break;
13089
13090     /* On all other arch's, PT_GETREGS == mach+1 and
13091        PT_GETFPREGS == mach+3.  */
13092     default:
13093       switch (e_type)
13094         {
13095         case NT_NETBSDCORE_FIRSTMACH + 1:
13096           return _("PT_GETREGS (reg structure)");
13097         case NT_NETBSDCORE_FIRSTMACH + 3:
13098           return _("PT_GETFPREGS (fpreg structure)");
13099         default:
13100           break;
13101         }
13102     }
13103
13104   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
13105             e_type - NT_NETBSDCORE_FIRSTMACH);
13106   return buff;
13107 }
13108
13109 static const char *
13110 get_stapsdt_note_type (unsigned e_type)
13111 {
13112   static char buff[64];
13113
13114   switch (e_type)
13115     {
13116     case NT_STAPSDT:
13117       return _("NT_STAPSDT (SystemTap probe descriptors)");
13118
13119     default:
13120       break;
13121     }
13122
13123   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13124   return buff;
13125 }
13126
13127 static int
13128 print_stapsdt_note (Elf_Internal_Note *pnote)
13129 {
13130   int addr_size = is_32bit_elf ? 4 : 8;
13131   char *data = pnote->descdata;
13132   char *data_end = pnote->descdata + pnote->descsz;
13133   bfd_vma pc, base_addr, semaphore;
13134   char *provider, *probe, *arg_fmt;
13135
13136   pc = byte_get ((unsigned char *) data, addr_size);
13137   data += addr_size;
13138   base_addr = byte_get ((unsigned char *) data, addr_size);
13139   data += addr_size;
13140   semaphore = byte_get ((unsigned char *) data, addr_size);
13141   data += addr_size;
13142
13143   provider = data;
13144   data += strlen (data) + 1;
13145   probe = data;
13146   data += strlen (data) + 1;
13147   arg_fmt = data;
13148   data += strlen (data) + 1;
13149
13150   printf (_("    Provider: %s\n"), provider);
13151   printf (_("    Name: %s\n"), probe);
13152   printf (_("    Location: "));
13153   print_vma (pc, FULL_HEX);
13154   printf (_(", Base: "));
13155   print_vma (base_addr, FULL_HEX);
13156   printf (_(", Semaphore: "));
13157   print_vma (semaphore, FULL_HEX);
13158   printf ("\n");
13159   printf (_("    Arguments: %s\n"), arg_fmt);
13160
13161   return data == data_end;
13162 }
13163
13164 static const char *
13165 get_ia64_vms_note_type (unsigned e_type)
13166 {
13167   static char buff[64];
13168
13169   switch (e_type)
13170     {
13171     case NT_VMS_MHD:
13172       return _("NT_VMS_MHD (module header)");
13173     case NT_VMS_LNM:
13174       return _("NT_VMS_LNM (language name)");
13175     case NT_VMS_SRC:
13176       return _("NT_VMS_SRC (source files)");
13177     case NT_VMS_TITLE:
13178       return "NT_VMS_TITLE";
13179     case NT_VMS_EIDC:
13180       return _("NT_VMS_EIDC (consistency check)");
13181     case NT_VMS_FPMODE:
13182       return _("NT_VMS_FPMODE (FP mode)");
13183     case NT_VMS_LINKTIME:
13184       return "NT_VMS_LINKTIME";
13185     case NT_VMS_IMGNAM:
13186       return _("NT_VMS_IMGNAM (image name)");
13187     case NT_VMS_IMGID:
13188       return _("NT_VMS_IMGID (image id)");
13189     case NT_VMS_LINKID:
13190       return _("NT_VMS_LINKID (link id)");
13191     case NT_VMS_IMGBID:
13192       return _("NT_VMS_IMGBID (build id)");
13193     case NT_VMS_GSTNAM:
13194       return _("NT_VMS_GSTNAM (sym table name)");
13195     case NT_VMS_ORIG_DYN:
13196       return "NT_VMS_ORIG_DYN";
13197     case NT_VMS_PATCHTIME:
13198       return "NT_VMS_PATCHTIME";
13199     default:
13200       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13201       return buff;
13202     }
13203 }
13204
13205 static int
13206 print_ia64_vms_note (Elf_Internal_Note * pnote)
13207 {
13208   switch (pnote->type)
13209     {
13210     case NT_VMS_MHD:
13211       if (pnote->descsz > 36)
13212         {
13213           size_t l = strlen (pnote->descdata + 34);
13214           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
13215           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
13216           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
13217           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
13218         }
13219       else
13220         printf (_("    Invalid size\n"));
13221       break;
13222     case NT_VMS_LNM:
13223       printf (_("   Language: %s\n"), pnote->descdata);
13224       break;
13225 #ifdef BFD64
13226     case NT_VMS_FPMODE:
13227       printf (_("   Floating Point mode: "));
13228       printf ("0x%016" BFD_VMA_FMT "x\n",
13229               (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
13230       break;
13231     case NT_VMS_LINKTIME:
13232       printf (_("   Link time: "));
13233       print_vms_time
13234         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13235       printf ("\n");
13236       break;
13237     case NT_VMS_PATCHTIME:
13238       printf (_("   Patch time: "));
13239       print_vms_time
13240         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13241       printf ("\n");
13242       break;
13243     case NT_VMS_ORIG_DYN:
13244       printf (_("   Major id: %u,  minor id: %u\n"),
13245               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
13246               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
13247       printf (_("   Last modified  : "));
13248       print_vms_time
13249         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
13250       printf (_("\n   Link flags  : "));
13251       printf ("0x%016" BFD_VMA_FMT "x\n",
13252               (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
13253       printf (_("   Header flags: 0x%08x\n"),
13254               (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
13255       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
13256       break;
13257 #endif
13258     case NT_VMS_IMGNAM:
13259       printf (_("    Image name: %s\n"), pnote->descdata);
13260       break;
13261     case NT_VMS_GSTNAM:
13262       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
13263       break;
13264     case NT_VMS_IMGID:
13265       printf (_("    Image id: %s\n"), pnote->descdata);
13266       break;
13267     case NT_VMS_LINKID:
13268       printf (_("    Linker id: %s\n"), pnote->descdata);
13269       break;
13270     default:
13271       break;
13272     }
13273   return 1;
13274 }
13275
13276 /* Note that by the ELF standard, the name field is already null byte
13277    terminated, and namesz includes the terminating null byte.
13278    I.E. the value of namesz for the name "FSF" is 4.
13279
13280    If the value of namesz is zero, there is no name present.  */
13281 static int
13282 process_note (Elf_Internal_Note * pnote)
13283 {
13284   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
13285   const char * nt;
13286
13287   if (pnote->namesz == 0)
13288     /* If there is no note name, then use the default set of
13289        note type strings.  */
13290     nt = get_note_type (pnote->type);
13291
13292   else if (const_strneq (pnote->namedata, "GNU"))
13293     /* GNU-specific object file notes.  */
13294     nt = get_gnu_elf_note_type (pnote->type);
13295
13296   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
13297     /* NetBSD-specific core file notes.  */
13298     nt = get_netbsd_elfcore_note_type (pnote->type);
13299
13300   else if (strneq (pnote->namedata, "SPU/", 4))
13301     {
13302       /* SPU-specific core file notes.  */
13303       nt = pnote->namedata + 4;
13304       name = "SPU";
13305     }
13306
13307   else if (const_strneq (pnote->namedata, "IPF/VMS"))
13308     /* VMS/ia64-specific file notes.  */
13309     nt = get_ia64_vms_note_type (pnote->type);
13310
13311   else if (const_strneq (pnote->namedata, "stapsdt"))
13312     nt = get_stapsdt_note_type (pnote->type);
13313
13314   else
13315     /* Don't recognize this note name; just use the default set of
13316        note type strings.  */
13317     nt = get_note_type (pnote->type);
13318
13319   printf ("  %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
13320
13321   if (const_strneq (pnote->namedata, "IPF/VMS"))
13322     return print_ia64_vms_note (pnote);
13323   else if (const_strneq (pnote->namedata, "GNU"))
13324     return print_gnu_note (pnote);
13325   else if (const_strneq (pnote->namedata, "stapsdt"))
13326     return print_stapsdt_note (pnote);
13327   else if (const_strneq (pnote->namedata, "CORE"))
13328     return print_core_note (pnote);
13329   else
13330     return 1;
13331 }
13332
13333
13334 static int
13335 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
13336 {
13337   Elf_External_Note * pnotes;
13338   Elf_External_Note * external;
13339   int res = 1;
13340
13341   if (length <= 0)
13342     return 0;
13343
13344   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
13345                                            _("notes"));
13346   if (pnotes == NULL)
13347     return 0;
13348
13349   external = pnotes;
13350
13351   printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
13352           (unsigned long) offset, (unsigned long) length);
13353   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
13354
13355   while (external < (Elf_External_Note *) ((char *) pnotes + length))
13356     {
13357       Elf_External_Note * next;
13358       Elf_Internal_Note inote;
13359       char * temp = NULL;
13360
13361       if (!is_ia64_vms ())
13362         {
13363           inote.type     = BYTE_GET (external->type);
13364           inote.namesz   = BYTE_GET (external->namesz);
13365           inote.namedata = external->name;
13366           inote.descsz   = BYTE_GET (external->descsz);
13367           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
13368           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
13369
13370           next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
13371         }
13372       else
13373         {
13374           Elf64_External_VMS_Note *vms_external;
13375
13376           vms_external = (Elf64_External_VMS_Note *)external;
13377           inote.type     = BYTE_GET (vms_external->type);
13378           inote.namesz   = BYTE_GET (vms_external->namesz);
13379           inote.namedata = vms_external->name;
13380           inote.descsz   = BYTE_GET (vms_external->descsz);
13381           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
13382           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
13383
13384           next = (Elf_External_Note *)
13385             (inote.descdata + align_power (inote.descsz, 3));
13386         }
13387
13388       if (   ((char *) next > ((char *) pnotes) + length)
13389           || ((char *) next <  (char *) pnotes))
13390         {
13391           warn (_("corrupt note found at offset %lx into core notes\n"),
13392                 (unsigned long) ((char *) external - (char *) pnotes));
13393           warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13394                 inote.type, inote.namesz, inote.descsz);
13395           break;
13396         }
13397
13398       external = next;
13399
13400       /* Prevent out-of-bounds indexing.  */
13401       if (inote.namedata + inote.namesz > (char *) pnotes + length
13402           || inote.namedata + inote.namesz < inote.namedata)
13403         {
13404           warn (_("corrupt note found at offset %lx into core notes\n"),
13405                 (unsigned long) ((char *) external - (char *) pnotes));
13406           warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13407                 inote.type, inote.namesz, inote.descsz);
13408           break;
13409         }
13410
13411       /* Verify that name is null terminated.  It appears that at least
13412          one version of Linux (RedHat 6.0) generates corefiles that don't
13413          comply with the ELF spec by failing to include the null byte in
13414          namesz.  */
13415       if (inote.namedata[inote.namesz - 1] != '\0')
13416         {
13417           temp = (char *) malloc (inote.namesz + 1);
13418
13419           if (temp == NULL)
13420             {
13421               error (_("Out of memory\n"));
13422               res = 0;
13423               break;
13424             }
13425
13426           strncpy (temp, inote.namedata, inote.namesz);
13427           temp[inote.namesz] = 0;
13428
13429           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
13430           inote.namedata = temp;
13431         }
13432
13433       res &= process_note (& inote);
13434
13435       if (temp != NULL)
13436         {
13437           free (temp);
13438           temp = NULL;
13439         }
13440     }
13441
13442   free (pnotes);
13443
13444   return res;
13445 }
13446
13447 static int
13448 process_corefile_note_segments (FILE * file)
13449 {
13450   Elf_Internal_Phdr * segment;
13451   unsigned int i;
13452   int res = 1;
13453
13454   if (! get_program_headers (file))
13455       return 0;
13456
13457   for (i = 0, segment = program_headers;
13458        i < elf_header.e_phnum;
13459        i++, segment++)
13460     {
13461       if (segment->p_type == PT_NOTE)
13462         res &= process_corefile_note_segment (file,
13463                                               (bfd_vma) segment->p_offset,
13464                                               (bfd_vma) segment->p_filesz);
13465     }
13466
13467   return res;
13468 }
13469
13470 static int
13471 process_note_sections (FILE * file)
13472 {
13473   Elf_Internal_Shdr * section;
13474   unsigned long i;
13475   int res = 1;
13476
13477   for (i = 0, section = section_headers;
13478        i < elf_header.e_shnum && section != NULL;
13479        i++, section++)
13480     if (section->sh_type == SHT_NOTE)
13481       res &= process_corefile_note_segment (file,
13482                                             (bfd_vma) section->sh_offset,
13483                                             (bfd_vma) section->sh_size);
13484
13485   return res;
13486 }
13487
13488 static int
13489 process_notes (FILE * file)
13490 {
13491   /* If we have not been asked to display the notes then do nothing.  */
13492   if (! do_notes)
13493     return 1;
13494
13495   if (elf_header.e_type != ET_CORE)
13496     return process_note_sections (file);
13497
13498   /* No program headers means no NOTE segment.  */
13499   if (elf_header.e_phnum > 0)
13500     return process_corefile_note_segments (file);
13501
13502   printf (_("No note segments present in the core file.\n"));
13503   return 1;
13504 }
13505
13506 static int
13507 process_arch_specific (FILE * file)
13508 {
13509   if (! do_arch)
13510     return 1;
13511
13512   switch (elf_header.e_machine)
13513     {
13514     case EM_ARM:
13515       return process_arm_specific (file);
13516     case EM_MIPS:
13517     case EM_MIPS_RS3_LE:
13518       return process_mips_specific (file);
13519       break;
13520     case EM_PPC:
13521       return process_power_specific (file);
13522       break;
13523     case EM_SPARC:
13524     case EM_SPARC32PLUS:
13525     case EM_SPARCV9:
13526       return process_sparc_specific (file);
13527       break;
13528     case EM_TI_C6000:
13529       return process_tic6x_specific (file);
13530       break;
13531     default:
13532       break;
13533     }
13534   return 1;
13535 }
13536
13537 static int
13538 get_file_header (FILE * file)
13539 {
13540   /* Read in the identity array.  */
13541   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
13542     return 0;
13543
13544   /* Determine how to read the rest of the header.  */
13545   switch (elf_header.e_ident[EI_DATA])
13546     {
13547     default: /* fall through */
13548     case ELFDATANONE: /* fall through */
13549     case ELFDATA2LSB:
13550       byte_get = byte_get_little_endian;
13551       byte_put = byte_put_little_endian;
13552       break;
13553     case ELFDATA2MSB:
13554       byte_get = byte_get_big_endian;
13555       byte_put = byte_put_big_endian;
13556       break;
13557     }
13558
13559   /* For now we only support 32 bit and 64 bit ELF files.  */
13560   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
13561
13562   /* Read in the rest of the header.  */
13563   if (is_32bit_elf)
13564     {
13565       Elf32_External_Ehdr ehdr32;
13566
13567       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
13568         return 0;
13569
13570       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
13571       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
13572       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
13573       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
13574       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
13575       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
13576       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
13577       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
13578       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
13579       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
13580       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
13581       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
13582       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
13583     }
13584   else
13585     {
13586       Elf64_External_Ehdr ehdr64;
13587
13588       /* If we have been compiled with sizeof (bfd_vma) == 4, then
13589          we will not be able to cope with the 64bit data found in
13590          64 ELF files.  Detect this now and abort before we start
13591          overwriting things.  */
13592       if (sizeof (bfd_vma) < 8)
13593         {
13594           error (_("This instance of readelf has been built without support for a\n\
13595 64 bit data type and so it cannot read 64 bit ELF files.\n"));
13596           return 0;
13597         }
13598
13599       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
13600         return 0;
13601
13602       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
13603       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
13604       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
13605       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
13606       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
13607       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
13608       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
13609       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
13610       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
13611       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
13612       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
13613       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
13614       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
13615     }
13616
13617   if (elf_header.e_shoff)
13618     {
13619       /* There may be some extensions in the first section header.  Don't
13620          bomb if we can't read it.  */
13621       if (is_32bit_elf)
13622         get_32bit_section_headers (file, 1);
13623       else
13624         get_64bit_section_headers (file, 1);
13625     }
13626
13627   return 1;
13628 }
13629
13630 /* Process one ELF object file according to the command line options.
13631    This file may actually be stored in an archive.  The file is
13632    positioned at the start of the ELF object.  */
13633
13634 static int
13635 process_object (char * file_name, FILE * file)
13636 {
13637   unsigned int i;
13638
13639   if (! get_file_header (file))
13640     {
13641       error (_("%s: Failed to read file header\n"), file_name);
13642       return 1;
13643     }
13644
13645   /* Initialise per file variables.  */
13646   for (i = ARRAY_SIZE (version_info); i--;)
13647     version_info[i] = 0;
13648
13649   for (i = ARRAY_SIZE (dynamic_info); i--;)
13650     dynamic_info[i] = 0;
13651   dynamic_info_DT_GNU_HASH = 0;
13652
13653   /* Process the file.  */
13654   if (show_name)
13655     printf (_("\nFile: %s\n"), file_name);
13656
13657   /* Initialise the dump_sects array from the cmdline_dump_sects array.
13658      Note we do this even if cmdline_dump_sects is empty because we
13659      must make sure that the dump_sets array is zeroed out before each
13660      object file is processed.  */
13661   if (num_dump_sects > num_cmdline_dump_sects)
13662     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
13663
13664   if (num_cmdline_dump_sects > 0)
13665     {
13666       if (num_dump_sects == 0)
13667         /* A sneaky way of allocating the dump_sects array.  */
13668         request_dump_bynumber (num_cmdline_dump_sects, 0);
13669
13670       assert (num_dump_sects >= num_cmdline_dump_sects);
13671       memcpy (dump_sects, cmdline_dump_sects,
13672               num_cmdline_dump_sects * sizeof (* dump_sects));
13673     }
13674
13675   if (! process_file_header ())
13676     return 1;
13677
13678   if (! process_section_headers (file))
13679     {
13680       /* Without loaded section headers we cannot process lots of
13681          things.  */
13682       do_unwind = do_version = do_dump = do_arch = 0;
13683
13684       if (! do_using_dynamic)
13685         do_syms = do_dyn_syms = do_reloc = 0;
13686     }
13687
13688   if (! process_section_groups (file))
13689     {
13690       /* Without loaded section groups we cannot process unwind.  */
13691       do_unwind = 0;
13692     }
13693
13694   if (process_program_headers (file))
13695     process_dynamic_section (file);
13696
13697   process_relocs (file);
13698
13699   process_unwind (file);
13700
13701   process_symbol_table (file);
13702
13703   process_syminfo (file);
13704
13705   process_version_sections (file);
13706
13707   process_section_contents (file);
13708
13709   process_notes (file);
13710
13711   process_gnu_liblist (file);
13712
13713   process_arch_specific (file);
13714
13715   if (program_headers)
13716     {
13717       free (program_headers);
13718       program_headers = NULL;
13719     }
13720
13721   if (section_headers)
13722     {
13723       free (section_headers);
13724       section_headers = NULL;
13725     }
13726
13727   if (string_table)
13728     {
13729       free (string_table);
13730       string_table = NULL;
13731       string_table_length = 0;
13732     }
13733
13734   if (dynamic_strings)
13735     {
13736       free (dynamic_strings);
13737       dynamic_strings = NULL;
13738       dynamic_strings_length = 0;
13739     }
13740
13741   if (dynamic_symbols)
13742     {
13743       free (dynamic_symbols);
13744       dynamic_symbols = NULL;
13745       num_dynamic_syms = 0;
13746     }
13747
13748   if (dynamic_syminfo)
13749     {
13750       free (dynamic_syminfo);
13751       dynamic_syminfo = NULL;
13752     }
13753
13754   if (dynamic_section)
13755     {
13756       free (dynamic_section);
13757       dynamic_section = NULL;
13758     }
13759
13760   if (section_headers_groups)
13761     {
13762       free (section_headers_groups);
13763       section_headers_groups = NULL;
13764     }
13765
13766   if (section_groups)
13767     {
13768       struct group_list * g;
13769       struct group_list * next;
13770
13771       for (i = 0; i < group_count; i++)
13772         {
13773           for (g = section_groups [i].root; g != NULL; g = next)
13774             {
13775               next = g->next;
13776               free (g);
13777             }
13778         }
13779
13780       free (section_groups);
13781       section_groups = NULL;
13782     }
13783
13784   free_debug_memory ();
13785
13786   return 0;
13787 }
13788
13789 /* Process an ELF archive.
13790    On entry the file is positioned just after the ARMAG string.  */
13791
13792 static int
13793 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
13794 {
13795   struct archive_info arch;
13796   struct archive_info nested_arch;
13797   size_t got;
13798   int ret;
13799
13800   show_name = 1;
13801
13802   /* The ARCH structure is used to hold information about this archive.  */
13803   arch.file_name = NULL;
13804   arch.file = NULL;
13805   arch.index_array = NULL;
13806   arch.sym_table = NULL;
13807   arch.longnames = NULL;
13808
13809   /* The NESTED_ARCH structure is used as a single-item cache of information
13810      about a nested archive (when members of a thin archive reside within
13811      another regular archive file).  */
13812   nested_arch.file_name = NULL;
13813   nested_arch.file = NULL;
13814   nested_arch.index_array = NULL;
13815   nested_arch.sym_table = NULL;
13816   nested_arch.longnames = NULL;
13817
13818   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
13819     {
13820       ret = 1;
13821       goto out;
13822     }
13823
13824   if (do_archive_index)
13825     {
13826       if (arch.sym_table == NULL)
13827         error (_("%s: unable to dump the index as none was found\n"), file_name);
13828       else
13829         {
13830           unsigned int i, l;
13831           unsigned long current_pos;
13832
13833           printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
13834                   file_name, (long) arch.index_num, arch.sym_size);
13835           current_pos = ftell (file);
13836
13837           for (i = l = 0; i < arch.index_num; i++)
13838             {
13839               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
13840                 {
13841                   char * member_name;
13842
13843                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
13844
13845                   if (member_name != NULL)
13846                     {
13847                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
13848
13849                       if (qualified_name != NULL)
13850                         {
13851                           printf (_("Contents of binary %s at offset "), qualified_name);
13852                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
13853                           putchar ('\n');
13854                           free (qualified_name);
13855                         }
13856                     }
13857                 }
13858
13859               if (l >= arch.sym_size)
13860                 {
13861                   error (_("%s: end of the symbol table reached before the end of the index\n"),
13862                          file_name);
13863                   break;
13864                 }
13865               printf ("\t%s\n", arch.sym_table + l);
13866               l += strlen (arch.sym_table + l) + 1;
13867             }
13868
13869           if (arch.uses_64bit_indicies)
13870             l = (l + 7) & ~ 7;
13871           else
13872             l += l & 1;
13873
13874           if (l < arch.sym_size)
13875             error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
13876                    file_name, arch.sym_size - l);
13877
13878           if (fseek (file, current_pos, SEEK_SET) != 0)
13879             {
13880               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
13881               ret = 1;
13882               goto out;
13883             }
13884         }
13885
13886       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
13887           && !do_segments && !do_header && !do_dump && !do_version
13888           && !do_histogram && !do_debugging && !do_arch && !do_notes
13889           && !do_section_groups && !do_dyn_syms)
13890         {
13891           ret = 0; /* Archive index only.  */
13892           goto out;
13893         }
13894     }
13895
13896   ret = 0;
13897
13898   while (1)
13899     {
13900       char * name;
13901       size_t namelen;
13902       char * qualified_name;
13903
13904       /* Read the next archive header.  */
13905       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13906         {
13907           error (_("%s: failed to seek to next archive header\n"), file_name);
13908           return 1;
13909         }
13910       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13911       if (got != sizeof arch.arhdr)
13912         {
13913           if (got == 0)
13914             break;
13915           error (_("%s: failed to read archive header\n"), file_name);
13916           ret = 1;
13917           break;
13918         }
13919       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13920         {
13921           error (_("%s: did not find a valid archive header\n"), arch.file_name);
13922           ret = 1;
13923           break;
13924         }
13925
13926       arch.next_arhdr_offset += sizeof arch.arhdr;
13927
13928       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13929       if (archive_file_size & 01)
13930         ++archive_file_size;
13931
13932       name = get_archive_member_name (&arch, &nested_arch);
13933       if (name == NULL)
13934         {
13935           error (_("%s: bad archive file name\n"), file_name);
13936           ret = 1;
13937           break;
13938         }
13939       namelen = strlen (name);
13940
13941       qualified_name = make_qualified_name (&arch, &nested_arch, name);
13942       if (qualified_name == NULL)
13943         {
13944           error (_("%s: bad archive file name\n"), file_name);
13945           ret = 1;
13946           break;
13947         }
13948
13949       if (is_thin_archive && arch.nested_member_origin == 0)
13950         {
13951           /* This is a proxy for an external member of a thin archive.  */
13952           FILE * member_file;
13953           char * member_file_name = adjust_relative_path (file_name, name, namelen);
13954           if (member_file_name == NULL)
13955             {
13956               ret = 1;
13957               break;
13958             }
13959
13960           member_file = fopen (member_file_name, "rb");
13961           if (member_file == NULL)
13962             {
13963               error (_("Input file '%s' is not readable.\n"), member_file_name);
13964               free (member_file_name);
13965               ret = 1;
13966               break;
13967             }
13968
13969           archive_file_offset = arch.nested_member_origin;
13970
13971           ret |= process_object (qualified_name, member_file);
13972
13973           fclose (member_file);
13974           free (member_file_name);
13975         }
13976       else if (is_thin_archive)
13977         {
13978           /* This is a proxy for a member of a nested archive.  */
13979           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
13980
13981           /* The nested archive file will have been opened and setup by
13982              get_archive_member_name.  */
13983           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
13984             {
13985               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
13986               ret = 1;
13987               break;
13988             }
13989
13990           ret |= process_object (qualified_name, nested_arch.file);
13991         }
13992       else
13993         {
13994           archive_file_offset = arch.next_arhdr_offset;
13995           arch.next_arhdr_offset += archive_file_size;
13996
13997           ret |= process_object (qualified_name, file);
13998         }
13999
14000       if (dump_sects != NULL)
14001         {
14002           free (dump_sects);
14003           dump_sects = NULL;
14004           num_dump_sects = 0;
14005         }
14006
14007       free (qualified_name);
14008     }
14009
14010  out:
14011   if (nested_arch.file != NULL)
14012     fclose (nested_arch.file);
14013   release_archive (&nested_arch);
14014   release_archive (&arch);
14015
14016   return ret;
14017 }
14018
14019 static int
14020 process_file (char * file_name)
14021 {
14022   FILE * file;
14023   struct stat statbuf;
14024   char armag[SARMAG];
14025   int ret;
14026
14027   if (stat (file_name, &statbuf) < 0)
14028     {
14029       if (errno == ENOENT)
14030         error (_("'%s': No such file\n"), file_name);
14031       else
14032         error (_("Could not locate '%s'.  System error message: %s\n"),
14033                file_name, strerror (errno));
14034       return 1;
14035     }
14036
14037   if (! S_ISREG (statbuf.st_mode))
14038     {
14039       error (_("'%s' is not an ordinary file\n"), file_name);
14040       return 1;
14041     }
14042
14043   file = fopen (file_name, "rb");
14044   if (file == NULL)
14045     {
14046       error (_("Input file '%s' is not readable.\n"), file_name);
14047       return 1;
14048     }
14049
14050   if (fread (armag, SARMAG, 1, file) != 1)
14051     {
14052       error (_("%s: Failed to read file's magic number\n"), file_name);
14053       fclose (file);
14054       return 1;
14055     }
14056
14057   if (memcmp (armag, ARMAG, SARMAG) == 0)
14058     ret = process_archive (file_name, file, FALSE);
14059   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
14060     ret = process_archive (file_name, file, TRUE);
14061   else
14062     {
14063       if (do_archive_index)
14064         error (_("File %s is not an archive so its index cannot be displayed.\n"),
14065                file_name);
14066
14067       rewind (file);
14068       archive_file_size = archive_file_offset = 0;
14069       ret = process_object (file_name, file);
14070     }
14071
14072   fclose (file);
14073
14074   return ret;
14075 }
14076
14077 #ifdef SUPPORT_DISASSEMBLY
14078 /* Needed by the i386 disassembler.  For extra credit, someone could
14079    fix this so that we insert symbolic addresses here, esp for GOT/PLT
14080    symbols.  */
14081
14082 void
14083 print_address (unsigned int addr, FILE * outfile)
14084 {
14085   fprintf (outfile,"0x%8.8x", addr);
14086 }
14087
14088 /* Needed by the i386 disassembler.  */
14089 void
14090 db_task_printsym (unsigned int addr)
14091 {
14092   print_address (addr, stderr);
14093 }
14094 #endif
14095
14096 int
14097 main (int argc, char ** argv)
14098 {
14099   int err;
14100
14101 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14102   setlocale (LC_MESSAGES, "");
14103 #endif
14104 #if defined (HAVE_SETLOCALE)
14105   setlocale (LC_CTYPE, "");
14106 #endif
14107   bindtextdomain (PACKAGE, LOCALEDIR);
14108   textdomain (PACKAGE);
14109
14110   expandargv (&argc, &argv);
14111
14112   parse_args (argc, argv);
14113
14114   if (num_dump_sects > 0)
14115     {
14116       /* Make a copy of the dump_sects array.  */
14117       cmdline_dump_sects = (dump_type *)
14118           malloc (num_dump_sects * sizeof (* dump_sects));
14119       if (cmdline_dump_sects == NULL)
14120         error (_("Out of memory allocating dump request table.\n"));
14121       else
14122         {
14123           memcpy (cmdline_dump_sects, dump_sects,
14124                   num_dump_sects * sizeof (* dump_sects));
14125           num_cmdline_dump_sects = num_dump_sects;
14126         }
14127     }
14128
14129   if (optind < (argc - 1))
14130     show_name = 1;
14131
14132   err = 0;
14133   while (optind < argc)
14134     err |= process_file (argv[optind++]);
14135
14136   if (dump_sects != NULL)
14137     free (dump_sects);
14138   if (cmdline_dump_sects != NULL)
14139     free (cmdline_dump_sects);
14140
14141   return err;
14142 }