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