binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998-2014 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/nds32.h"
 135 #include "elf/nios2.h"
 136 #include "elf/or32.h"
 137 #include "elf/pj.h"
 138 #include "elf/ppc.h"
 139 #include "elf/ppc64.h"
 140 #include "elf/rl78.h"
 141 #include "elf/rx.h"
 142 #include "elf/s390.h"
 143 #include "elf/score.h"
 144 #include "elf/sh.h"
 145 #include "elf/sparc.h"
 146 #include "elf/spu.h"
 147 #include "elf/tic6x.h"
 148 #include "elf/tilegx.h"
 149 #include "elf/tilepro.h"
 150 #include "elf/v850.h"
 151 #include "elf/vax.h"
 152 #include "elf/x86-64.h"
 153 #include "elf/xc16x.h"
 154 #include "elf/xgate.h"
 155 #include "elf/xstormy16.h"
 156 #include "elf/xtensa.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_NDS32:
 631     case EM_NIOS32:
 632     case EM_PPC64:
 633     case EM_PPC:
 634     case EM_RL78:
 635     case EM_RX:
 636     case EM_S390:
 637     case EM_S390_OLD:
 638     case EM_SH:
 639     case EM_SPARC:
 640     case EM_SPARC32PLUS:
 641     case EM_SPARCV9:
 642     case EM_SPU:
 643     case EM_TI_C6000:
 644     case EM_TILEGX:
 645     case EM_TILEPRO:
 646     case EM_V800:
 647     case EM_V850:
 648     case EM_CYGNUS_V850:
 649     case EM_VAX:
 650     case EM_X86_64:
 651     case EM_L1OM:
 652     case EM_K1OM:
 653     case EM_XSTORMY16:
 654     case EM_XTENSA:
 655     case EM_XTENSA_OLD:
 656     case EM_MICROBLAZE:
 657     case EM_MICROBLAZE_OLD:
 658       return TRUE;
 659
 660     case EM_68HC05:
 661     case EM_68HC08:
 662     case EM_68HC11:
 663     case EM_68HC16:
 664     case EM_FX66:
 665     case EM_ME16:
 666     case EM_MMA:
 667     case EM_NCPU:
 668     case EM_NDR1:
 669     case EM_PCP:
 670     case EM_ST100:
 671     case EM_ST19:
 672     case EM_ST7:
 673     case EM_ST9PLUS:
 674     case EM_STARCORE:
 675     case EM_SVX:
 676     case EM_TINYJ:
 677     default:
 678       warn (_("Don't know about relocations on this machine architecture\n"));
 679       return FALSE;
 680     }
 681 }
 682
 683 static int
 684 slurp_rela_relocs (FILE * file,
 685                    unsigned long rel_offset,
 686                    unsigned long rel_size,
 687                    Elf_Internal_Rela ** relasp,
 688                    unsigned long * nrelasp)
 689 {
 690   Elf_Internal_Rela * relas;
 691   unsigned long nrelas;
 692   unsigned int i;
 693
 694   if (is_32bit_elf)
 695     {
 696       Elf32_External_Rela * erelas;
 697
 698       erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
 699                                                  rel_size, _("32-bit relocation data"));
 700       if (!erelas)
 701         return 0;
 702
 703       nrelas = rel_size / sizeof (Elf32_External_Rela);
 704
 705       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 706                                              sizeof (Elf_Internal_Rela));
 707
 708       if (relas == NULL)
 709         {
 710           free (erelas);
 711           error (_("out of memory parsing relocs\n"));
 712           return 0;
 713         }
 714
 715       for (i = 0; i < nrelas; i++)
 716         {
 717           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 718           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 719           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 720         }
 721
 722       free (erelas);
 723     }
 724   else
 725     {
 726       Elf64_External_Rela * erelas;
 727
 728       erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
 729                                                  rel_size, _("64-bit relocation data"));
 730       if (!erelas)
 731         return 0;
 732
 733       nrelas = rel_size / sizeof (Elf64_External_Rela);
 734
 735       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 736                                              sizeof (Elf_Internal_Rela));
 737
 738       if (relas == NULL)
 739         {
 740           free (erelas);
 741           error (_("out of memory parsing relocs\n"));
 742           return 0;
 743         }
 744
 745       for (i = 0; i < nrelas; i++)
 746         {
 747           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 748           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 749           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 750
 751           /* The #ifdef BFD64 below is to prevent a compile time
 752              warning.  We know that if we do not have a 64 bit data
 753              type that we will never execute this code anyway.  */
 754 #ifdef BFD64
 755           if (elf_header.e_machine == EM_MIPS
 756               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 757             {
 758               /* In little-endian objects, r_info isn't really a
 759                  64-bit little-endian value: it has a 32-bit
 760                  little-endian symbol index followed by four
 761                  individual byte fields.  Reorder INFO
 762                  accordingly.  */
 763               bfd_vma inf = relas[i].r_info;
 764               inf = (((inf & 0xffffffff) << 32)
 765                       | ((inf >> 56) & 0xff)
 766                       | ((inf >> 40) & 0xff00)
 767                       | ((inf >> 24) & 0xff0000)
 768                       | ((inf >> 8) & 0xff000000));
 769               relas[i].r_info = inf;
 770             }
 771 #endif /* BFD64 */
 772         }
 773
 774       free (erelas);
 775     }
 776   *relasp = relas;
 777   *nrelasp = nrelas;
 778   return 1;
 779 }
 780
 781 static int
 782 slurp_rel_relocs (FILE * file,
 783                   unsigned long rel_offset,
 784                   unsigned long rel_size,
 785                   Elf_Internal_Rela ** relsp,
 786                   unsigned long * nrelsp)
 787 {
 788   Elf_Internal_Rela * rels;
 789   unsigned long nrels;
 790   unsigned int i;
 791
 792   if (is_32bit_elf)
 793     {
 794       Elf32_External_Rel * erels;
 795
 796       erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
 797                                                rel_size, _("32-bit relocation data"));
 798       if (!erels)
 799         return 0;
 800
 801       nrels = rel_size / sizeof (Elf32_External_Rel);
 802
 803       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 804
 805       if (rels == NULL)
 806         {
 807           free (erels);
 808           error (_("out of memory parsing relocs\n"));
 809           return 0;
 810         }
 811
 812       for (i = 0; i < nrels; i++)
 813         {
 814           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 815           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 816           rels[i].r_addend = 0;
 817         }
 818
 819       free (erels);
 820     }
 821   else
 822     {
 823       Elf64_External_Rel * erels;
 824
 825       erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
 826                                                rel_size, _("64-bit relocation data"));
 827       if (!erels)
 828         return 0;
 829
 830       nrels = rel_size / sizeof (Elf64_External_Rel);
 831
 832       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 833
 834       if (rels == NULL)
 835         {
 836           free (erels);
 837           error (_("out of memory parsing relocs\n"));
 838           return 0;
 839         }
 840
 841       for (i = 0; i < nrels; i++)
 842         {
 843           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 844           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 845           rels[i].r_addend = 0;
 846
 847           /* The #ifdef BFD64 below is to prevent a compile time
 848              warning.  We know that if we do not have a 64 bit data
 849              type that we will never execute this code anyway.  */
 850 #ifdef BFD64
 851           if (elf_header.e_machine == EM_MIPS
 852               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 853             {
 854               /* In little-endian objects, r_info isn't really a
 855                  64-bit little-endian value: it has a 32-bit
 856                  little-endian symbol index followed by four
 857                  individual byte fields.  Reorder INFO
 858                  accordingly.  */
 859               bfd_vma inf = rels[i].r_info;
 860               inf = (((inf & 0xffffffff) << 32)
 861                      | ((inf >> 56) & 0xff)
 862                      | ((inf >> 40) & 0xff00)
 863                      | ((inf >> 24) & 0xff0000)
 864                      | ((inf >> 8) & 0xff000000));
 865               rels[i].r_info = inf;
 866             }
 867 #endif /* BFD64 */
 868         }
 869
 870       free (erels);
 871     }
 872   *relsp = rels;
 873   *nrelsp = nrels;
 874   return 1;
 875 }
 876
 877 /* Returns the reloc type extracted from the reloc info field.  */
 878
 879 static unsigned int
 880 get_reloc_type (bfd_vma reloc_info)
 881 {
 882   if (is_32bit_elf)
 883     return ELF32_R_TYPE (reloc_info);
 884
 885   switch (elf_header.e_machine)
 886     {
 887     case EM_MIPS:
 888       /* Note: We assume that reloc_info has already been adjusted for us.  */
 889       return ELF64_MIPS_R_TYPE (reloc_info);
 890
 891     case EM_SPARCV9:
 892       return ELF64_R_TYPE_ID (reloc_info);
 893
 894     default:
 895       return ELF64_R_TYPE (reloc_info);
 896     }
 897 }
 898
 899 /* Return the symbol index extracted from the reloc info field.  */
 900
 901 static bfd_vma
 902 get_reloc_symindex (bfd_vma reloc_info)
 903 {
 904   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
 905 }
 906
 907 static inline bfd_boolean
 908 uses_msp430x_relocs (void)
 909 {
 910   return
 911     elf_header.e_machine == EM_MSP430 /* Paranoia.  */
 912     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
 913     && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
 914         /* TI compiler uses ELFOSABI_NONE.  */
 915         || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
 916 }
 917
 918 /* Display the contents of the relocation data found at the specified
 919    offset.  */
 920
 921 static void
 922 dump_relocations (FILE * file,
 923                   unsigned long rel_offset,
 924                   unsigned long rel_size,
 925                   Elf_Internal_Sym * symtab,
 926                   unsigned long nsyms,
 927                   char * strtab,
 928                   unsigned long strtablen,
 929                   int is_rela)
 930 {
 931   unsigned int i;
 932   Elf_Internal_Rela * rels;
 933
 934   if (is_rela == UNKNOWN)
 935     is_rela = guess_is_rela (elf_header.e_machine);
 936
 937   if (is_rela)
 938     {
 939       if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
 940         return;
 941     }
 942   else
 943     {
 944       if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
 945         return;
 946     }
 947
 948   if (is_32bit_elf)
 949     {
 950       if (is_rela)
 951         {
 952           if (do_wide)
 953             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
 954           else
 955             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
 956         }
 957       else
 958         {
 959           if (do_wide)
 960             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
 961           else
 962             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
 963         }
 964     }
 965   else
 966     {
 967       if (is_rela)
 968         {
 969           if (do_wide)
 970             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
 971           else
 972             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
 973         }
 974       else
 975         {
 976           if (do_wide)
 977             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
 978           else
 979             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
 980         }
 981     }
 982
 983   for (i = 0; i < rel_size; i++)
 984     {
 985       const char * rtype;
 986       bfd_vma offset;
 987       bfd_vma inf;
 988       bfd_vma symtab_index;
 989       bfd_vma type;
 990
 991       offset = rels[i].r_offset;
 992       inf    = rels[i].r_info;
 993
 994       type = get_reloc_type (inf);
 995       symtab_index = get_reloc_symindex  (inf);
 996
 997       if (is_32bit_elf)
 998         {
 999           printf ("%8.8lx  %8.8lx ",
1000                   (unsigned long) offset & 0xffffffff,
1001                   (unsigned long) inf & 0xffffffff);
1002         }
1003       else
1004         {
1005 #if BFD_HOST_64BIT_LONG
1006           printf (do_wide
1007                   ? "%16.16lx  %16.16lx "
1008                   : "%12.12lx  %12.12lx ",
1009                   offset, inf);
1010 #elif BFD_HOST_64BIT_LONG_LONG
1011 #ifndef __MSVCRT__
1012           printf (do_wide
1013                   ? "%16.16llx  %16.16llx "
1014                   : "%12.12llx  %12.12llx ",
1015                   offset, inf);
1016 #else
1017           printf (do_wide
1018                   ? "%16.16I64x  %16.16I64x "
1019                   : "%12.12I64x  %12.12I64x ",
1020                   offset, inf);
1021 #endif
1022 #else
1023           printf (do_wide
1024                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1025                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1026                   _bfd_int64_high (offset),
1027                   _bfd_int64_low (offset),
1028                   _bfd_int64_high (inf),
1029                   _bfd_int64_low (inf));
1030 #endif
1031         }
1032
1033       switch (elf_header.e_machine)
1034         {
1035         default:
1036           rtype = NULL;
1037           break;
1038
1039         case EM_AARCH64:
1040           rtype = elf_aarch64_reloc_type (type);
1041           break;
1042
1043         case EM_M32R:
1044         case EM_CYGNUS_M32R:
1045           rtype = elf_m32r_reloc_type (type);
1046           break;
1047
1048         case EM_386:
1049         case EM_486:
1050           rtype = elf_i386_reloc_type (type);
1051           break;
1052
1053         case EM_68HC11:
1054         case EM_68HC12:
1055           rtype = elf_m68hc11_reloc_type (type);
1056           break;
1057
1058         case EM_68K:
1059           rtype = elf_m68k_reloc_type (type);
1060           break;
1061
1062         case EM_960:
1063           rtype = elf_i960_reloc_type (type);
1064           break;
1065
1066         case EM_AVR:
1067         case EM_AVR_OLD:
1068           rtype = elf_avr_reloc_type (type);
1069           break;
1070
1071         case EM_OLD_SPARCV9:
1072         case EM_SPARC32PLUS:
1073         case EM_SPARCV9:
1074         case EM_SPARC:
1075           rtype = elf_sparc_reloc_type (type);
1076           break;
1077
1078         case EM_SPU:
1079           rtype = elf_spu_reloc_type (type);
1080           break;
1081
1082         case EM_V800:
1083           rtype = v800_reloc_type (type);
1084           break;
1085         case EM_V850:
1086         case EM_CYGNUS_V850:
1087           rtype = v850_reloc_type (type);
1088           break;
1089
1090         case EM_D10V:
1091         case EM_CYGNUS_D10V:
1092           rtype = elf_d10v_reloc_type (type);
1093           break;
1094
1095         case EM_D30V:
1096         case EM_CYGNUS_D30V:
1097           rtype = elf_d30v_reloc_type (type);
1098           break;
1099
1100         case EM_DLX:
1101           rtype = elf_dlx_reloc_type (type);
1102           break;
1103
1104         case EM_SH:
1105           rtype = elf_sh_reloc_type (type);
1106           break;
1107
1108         case EM_MN10300:
1109         case EM_CYGNUS_MN10300:
1110           rtype = elf_mn10300_reloc_type (type);
1111           break;
1112
1113         case EM_MN10200:
1114         case EM_CYGNUS_MN10200:
1115           rtype = elf_mn10200_reloc_type (type);
1116           break;
1117
1118         case EM_FR30:
1119         case EM_CYGNUS_FR30:
1120           rtype = elf_fr30_reloc_type (type);
1121           break;
1122
1123         case EM_CYGNUS_FRV:
1124           rtype = elf_frv_reloc_type (type);
1125           break;
1126
1127         case EM_MCORE:
1128           rtype = elf_mcore_reloc_type (type);
1129           break;
1130
1131         case EM_MMIX:
1132           rtype = elf_mmix_reloc_type (type);
1133           break;
1134
1135         case EM_MOXIE:
1136           rtype = elf_moxie_reloc_type (type);
1137           break;
1138
1139         case EM_MSP430:
1140           if (uses_msp430x_relocs ())
1141             {
1142               rtype = elf_msp430x_reloc_type (type);
1143               break;
1144             }
1145         case EM_MSP430_OLD:
1146           rtype = elf_msp430_reloc_type (type);
1147           break;
1148
1149         case EM_NDS32:
1150           rtype = elf_nds32_reloc_type (type);
1151           break;
1152
1153         case EM_PPC:
1154           rtype = elf_ppc_reloc_type (type);
1155           break;
1156
1157         case EM_PPC64:
1158           rtype = elf_ppc64_reloc_type (type);
1159           break;
1160
1161         case EM_MIPS:
1162         case EM_MIPS_RS3_LE:
1163           rtype = elf_mips_reloc_type (type);
1164           break;
1165
1166         case EM_ALPHA:
1167           rtype = elf_alpha_reloc_type (type);
1168           break;
1169
1170         case EM_ARM:
1171           rtype = elf_arm_reloc_type (type);
1172           break;
1173
1174         case EM_ARC:
1175           rtype = elf_arc_reloc_type (type);
1176           break;
1177
1178         case EM_PARISC:
1179           rtype = elf_hppa_reloc_type (type);
1180           break;
1181
1182         case EM_H8_300:
1183         case EM_H8_300H:
1184         case EM_H8S:
1185           rtype = elf_h8_reloc_type (type);
1186           break;
1187
1188         case EM_OPENRISC:
1189         case EM_OR32:
1190           rtype = elf_or32_reloc_type (type);
1191           break;
1192
1193         case EM_PJ:
1194         case EM_PJ_OLD:
1195           rtype = elf_pj_reloc_type (type);
1196           break;
1197         case EM_IA_64:
1198           rtype = elf_ia64_reloc_type (type);
1199           break;
1200
1201         case EM_CRIS:
1202           rtype = elf_cris_reloc_type (type);
1203           break;
1204
1205         case EM_860:
1206           rtype = elf_i860_reloc_type (type);
1207           break;
1208
1209         case EM_X86_64:
1210         case EM_L1OM:
1211         case EM_K1OM:
1212           rtype = elf_x86_64_reloc_type (type);
1213           break;
1214
1215         case EM_S370:
1216           rtype = i370_reloc_type (type);
1217           break;
1218
1219         case EM_S390_OLD:
1220         case EM_S390:
1221           rtype = elf_s390_reloc_type (type);
1222           break;
1223
1224         case EM_SCORE:
1225           rtype = elf_score_reloc_type (type);
1226           break;
1227
1228         case EM_XSTORMY16:
1229           rtype = elf_xstormy16_reloc_type (type);
1230           break;
1231
1232         case EM_CRX:
1233           rtype = elf_crx_reloc_type (type);
1234           break;
1235
1236         case EM_VAX:
1237           rtype = elf_vax_reloc_type (type);
1238           break;
1239
1240         case EM_ADAPTEVA_EPIPHANY:
1241           rtype = elf_epiphany_reloc_type (type);
1242           break;
1243
1244         case EM_IP2K:
1245         case EM_IP2K_OLD:
1246           rtype = elf_ip2k_reloc_type (type);
1247           break;
1248
1249         case EM_IQ2000:
1250           rtype = elf_iq2000_reloc_type (type);
1251           break;
1252
1253         case EM_XTENSA_OLD:
1254         case EM_XTENSA:
1255           rtype = elf_xtensa_reloc_type (type);
1256           break;
1257
1258         case EM_LATTICEMICO32:
1259           rtype = elf_lm32_reloc_type (type);
1260           break;
1261
1262         case EM_M32C_OLD:
1263         case EM_M32C:
1264           rtype = elf_m32c_reloc_type (type);
1265           break;
1266
1267         case EM_MT:
1268           rtype = elf_mt_reloc_type (type);
1269           break;
1270
1271         case EM_BLACKFIN:
1272           rtype = elf_bfin_reloc_type (type);
1273           break;
1274
1275         case EM_CYGNUS_MEP:
1276           rtype = elf_mep_reloc_type (type);
1277           break;
1278
1279         case EM_CR16:
1280           rtype = elf_cr16_reloc_type (type);
1281           break;
1282
1283         case EM_MICROBLAZE:
1284         case EM_MICROBLAZE_OLD:
1285           rtype = elf_microblaze_reloc_type (type);
1286           break;
1287
1288         case EM_RL78:
1289           rtype = elf_rl78_reloc_type (type);
1290           break;
1291
1292         case EM_RX:
1293           rtype = elf_rx_reloc_type (type);
1294           break;
1295
1296         case EM_METAG:
1297           rtype = elf_metag_reloc_type (type);
1298           break;
1299
1300         case EM_XC16X:
1301         case EM_C166:
1302           rtype = elf_xc16x_reloc_type (type);
1303           break;
1304
1305         case EM_TI_C6000:
1306           rtype = elf_tic6x_reloc_type (type);
1307           break;
1308
1309         case EM_TILEGX:
1310           rtype = elf_tilegx_reloc_type (type);
1311           break;
1312
1313         case EM_TILEPRO:
1314           rtype = elf_tilepro_reloc_type (type);
1315           break;
1316
1317         case EM_XGATE:
1318           rtype = elf_xgate_reloc_type (type);
1319           break;
1320
1321         case EM_ALTERA_NIOS2:
1322           rtype = elf_nios2_reloc_type (type);
1323           break;
1324         }
1325
1326       if (rtype == NULL)
1327         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1328       else
1329         printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1330
1331       if (elf_header.e_machine == EM_ALPHA
1332           && rtype != NULL
1333           && streq (rtype, "R_ALPHA_LITUSE")
1334           && is_rela)
1335         {
1336           switch (rels[i].r_addend)
1337             {
1338             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1339             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1340             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1341             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1342             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1343             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1344             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1345             default: rtype = NULL;
1346             }
1347           if (rtype)
1348             printf (" (%s)", rtype);
1349           else
1350             {
1351               putchar (' ');
1352               printf (_("<unknown addend: %lx>"),
1353                       (unsigned long) rels[i].r_addend);
1354             }
1355         }
1356       else if (symtab_index)
1357         {
1358           if (symtab == NULL || symtab_index >= nsyms)
1359             printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1360           else
1361             {
1362               Elf_Internal_Sym * psym;
1363
1364               psym = symtab + symtab_index;
1365
1366               printf (" ");
1367
1368               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1369                 {
1370                   const char * name;
1371                   unsigned int len;
1372                   unsigned int width = is_32bit_elf ? 8 : 14;
1373
1374                   /* Relocations against GNU_IFUNC symbols do not use the value
1375                      of the symbol as the address to relocate against.  Instead
1376                      they invoke the function named by the symbol and use its
1377                      result as the address for relocation.
1378
1379                      To indicate this to the user, do not display the value of
1380                      the symbol in the "Symbols's Value" field.  Instead show
1381                      its name followed by () as a hint that the symbol is
1382                      invoked.  */
1383
1384                   if (strtab == NULL
1385                       || psym->st_name == 0
1386                       || psym->st_name >= strtablen)
1387                     name = "??";
1388                   else
1389                     name = strtab + psym->st_name;
1390
1391                   len = print_symbol (width, name);
1392                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1393                 }
1394               else
1395                 {
1396                   print_vma (psym->st_value, LONG_HEX);
1397
1398                   printf (is_32bit_elf ? "   " : " ");
1399                 }
1400
1401               if (psym->st_name == 0)
1402                 {
1403                   const char * sec_name = "<null>";
1404                   char name_buf[40];
1405
1406                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1407                     {
1408                       if (psym->st_shndx < elf_header.e_shnum)
1409                         sec_name
1410                           = SECTION_NAME (section_headers + psym->st_shndx);
1411                       else if (psym->st_shndx == SHN_ABS)
1412                         sec_name = "ABS";
1413                       else if (psym->st_shndx == SHN_COMMON)
1414                         sec_name = "COMMON";
1415                       else if ((elf_header.e_machine == EM_MIPS
1416                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1417                                || (elf_header.e_machine == EM_TI_C6000
1418                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1419                         sec_name = "SCOMMON";
1420                       else if (elf_header.e_machine == EM_MIPS
1421                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1422                         sec_name = "SUNDEF";
1423                       else if ((elf_header.e_machine == EM_X86_64
1424                                 || elf_header.e_machine == EM_L1OM
1425                                 || elf_header.e_machine == EM_K1OM)
1426                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1427                         sec_name = "LARGE_COMMON";
1428                       else if (elf_header.e_machine == EM_IA_64
1429                                && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1430                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1431                         sec_name = "ANSI_COM";
1432                       else if (is_ia64_vms ()
1433                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1434                         sec_name = "VMS_SYMVEC";
1435                       else
1436                         {
1437                           sprintf (name_buf, "<section 0x%x>",
1438                                    (unsigned int) psym->st_shndx);
1439                           sec_name = name_buf;
1440                         }
1441                     }
1442                   print_symbol (22, sec_name);
1443                 }
1444               else if (strtab == NULL)
1445                 printf (_("<string table index: %3ld>"), psym->st_name);
1446               else if (psym->st_name >= strtablen)
1447                 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1448               else
1449                 print_symbol (22, strtab + psym->st_name);
1450
1451               if (is_rela)
1452                 {
1453                   bfd_signed_vma off = rels[i].r_addend;
1454
1455                   if (off < 0)
1456                     printf (" - %" BFD_VMA_FMT "x", - off);
1457                   else
1458                     printf (" + %" BFD_VMA_FMT "x", off);
1459                 }
1460             }
1461         }
1462       else if (is_rela)
1463         {
1464           bfd_signed_vma off = rels[i].r_addend;
1465
1466           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1467           if (off < 0)
1468             printf ("-%" BFD_VMA_FMT "x", - off);
1469           else
1470             printf ("%" BFD_VMA_FMT "x", off);
1471         }
1472
1473       if (elf_header.e_machine == EM_SPARCV9
1474           && rtype != NULL
1475           && streq (rtype, "R_SPARC_OLO10"))
1476         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1477
1478       putchar ('\n');
1479
1480 #ifdef BFD64
1481       if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1482         {
1483           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1484           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1485           const char * rtype2 = elf_mips_reloc_type (type2);
1486           const char * rtype3 = elf_mips_reloc_type (type3);
1487
1488           printf ("                    Type2: ");
1489
1490           if (rtype2 == NULL)
1491             printf (_("unrecognized: %-7lx"),
1492                     (unsigned long) type2 & 0xffffffff);
1493           else
1494             printf ("%-17.17s", rtype2);
1495
1496           printf ("\n                    Type3: ");
1497
1498           if (rtype3 == NULL)
1499             printf (_("unrecognized: %-7lx"),
1500                     (unsigned long) type3 & 0xffffffff);
1501           else
1502             printf ("%-17.17s", rtype3);
1503
1504           putchar ('\n');
1505         }
1506 #endif /* BFD64 */
1507     }
1508
1509   free (rels);
1510 }
1511
1512 static const char *
1513 get_mips_dynamic_type (unsigned long type)
1514 {
1515   switch (type)
1516     {
1517     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1518     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1519     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1520     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1521     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1522     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1523     case DT_MIPS_MSYM: return "MIPS_MSYM";
1524     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1525     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1526     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1527     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1528     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1529     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1530     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1531     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1532     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1533     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1534     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1535     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1536     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1537     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1538     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1539     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1540     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1541     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1542     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1543     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1544     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1545     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1546     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1547     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1548     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1549     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1550     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1551     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1552     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1553     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1554     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1555     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1556     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1557     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1558     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1559     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1560     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1561     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1562     default:
1563       return NULL;
1564     }
1565 }
1566
1567 static const char *
1568 get_sparc64_dynamic_type (unsigned long type)
1569 {
1570   switch (type)
1571     {
1572     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1573     default:
1574       return NULL;
1575     }
1576 }
1577
1578 static const char *
1579 get_ppc_dynamic_type (unsigned long type)
1580 {
1581   switch (type)
1582     {
1583     case DT_PPC_GOT:    return "PPC_GOT";
1584     case DT_PPC_OPT:    return "PPC_OPT";
1585     default:
1586       return NULL;
1587     }
1588 }
1589
1590 static const char *
1591 get_ppc64_dynamic_type (unsigned long type)
1592 {
1593   switch (type)
1594     {
1595     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1596     case DT_PPC64_OPD:    return "PPC64_OPD";
1597     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1598     case DT_PPC64_OPT:    return "PPC64_OPT";
1599     default:
1600       return NULL;
1601     }
1602 }
1603
1604 static const char *
1605 get_parisc_dynamic_type (unsigned long type)
1606 {
1607   switch (type)
1608     {
1609     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1610     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1611     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1612     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1613     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1614     case DT_HP_PREINIT:         return "HP_PREINIT";
1615     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1616     case DT_HP_NEEDED:          return "HP_NEEDED";
1617     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1618     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1619     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1620     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1621     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1622     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1623     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1624     case DT_HP_FILTERED:        return "HP_FILTERED";
1625     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1626     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1627     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1628     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1629     case DT_PLT:                return "PLT";
1630     case DT_PLT_SIZE:           return "PLT_SIZE";
1631     case DT_DLT:                return "DLT";
1632     case DT_DLT_SIZE:           return "DLT_SIZE";
1633     default:
1634       return NULL;
1635     }
1636 }
1637
1638 static const char *
1639 get_ia64_dynamic_type (unsigned long type)
1640 {
1641   switch (type)
1642     {
1643     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1644     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1645     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1646     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1647     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1648     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1649     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1650     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1651     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1652     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1653     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1654     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1655     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1656     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1657     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1658     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1659     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1660     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1661     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1662     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1663     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1664     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1665     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1666     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1667     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1668     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1669     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1670     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1671     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1672     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1673     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1674     default:
1675       return NULL;
1676     }
1677 }
1678
1679 static const char *
1680 get_alpha_dynamic_type (unsigned long type)
1681 {
1682   switch (type)
1683     {
1684     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1685     default:
1686       return NULL;
1687     }
1688 }
1689
1690 static const char *
1691 get_score_dynamic_type (unsigned long type)
1692 {
1693   switch (type)
1694     {
1695     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1696     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1697     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1698     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1699     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1700     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1701     default:
1702       return NULL;
1703     }
1704 }
1705
1706 static const char *
1707 get_tic6x_dynamic_type (unsigned long type)
1708 {
1709   switch (type)
1710     {
1711     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1712     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1713     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
1714     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
1715     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
1716     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
1717     default:
1718       return NULL;
1719     }
1720 }
1721
1722 static const char *
1723 get_nios2_dynamic_type (unsigned long type)
1724 {
1725   switch (type)
1726     {
1727     case DT_NIOS2_GP: return "NIOS2_GP";
1728     default:
1729       return NULL;
1730     }
1731 }
1732
1733 static const char *
1734 get_dynamic_type (unsigned long type)
1735 {
1736   static char buff[64];
1737
1738   switch (type)
1739     {
1740     case DT_NULL:       return "NULL";
1741     case DT_NEEDED:     return "NEEDED";
1742     case DT_PLTRELSZ:   return "PLTRELSZ";
1743     case DT_PLTGOT:     return "PLTGOT";
1744     case DT_HASH:       return "HASH";
1745     case DT_STRTAB:     return "STRTAB";
1746     case DT_SYMTAB:     return "SYMTAB";
1747     case DT_RELA:       return "RELA";
1748     case DT_RELASZ:     return "RELASZ";
1749     case DT_RELAENT:    return "RELAENT";
1750     case DT_STRSZ:      return "STRSZ";
1751     case DT_SYMENT:     return "SYMENT";
1752     case DT_INIT:       return "INIT";
1753     case DT_FINI:       return "FINI";
1754     case DT_SONAME:     return "SONAME";
1755     case DT_RPATH:      return "RPATH";
1756     case DT_SYMBOLIC:   return "SYMBOLIC";
1757     case DT_REL:        return "REL";
1758     case DT_RELSZ:      return "RELSZ";
1759     case DT_RELENT:     return "RELENT";
1760     case DT_PLTREL:     return "PLTREL";
1761     case DT_DEBUG:      return "DEBUG";
1762     case DT_TEXTREL:    return "TEXTREL";
1763     case DT_JMPREL:     return "JMPREL";
1764     case DT_BIND_NOW:   return "BIND_NOW";
1765     case DT_INIT_ARRAY: return "INIT_ARRAY";
1766     case DT_FINI_ARRAY: return "FINI_ARRAY";
1767     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1768     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1769     case DT_RUNPATH:    return "RUNPATH";
1770     case DT_FLAGS:      return "FLAGS";
1771
1772     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1773     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1774
1775     case DT_CHECKSUM:   return "CHECKSUM";
1776     case DT_PLTPADSZ:   return "PLTPADSZ";
1777     case DT_MOVEENT:    return "MOVEENT";
1778     case DT_MOVESZ:     return "MOVESZ";
1779     case DT_FEATURE:    return "FEATURE";
1780     case DT_POSFLAG_1:  return "POSFLAG_1";
1781     case DT_SYMINSZ:    return "SYMINSZ";
1782     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
1783
1784     case DT_ADDRRNGLO:  return "ADDRRNGLO";
1785     case DT_CONFIG:     return "CONFIG";
1786     case DT_DEPAUDIT:   return "DEPAUDIT";
1787     case DT_AUDIT:      return "AUDIT";
1788     case DT_PLTPAD:     return "PLTPAD";
1789     case DT_MOVETAB:    return "MOVETAB";
1790     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
1791
1792     case DT_VERSYM:     return "VERSYM";
1793
1794     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1795     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1796     case DT_RELACOUNT:  return "RELACOUNT";
1797     case DT_RELCOUNT:   return "RELCOUNT";
1798     case DT_FLAGS_1:    return "FLAGS_1";
1799     case DT_VERDEF:     return "VERDEF";
1800     case DT_VERDEFNUM:  return "VERDEFNUM";
1801     case DT_VERNEED:    return "VERNEED";
1802     case DT_VERNEEDNUM: return "VERNEEDNUM";
1803
1804     case DT_AUXILIARY:  return "AUXILIARY";
1805     case DT_USED:       return "USED";
1806     case DT_FILTER:     return "FILTER";
1807
1808     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1809     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1810     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1811     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1812     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1813     case DT_GNU_HASH:   return "GNU_HASH";
1814
1815     default:
1816       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1817         {
1818           const char * result;
1819
1820           switch (elf_header.e_machine)
1821             {
1822             case EM_MIPS:
1823             case EM_MIPS_RS3_LE:
1824               result = get_mips_dynamic_type (type);
1825               break;
1826             case EM_SPARCV9:
1827               result = get_sparc64_dynamic_type (type);
1828               break;
1829             case EM_PPC:
1830               result = get_ppc_dynamic_type (type);
1831               break;
1832             case EM_PPC64:
1833               result = get_ppc64_dynamic_type (type);
1834               break;
1835             case EM_IA_64:
1836               result = get_ia64_dynamic_type (type);
1837               break;
1838             case EM_ALPHA:
1839               result = get_alpha_dynamic_type (type);
1840               break;
1841             case EM_SCORE:
1842               result = get_score_dynamic_type (type);
1843               break;
1844             case EM_TI_C6000:
1845               result = get_tic6x_dynamic_type (type);
1846               break;
1847             case EM_ALTERA_NIOS2:
1848               result = get_nios2_dynamic_type (type);
1849               break;
1850             default:
1851               result = NULL;
1852               break;
1853             }
1854
1855           if (result != NULL)
1856             return result;
1857
1858           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1859         }
1860       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1861                || (elf_header.e_machine == EM_PARISC
1862                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1863         {
1864           const char * result;
1865
1866           switch (elf_header.e_machine)
1867             {
1868             case EM_PARISC:
1869               result = get_parisc_dynamic_type (type);
1870               break;
1871             case EM_IA_64:
1872               result = get_ia64_dynamic_type (type);
1873               break;
1874             default:
1875               result = NULL;
1876               break;
1877             }
1878
1879           if (result != NULL)
1880             return result;
1881
1882           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1883                     type);
1884         }
1885       else
1886         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1887
1888       return buff;
1889     }
1890 }
1891
1892 static char *
1893 get_file_type (unsigned e_type)
1894 {
1895   static char buff[32];
1896
1897   switch (e_type)
1898     {
1899     case ET_NONE:       return _("NONE (None)");
1900     case ET_REL:        return _("REL (Relocatable file)");
1901     case ET_EXEC:       return _("EXEC (Executable file)");
1902     case ET_DYN:        return _("DYN (Shared object file)");
1903     case ET_CORE:       return _("CORE (Core file)");
1904
1905     default:
1906       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1907         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1908       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1909         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1910       else
1911         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1912       return buff;
1913     }
1914 }
1915
1916 static char *
1917 get_machine_name (unsigned e_machine)
1918 {
1919   static char buff[64]; /* XXX */
1920
1921   switch (e_machine)
1922     {
1923     case EM_NONE:               return _("None");
1924     case EM_AARCH64:            return "AArch64";
1925     case EM_M32:                return "WE32100";
1926     case EM_SPARC:              return "Sparc";
1927     case EM_SPU:                return "SPU";
1928     case EM_386:                return "Intel 80386";
1929     case EM_68K:                return "MC68000";
1930     case EM_88K:                return "MC88000";
1931     case EM_486:                return "Intel 80486";
1932     case EM_860:                return "Intel 80860";
1933     case EM_MIPS:               return "MIPS R3000";
1934     case EM_S370:               return "IBM System/370";
1935     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
1936     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
1937     case EM_PARISC:             return "HPPA";
1938     case EM_PPC_OLD:            return "Power PC (old)";
1939     case EM_SPARC32PLUS:        return "Sparc v8+" ;
1940     case EM_960:                return "Intel 90860";
1941     case EM_PPC:                return "PowerPC";
1942     case EM_PPC64:              return "PowerPC64";
1943     case EM_FR20:               return "Fujitsu FR20";
1944     case EM_RH32:               return "TRW RH32";
1945     case EM_MCORE:              return "MCORE";
1946     case EM_ARM:                return "ARM";
1947     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
1948     case EM_SH:                 return "Renesas / SuperH SH";
1949     case EM_SPARCV9:            return "Sparc v9";
1950     case EM_TRICORE:            return "Siemens Tricore";
1951     case EM_ARC:                return "ARC";
1952     case EM_H8_300:             return "Renesas H8/300";
1953     case EM_H8_300H:            return "Renesas H8/300H";
1954     case EM_H8S:                return "Renesas H8S";
1955     case EM_H8_500:             return "Renesas H8/500";
1956     case EM_IA_64:              return "Intel IA-64";
1957     case EM_MIPS_X:             return "Stanford MIPS-X";
1958     case EM_COLDFIRE:           return "Motorola Coldfire";
1959     case EM_ALPHA:              return "Alpha";
1960     case EM_CYGNUS_D10V:
1961     case EM_D10V:               return "d10v";
1962     case EM_CYGNUS_D30V:
1963     case EM_D30V:               return "d30v";
1964     case EM_CYGNUS_M32R:
1965     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
1966     case EM_CYGNUS_V850:
1967     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
1968     case EM_V850:               return "Renesas V850";
1969     case EM_CYGNUS_MN10300:
1970     case EM_MN10300:            return "mn10300";
1971     case EM_CYGNUS_MN10200:
1972     case EM_MN10200:            return "mn10200";
1973     case EM_MOXIE:              return "Moxie";
1974     case EM_CYGNUS_FR30:
1975     case EM_FR30:               return "Fujitsu FR30";
1976     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
1977     case EM_PJ_OLD:
1978     case EM_PJ:                 return "picoJava";
1979     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
1980     case EM_PCP:                return "Siemens PCP";
1981     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
1982     case EM_NDR1:               return "Denso NDR1 microprocesspr";
1983     case EM_STARCORE:           return "Motorola Star*Core processor";
1984     case EM_ME16:               return "Toyota ME16 processor";
1985     case EM_ST100:              return "STMicroelectronics ST100 processor";
1986     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
1987     case EM_PDSP:               return "Sony DSP processor";
1988     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
1989     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
1990     case EM_FX66:               return "Siemens FX66 microcontroller";
1991     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1992     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
1993     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
1994     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
1995     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
1996     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
1997     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
1998     case EM_SVX:                return "Silicon Graphics SVx";
1999     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2000     case EM_VAX:                return "Digital VAX";
2001     case EM_AVR_OLD:
2002     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2003     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2004     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2005     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2006     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2007     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2008     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2009     case EM_PRISM:              return "Vitesse Prism";
2010     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2011     case EM_L1OM:               return "Intel L1OM";
2012     case EM_K1OM:               return "Intel K1OM";
2013     case EM_S390_OLD:
2014     case EM_S390:               return "IBM S/390";
2015     case EM_SCORE:              return "SUNPLUS S+Core";
2016     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2017     case EM_OPENRISC:
2018     case EM_OR32:               return "OpenRISC";
2019     case EM_ARC_A5:             return "ARC International ARCompact processor";
2020     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2021     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2022     case EM_DLX:                return "OpenDLX";
2023     case EM_IP2K_OLD:
2024     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2025     case EM_IQ2000:             return "Vitesse IQ2000";
2026     case EM_XTENSA_OLD:
2027     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2028     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2029     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2030     case EM_NS32K:              return "National Semiconductor 32000 series";
2031     case EM_TPC:                return "Tenor Network TPC processor";
2032     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2033     case EM_MAX:                return "MAX Processor";
2034     case EM_CR:                 return "National Semiconductor CompactRISC";
2035     case EM_F2MC16:             return "Fujitsu F2MC16";
2036     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2037     case EM_LATTICEMICO32:      return "Lattice Mico32";
2038     case EM_M32C_OLD:
2039     case EM_M32C:               return "Renesas M32c";
2040     case EM_MT:                 return "Morpho Techologies MT processor";
2041     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2042     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2043     case EM_SEP:                return "Sharp embedded microprocessor";
2044     case EM_ARCA:               return "Arca RISC microprocessor";
2045     case EM_UNICORE:            return "Unicore";
2046     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2047     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2048     case EM_NIOS32:             return "Altera Nios";
2049     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2050     case EM_C166:
2051     case EM_XC16X:              return "Infineon Technologies xc16x";
2052     case EM_M16C:               return "Renesas M16C series microprocessors";
2053     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2054     case EM_CE:                 return "Freescale Communication Engine RISC core";
2055     case EM_TSK3000:            return "Altium TSK3000 core";
2056     case EM_RS08:               return "Freescale RS08 embedded processor";
2057     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2058     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2059     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2060     case EM_SE_C17:             return "Seiko Epson C17 family";
2061     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2062     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2063     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2064     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2065     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2066     case EM_R32C:               return "Renesas R32C series microprocessors";
2067     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2068     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2069     case EM_8051:               return "Intel 8051 and variants";
2070     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2071     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2072     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2073     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2074     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2075     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2076     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2077     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2078     case EM_CR16:
2079     case EM_MICROBLAZE:
2080     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2081     case EM_RL78:               return "Renesas RL78";
2082     case EM_RX:                 return "Renesas RX";
2083     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2084     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2085     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2086     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2087     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2088     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor family";
2089     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2090     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2091     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2092     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2093     case EM_CUDA:               return "NVIDIA CUDA architecture";
2094     case EM_XGATE:              return "Motorola XGATE embedded processor";
2095     default:
2096       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2097       return buff;
2098     }
2099 }
2100
2101 static void
2102 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2103 {
2104   unsigned eabi;
2105   int unknown = 0;
2106
2107   eabi = EF_ARM_EABI_VERSION (e_flags);
2108   e_flags &= ~ EF_ARM_EABIMASK;
2109
2110   /* Handle "generic" ARM flags.  */
2111   if (e_flags & EF_ARM_RELEXEC)
2112     {
2113       strcat (buf, ", relocatable executable");
2114       e_flags &= ~ EF_ARM_RELEXEC;
2115     }
2116
2117   if (e_flags & EF_ARM_HASENTRY)
2118     {
2119       strcat (buf, ", has entry point");
2120       e_flags &= ~ EF_ARM_HASENTRY;
2121     }
2122
2123   /* Now handle EABI specific flags.  */
2124   switch (eabi)
2125     {
2126     default:
2127       strcat (buf, ", <unrecognized EABI>");
2128       if (e_flags)
2129         unknown = 1;
2130       break;
2131
2132     case EF_ARM_EABI_VER1:
2133       strcat (buf, ", Version1 EABI");
2134       while (e_flags)
2135         {
2136           unsigned flag;
2137
2138           /* Process flags one bit at a time.  */
2139           flag = e_flags & - e_flags;
2140           e_flags &= ~ flag;
2141
2142           switch (flag)
2143             {
2144             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2145               strcat (buf, ", sorted symbol tables");
2146               break;
2147
2148             default:
2149               unknown = 1;
2150               break;
2151             }
2152         }
2153       break;
2154
2155     case EF_ARM_EABI_VER2:
2156       strcat (buf, ", Version2 EABI");
2157       while (e_flags)
2158         {
2159           unsigned flag;
2160
2161           /* Process flags one bit at a time.  */
2162           flag = e_flags & - e_flags;
2163           e_flags &= ~ flag;
2164
2165           switch (flag)
2166             {
2167             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2168               strcat (buf, ", sorted symbol tables");
2169               break;
2170
2171             case EF_ARM_DYNSYMSUSESEGIDX:
2172               strcat (buf, ", dynamic symbols use segment index");
2173               break;
2174
2175             case EF_ARM_MAPSYMSFIRST:
2176               strcat (buf, ", mapping symbols precede others");
2177               break;
2178
2179             default:
2180               unknown = 1;
2181               break;
2182             }
2183         }
2184       break;
2185
2186     case EF_ARM_EABI_VER3:
2187       strcat (buf, ", Version3 EABI");
2188       break;
2189
2190     case EF_ARM_EABI_VER4:
2191       strcat (buf, ", Version4 EABI");
2192       while (e_flags)
2193         {
2194           unsigned flag;
2195
2196           /* Process flags one bit at a time.  */
2197           flag = e_flags & - e_flags;
2198           e_flags &= ~ flag;
2199
2200           switch (flag)
2201             {
2202             case EF_ARM_BE8:
2203               strcat (buf, ", BE8");
2204               break;
2205
2206             case EF_ARM_LE8:
2207               strcat (buf, ", LE8");
2208               break;
2209
2210             default:
2211               unknown = 1;
2212               break;
2213             }
2214       break;
2215         }
2216       break;
2217
2218     case EF_ARM_EABI_VER5:
2219       strcat (buf, ", Version5 EABI");
2220       while (e_flags)
2221         {
2222           unsigned flag;
2223
2224           /* Process flags one bit at a time.  */
2225           flag = e_flags & - e_flags;
2226           e_flags &= ~ flag;
2227
2228           switch (flag)
2229             {
2230             case EF_ARM_BE8:
2231               strcat (buf, ", BE8");
2232               break;
2233
2234             case EF_ARM_LE8:
2235               strcat (buf, ", LE8");
2236               break;
2237
2238             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2239               strcat (buf, ", soft-float ABI");
2240               break;
2241
2242             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2243               strcat (buf, ", hard-float ABI");
2244               break;
2245
2246             default:
2247               unknown = 1;
2248               break;
2249             }
2250         }
2251       break;
2252
2253     case EF_ARM_EABI_UNKNOWN:
2254       strcat (buf, ", GNU EABI");
2255       while (e_flags)
2256         {
2257           unsigned flag;
2258
2259           /* Process flags one bit at a time.  */
2260           flag = e_flags & - e_flags;
2261           e_flags &= ~ flag;
2262
2263           switch (flag)
2264             {
2265             case EF_ARM_INTERWORK:
2266               strcat (buf, ", interworking enabled");
2267               break;
2268
2269             case EF_ARM_APCS_26:
2270               strcat (buf, ", uses APCS/26");
2271               break;
2272
2273             case EF_ARM_APCS_FLOAT:
2274               strcat (buf, ", uses APCS/float");
2275               break;
2276
2277             case EF_ARM_PIC:
2278               strcat (buf, ", position independent");
2279               break;
2280
2281             case EF_ARM_ALIGN8:
2282               strcat (buf, ", 8 bit structure alignment");
2283               break;
2284
2285             case EF_ARM_NEW_ABI:
2286               strcat (buf, ", uses new ABI");
2287               break;
2288
2289             case EF_ARM_OLD_ABI:
2290               strcat (buf, ", uses old ABI");
2291               break;
2292
2293             case EF_ARM_SOFT_FLOAT:
2294               strcat (buf, ", software FP");
2295               break;
2296
2297             case EF_ARM_VFP_FLOAT:
2298               strcat (buf, ", VFP");
2299               break;
2300
2301             case EF_ARM_MAVERICK_FLOAT:
2302               strcat (buf, ", Maverick FP");
2303               break;
2304
2305             default:
2306               unknown = 1;
2307               break;
2308             }
2309         }
2310     }
2311
2312   if (unknown)
2313     strcat (buf,_(", <unknown>"));
2314 }
2315
2316 static void
2317 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2318 {
2319   unsigned abi;
2320   unsigned arch;
2321   unsigned config;
2322   unsigned version;
2323   int has_fpu = 0;
2324   int r = 0;
2325
2326   static const char *ABI_STRINGS[] =
2327   {
2328     "ABI v0", /* use r5 as return register; only used in N1213HC */
2329     "ABI v1", /* use r0 as return register */
2330     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2331     "ABI v2fp", /* for FPU */
2332     "AABI"
2333   };
2334   static const char *VER_STRINGS[] =
2335   {
2336     "Andes ELF V1.3 or older",
2337     "Andes ELF V1.3.1",
2338     "Andes ELF V1.4"
2339   };
2340   static const char *ARCH_STRINGS[] =
2341   {
2342     "",
2343     "Andes Star v1.0",
2344     "Andes Star v2.0",
2345     "Andes Star v3.0",
2346     "Andes Star v3.0m"
2347   };
2348
2349   abi = EF_NDS_ABI & e_flags;
2350   arch = EF_NDS_ARCH & e_flags;
2351   config = EF_NDS_INST & e_flags;
2352   version = EF_NDS32_ELF_VERSION & e_flags;
2353
2354   memset (buf, 0, size);
2355
2356   switch (abi)
2357     {
2358     case E_NDS_ABI_V0:
2359     case E_NDS_ABI_V1:
2360     case E_NDS_ABI_V2:
2361     case E_NDS_ABI_V2FP:
2362     case E_NDS_ABI_AABI:
2363       /* In case there are holes in the array.  */
2364       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2365       break;
2366
2367     default:
2368       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2369       break;
2370     }
2371
2372   switch (version)
2373     {
2374     case E_NDS32_ELF_VER_1_2:
2375     case E_NDS32_ELF_VER_1_3:
2376     case E_NDS32_ELF_VER_1_4:
2377       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2378       break;
2379
2380     default:
2381       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2382       break;
2383     }
2384
2385   if (E_NDS_ABI_V0 == abi)
2386     {
2387       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2388       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2389       if (arch == E_NDS_ARCH_STAR_V1_0)
2390         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2391       return;
2392     }
2393
2394   switch (arch)
2395     {
2396     case E_NDS_ARCH_STAR_V1_0:
2397     case E_NDS_ARCH_STAR_V2_0:
2398     case E_NDS_ARCH_STAR_V3_0:
2399     case E_NDS_ARCH_STAR_V3_M:
2400       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2401       break;
2402
2403     default:
2404       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2405       /* ARCH version determines how the e_flags are interpreted.
2406          If it is unknown, we cannot proceed.  */
2407       return;
2408     }
2409
2410   /* Newer ABI; Now handle architecture specific flags.  */
2411   if (arch == E_NDS_ARCH_STAR_V1_0)
2412     {
2413       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2414         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2415
2416       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2417         r += snprintf (buf + r, size -r, ", MAC");
2418
2419       if (config & E_NDS32_HAS_DIV_INST)
2420         r += snprintf (buf + r, size -r, ", DIV");
2421
2422       if (config & E_NDS32_HAS_16BIT_INST)
2423         r += snprintf (buf + r, size -r, ", 16b");
2424     }
2425   else
2426     {
2427       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2428         {
2429           if (version <= E_NDS32_ELF_VER_1_3)
2430             r += snprintf (buf + r, size -r, ", [B8]");
2431           else
2432             r += snprintf (buf + r, size -r, ", EX9");
2433         }
2434
2435       if (config & E_NDS32_HAS_MAC_DX_INST)
2436         r += snprintf (buf + r, size -r, ", MAC_DX");
2437
2438       if (config & E_NDS32_HAS_DIV_DX_INST)
2439         r += snprintf (buf + r, size -r, ", DIV_DX");
2440
2441       if (config & E_NDS32_HAS_16BIT_INST)
2442         {
2443           if (version <= E_NDS32_ELF_VER_1_3)
2444             r += snprintf (buf + r, size -r, ", 16b");
2445           else
2446             r += snprintf (buf + r, size -r, ", IFC");
2447         }
2448     }
2449
2450   if (config & E_NDS32_HAS_EXT_INST)
2451     r += snprintf (buf + r, size -r, ", PERF1");
2452
2453   if (config & E_NDS32_HAS_EXT2_INST)
2454     r += snprintf (buf + r, size -r, ", PERF2");
2455
2456   if (config & E_NDS32_HAS_FPU_INST)
2457     {
2458       has_fpu = 1;
2459       r += snprintf (buf + r, size -r, ", FPU_SP");
2460     }
2461
2462   if (config & E_NDS32_HAS_FPU_DP_INST)
2463     {
2464       has_fpu = 1;
2465       r += snprintf (buf + r, size -r, ", FPU_DP");
2466     }
2467
2468   if (config & E_NDS32_HAS_FPU_MAC_INST)
2469     {
2470       has_fpu = 1;
2471       r += snprintf (buf + r, size -r, ", FPU_MAC");
2472     }
2473
2474   if (has_fpu)
2475     {
2476       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2477         {
2478         case E_NDS32_FPU_REG_8SP_4DP:
2479           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2480           break;
2481         case E_NDS32_FPU_REG_16SP_8DP:
2482           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2483           break;
2484         case E_NDS32_FPU_REG_32SP_16DP:
2485           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2486           break;
2487         case E_NDS32_FPU_REG_32SP_32DP:
2488           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2489           break;
2490         }
2491     }
2492
2493   if (config & E_NDS32_HAS_AUDIO_INST)
2494     r += snprintf (buf + r, size -r, ", AUDIO");
2495
2496   if (config & E_NDS32_HAS_STRING_INST)
2497     r += snprintf (buf + r, size -r, ", STR");
2498
2499   if (config & E_NDS32_HAS_REDUCED_REGS)
2500     r += snprintf (buf + r, size -r, ", 16REG");
2501
2502   if (config & E_NDS32_HAS_VIDEO_INST)
2503     {
2504       if (version <= E_NDS32_ELF_VER_1_3)
2505         r += snprintf (buf + r, size -r, ", VIDEO");
2506       else
2507         r += snprintf (buf + r, size -r, ", SATURATION");
2508     }
2509
2510   if (config & E_NDS32_HAS_ENCRIPT_INST)
2511     r += snprintf (buf + r, size -r, ", ENCRP");
2512
2513   if (config & E_NDS32_HAS_L2C_INST)
2514     r += snprintf (buf + r, size -r, ", L2C");
2515 }
2516
2517 static char *
2518 get_machine_flags (unsigned e_flags, unsigned e_machine)
2519 {
2520   static char buf[1024];
2521
2522   buf[0] = '\0';
2523
2524   if (e_flags)
2525     {
2526       switch (e_machine)
2527         {
2528         default:
2529           break;
2530
2531         case EM_ARM:
2532           decode_ARM_machine_flags (e_flags, buf);
2533           break;
2534
2535         case EM_BLACKFIN:
2536           if (e_flags & EF_BFIN_PIC)
2537             strcat (buf, ", PIC");
2538
2539           if (e_flags & EF_BFIN_FDPIC)
2540             strcat (buf, ", FDPIC");
2541
2542           if (e_flags & EF_BFIN_CODE_IN_L1)
2543             strcat (buf, ", code in L1");
2544
2545           if (e_flags & EF_BFIN_DATA_IN_L1)
2546             strcat (buf, ", data in L1");
2547
2548           break;
2549
2550         case EM_CYGNUS_FRV:
2551           switch (e_flags & EF_FRV_CPU_MASK)
2552             {
2553             case EF_FRV_CPU_GENERIC:
2554               break;
2555
2556             default:
2557               strcat (buf, ", fr???");
2558               break;
2559
2560             case EF_FRV_CPU_FR300:
2561               strcat (buf, ", fr300");
2562               break;
2563
2564             case EF_FRV_CPU_FR400:
2565               strcat (buf, ", fr400");
2566               break;
2567             case EF_FRV_CPU_FR405:
2568               strcat (buf, ", fr405");
2569               break;
2570
2571             case EF_FRV_CPU_FR450:
2572               strcat (buf, ", fr450");
2573               break;
2574
2575             case EF_FRV_CPU_FR500:
2576               strcat (buf, ", fr500");
2577               break;
2578             case EF_FRV_CPU_FR550:
2579               strcat (buf, ", fr550");
2580               break;
2581
2582             case EF_FRV_CPU_SIMPLE:
2583               strcat (buf, ", simple");
2584               break;
2585             case EF_FRV_CPU_TOMCAT:
2586               strcat (buf, ", tomcat");
2587               break;
2588             }
2589           break;
2590
2591         case EM_68K:
2592           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2593             strcat (buf, ", m68000");
2594           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2595             strcat (buf, ", cpu32");
2596           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2597             strcat (buf, ", fido_a");
2598           else
2599             {
2600               char const * isa = _("unknown");
2601               char const * mac = _("unknown mac");
2602               char const * additional = NULL;
2603
2604               switch (e_flags & EF_M68K_CF_ISA_MASK)
2605                 {
2606                 case EF_M68K_CF_ISA_A_NODIV:
2607                   isa = "A";
2608                   additional = ", nodiv";
2609                   break;
2610                 case EF_M68K_CF_ISA_A:
2611                   isa = "A";
2612                   break;
2613                 case EF_M68K_CF_ISA_A_PLUS:
2614                   isa = "A+";
2615                   break;
2616                 case EF_M68K_CF_ISA_B_NOUSP:
2617                   isa = "B";
2618                   additional = ", nousp";
2619                   break;
2620                 case EF_M68K_CF_ISA_B:
2621                   isa = "B";
2622                   break;
2623                 case EF_M68K_CF_ISA_C:
2624                   isa = "C";
2625                   break;
2626                 case EF_M68K_CF_ISA_C_NODIV:
2627                   isa = "C";
2628                   additional = ", nodiv";
2629                   break;
2630                 }
2631               strcat (buf, ", cf, isa ");
2632               strcat (buf, isa);
2633               if (additional)
2634                 strcat (buf, additional);
2635               if (e_flags & EF_M68K_CF_FLOAT)
2636                 strcat (buf, ", float");
2637               switch (e_flags & EF_M68K_CF_MAC_MASK)
2638                 {
2639                 case 0:
2640                   mac = NULL;
2641                   break;
2642                 case EF_M68K_CF_MAC:
2643                   mac = "mac";
2644                   break;
2645                 case EF_M68K_CF_EMAC:
2646                   mac = "emac";
2647                   break;
2648                 case EF_M68K_CF_EMAC_B:
2649                   mac = "emac_b";
2650                   break;
2651                 }
2652               if (mac)
2653                 {
2654                   strcat (buf, ", ");
2655                   strcat (buf, mac);
2656                 }
2657             }
2658           break;
2659
2660         case EM_PPC:
2661           if (e_flags & EF_PPC_EMB)
2662             strcat (buf, ", emb");
2663
2664           if (e_flags & EF_PPC_RELOCATABLE)
2665             strcat (buf, _(", relocatable"));
2666
2667           if (e_flags & EF_PPC_RELOCATABLE_LIB)
2668             strcat (buf, _(", relocatable-lib"));
2669           break;
2670
2671         case EM_PPC64:
2672           if (e_flags & EF_PPC64_ABI)
2673             {
2674               char abi[] = ", abiv0";
2675
2676               abi[6] += e_flags & EF_PPC64_ABI;
2677               strcat (buf, abi);
2678             }
2679           break;
2680
2681         case EM_V800:
2682           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2683             strcat (buf, ", RH850 ABI");
2684
2685           if (e_flags & EF_V800_850E3)
2686             strcat (buf, ", V3 architecture");
2687
2688           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2689             strcat (buf, ", FPU not used");
2690
2691           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2692             strcat (buf, ", regmode: COMMON");
2693
2694           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2695             strcat (buf, ", r4 not used");
2696
2697           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2698             strcat (buf, ", r30 not used");
2699
2700           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2701             strcat (buf, ", r5 not used");
2702
2703           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2704             strcat (buf, ", r2 not used");
2705
2706           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2707             {
2708               switch (e_flags & - e_flags)
2709                 {
2710                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2711                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2712                 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2713                 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2714                 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2715                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2716                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2717                 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2718                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2719                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2720                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2721                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2722                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2723                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2724                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2725                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2726                 default: break;
2727                 }
2728             }
2729           break;
2730
2731         case EM_V850:
2732         case EM_CYGNUS_V850:
2733           switch (e_flags & EF_V850_ARCH)
2734             {
2735             case E_V850E3V5_ARCH:
2736               strcat (buf, ", v850e3v5");
2737               break;
2738             case E_V850E2V3_ARCH:
2739               strcat (buf, ", v850e2v3");
2740               break;
2741             case E_V850E2_ARCH:
2742               strcat (buf, ", v850e2");
2743               break;
2744             case E_V850E1_ARCH:
2745               strcat (buf, ", v850e1");
2746               break;
2747             case E_V850E_ARCH:
2748               strcat (buf, ", v850e");
2749               break;
2750             case E_V850_ARCH:
2751               strcat (buf, ", v850");
2752               break;
2753             default:
2754               strcat (buf, _(", unknown v850 architecture variant"));
2755               break;
2756             }
2757           break;
2758
2759         case EM_M32R:
2760         case EM_CYGNUS_M32R:
2761           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2762             strcat (buf, ", m32r");
2763           break;
2764
2765         case EM_MIPS:
2766         case EM_MIPS_RS3_LE:
2767           if (e_flags & EF_MIPS_NOREORDER)
2768             strcat (buf, ", noreorder");
2769
2770           if (e_flags & EF_MIPS_PIC)
2771             strcat (buf, ", pic");
2772
2773           if (e_flags & EF_MIPS_CPIC)
2774             strcat (buf, ", cpic");
2775
2776           if (e_flags & EF_MIPS_UCODE)
2777             strcat (buf, ", ugen_reserved");
2778
2779           if (e_flags & EF_MIPS_ABI2)
2780             strcat (buf, ", abi2");
2781
2782           if (e_flags & EF_MIPS_OPTIONS_FIRST)
2783             strcat (buf, ", odk first");
2784
2785           if (e_flags & EF_MIPS_32BITMODE)
2786             strcat (buf, ", 32bitmode");
2787
2788           if (e_flags & EF_MIPS_NAN2008)
2789             strcat (buf, ", nan2008");
2790
2791           if (e_flags & EF_MIPS_FP64)
2792             strcat (buf, ", fp64");
2793
2794           switch ((e_flags & EF_MIPS_MACH))
2795             {
2796             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2797             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2798             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2799             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2800             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2801             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2802             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2803             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2804             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
2805             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2806             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2807             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2808             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
2809             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2810             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2811             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
2812             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
2813             case 0:
2814             /* We simply ignore the field in this case to avoid confusion:
2815                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2816                extension.  */
2817               break;
2818             default: strcat (buf, _(", unknown CPU")); break;
2819             }
2820
2821           switch ((e_flags & EF_MIPS_ABI))
2822             {
2823             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2824             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2825             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2826             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2827             case 0:
2828             /* We simply ignore the field in this case to avoid confusion:
2829                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2830                This means it is likely to be an o32 file, but not for
2831                sure.  */
2832               break;
2833             default: strcat (buf, _(", unknown ABI")); break;
2834             }
2835
2836           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2837             strcat (buf, ", mdmx");
2838
2839           if (e_flags & EF_MIPS_ARCH_ASE_M16)
2840             strcat (buf, ", mips16");
2841
2842           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2843             strcat (buf, ", micromips");
2844
2845           switch ((e_flags & EF_MIPS_ARCH))
2846             {
2847             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2848             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2849             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2850             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2851             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2852             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2853             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2854             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2855             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2856             default: strcat (buf, _(", unknown ISA")); break;
2857             }
2858           break;
2859
2860         case EM_NDS32:
2861           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
2862           break;
2863
2864         case EM_SH:
2865           switch ((e_flags & EF_SH_MACH_MASK))
2866             {
2867             case EF_SH1: strcat (buf, ", sh1"); break;
2868             case EF_SH2: strcat (buf, ", sh2"); break;
2869             case EF_SH3: strcat (buf, ", sh3"); break;
2870             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2871             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2872             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2873             case EF_SH3E: strcat (buf, ", sh3e"); break;
2874             case EF_SH4: strcat (buf, ", sh4"); break;
2875             case EF_SH5: strcat (buf, ", sh5"); break;
2876             case EF_SH2E: strcat (buf, ", sh2e"); break;
2877             case EF_SH4A: strcat (buf, ", sh4a"); break;
2878             case EF_SH2A: strcat (buf, ", sh2a"); break;
2879             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2880             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2881             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2882             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2883             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2884             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2885             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2886             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2887             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2888             default: strcat (buf, _(", unknown ISA")); break;
2889             }
2890
2891           if (e_flags & EF_SH_PIC)
2892             strcat (buf, ", pic");
2893
2894           if (e_flags & EF_SH_FDPIC)
2895             strcat (buf, ", fdpic");
2896           break;
2897
2898         case EM_SPARCV9:
2899           if (e_flags & EF_SPARC_32PLUS)
2900             strcat (buf, ", v8+");
2901
2902           if (e_flags & EF_SPARC_SUN_US1)
2903             strcat (buf, ", ultrasparcI");
2904
2905           if (e_flags & EF_SPARC_SUN_US3)
2906             strcat (buf, ", ultrasparcIII");
2907
2908           if (e_flags & EF_SPARC_HAL_R1)
2909             strcat (buf, ", halr1");
2910
2911           if (e_flags & EF_SPARC_LEDATA)
2912             strcat (buf, ", ledata");
2913
2914           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2915             strcat (buf, ", tso");
2916
2917           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2918             strcat (buf, ", pso");
2919
2920           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2921             strcat (buf, ", rmo");
2922           break;
2923
2924         case EM_PARISC:
2925           switch (e_flags & EF_PARISC_ARCH)
2926             {
2927             case EFA_PARISC_1_0:
2928               strcpy (buf, ", PA-RISC 1.0");
2929               break;
2930             case EFA_PARISC_1_1:
2931               strcpy (buf, ", PA-RISC 1.1");
2932               break;
2933             case EFA_PARISC_2_0:
2934               strcpy (buf, ", PA-RISC 2.0");
2935               break;
2936             default:
2937               break;
2938             }
2939           if (e_flags & EF_PARISC_TRAPNIL)
2940             strcat (buf, ", trapnil");
2941           if (e_flags & EF_PARISC_EXT)
2942             strcat (buf, ", ext");
2943           if (e_flags & EF_PARISC_LSB)
2944             strcat (buf, ", lsb");
2945           if (e_flags & EF_PARISC_WIDE)
2946             strcat (buf, ", wide");
2947           if (e_flags & EF_PARISC_NO_KABP)
2948             strcat (buf, ", no kabp");
2949           if (e_flags & EF_PARISC_LAZYSWAP)
2950             strcat (buf, ", lazyswap");
2951           break;
2952
2953         case EM_PJ:
2954         case EM_PJ_OLD:
2955           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2956             strcat (buf, ", new calling convention");
2957
2958           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2959             strcat (buf, ", gnu calling convention");
2960           break;
2961
2962         case EM_IA_64:
2963           if ((e_flags & EF_IA_64_ABI64))
2964             strcat (buf, ", 64-bit");
2965           else
2966             strcat (buf, ", 32-bit");
2967           if ((e_flags & EF_IA_64_REDUCEDFP))
2968             strcat (buf, ", reduced fp model");
2969           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2970             strcat (buf, ", no function descriptors, constant gp");
2971           else if ((e_flags & EF_IA_64_CONS_GP))
2972             strcat (buf, ", constant gp");
2973           if ((e_flags & EF_IA_64_ABSOLUTE))
2974             strcat (buf, ", absolute");
2975           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2976             {
2977               if ((e_flags & EF_IA_64_VMS_LINKAGES))
2978                 strcat (buf, ", vms_linkages");
2979               switch ((e_flags & EF_IA_64_VMS_COMCOD))
2980                 {
2981                 case EF_IA_64_VMS_COMCOD_SUCCESS:
2982                   break;
2983                 case EF_IA_64_VMS_COMCOD_WARNING:
2984                   strcat (buf, ", warning");
2985                   break;
2986                 case EF_IA_64_VMS_COMCOD_ERROR:
2987                   strcat (buf, ", error");
2988                   break;
2989                 case EF_IA_64_VMS_COMCOD_ABORT:
2990                   strcat (buf, ", abort");
2991                   break;
2992                 default:
2993                   abort ();
2994                 }
2995             }
2996           break;
2997
2998         case EM_VAX:
2999           if ((e_flags & EF_VAX_NONPIC))
3000             strcat (buf, ", non-PIC");
3001           if ((e_flags & EF_VAX_DFLOAT))
3002             strcat (buf, ", D-Float");
3003           if ((e_flags & EF_VAX_GFLOAT))
3004             strcat (buf, ", G-Float");
3005           break;
3006
3007         case EM_RL78:
3008           if (e_flags & E_FLAG_RL78_G10)
3009             strcat (buf, ", G10");
3010           break;
3011
3012         case EM_RX:
3013           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3014             strcat (buf, ", 64-bit doubles");
3015           if (e_flags & E_FLAG_RX_DSP)
3016             strcat (buf, ", dsp");
3017           if (e_flags & E_FLAG_RX_PID)
3018             strcat (buf, ", pid");
3019           if (e_flags & E_FLAG_RX_ABI)
3020             strcat (buf, ", RX ABI");
3021           break;
3022
3023         case EM_S390:
3024           if (e_flags & EF_S390_HIGH_GPRS)
3025             strcat (buf, ", highgprs");
3026           break;
3027
3028         case EM_TI_C6000:
3029           if ((e_flags & EF_C6000_REL))
3030             strcat (buf, ", relocatable module");
3031           break;
3032
3033         case EM_MSP430:
3034           strcat (buf, _(": architecture variant: "));
3035           switch (e_flags & EF_MSP430_MACH)
3036             {
3037             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3038             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3039             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3040             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3041             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3042             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3043             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3044             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3045             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3046             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3047             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3048             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3049             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3050             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3051             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3052             default:
3053               strcat (buf, _(": unknown")); break;
3054             }
3055
3056           if (e_flags & ~ EF_MSP430_MACH)
3057             strcat (buf, _(": unknown extra flag bits also present"));
3058         }
3059     }
3060
3061   return buf;
3062 }
3063
3064 static const char *
3065 get_osabi_name (unsigned int osabi)
3066 {
3067   static char buff[32];
3068
3069   switch (osabi)
3070     {
3071     case ELFOSABI_NONE:         return "UNIX - System V";
3072     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3073     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3074     case ELFOSABI_GNU:          return "UNIX - GNU";
3075     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3076     case ELFOSABI_AIX:          return "UNIX - AIX";
3077     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3078     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3079     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3080     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3081     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3082     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3083     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3084     case ELFOSABI_AROS:         return "AROS";
3085     case ELFOSABI_FENIXOS:      return "FenixOS";
3086     default:
3087       if (osabi >= 64)
3088         switch (elf_header.e_machine)
3089           {
3090           case EM_ARM:
3091             switch (osabi)
3092               {
3093               case ELFOSABI_ARM:        return "ARM";
3094               default:
3095                 break;
3096               }
3097             break;
3098
3099           case EM_MSP430:
3100           case EM_MSP430_OLD:
3101             switch (osabi)
3102               {
3103               case ELFOSABI_STANDALONE: return _("Standalone App");
3104               default:
3105                 break;
3106               }
3107             break;
3108
3109           case EM_TI_C6000:
3110             switch (osabi)
3111               {
3112               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3113               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3114               default:
3115                 break;
3116               }
3117             break;
3118
3119           default:
3120             break;
3121           }
3122       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3123       return buff;
3124     }
3125 }
3126
3127 static const char *
3128 get_aarch64_segment_type (unsigned long type)
3129 {
3130   switch (type)
3131     {
3132     case PT_AARCH64_ARCHEXT:
3133       return "AARCH64_ARCHEXT";
3134     default:
3135       break;
3136     }
3137
3138   return NULL;
3139 }
3140
3141 static const char *
3142 get_arm_segment_type (unsigned long type)
3143 {
3144   switch (type)
3145     {
3146     case PT_ARM_EXIDX:
3147       return "EXIDX";
3148     default:
3149       break;
3150     }
3151
3152   return NULL;
3153 }
3154
3155 static const char *
3156 get_mips_segment_type (unsigned long type)
3157 {
3158   switch (type)
3159     {
3160     case PT_MIPS_REGINFO:
3161       return "REGINFO";
3162     case PT_MIPS_RTPROC:
3163       return "RTPROC";
3164     case PT_MIPS_OPTIONS:
3165       return "OPTIONS";
3166     default:
3167       break;
3168     }
3169
3170   return NULL;
3171 }
3172
3173 static const char *
3174 get_parisc_segment_type (unsigned long type)
3175 {
3176   switch (type)
3177     {
3178     case PT_HP_TLS:             return "HP_TLS";
3179     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3180     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3181     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3182     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3183     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3184     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3185     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3186     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3187     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3188     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3189     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3190     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3191     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3192     case PT_HP_STACK:           return "HP_STACK";
3193     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3194     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3195     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3196     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3197     default:
3198       break;
3199     }
3200
3201   return NULL;
3202 }
3203
3204 static const char *
3205 get_ia64_segment_type (unsigned long type)
3206 {
3207   switch (type)
3208     {
3209     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3210     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3211     case PT_HP_TLS:             return "HP_TLS";
3212     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3213     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3214     case PT_IA_64_HP_STACK:     return "HP_STACK";
3215     default:
3216       break;
3217     }
3218
3219   return NULL;
3220 }
3221
3222 static const char *
3223 get_tic6x_segment_type (unsigned long type)
3224 {
3225   switch (type)
3226     {
3227     case PT_C6000_PHATTR:       return "C6000_PHATTR";
3228     default:
3229       break;
3230     }
3231
3232   return NULL;
3233 }
3234
3235 static const char *
3236 get_segment_type (unsigned long p_type)
3237 {
3238   static char buff[32];
3239
3240   switch (p_type)
3241     {
3242     case PT_NULL:       return "NULL";
3243     case PT_LOAD:       return "LOAD";
3244     case PT_DYNAMIC:    return "DYNAMIC";
3245     case PT_INTERP:     return "INTERP";
3246     case PT_NOTE:       return "NOTE";
3247     case PT_SHLIB:      return "SHLIB";
3248     case PT_PHDR:       return "PHDR";
3249     case PT_TLS:        return "TLS";
3250
3251     case PT_GNU_EH_FRAME:
3252                         return "GNU_EH_FRAME";
3253     case PT_GNU_STACK:  return "GNU_STACK";
3254     case PT_GNU_RELRO:  return "GNU_RELRO";
3255
3256     default:
3257       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3258         {
3259           const char * result;
3260
3261           switch (elf_header.e_machine)
3262             {
3263             case EM_AARCH64:
3264               result = get_aarch64_segment_type (p_type);
3265               break;
3266             case EM_ARM:
3267               result = get_arm_segment_type (p_type);
3268               break;
3269             case EM_MIPS:
3270             case EM_MIPS_RS3_LE:
3271               result = get_mips_segment_type (p_type);
3272               break;
3273             case EM_PARISC:
3274               result = get_parisc_segment_type (p_type);
3275               break;
3276             case EM_IA_64:
3277               result = get_ia64_segment_type (p_type);
3278               break;
3279             case EM_TI_C6000:
3280               result = get_tic6x_segment_type (p_type);
3281               break;
3282             default:
3283               result = NULL;
3284               break;
3285             }
3286
3287           if (result != NULL)
3288             return result;
3289
3290           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3291         }
3292       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3293         {
3294           const char * result;
3295
3296           switch (elf_header.e_machine)
3297             {
3298             case EM_PARISC:
3299               result = get_parisc_segment_type (p_type);
3300               break;
3301             case EM_IA_64:
3302               result = get_ia64_segment_type (p_type);
3303               break;
3304             default:
3305               result = NULL;
3306               break;
3307             }
3308
3309           if (result != NULL)
3310             return result;
3311
3312           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3313         }
3314       else
3315         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3316
3317       return buff;
3318     }
3319 }
3320
3321 static const char *
3322 get_mips_section_type_name (unsigned int sh_type)
3323 {
3324   switch (sh_type)
3325     {
3326     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3327     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3328     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3329     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3330     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3331     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3332     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3333     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3334     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3335     case SHT_MIPS_RELD:          return "MIPS_RELD";
3336     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3337     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3338     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3339     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3340     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3341     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3342     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3343     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3344     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3345     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3346     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3347     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3348     case SHT_MIPS_LINE:          return "MIPS_LINE";
3349     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3350     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3351     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3352     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3353     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3354     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3355     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3356     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3357     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3358     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3359     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3360     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3361     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3362     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3363     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3364     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3365     default:
3366       break;
3367     }
3368   return NULL;
3369 }
3370
3371 static const char *
3372 get_parisc_section_type_name (unsigned int sh_type)
3373 {
3374   switch (sh_type)
3375     {
3376     case SHT_PARISC_EXT:        return "PARISC_EXT";
3377     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
3378     case SHT_PARISC_DOC:        return "PARISC_DOC";
3379     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
3380     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
3381     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
3382     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
3383     default:
3384       break;
3385     }
3386   return NULL;
3387 }
3388
3389 static const char *
3390 get_ia64_section_type_name (unsigned int sh_type)
3391 {
3392   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
3393   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3394     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3395
3396   switch (sh_type)
3397     {
3398     case SHT_IA_64_EXT:                return "IA_64_EXT";
3399     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
3400     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
3401     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
3402     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3403     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
3404     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
3405     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
3406     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
3407     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
3408     default:
3409       break;
3410     }
3411   return NULL;
3412 }
3413
3414 static const char *
3415 get_x86_64_section_type_name (unsigned int sh_type)
3416 {
3417   switch (sh_type)
3418     {
3419     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
3420     default:
3421       break;
3422     }
3423   return NULL;
3424 }
3425
3426 static const char *
3427 get_aarch64_section_type_name (unsigned int sh_type)
3428 {
3429   switch (sh_type)
3430     {
3431     case SHT_AARCH64_ATTRIBUTES:
3432       return "AARCH64_ATTRIBUTES";
3433     default:
3434       break;
3435     }
3436   return NULL;
3437 }
3438
3439 static const char *
3440 get_arm_section_type_name (unsigned int sh_type)
3441 {
3442   switch (sh_type)
3443     {
3444     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
3445     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
3446     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
3447     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
3448     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
3449     default:
3450       break;
3451     }
3452   return NULL;
3453 }
3454
3455 static const char *
3456 get_tic6x_section_type_name (unsigned int sh_type)
3457 {
3458   switch (sh_type)
3459     {
3460     case SHT_C6000_UNWIND:
3461       return "C6000_UNWIND";
3462     case SHT_C6000_PREEMPTMAP:
3463       return "C6000_PREEMPTMAP";
3464     case SHT_C6000_ATTRIBUTES:
3465       return "C6000_ATTRIBUTES";
3466     case SHT_TI_ICODE:
3467       return "TI_ICODE";
3468     case SHT_TI_XREF:
3469       return "TI_XREF";
3470     case SHT_TI_HANDLER:
3471       return "TI_HANDLER";
3472     case SHT_TI_INITINFO:
3473       return "TI_INITINFO";
3474     case SHT_TI_PHATTRS:
3475       return "TI_PHATTRS";
3476     default:
3477       break;
3478     }
3479   return NULL;
3480 }
3481
3482 static const char *
3483 get_msp430x_section_type_name (unsigned int sh_type)
3484 {
3485   switch (sh_type)
3486     {
3487     case SHT_MSP430_SEC_FLAGS:   return "MSP430_SEC_FLAGS";
3488     case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3489     case SHT_MSP430_ATTRIBUTES:  return "MSP430_ATTRIBUTES";
3490     default: return NULL;
3491     }
3492 }
3493
3494 static const char *
3495 get_section_type_name (unsigned int sh_type)
3496 {
3497   static char buff[32];
3498
3499   switch (sh_type)
3500     {
3501     case SHT_NULL:              return "NULL";
3502     case SHT_PROGBITS:          return "PROGBITS";
3503     case SHT_SYMTAB:            return "SYMTAB";
3504     case SHT_STRTAB:            return "STRTAB";
3505     case SHT_RELA:              return "RELA";
3506     case SHT_HASH:              return "HASH";
3507     case SHT_DYNAMIC:           return "DYNAMIC";
3508     case SHT_NOTE:              return "NOTE";
3509     case SHT_NOBITS:            return "NOBITS";
3510     case SHT_REL:               return "REL";
3511     case SHT_SHLIB:             return "SHLIB";
3512     case SHT_DYNSYM:            return "DYNSYM";
3513     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
3514     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
3515     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
3516     case SHT_GNU_HASH:          return "GNU_HASH";
3517     case SHT_GROUP:             return "GROUP";
3518     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
3519     case SHT_GNU_verdef:        return "VERDEF";
3520     case SHT_GNU_verneed:       return "VERNEED";
3521     case SHT_GNU_versym:        return "VERSYM";
3522     case 0x6ffffff0:            return "VERSYM";
3523     case 0x6ffffffc:            return "VERDEF";
3524     case 0x7ffffffd:            return "AUXILIARY";
3525     case 0x7fffffff:            return "FILTER";
3526     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
3527
3528     default:
3529       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3530         {
3531           const char * result;
3532
3533           switch (elf_header.e_machine)
3534             {
3535             case EM_MIPS:
3536             case EM_MIPS_RS3_LE:
3537               result = get_mips_section_type_name (sh_type);
3538               break;
3539             case EM_PARISC:
3540               result = get_parisc_section_type_name (sh_type);
3541               break;
3542             case EM_IA_64:
3543               result = get_ia64_section_type_name (sh_type);
3544               break;
3545             case EM_X86_64:
3546             case EM_L1OM:
3547             case EM_K1OM:
3548               result = get_x86_64_section_type_name (sh_type);
3549               break;
3550             case EM_AARCH64:
3551               result = get_aarch64_section_type_name (sh_type);
3552               break;
3553             case EM_ARM:
3554               result = get_arm_section_type_name (sh_type);
3555               break;
3556             case EM_TI_C6000:
3557               result = get_tic6x_section_type_name (sh_type);
3558               break;
3559             case EM_MSP430:
3560               result = get_msp430x_section_type_name (sh_type);
3561               break;
3562             default:
3563               result = NULL;
3564               break;
3565             }
3566
3567           if (result != NULL)
3568             return result;
3569
3570           sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3571         }
3572       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3573         {
3574           const char * result;
3575
3576           switch (elf_header.e_machine)
3577             {
3578             case EM_IA_64:
3579               result = get_ia64_section_type_name (sh_type);
3580               break;
3581             default:
3582               result = NULL;
3583               break;
3584             }
3585
3586           if (result != NULL)
3587             return result;
3588
3589           sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3590         }
3591       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3592         sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3593       else
3594         /* This message is probably going to be displayed in a 15
3595            character wide field, so put the hex value first.  */
3596         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3597
3598       return buff;
3599     }
3600 }
3601
3602 #define OPTION_DEBUG_DUMP       512
3603 #define OPTION_DYN_SYMS         513
3604 #define OPTION_DWARF_DEPTH      514
3605 #define OPTION_DWARF_START      515
3606 #define OPTION_DWARF_CHECK      516
3607
3608 static struct option options[] =
3609 {
3610   {"all",              no_argument, 0, 'a'},
3611   {"file-header",      no_argument, 0, 'h'},
3612   {"program-headers",  no_argument, 0, 'l'},
3613   {"headers",          no_argument, 0, 'e'},
3614   {"histogram",        no_argument, 0, 'I'},
3615   {"segments",         no_argument, 0, 'l'},
3616   {"sections",         no_argument, 0, 'S'},
3617   {"section-headers",  no_argument, 0, 'S'},
3618   {"section-groups",   no_argument, 0, 'g'},
3619   {"section-details",  no_argument, 0, 't'},
3620   {"full-section-name",no_argument, 0, 'N'},
3621   {"symbols",          no_argument, 0, 's'},
3622   {"syms",             no_argument, 0, 's'},
3623   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
3624   {"relocs",           no_argument, 0, 'r'},
3625   {"notes",            no_argument, 0, 'n'},
3626   {"dynamic",          no_argument, 0, 'd'},
3627   {"arch-specific",    no_argument, 0, 'A'},
3628   {"version-info",     no_argument, 0, 'V'},
3629   {"use-dynamic",      no_argument, 0, 'D'},
3630   {"unwind",           no_argument, 0, 'u'},
3631   {"archive-index",    no_argument, 0, 'c'},
3632   {"hex-dump",         required_argument, 0, 'x'},
3633   {"relocated-dump",   required_argument, 0, 'R'},
3634   {"string-dump",      required_argument, 0, 'p'},
3635 #ifdef SUPPORT_DISASSEMBLY
3636   {"instruction-dump", required_argument, 0, 'i'},
3637 #endif
3638   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
3639
3640   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
3641   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
3642   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
3643
3644   {"version",          no_argument, 0, 'v'},
3645   {"wide",             no_argument, 0, 'W'},
3646   {"help",             no_argument, 0, 'H'},
3647   {0,                  no_argument, 0, 0}
3648 };
3649
3650 static void
3651 usage (FILE * stream)
3652 {
3653   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3654   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3655   fprintf (stream, _(" Options are:\n\
3656   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3657   -h --file-header       Display the ELF file header\n\
3658   -l --program-headers   Display the program headers\n\
3659      --segments          An alias for --program-headers\n\
3660   -S --section-headers   Display the sections' header\n\
3661      --sections          An alias for --section-headers\n\
3662   -g --section-groups    Display the section groups\n\
3663   -t --section-details   Display the section details\n\
3664   -e --headers           Equivalent to: -h -l -S\n\
3665   -s --syms              Display the symbol table\n\
3666      --symbols           An alias for --syms\n\
3667   --dyn-syms             Display the dynamic symbol table\n\
3668   -n --notes             Display the core notes (if present)\n\
3669   -r --relocs            Display the relocations (if present)\n\
3670   -u --unwind            Display the unwind info (if present)\n\
3671   -d --dynamic           Display the dynamic section (if present)\n\
3672   -V --version-info      Display the version sections (if present)\n\
3673   -A --arch-specific     Display architecture specific information (if any)\n\
3674   -c --archive-index     Display the symbol/file index in an archive\n\
3675   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
3676   -x --hex-dump=<number|name>\n\
3677                          Dump the contents of section <number|name> as bytes\n\
3678   -p --string-dump=<number|name>\n\
3679                          Dump the contents of section <number|name> as strings\n\
3680   -R --relocated-dump=<number|name>\n\
3681                          Dump the contents of section <number|name> as relocated bytes\n\
3682   -w[lLiaprmfFsoRt] or\n\
3683   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3684                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3685                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3686                =addr,=cu_index]\n\
3687                          Display the contents of DWARF2 debug sections\n"));
3688   fprintf (stream, _("\
3689   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
3690   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
3691                          or deeper\n"));
3692 #ifdef SUPPORT_DISASSEMBLY
3693   fprintf (stream, _("\
3694   -i --instruction-dump=<number|name>\n\
3695                          Disassemble the contents of section <number|name>\n"));
3696 #endif
3697   fprintf (stream, _("\
3698   -I --histogram         Display histogram of bucket list lengths\n\
3699   -W --wide              Allow output width to exceed 80 characters\n\
3700   @<file>                Read options from <file>\n\
3701   -H --help              Display this information\n\
3702   -v --version           Display the version number of readelf\n"));
3703
3704   if (REPORT_BUGS_TO[0] && stream == stdout)
3705     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3706
3707   exit (stream == stdout ? 0 : 1);
3708 }
3709
3710 /* Record the fact that the user wants the contents of section number
3711    SECTION to be displayed using the method(s) encoded as flags bits
3712    in TYPE.  Note, TYPE can be zero if we are creating the array for
3713    the first time.  */
3714
3715 static void
3716 request_dump_bynumber (unsigned int section, dump_type type)
3717 {
3718   if (section >= num_dump_sects)
3719     {
3720       dump_type * new_dump_sects;
3721
3722       new_dump_sects = (dump_type *) calloc (section + 1,
3723                                              sizeof (* dump_sects));
3724
3725       if (new_dump_sects == NULL)
3726         error (_("Out of memory allocating dump request table.\n"));
3727       else
3728         {
3729           /* Copy current flag settings.  */
3730           memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3731
3732           free (dump_sects);
3733
3734           dump_sects = new_dump_sects;
3735           num_dump_sects = section + 1;
3736         }
3737     }
3738
3739   if (dump_sects)
3740     dump_sects[section] |= type;
3741
3742   return;
3743 }
3744
3745 /* Request a dump by section name.  */
3746
3747 static void
3748 request_dump_byname (const char * section, dump_type type)
3749 {
3750   struct dump_list_entry * new_request;
3751
3752   new_request = (struct dump_list_entry *)
3753       malloc (sizeof (struct dump_list_entry));
3754   if (!new_request)
3755     error (_("Out of memory allocating dump request table.\n"));
3756
3757   new_request->name = strdup (section);
3758   if (!new_request->name)
3759     error (_("Out of memory allocating dump request table.\n"));
3760
3761   new_request->type = type;
3762
3763   new_request->next = dump_sects_byname;
3764   dump_sects_byname = new_request;
3765 }
3766
3767 static inline void
3768 request_dump (dump_type type)
3769 {
3770   int section;
3771   char * cp;
3772
3773   do_dump++;
3774   section = strtoul (optarg, & cp, 0);
3775
3776   if (! *cp && section >= 0)
3777     request_dump_bynumber (section, type);
3778   else
3779     request_dump_byname (optarg, type);
3780 }
3781
3782
3783 static void
3784 parse_args (int argc, char ** argv)
3785 {
3786   int c;
3787
3788   if (argc < 2)
3789     usage (stderr);
3790
3791   while ((c = getopt_long
3792           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3793     {
3794       switch (c)
3795         {
3796         case 0:
3797           /* Long options.  */
3798           break;
3799         case 'H':
3800           usage (stdout);
3801           break;
3802
3803         case 'a':
3804           do_syms++;
3805           do_reloc++;
3806           do_unwind++;
3807           do_dynamic++;
3808           do_header++;
3809           do_sections++;
3810           do_section_groups++;
3811           do_segments++;
3812           do_version++;
3813           do_histogram++;
3814           do_arch++;
3815           do_notes++;
3816           break;
3817         case 'g':
3818           do_section_groups++;
3819           break;
3820         case 't':
3821         case 'N':
3822           do_sections++;
3823           do_section_details++;
3824           break;
3825         case 'e':
3826           do_header++;
3827           do_sections++;
3828           do_segments++;
3829           break;
3830         case 'A':
3831           do_arch++;
3832           break;
3833         case 'D':
3834           do_using_dynamic++;
3835           break;
3836         case 'r':
3837           do_reloc++;
3838           break;
3839         case 'u':
3840           do_unwind++;
3841           break;
3842         case 'h':
3843           do_header++;
3844           break;
3845         case 'l':
3846           do_segments++;
3847           break;
3848         case 's':
3849           do_syms++;
3850           break;
3851         case 'S':
3852           do_sections++;
3853           break;
3854         case 'd':
3855           do_dynamic++;
3856           break;
3857         case 'I':
3858           do_histogram++;
3859           break;
3860         case 'n':
3861           do_notes++;
3862           break;
3863         case 'c':
3864           do_archive_index++;
3865           break;
3866         case 'x':
3867           request_dump (HEX_DUMP);
3868           break;
3869         case 'p':
3870           request_dump (STRING_DUMP);
3871           break;
3872         case 'R':
3873           request_dump (RELOC_DUMP);
3874           break;
3875         case 'w':
3876           do_dump++;
3877           if (optarg == 0)
3878             {
3879               do_debugging = 1;
3880               dwarf_select_sections_all ();
3881             }
3882           else
3883             {
3884               do_debugging = 0;
3885               dwarf_select_sections_by_letters (optarg);
3886             }
3887           break;
3888         case OPTION_DEBUG_DUMP:
3889           do_dump++;
3890           if (optarg == 0)
3891             do_debugging = 1;
3892           else
3893             {
3894               do_debugging = 0;
3895               dwarf_select_sections_by_names (optarg);
3896             }
3897           break;
3898         case OPTION_DWARF_DEPTH:
3899           {
3900             char *cp;
3901
3902             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3903           }
3904           break;
3905         case OPTION_DWARF_START:
3906           {
3907             char *cp;
3908
3909             dwarf_start_die = strtoul (optarg, & cp, 0);
3910           }
3911           break;
3912         case OPTION_DWARF_CHECK:
3913           dwarf_check = 1;
3914           break;
3915         case OPTION_DYN_SYMS:
3916           do_dyn_syms++;
3917           break;
3918 #ifdef SUPPORT_DISASSEMBLY
3919         case 'i':
3920           request_dump (DISASS_DUMP);
3921           break;
3922 #endif
3923         case 'v':
3924           print_version (program_name);
3925           break;
3926         case 'V':
3927           do_version++;
3928           break;
3929         case 'W':
3930           do_wide++;
3931           break;
3932         default:
3933           /* xgettext:c-format */
3934           error (_("Invalid option '-%c'\n"), c);
3935           /* Drop through.  */
3936         case '?':
3937           usage (stderr);
3938         }
3939     }
3940
3941   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3942       && !do_segments && !do_header && !do_dump && !do_version
3943       && !do_histogram && !do_debugging && !do_arch && !do_notes
3944       && !do_section_groups && !do_archive_index
3945       && !do_dyn_syms)
3946     usage (stderr);
3947   else if (argc < 3)
3948     {
3949       warn (_("Nothing to do.\n"));
3950       usage (stderr);
3951     }
3952 }
3953
3954 static const char *
3955 get_elf_class (unsigned int elf_class)
3956 {
3957   static char buff[32];
3958
3959   switch (elf_class)
3960     {
3961     case ELFCLASSNONE: return _("none");
3962     case ELFCLASS32:   return "ELF32";
3963     case ELFCLASS64:   return "ELF64";
3964     default:
3965       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3966       return buff;
3967     }
3968 }
3969
3970 static const char *
3971 get_data_encoding (unsigned int encoding)
3972 {
3973   static char buff[32];
3974
3975   switch (encoding)
3976     {
3977     case ELFDATANONE: return _("none");
3978     case ELFDATA2LSB: return _("2's complement, little endian");
3979     case ELFDATA2MSB: return _("2's complement, big endian");
3980     default:
3981       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3982       return buff;
3983     }
3984 }
3985
3986 /* Decode the data held in 'elf_header'.  */
3987
3988 static int
3989 process_file_header (void)
3990 {
3991   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
3992       || elf_header.e_ident[EI_MAG1] != ELFMAG1
3993       || elf_header.e_ident[EI_MAG2] != ELFMAG2
3994       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3995     {
3996       error
3997         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3998       return 0;
3999     }
4000
4001   init_dwarf_regnames (elf_header.e_machine);
4002
4003   if (do_header)
4004     {
4005       int i;
4006
4007       printf (_("ELF Header:\n"));
4008       printf (_("  Magic:   "));
4009       for (i = 0; i < EI_NIDENT; i++)
4010         printf ("%2.2x ", elf_header.e_ident[i]);
4011       printf ("\n");
4012       printf (_("  Class:                             %s\n"),
4013               get_elf_class (elf_header.e_ident[EI_CLASS]));
4014       printf (_("  Data:                              %s\n"),
4015               get_data_encoding (elf_header.e_ident[EI_DATA]));
4016       printf (_("  Version:                           %d %s\n"),
4017               elf_header.e_ident[EI_VERSION],
4018               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4019                ? "(current)"
4020                : (elf_header.e_ident[EI_VERSION] != EV_NONE
4021                   ? _("<unknown: %lx>")
4022                   : "")));
4023       printf (_("  OS/ABI:                            %s\n"),
4024               get_osabi_name (elf_header.e_ident[EI_OSABI]));
4025       printf (_("  ABI Version:                       %d\n"),
4026               elf_header.e_ident[EI_ABIVERSION]);
4027       printf (_("  Type:                              %s\n"),
4028               get_file_type (elf_header.e_type));
4029       printf (_("  Machine:                           %s\n"),
4030               get_machine_name (elf_header.e_machine));
4031       printf (_("  Version:                           0x%lx\n"),
4032               (unsigned long) elf_header.e_version);
4033
4034       printf (_("  Entry point address:               "));
4035       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4036       printf (_("\n  Start of program headers:          "));
4037       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4038       printf (_(" (bytes into file)\n  Start of section headers:          "));
4039       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4040       printf (_(" (bytes into file)\n"));
4041
4042       printf (_("  Flags:                             0x%lx%s\n"),
4043               (unsigned long) elf_header.e_flags,
4044               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4045       printf (_("  Size of this header:               %ld (bytes)\n"),
4046               (long) elf_header.e_ehsize);
4047       printf (_("  Size of program headers:           %ld (bytes)\n"),
4048               (long) elf_header.e_phentsize);
4049       printf (_("  Number of program headers:         %ld"),
4050               (long) elf_header.e_phnum);
4051       if (section_headers != NULL
4052           && elf_header.e_phnum == PN_XNUM
4053           && section_headers[0].sh_info != 0)
4054         printf (" (%ld)", (long) section_headers[0].sh_info);
4055       putc ('\n', stdout);
4056       printf (_("  Size of section headers:           %ld (bytes)\n"),
4057               (long) elf_header.e_shentsize);
4058       printf (_("  Number of section headers:         %ld"),
4059               (long) elf_header.e_shnum);
4060       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4061         printf (" (%ld)", (long) section_headers[0].sh_size);
4062       putc ('\n', stdout);
4063       printf (_("  Section header string table index: %ld"),
4064               (long) elf_header.e_shstrndx);
4065       if (section_headers != NULL
4066           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4067         printf (" (%u)", section_headers[0].sh_link);
4068       else if (elf_header.e_shstrndx != SHN_UNDEF
4069                && elf_header.e_shstrndx >= elf_header.e_shnum)
4070         printf (_(" <corrupt: out of range>"));
4071       putc ('\n', stdout);
4072     }
4073
4074   if (section_headers != NULL)
4075     {
4076       if (elf_header.e_phnum == PN_XNUM
4077           && section_headers[0].sh_info != 0)
4078         elf_header.e_phnum = section_headers[0].sh_info;
4079       if (elf_header.e_shnum == SHN_UNDEF)
4080         elf_header.e_shnum = section_headers[0].sh_size;
4081       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4082         elf_header.e_shstrndx = section_headers[0].sh_link;
4083       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4084         elf_header.e_shstrndx = SHN_UNDEF;
4085       free (section_headers);
4086       section_headers = NULL;
4087     }
4088
4089   return 1;
4090 }
4091
4092
4093 static int
4094 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4095 {
4096   Elf32_External_Phdr * phdrs;
4097   Elf32_External_Phdr * external;
4098   Elf_Internal_Phdr *   internal;
4099   unsigned int i;
4100
4101   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4102                                             elf_header.e_phentsize,
4103                                             elf_header.e_phnum,
4104                                             _("program headers"));
4105   if (!phdrs)
4106     return 0;
4107
4108   for (i = 0, internal = pheaders, external = phdrs;
4109        i < elf_header.e_phnum;
4110        i++, internal++, external++)
4111     {
4112       internal->p_type   = BYTE_GET (external->p_type);
4113       internal->p_offset = BYTE_GET (external->p_offset);
4114       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4115       internal->p_paddr  = BYTE_GET (external->p_paddr);
4116       internal->p_filesz = BYTE_GET (external->p_filesz);
4117       internal->p_memsz  = BYTE_GET (external->p_memsz);
4118       internal->p_flags  = BYTE_GET (external->p_flags);
4119       internal->p_align  = BYTE_GET (external->p_align);
4120     }
4121
4122   free (phdrs);
4123
4124   return 1;
4125 }
4126
4127 static int
4128 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4129 {
4130   Elf64_External_Phdr * phdrs;
4131   Elf64_External_Phdr * external;
4132   Elf_Internal_Phdr *   internal;
4133   unsigned int i;
4134
4135   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4136                                             elf_header.e_phentsize,
4137                                             elf_header.e_phnum,
4138                                             _("program headers"));
4139   if (!phdrs)
4140     return 0;
4141
4142   for (i = 0, internal = pheaders, external = phdrs;
4143        i < elf_header.e_phnum;
4144        i++, internal++, external++)
4145     {
4146       internal->p_type   = BYTE_GET (external->p_type);
4147       internal->p_flags  = BYTE_GET (external->p_flags);
4148       internal->p_offset = BYTE_GET (external->p_offset);
4149       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4150       internal->p_paddr  = BYTE_GET (external->p_paddr);
4151       internal->p_filesz = BYTE_GET (external->p_filesz);
4152       internal->p_memsz  = BYTE_GET (external->p_memsz);
4153       internal->p_align  = BYTE_GET (external->p_align);
4154     }
4155
4156   free (phdrs);
4157
4158   return 1;
4159 }
4160
4161 /* Returns 1 if the program headers were read into `program_headers'.  */
4162
4163 static int
4164 get_program_headers (FILE * file)
4165 {
4166   Elf_Internal_Phdr * phdrs;
4167
4168   /* Check cache of prior read.  */
4169   if (program_headers != NULL)
4170     return 1;
4171
4172   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4173                                          sizeof (Elf_Internal_Phdr));
4174
4175   if (phdrs == NULL)
4176     {
4177       error (_("Out of memory\n"));
4178       return 0;
4179     }
4180
4181   if (is_32bit_elf
4182       ? get_32bit_program_headers (file, phdrs)
4183       : get_64bit_program_headers (file, phdrs))
4184     {
4185       program_headers = phdrs;
4186       return 1;
4187     }
4188
4189   free (phdrs);
4190   return 0;
4191 }
4192
4193 /* Returns 1 if the program headers were loaded.  */
4194
4195 static int
4196 process_program_headers (FILE * file)
4197 {
4198   Elf_Internal_Phdr * segment;
4199   unsigned int i;
4200
4201   if (elf_header.e_phnum == 0)
4202     {
4203       /* PR binutils/12467.  */
4204       if (elf_header.e_phoff != 0)
4205         warn (_("possibly corrupt ELF header - it has a non-zero program"
4206                 " header offset, but no program headers"));
4207       else if (do_segments)
4208         printf (_("\nThere are no program headers in this file.\n"));
4209       return 0;
4210     }
4211
4212   if (do_segments && !do_header)
4213     {
4214       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4215       printf (_("Entry point "));
4216       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4217       printf (_("\nThere are %d program headers, starting at offset "),
4218               elf_header.e_phnum);
4219       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4220       printf ("\n");
4221     }
4222
4223   if (! get_program_headers (file))
4224       return 0;
4225
4226   if (do_segments)
4227     {
4228       if (elf_header.e_phnum > 1)
4229         printf (_("\nProgram Headers:\n"));
4230       else
4231         printf (_("\nProgram Headers:\n"));
4232
4233       if (is_32bit_elf)
4234         printf
4235           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4236       else if (do_wide)
4237         printf
4238           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4239       else
4240         {
4241           printf
4242             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4243           printf
4244             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4245         }
4246     }
4247
4248   dynamic_addr = 0;
4249   dynamic_size = 0;
4250
4251   for (i = 0, segment = program_headers;
4252        i < elf_header.e_phnum;
4253        i++, segment++)
4254     {
4255       if (do_segments)
4256         {
4257           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4258
4259           if (is_32bit_elf)
4260             {
4261               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4262               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4263               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4264               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4265               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4266               printf ("%c%c%c ",
4267                       (segment->p_flags & PF_R ? 'R' : ' '),
4268                       (segment->p_flags & PF_W ? 'W' : ' '),
4269                       (segment->p_flags & PF_X ? 'E' : ' '));
4270               printf ("%#lx", (unsigned long) segment->p_align);
4271             }
4272           else if (do_wide)
4273             {
4274               if ((unsigned long) segment->p_offset == segment->p_offset)
4275                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4276               else
4277                 {
4278                   print_vma (segment->p_offset, FULL_HEX);
4279                   putchar (' ');
4280                 }
4281
4282               print_vma (segment->p_vaddr, FULL_HEX);
4283               putchar (' ');
4284               print_vma (segment->p_paddr, FULL_HEX);
4285               putchar (' ');
4286
4287               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4288                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4289               else
4290                 {
4291                   print_vma (segment->p_filesz, FULL_HEX);
4292                   putchar (' ');
4293                 }
4294
4295               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4296                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4297               else
4298                 {
4299                   print_vma (segment->p_memsz, FULL_HEX);
4300                 }
4301
4302               printf (" %c%c%c ",
4303                       (segment->p_flags & PF_R ? 'R' : ' '),
4304                       (segment->p_flags & PF_W ? 'W' : ' '),
4305                       (segment->p_flags & PF_X ? 'E' : ' '));
4306
4307               if ((unsigned long) segment->p_align == segment->p_align)
4308                 printf ("%#lx", (unsigned long) segment->p_align);
4309               else
4310                 {
4311                   print_vma (segment->p_align, PREFIX_HEX);
4312                 }
4313             }
4314           else
4315             {
4316               print_vma (segment->p_offset, FULL_HEX);
4317               putchar (' ');
4318               print_vma (segment->p_vaddr, FULL_HEX);
4319               putchar (' ');
4320               print_vma (segment->p_paddr, FULL_HEX);
4321               printf ("\n                 ");
4322               print_vma (segment->p_filesz, FULL_HEX);
4323               putchar (' ');
4324               print_vma (segment->p_memsz, FULL_HEX);
4325               printf ("  %c%c%c    ",
4326                       (segment->p_flags & PF_R ? 'R' : ' '),
4327                       (segment->p_flags & PF_W ? 'W' : ' '),
4328                       (segment->p_flags & PF_X ? 'E' : ' '));
4329               print_vma (segment->p_align, HEX);
4330             }
4331         }
4332
4333       switch (segment->p_type)
4334         {
4335         case PT_DYNAMIC:
4336           if (dynamic_addr)
4337             error (_("more than one dynamic segment\n"));
4338
4339           /* By default, assume that the .dynamic section is the first
4340              section in the DYNAMIC segment.  */
4341           dynamic_addr = segment->p_offset;
4342           dynamic_size = segment->p_filesz;
4343
4344           /* Try to locate the .dynamic section. If there is
4345              a section header table, we can easily locate it.  */
4346           if (section_headers != NULL)
4347             {
4348               Elf_Internal_Shdr * sec;
4349
4350               sec = find_section (".dynamic");
4351               if (sec == NULL || sec->sh_size == 0)
4352                 {
4353                   /* A corresponding .dynamic section is expected, but on
4354                      IA-64/OpenVMS it is OK for it to be missing.  */
4355                   if (!is_ia64_vms ())
4356                     error (_("no .dynamic section in the dynamic segment\n"));
4357                   break;
4358                 }
4359
4360               if (sec->sh_type == SHT_NOBITS)
4361                 {
4362                   dynamic_size = 0;
4363                   break;
4364                 }
4365
4366               dynamic_addr = sec->sh_offset;
4367               dynamic_size = sec->sh_size;
4368
4369               if (dynamic_addr < segment->p_offset
4370                   || dynamic_addr > segment->p_offset + segment->p_filesz)
4371                 warn (_("the .dynamic section is not contained"
4372                         " within the dynamic segment\n"));
4373               else if (dynamic_addr > segment->p_offset)
4374                 warn (_("the .dynamic section is not the first section"
4375                         " in the dynamic segment.\n"));
4376             }
4377           break;
4378
4379         case PT_INTERP:
4380           if (fseek (file, archive_file_offset + (long) segment->p_offset,
4381                      SEEK_SET))
4382             error (_("Unable to find program interpreter name\n"));
4383           else
4384             {
4385               char fmt [32];
4386               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
4387
4388               if (ret >= (int) sizeof (fmt) || ret < 0)
4389                 error (_("Internal error: failed to create format string to display program interpreter\n"));
4390
4391               program_interpreter[0] = 0;
4392               if (fscanf (file, fmt, program_interpreter) <= 0)
4393                 error (_("Unable to read program interpreter name\n"));
4394
4395               if (do_segments)
4396                 printf (_("\n      [Requesting program interpreter: %s]"),
4397                     program_interpreter);
4398             }
4399           break;
4400         }
4401
4402       if (do_segments)
4403         putc ('\n', stdout);
4404     }
4405
4406   if (do_segments && section_headers != NULL && string_table != NULL)
4407     {
4408       printf (_("\n Section to Segment mapping:\n"));
4409       printf (_("  Segment Sections...\n"));
4410
4411       for (i = 0; i < elf_header.e_phnum; i++)
4412         {
4413           unsigned int j;
4414           Elf_Internal_Shdr * section;
4415
4416           segment = program_headers + i;
4417           section = section_headers + 1;
4418
4419           printf ("   %2.2d     ", i);
4420
4421           for (j = 1; j < elf_header.e_shnum; j++, section++)
4422             {
4423               if (!ELF_TBSS_SPECIAL (section, segment)
4424                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4425                 printf ("%s ", SECTION_NAME (section));
4426             }
4427
4428           putc ('\n',stdout);
4429         }
4430     }
4431
4432   return 1;
4433 }
4434
4435
4436 /* Find the file offset corresponding to VMA by using the program headers.  */
4437
4438 static long
4439 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4440 {
4441   Elf_Internal_Phdr * seg;
4442
4443   if (! get_program_headers (file))
4444     {
4445       warn (_("Cannot interpret virtual addresses without program headers.\n"));
4446       return (long) vma;
4447     }
4448
4449   for (seg = program_headers;
4450        seg < program_headers + elf_header.e_phnum;
4451        ++seg)
4452     {
4453       if (seg->p_type != PT_LOAD)
4454         continue;
4455
4456       if (vma >= (seg->p_vaddr & -seg->p_align)
4457           && vma + size <= seg->p_vaddr + seg->p_filesz)
4458         return vma - seg->p_vaddr + seg->p_offset;
4459     }
4460
4461   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4462         (unsigned long) vma);
4463   return (long) vma;
4464 }
4465
4466
4467 static int
4468 get_32bit_section_headers (FILE * file, unsigned int num)
4469 {
4470   Elf32_External_Shdr * shdrs;
4471   Elf_Internal_Shdr *   internal;
4472   unsigned int i;
4473
4474   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4475                                             elf_header.e_shentsize, num,
4476                                             _("section headers"));
4477   if (!shdrs)
4478     return 0;
4479
4480   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4481                                                    sizeof (Elf_Internal_Shdr));
4482
4483   if (section_headers == NULL)
4484     {
4485       error (_("Out of memory\n"));
4486       return 0;
4487     }
4488
4489   for (i = 0, internal = section_headers;
4490        i < num;
4491        i++, internal++)
4492     {
4493       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4494       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4495       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4496       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4497       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4498       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4499       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4500       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4501       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4502       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4503     }
4504
4505   free (shdrs);
4506
4507   return 1;
4508 }
4509
4510 static int
4511 get_64bit_section_headers (FILE * file, unsigned int num)
4512 {
4513   Elf64_External_Shdr * shdrs;
4514   Elf_Internal_Shdr *   internal;
4515   unsigned int i;
4516
4517   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4518                                             elf_header.e_shentsize, num,
4519                                             _("section headers"));
4520   if (!shdrs)
4521     return 0;
4522
4523   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4524                                                    sizeof (Elf_Internal_Shdr));
4525
4526   if (section_headers == NULL)
4527     {
4528       error (_("Out of memory\n"));
4529       return 0;
4530     }
4531
4532   for (i = 0, internal = section_headers;
4533        i < num;
4534        i++, internal++)
4535     {
4536       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4537       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4538       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4539       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4540       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4541       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4542       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4543       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4544       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4545       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4546     }
4547
4548   free (shdrs);
4549
4550   return 1;
4551 }
4552
4553 static Elf_Internal_Sym *
4554 get_32bit_elf_symbols (FILE * file,
4555                        Elf_Internal_Shdr * section,
4556                        unsigned long * num_syms_return)
4557 {
4558   unsigned long number = 0;
4559   Elf32_External_Sym * esyms = NULL;
4560   Elf_External_Sym_Shndx * shndx = NULL;
4561   Elf_Internal_Sym * isyms = NULL;
4562   Elf_Internal_Sym * psym;
4563   unsigned int j;
4564
4565   /* Run some sanity checks first.  */
4566   if (section->sh_entsize == 0)
4567     {
4568       error (_("sh_entsize is zero\n"));
4569       goto exit_point;
4570     }
4571
4572   number = section->sh_size / section->sh_entsize;
4573
4574   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4575     {
4576       error (_("Invalid sh_entsize\n"));
4577       goto exit_point;
4578     }
4579
4580   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4581                                            section->sh_size, _("symbols"));
4582   if (esyms == NULL)
4583     goto exit_point;
4584
4585   shndx = NULL;
4586   if (symtab_shndx_hdr != NULL
4587       && (symtab_shndx_hdr->sh_link
4588           == (unsigned long) (section - section_headers)))
4589     {
4590       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4591                                                    symtab_shndx_hdr->sh_offset,
4592                                                    1, symtab_shndx_hdr->sh_size,
4593                                                    _("symbol table section indicies"));
4594       if (shndx == NULL)
4595         goto exit_point;
4596     }
4597
4598   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4599
4600   if (isyms == NULL)
4601     {
4602       error (_("Out of memory\n"));
4603       goto exit_point;
4604     }
4605
4606   for (j = 0, psym = isyms; j < number; j++, psym++)
4607     {
4608       psym->st_name  = BYTE_GET (esyms[j].st_name);
4609       psym->st_value = BYTE_GET (esyms[j].st_value);
4610       psym->st_size  = BYTE_GET (esyms[j].st_size);
4611       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4612       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4613         psym->st_shndx
4614           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4615       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4616         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4617       psym->st_info  = BYTE_GET (esyms[j].st_info);
4618       psym->st_other = BYTE_GET (esyms[j].st_other);
4619     }
4620
4621  exit_point:
4622   if (shndx != NULL)
4623     free (shndx);
4624   if (esyms != NULL)
4625     free (esyms);
4626
4627   if (num_syms_return != NULL)
4628     * num_syms_return = isyms == NULL ? 0 : number;
4629
4630   return isyms;
4631 }
4632
4633 static Elf_Internal_Sym *
4634 get_64bit_elf_symbols (FILE * file,
4635                        Elf_Internal_Shdr * section,
4636                        unsigned long * num_syms_return)
4637 {
4638   unsigned long number = 0;
4639   Elf64_External_Sym * esyms = NULL;
4640   Elf_External_Sym_Shndx * shndx = NULL;
4641   Elf_Internal_Sym * isyms = NULL;
4642   Elf_Internal_Sym * psym;
4643   unsigned int j;
4644
4645   /* Run some sanity checks first.  */
4646   if (section->sh_entsize == 0)
4647     {
4648       error (_("sh_entsize is zero\n"));
4649       goto exit_point;
4650     }
4651
4652   number = section->sh_size / section->sh_entsize;
4653
4654   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4655     {
4656       error (_("Invalid sh_entsize\n"));
4657       goto exit_point;
4658     }
4659
4660   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4661                                            section->sh_size, _("symbols"));
4662   if (!esyms)
4663     goto exit_point;
4664
4665   if (symtab_shndx_hdr != NULL
4666       && (symtab_shndx_hdr->sh_link
4667           == (unsigned long) (section - section_headers)))
4668     {
4669       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4670                                                    symtab_shndx_hdr->sh_offset,
4671                                                    1, symtab_shndx_hdr->sh_size,
4672                                                    _("symbol table section indicies"));
4673       if (shndx == NULL)
4674         goto exit_point;
4675     }
4676
4677   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4678
4679   if (isyms == NULL)
4680     {
4681       error (_("Out of memory\n"));
4682       goto exit_point;
4683     }
4684
4685   for (j = 0, psym = isyms; j < number; j++, psym++)
4686     {
4687       psym->st_name  = BYTE_GET (esyms[j].st_name);
4688       psym->st_info  = BYTE_GET (esyms[j].st_info);
4689       psym->st_other = BYTE_GET (esyms[j].st_other);
4690       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4691
4692       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4693         psym->st_shndx
4694           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4695       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4696         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4697
4698       psym->st_value = BYTE_GET (esyms[j].st_value);
4699       psym->st_size  = BYTE_GET (esyms[j].st_size);
4700     }
4701
4702  exit_point:
4703   if (shndx != NULL)
4704     free (shndx);
4705   if (esyms != NULL)
4706     free (esyms);
4707
4708   if (num_syms_return != NULL)
4709     * num_syms_return = isyms == NULL ? 0 : number;
4710
4711   return isyms;
4712 }
4713
4714 static const char *
4715 get_elf_section_flags (bfd_vma sh_flags)
4716 {
4717   static char buff[1024];
4718   char * p = buff;
4719   int field_size = is_32bit_elf ? 8 : 16;
4720   int sindex;
4721   int size = sizeof (buff) - (field_size + 4 + 1);
4722   bfd_vma os_flags = 0;
4723   bfd_vma proc_flags = 0;
4724   bfd_vma unknown_flags = 0;
4725   static const struct
4726     {
4727       const char * str;
4728       int len;
4729     }
4730   flags [] =
4731     {
4732       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
4733       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
4734       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
4735       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
4736       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
4737       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
4738       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4739       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4740       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
4741       /*  9 */ { STRING_COMMA_LEN ("TLS") },
4742       /* IA-64 specific.  */
4743       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4744       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4745       /* IA-64 OpenVMS specific.  */
4746       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4747       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4748       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4749       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4750       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4751       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4752       /* Generic.  */
4753       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4754       /* SPARC specific.  */
4755       /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4756     };
4757
4758   if (do_section_details)
4759     {
4760       sprintf (buff, "[%*.*lx]: ",
4761                field_size, field_size, (unsigned long) sh_flags);
4762       p += field_size + 4;
4763     }
4764
4765   while (sh_flags)
4766     {
4767       bfd_vma flag;
4768
4769       flag = sh_flags & - sh_flags;
4770       sh_flags &= ~ flag;
4771
4772       if (do_section_details)
4773         {
4774           switch (flag)
4775             {
4776             case SHF_WRITE:             sindex = 0; break;
4777             case SHF_ALLOC:             sindex = 1; break;
4778             case SHF_EXECINSTR:         sindex = 2; break;
4779             case SHF_MERGE:             sindex = 3; break;
4780             case SHF_STRINGS:           sindex = 4; break;
4781             case SHF_INFO_LINK:         sindex = 5; break;
4782             case SHF_LINK_ORDER:        sindex = 6; break;
4783             case SHF_OS_NONCONFORMING:  sindex = 7; break;
4784             case SHF_GROUP:             sindex = 8; break;
4785             case SHF_TLS:               sindex = 9; break;
4786             case SHF_EXCLUDE:           sindex = 18; break;
4787
4788             default:
4789               sindex = -1;
4790               switch (elf_header.e_machine)
4791                 {
4792                 case EM_IA_64:
4793                   if (flag == SHF_IA_64_SHORT)
4794                     sindex = 10;
4795                   else if (flag == SHF_IA_64_NORECOV)
4796                     sindex = 11;
4797 #ifdef BFD64
4798                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4799                     switch (flag)
4800                       {
4801                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
4802                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
4803                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
4804                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
4805                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4806                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
4807                       default:                        break;
4808                       }
4809 #endif
4810                   break;
4811
4812                 case EM_386:
4813                 case EM_486:
4814                 case EM_X86_64:
4815                 case EM_L1OM:
4816                 case EM_K1OM:
4817                 case EM_OLD_SPARCV9:
4818                 case EM_SPARC32PLUS:
4819                 case EM_SPARCV9:
4820                 case EM_SPARC:
4821                   if (flag == SHF_ORDERED)
4822                     sindex = 19;
4823                   break;
4824                 default:
4825                   break;
4826                 }
4827             }
4828
4829           if (sindex != -1)
4830             {
4831               if (p != buff + field_size + 4)
4832                 {
4833                   if (size < (10 + 2))
4834                     abort ();
4835                   size -= 2;
4836                   *p++ = ',';
4837                   *p++ = ' ';
4838                 }
4839
4840               size -= flags [sindex].len;
4841               p = stpcpy (p, flags [sindex].str);
4842             }
4843           else if (flag & SHF_MASKOS)
4844             os_flags |= flag;
4845           else if (flag & SHF_MASKPROC)
4846             proc_flags |= flag;
4847           else
4848             unknown_flags |= flag;
4849         }
4850       else
4851         {
4852           switch (flag)
4853             {
4854             case SHF_WRITE:             *p = 'W'; break;
4855             case SHF_ALLOC:             *p = 'A'; break;
4856             case SHF_EXECINSTR:         *p = 'X'; break;
4857             case SHF_MERGE:             *p = 'M'; break;
4858             case SHF_STRINGS:           *p = 'S'; break;
4859             case SHF_INFO_LINK:         *p = 'I'; break;
4860             case SHF_LINK_ORDER:        *p = 'L'; break;
4861             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
4862             case SHF_GROUP:             *p = 'G'; break;
4863             case SHF_TLS:               *p = 'T'; break;
4864             case SHF_EXCLUDE:           *p = 'E'; break;
4865
4866             default:
4867               if ((elf_header.e_machine == EM_X86_64
4868                    || elf_header.e_machine == EM_L1OM
4869                    || elf_header.e_machine == EM_K1OM)
4870                   && flag == SHF_X86_64_LARGE)
4871                 *p = 'l';
4872               else if (flag & SHF_MASKOS)
4873                 {
4874                   *p = 'o';
4875                   sh_flags &= ~ SHF_MASKOS;
4876                 }
4877               else if (flag & SHF_MASKPROC)
4878                 {
4879                   *p = 'p';
4880                   sh_flags &= ~ SHF_MASKPROC;
4881                 }
4882               else
4883                 *p = 'x';
4884               break;
4885             }
4886           p++;
4887         }
4888     }
4889
4890   if (do_section_details)
4891     {
4892       if (os_flags)
4893         {
4894           size -= 5 + field_size;
4895           if (p != buff + field_size + 4)
4896             {
4897               if (size < (2 + 1))
4898                 abort ();
4899               size -= 2;
4900               *p++ = ',';
4901               *p++ = ' ';
4902             }
4903           sprintf (p, "OS (%*.*lx)", field_size, field_size,
4904                    (unsigned long) os_flags);
4905           p += 5 + field_size;
4906         }
4907       if (proc_flags)
4908         {
4909           size -= 7 + field_size;
4910           if (p != buff + field_size + 4)
4911             {
4912               if (size < (2 + 1))
4913                 abort ();
4914               size -= 2;
4915               *p++ = ',';
4916               *p++ = ' ';
4917             }
4918           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4919                    (unsigned long) proc_flags);
4920           p += 7 + field_size;
4921         }
4922       if (unknown_flags)
4923         {
4924           size -= 10 + field_size;
4925           if (p != buff + field_size + 4)
4926             {
4927               if (size < (2 + 1))
4928                 abort ();
4929               size -= 2;
4930               *p++ = ',';
4931               *p++ = ' ';
4932             }
4933           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
4934                    (unsigned long) unknown_flags);
4935           p += 10 + field_size;
4936         }
4937     }
4938
4939   *p = '\0';
4940   return buff;
4941 }
4942
4943 static int
4944 process_section_headers (FILE * file)
4945 {
4946   Elf_Internal_Shdr * section;
4947   unsigned int i;
4948
4949   section_headers = NULL;
4950
4951   if (elf_header.e_shnum == 0)
4952     {
4953       /* PR binutils/12467.  */
4954       if (elf_header.e_shoff != 0)
4955         warn (_("possibly corrupt ELF file header - it has a non-zero"
4956                 " section header offset, but no section headers\n"));
4957       else if (do_sections)
4958         printf (_("\nThere are no sections in this file.\n"));
4959
4960       return 1;
4961     }
4962
4963   if (do_sections && !do_header)
4964     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4965             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4966
4967   if (is_32bit_elf)
4968     {
4969       if (! get_32bit_section_headers (file, elf_header.e_shnum))
4970         return 0;
4971     }
4972   else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4973     return 0;
4974
4975   /* Read in the string table, so that we have names to display.  */
4976   if (elf_header.e_shstrndx != SHN_UNDEF
4977        && elf_header.e_shstrndx < elf_header.e_shnum)
4978     {
4979       section = section_headers + elf_header.e_shstrndx;
4980
4981       if (section->sh_size != 0)
4982         {
4983           string_table = (char *) get_data (NULL, file, section->sh_offset,
4984                                             1, section->sh_size,
4985                                             _("string table"));
4986
4987           string_table_length = string_table != NULL ? section->sh_size : 0;
4988         }
4989     }
4990
4991   /* Scan the sections for the dynamic symbol table
4992      and dynamic string table and debug sections.  */
4993   dynamic_symbols = NULL;
4994   dynamic_strings = NULL;
4995   dynamic_syminfo = NULL;
4996   symtab_shndx_hdr = NULL;
4997
4998   eh_addr_size = is_32bit_elf ? 4 : 8;
4999   switch (elf_header.e_machine)
5000     {
5001     case EM_MIPS:
5002     case EM_MIPS_RS3_LE:
5003       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5004          FDE addresses.  However, the ABI also has a semi-official ILP32
5005          variant for which the normal FDE address size rules apply.
5006
5007          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5008          section, where XX is the size of longs in bits.  Unfortunately,
5009          earlier compilers provided no way of distinguishing ILP32 objects
5010          from LP64 objects, so if there's any doubt, we should assume that
5011          the official LP64 form is being used.  */
5012       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5013           && find_section (".gcc_compiled_long32") == NULL)
5014         eh_addr_size = 8;
5015       break;
5016
5017     case EM_H8_300:
5018     case EM_H8_300H:
5019       switch (elf_header.e_flags & EF_H8_MACH)
5020         {
5021         case E_H8_MACH_H8300:
5022         case E_H8_MACH_H8300HN:
5023         case E_H8_MACH_H8300SN:
5024         case E_H8_MACH_H8300SXN:
5025           eh_addr_size = 2;
5026           break;
5027         case E_H8_MACH_H8300H:
5028         case E_H8_MACH_H8300S:
5029         case E_H8_MACH_H8300SX:
5030           eh_addr_size = 4;
5031           break;
5032         }
5033       break;
5034
5035     case EM_M32C_OLD:
5036     case EM_M32C:
5037       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5038         {
5039         case EF_M32C_CPU_M16C:
5040           eh_addr_size = 2;
5041           break;
5042         }
5043       break;
5044     }
5045
5046 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5047   do                                                                        \
5048     {                                                                       \
5049       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;      \
5050       if (section->sh_entsize != expected_entsize)                          \
5051         {                                                               \
5052           error (_("Section %d has invalid sh_entsize of %" BFD_VMA_FMT "x\n"), \
5053                  i, section->sh_entsize);       \
5054           error (_("(Using the expected size of %d for the rest of this dump)\n"), \
5055                    (int) expected_entsize); \
5056           section->sh_entsize = expected_entsize;                       \
5057         } \
5058     }                                                                       \
5059   while (0)
5060
5061 #define CHECK_ENTSIZE(section, i, type)                                 \
5062   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
5063                         sizeof (Elf64_External_##type))
5064
5065   for (i = 0, section = section_headers;
5066        i < elf_header.e_shnum;
5067        i++, section++)
5068     {
5069       char * name = SECTION_NAME (section);
5070
5071       if (section->sh_type == SHT_DYNSYM)
5072         {
5073           if (dynamic_symbols != NULL)
5074             {
5075               error (_("File contains multiple dynamic symbol tables\n"));
5076               continue;
5077             }
5078
5079           CHECK_ENTSIZE (section, i, Sym);
5080           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5081         }
5082       else if (section->sh_type == SHT_STRTAB
5083                && streq (name, ".dynstr"))
5084         {
5085           if (dynamic_strings != NULL)
5086             {
5087               error (_("File contains multiple dynamic string tables\n"));
5088               continue;
5089             }
5090
5091           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5092                                                1, section->sh_size,
5093                                                _("dynamic strings"));
5094           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5095         }
5096       else if (section->sh_type == SHT_SYMTAB_SHNDX)
5097         {
5098           if (symtab_shndx_hdr != NULL)
5099             {
5100               error (_("File contains multiple symtab shndx tables\n"));
5101               continue;
5102             }
5103           symtab_shndx_hdr = section;
5104         }
5105       else if (section->sh_type == SHT_SYMTAB)
5106         CHECK_ENTSIZE (section, i, Sym);
5107       else if (section->sh_type == SHT_GROUP)
5108         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5109       else if (section->sh_type == SHT_REL)
5110         CHECK_ENTSIZE (section, i, Rel);
5111       else if (section->sh_type == SHT_RELA)
5112         CHECK_ENTSIZE (section, i, Rela);
5113       else if ((do_debugging || do_debug_info || do_debug_abbrevs
5114                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5115                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5116                 || do_debug_str || do_debug_loc || do_debug_ranges
5117                 || do_debug_addr || do_debug_cu_index)
5118                && (const_strneq (name, ".debug_")
5119                    || const_strneq (name, ".zdebug_")))
5120         {
5121           if (name[1] == 'z')
5122             name += sizeof (".zdebug_") - 1;
5123           else
5124             name += sizeof (".debug_") - 1;
5125
5126           if (do_debugging
5127               || (do_debug_info     && const_strneq (name, "info"))
5128               || (do_debug_info     && const_strneq (name, "types"))
5129               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
5130               || (do_debug_lines    && strcmp (name, "line") == 0)
5131               || (do_debug_lines    && const_strneq (name, "line."))
5132               || (do_debug_pubnames && const_strneq (name, "pubnames"))
5133               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5134               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5135               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5136               || (do_debug_aranges  && const_strneq (name, "aranges"))
5137               || (do_debug_ranges   && const_strneq (name, "ranges"))
5138               || (do_debug_frames   && const_strneq (name, "frame"))
5139               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
5140               || (do_debug_macinfo  && const_strneq (name, "macro"))
5141               || (do_debug_str      && const_strneq (name, "str"))
5142               || (do_debug_loc      && const_strneq (name, "loc"))
5143               || (do_debug_addr     && const_strneq (name, "addr"))
5144               || (do_debug_cu_index && const_strneq (name, "cu_index"))
5145               || (do_debug_cu_index && const_strneq (name, "tu_index"))
5146               )
5147             request_dump_bynumber (i, DEBUG_DUMP);
5148         }
5149       /* Linkonce section to be combined with .debug_info at link time.  */
5150       else if ((do_debugging || do_debug_info)
5151                && const_strneq (name, ".gnu.linkonce.wi."))
5152         request_dump_bynumber (i, DEBUG_DUMP);
5153       else if (do_debug_frames && streq (name, ".eh_frame"))
5154         request_dump_bynumber (i, DEBUG_DUMP);
5155       else if (do_gdb_index && streq (name, ".gdb_index"))
5156         request_dump_bynumber (i, DEBUG_DUMP);
5157       /* Trace sections for Itanium VMS.  */
5158       else if ((do_debugging || do_trace_info || do_trace_abbrevs
5159                 || do_trace_aranges)
5160                && const_strneq (name, ".trace_"))
5161         {
5162           name += sizeof (".trace_") - 1;
5163
5164           if (do_debugging
5165               || (do_trace_info     && streq (name, "info"))
5166               || (do_trace_abbrevs  && streq (name, "abbrev"))
5167               || (do_trace_aranges  && streq (name, "aranges"))
5168               )
5169             request_dump_bynumber (i, DEBUG_DUMP);
5170         }
5171
5172     }
5173
5174   if (! do_sections)
5175     return 1;
5176
5177   if (elf_header.e_shnum > 1)
5178     printf (_("\nSection Headers:\n"));
5179   else
5180     printf (_("\nSection Header:\n"));
5181
5182   if (is_32bit_elf)
5183     {
5184       if (do_section_details)
5185         {
5186           printf (_("  [Nr] Name\n"));
5187           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
5188         }
5189       else
5190         printf
5191           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
5192     }
5193   else if (do_wide)
5194     {
5195       if (do_section_details)
5196         {
5197           printf (_("  [Nr] Name\n"));
5198           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
5199         }
5200       else
5201         printf
5202           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
5203     }
5204   else
5205     {
5206       if (do_section_details)
5207         {
5208           printf (_("  [Nr] Name\n"));
5209           printf (_("       Type              Address          Offset            Link\n"));
5210           printf (_("       Size              EntSize          Info              Align\n"));
5211         }
5212       else
5213         {
5214           printf (_("  [Nr] Name              Type             Address           Offset\n"));
5215           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
5216         }
5217     }
5218
5219   if (do_section_details)
5220     printf (_("       Flags\n"));
5221
5222   for (i = 0, section = section_headers;
5223        i < elf_header.e_shnum;
5224        i++, section++)
5225     {
5226       printf ("  [%2u] ", i);
5227       if (do_section_details)
5228         {
5229           print_symbol (INT_MAX, SECTION_NAME (section));
5230           printf ("\n      ");
5231         }
5232       else
5233         {
5234           print_symbol (-17, SECTION_NAME (section));
5235         }
5236
5237       printf (do_wide ? " %-15s " : " %-15.15s ",
5238               get_section_type_name (section->sh_type));
5239
5240       if (is_32bit_elf)
5241         {
5242           const char * link_too_big = NULL;
5243
5244           print_vma (section->sh_addr, LONG_HEX);
5245
5246           printf ( " %6.6lx %6.6lx %2.2lx",
5247                    (unsigned long) section->sh_offset,
5248                    (unsigned long) section->sh_size,
5249                    (unsigned long) section->sh_entsize);
5250
5251           if (do_section_details)
5252             fputs ("  ", stdout);
5253           else
5254             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5255
5256           if (section->sh_link >= elf_header.e_shnum)
5257             {
5258               link_too_big = "";
5259               /* The sh_link value is out of range.  Normally this indicates
5260                  an error but it can have special values in Solaris binaries.  */
5261               switch (elf_header.e_machine)
5262                 {
5263                 case EM_386:
5264                 case EM_486:
5265                 case EM_X86_64:
5266                 case EM_L1OM:
5267                 case EM_K1OM:
5268                 case EM_OLD_SPARCV9:
5269                 case EM_SPARC32PLUS:
5270                 case EM_SPARCV9:
5271                 case EM_SPARC:
5272                   if (section->sh_link == (SHN_BEFORE & 0xffff))
5273                     link_too_big = "BEFORE";
5274                   else if (section->sh_link == (SHN_AFTER & 0xffff))
5275                     link_too_big = "AFTER";
5276                   break;
5277                 default:
5278                   break;
5279                 }
5280             }
5281
5282           if (do_section_details)
5283             {
5284               if (link_too_big != NULL && * link_too_big)
5285                 printf ("<%s> ", link_too_big);
5286               else
5287                 printf ("%2u ", section->sh_link);
5288               printf ("%3u %2lu\n", section->sh_info,
5289                       (unsigned long) section->sh_addralign);
5290             }
5291           else
5292             printf ("%2u %3u %2lu\n",
5293                     section->sh_link,
5294                     section->sh_info,
5295                     (unsigned long) section->sh_addralign);
5296
5297           if (link_too_big && ! * link_too_big)
5298             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5299                   i, section->sh_link);
5300         }
5301       else if (do_wide)
5302         {
5303           print_vma (section->sh_addr, LONG_HEX);
5304
5305           if ((long) section->sh_offset == section->sh_offset)
5306             printf (" %6.6lx", (unsigned long) section->sh_offset);
5307           else
5308             {
5309               putchar (' ');
5310               print_vma (section->sh_offset, LONG_HEX);
5311             }
5312
5313           if ((unsigned long) section->sh_size == section->sh_size)
5314             printf (" %6.6lx", (unsigned long) section->sh_size);
5315           else
5316             {
5317               putchar (' ');
5318               print_vma (section->sh_size, LONG_HEX);
5319             }
5320
5321           if ((unsigned long) section->sh_entsize == section->sh_entsize)
5322             printf (" %2.2lx", (unsigned long) section->sh_entsize);
5323           else
5324             {
5325               putchar (' ');
5326               print_vma (section->sh_entsize, LONG_HEX);
5327             }
5328
5329           if (do_section_details)
5330             fputs ("  ", stdout);
5331           else
5332             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5333
5334           printf ("%2u %3u ", section->sh_link, section->sh_info);
5335
5336           if ((unsigned long) section->sh_addralign == section->sh_addralign)
5337             printf ("%2lu\n", (unsigned long) section->sh_addralign);
5338           else
5339             {
5340               print_vma (section->sh_addralign, DEC);
5341               putchar ('\n');
5342             }
5343         }
5344       else if (do_section_details)
5345         {
5346           printf ("       %-15.15s  ",
5347                   get_section_type_name (section->sh_type));
5348           print_vma (section->sh_addr, LONG_HEX);
5349           if ((long) section->sh_offset == section->sh_offset)
5350             printf ("  %16.16lx", (unsigned long) section->sh_offset);
5351           else
5352             {
5353               printf ("  ");
5354               print_vma (section->sh_offset, LONG_HEX);
5355             }
5356           printf ("  %u\n       ", section->sh_link);
5357           print_vma (section->sh_size, LONG_HEX);
5358           putchar (' ');
5359           print_vma (section->sh_entsize, LONG_HEX);
5360
5361           printf ("  %-16u  %lu\n",
5362                   section->sh_info,
5363                   (unsigned long) section->sh_addralign);
5364         }
5365       else
5366         {
5367           putchar (' ');
5368           print_vma (section->sh_addr, LONG_HEX);
5369           if ((long) section->sh_offset == section->sh_offset)
5370             printf ("  %8.8lx", (unsigned long) section->sh_offset);
5371           else
5372             {
5373               printf ("  ");
5374               print_vma (section->sh_offset, LONG_HEX);
5375             }
5376           printf ("\n       ");
5377           print_vma (section->sh_size, LONG_HEX);
5378           printf ("  ");
5379           print_vma (section->sh_entsize, LONG_HEX);
5380
5381           printf (" %3s ", get_elf_section_flags (section->sh_flags));
5382
5383           printf ("     %2u   %3u     %lu\n",
5384                   section->sh_link,
5385                   section->sh_info,
5386                   (unsigned long) section->sh_addralign);
5387         }
5388
5389       if (do_section_details)
5390         printf ("       %s\n", get_elf_section_flags (section->sh_flags));
5391     }
5392
5393   if (!do_section_details)
5394     {
5395       if (elf_header.e_machine == EM_X86_64
5396           || elf_header.e_machine == EM_L1OM
5397           || elf_header.e_machine == EM_K1OM)
5398         printf (_("Key to Flags:\n\
5399   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5400   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5401   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5402       else
5403         printf (_("Key to Flags:\n\
5404   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5405   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5406   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5407     }
5408
5409   return 1;
5410 }
5411
5412 static const char *
5413 get_group_flags (unsigned int flags)
5414 {
5415   static char buff[32];
5416   switch (flags)
5417     {
5418     case 0:
5419       return "";
5420
5421     case GRP_COMDAT:
5422       return "COMDAT ";
5423
5424    default:
5425       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5426       break;
5427     }
5428   return buff;
5429 }
5430
5431 static int
5432 process_section_groups (FILE * file)
5433 {
5434   Elf_Internal_Shdr * section;
5435   unsigned int i;
5436   struct group * group;
5437   Elf_Internal_Shdr * symtab_sec;
5438   Elf_Internal_Shdr * strtab_sec;
5439   Elf_Internal_Sym * symtab;
5440   unsigned long num_syms;
5441   char * strtab;
5442   size_t strtab_size;
5443
5444   /* Don't process section groups unless needed.  */
5445   if (!do_unwind && !do_section_groups)
5446     return 1;
5447
5448   if (elf_header.e_shnum == 0)
5449     {
5450       if (do_section_groups)
5451         printf (_("\nThere are no sections to group in this file.\n"));
5452
5453       return 1;
5454     }
5455
5456   if (section_headers == NULL)
5457     {
5458       error (_("Section headers are not available!\n"));
5459       /* PR 13622: This can happen with a corrupt ELF header.  */
5460       return 0;
5461     }
5462
5463   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5464                                                      sizeof (struct group *));
5465
5466   if (section_headers_groups == NULL)
5467     {
5468       error (_("Out of memory\n"));
5469       return 0;
5470     }
5471
5472   /* Scan the sections for the group section.  */
5473   group_count = 0;
5474   for (i = 0, section = section_headers;
5475        i < elf_header.e_shnum;
5476        i++, section++)
5477     if (section->sh_type == SHT_GROUP)
5478       group_count++;
5479
5480   if (group_count == 0)
5481     {
5482       if (do_section_groups)
5483         printf (_("\nThere are no section groups in this file.\n"));
5484
5485       return 1;
5486     }
5487
5488   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5489
5490   if (section_groups == NULL)
5491     {
5492       error (_("Out of memory\n"));
5493       return 0;
5494     }
5495
5496   symtab_sec = NULL;
5497   strtab_sec = NULL;
5498   symtab = NULL;
5499   num_syms = 0;
5500   strtab = NULL;
5501   strtab_size = 0;
5502   for (i = 0, section = section_headers, group = section_groups;
5503        i < elf_header.e_shnum;
5504        i++, section++)
5505     {
5506       if (section->sh_type == SHT_GROUP)
5507         {
5508           char * name = SECTION_NAME (section);
5509           char * group_name;
5510           unsigned char * start;
5511           unsigned char * indices;
5512           unsigned int entry, j, size;
5513           Elf_Internal_Shdr * sec;
5514           Elf_Internal_Sym * sym;
5515
5516           /* Get the symbol table.  */
5517           if (section->sh_link >= elf_header.e_shnum
5518               || ((sec = section_headers + section->sh_link)->sh_type
5519                   != SHT_SYMTAB))
5520             {
5521               error (_("Bad sh_link in group section `%s'\n"), name);
5522               continue;
5523             }
5524
5525           if (symtab_sec != sec)
5526             {
5527               symtab_sec = sec;
5528               if (symtab)
5529                 free (symtab);
5530               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5531             }
5532
5533           if (symtab == NULL)
5534             {
5535               error (_("Corrupt header in group section `%s'\n"), name);
5536               continue;
5537             }
5538
5539           if (section->sh_info >= num_syms)
5540             {
5541               error (_("Bad sh_info in group section `%s'\n"), name);
5542               continue;
5543             }
5544
5545           sym = symtab + section->sh_info;
5546
5547           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5548             {
5549               if (sym->st_shndx == 0
5550                   || sym->st_shndx >= elf_header.e_shnum)
5551                 {
5552                   error (_("Bad sh_info in group section `%s'\n"), name);
5553                   continue;
5554                 }
5555
5556               group_name = SECTION_NAME (section_headers + sym->st_shndx);
5557               strtab_sec = NULL;
5558               if (strtab)
5559                 free (strtab);
5560               strtab = NULL;
5561               strtab_size = 0;
5562             }
5563           else
5564             {
5565               /* Get the string table.  */
5566               if (symtab_sec->sh_link >= elf_header.e_shnum)
5567                 {
5568                   strtab_sec = NULL;
5569                   if (strtab)
5570                     free (strtab);
5571                   strtab = NULL;
5572                   strtab_size = 0;
5573                 }
5574               else if (strtab_sec
5575                        != (sec = section_headers + symtab_sec->sh_link))
5576                 {
5577                   strtab_sec = sec;
5578                   if (strtab)
5579                     free (strtab);
5580                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5581                                               1, strtab_sec->sh_size,
5582                                               _("string table"));
5583                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5584                 }
5585               group_name = sym->st_name < strtab_size
5586                 ? strtab + sym->st_name : _("<corrupt>");
5587             }
5588
5589           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5590                                               1, section->sh_size,
5591                                               _("section data"));
5592           if (start == NULL)
5593             continue;
5594
5595           indices = start;
5596           size = (section->sh_size / section->sh_entsize) - 1;
5597           entry = byte_get (indices, 4);
5598           indices += 4;
5599
5600           if (do_section_groups)
5601             {
5602               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5603                       get_group_flags (entry), i, name, group_name, size);
5604
5605               printf (_("   [Index]    Name\n"));
5606             }
5607
5608           group->group_index = i;
5609
5610           for (j = 0; j < size; j++)
5611             {
5612               struct group_list * g;
5613
5614               entry = byte_get (indices, 4);
5615               indices += 4;
5616
5617               if (entry >= elf_header.e_shnum)
5618                 {
5619                   error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5620                          entry, i, elf_header.e_shnum - 1);
5621                   continue;
5622                 }
5623
5624               if (section_headers_groups [entry] != NULL)
5625                 {
5626                   if (entry)
5627                     {
5628                       error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5629                              entry, i,
5630                              section_headers_groups [entry]->group_index);
5631                       continue;
5632                     }
5633                   else
5634                     {
5635                       /* Intel C/C++ compiler may put section 0 in a
5636                          section group. We just warn it the first time
5637                          and ignore it afterwards.  */
5638                       static int warned = 0;
5639                       if (!warned)
5640                         {
5641                           error (_("section 0 in group section [%5u]\n"),
5642                                  section_headers_groups [entry]->group_index);
5643                           warned++;
5644                         }
5645                     }
5646                 }
5647
5648               section_headers_groups [entry] = group;
5649
5650               if (do_section_groups)
5651                 {
5652                   sec = section_headers + entry;
5653                   printf ("   [%5u]   %s\n", entry, SECTION_NAME (sec));
5654                 }
5655
5656               g = (struct group_list *) xmalloc (sizeof (struct group_list));
5657               g->section_index = entry;
5658               g->next = group->root;
5659               group->root = g;
5660             }
5661
5662           if (start)
5663             free (start);
5664
5665           group++;
5666         }
5667     }
5668
5669   if (symtab)
5670     free (symtab);
5671   if (strtab)
5672     free (strtab);
5673   return 1;
5674 }
5675
5676 /* Data used to display dynamic fixups.  */
5677
5678 struct ia64_vms_dynfixup
5679 {
5680   bfd_vma needed_ident;         /* Library ident number.  */
5681   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
5682   bfd_vma fixup_needed;         /* Index of the library.  */
5683   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
5684   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
5685 };
5686
5687 /* Data used to display dynamic relocations.  */
5688
5689 struct ia64_vms_dynimgrela
5690 {
5691   bfd_vma img_rela_cnt;         /* Number of relocations.  */
5692   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
5693 };
5694
5695 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5696    library).  */
5697
5698 static void
5699 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5700                               const char *strtab, unsigned int strtab_sz)
5701 {
5702   Elf64_External_VMS_IMAGE_FIXUP *imfs;
5703   long i;
5704   const char *lib_name;
5705
5706   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5707                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
5708                    _("dynamic section image fixups"));
5709   if (!imfs)
5710     return;
5711
5712   if (fixup->needed < strtab_sz)
5713     lib_name = strtab + fixup->needed;
5714   else
5715     {
5716       warn ("corrupt library name index of 0x%lx found in dynamic entry",
5717             (unsigned long) fixup->needed);
5718       lib_name = "???";
5719     }
5720   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5721           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5722   printf
5723     (_("Seg Offset           Type                             SymVec DataType\n"));
5724
5725   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5726     {
5727       unsigned int type;
5728       const char *rtype;
5729
5730       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5731       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5732       type = BYTE_GET (imfs [i].type);
5733       rtype = elf_ia64_reloc_type (type);
5734       if (rtype == NULL)
5735         printf (" 0x%08x                       ", type);
5736       else
5737         printf (" %-32s ", rtype);
5738       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5739       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5740     }
5741
5742   free (imfs);
5743 }
5744
5745 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
5746
5747 static void
5748 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5749 {
5750   Elf64_External_VMS_IMAGE_RELA *imrs;
5751   long i;
5752
5753   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5754                    1, imgrela->img_rela_cnt * sizeof (*imrs),
5755                    _("dynamic section image relocations"));
5756   if (!imrs)
5757     return;
5758
5759   printf (_("\nImage relocs\n"));
5760   printf
5761     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
5762
5763   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5764     {
5765       unsigned int type;
5766       const char *rtype;
5767
5768       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5769       printf ("%08" BFD_VMA_FMT "x ",
5770               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5771       type = BYTE_GET (imrs [i].type);
5772       rtype = elf_ia64_reloc_type (type);
5773       if (rtype == NULL)
5774         printf ("0x%08x                      ", type);
5775       else
5776         printf ("%-31s ", rtype);
5777       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5778       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5779       printf ("%08" BFD_VMA_FMT "x\n",
5780               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5781     }
5782
5783   free (imrs);
5784 }
5785
5786 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
5787
5788 static int
5789 process_ia64_vms_dynamic_relocs (FILE *file)
5790 {
5791   struct ia64_vms_dynfixup fixup;
5792   struct ia64_vms_dynimgrela imgrela;
5793   Elf_Internal_Dyn *entry;
5794   int res = 0;
5795   bfd_vma strtab_off = 0;
5796   bfd_vma strtab_sz = 0;
5797   char *strtab = NULL;
5798
5799   memset (&fixup, 0, sizeof (fixup));
5800   memset (&imgrela, 0, sizeof (imgrela));
5801
5802   /* Note: the order of the entries is specified by the OpenVMS specs.  */
5803   for (entry = dynamic_section;
5804        entry < dynamic_section + dynamic_nent;
5805        entry++)
5806     {
5807       switch (entry->d_tag)
5808         {
5809         case DT_IA_64_VMS_STRTAB_OFFSET:
5810           strtab_off = entry->d_un.d_val;
5811           break;
5812         case DT_STRSZ:
5813           strtab_sz = entry->d_un.d_val;
5814           if (strtab == NULL)
5815             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5816                                1, strtab_sz, _("dynamic string section"));
5817           break;
5818
5819         case DT_IA_64_VMS_NEEDED_IDENT:
5820           fixup.needed_ident = entry->d_un.d_val;
5821           break;
5822         case DT_NEEDED:
5823           fixup.needed = entry->d_un.d_val;
5824           break;
5825         case DT_IA_64_VMS_FIXUP_NEEDED:
5826           fixup.fixup_needed = entry->d_un.d_val;
5827           break;
5828         case DT_IA_64_VMS_FIXUP_RELA_CNT:
5829           fixup.fixup_rela_cnt = entry->d_un.d_val;
5830           break;
5831         case DT_IA_64_VMS_FIXUP_RELA_OFF:
5832           fixup.fixup_rela_off = entry->d_un.d_val;
5833           res++;
5834           dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5835           break;
5836
5837         case DT_IA_64_VMS_IMG_RELA_CNT:
5838           imgrela.img_rela_cnt = entry->d_un.d_val;
5839           break;
5840         case DT_IA_64_VMS_IMG_RELA_OFF:
5841           imgrela.img_rela_off = entry->d_un.d_val;
5842           res++;
5843           dump_ia64_vms_dynamic_relocs (file, &imgrela);
5844           break;
5845
5846         default:
5847           break;
5848         }
5849     }
5850
5851   if (strtab != NULL)
5852     free (strtab);
5853
5854   return res;
5855 }
5856
5857 static struct
5858 {
5859   const char * name;
5860   int reloc;
5861   int size;
5862   int rela;
5863 } dynamic_relocations [] =
5864 {
5865     { "REL", DT_REL, DT_RELSZ, FALSE },
5866     { "RELA", DT_RELA, DT_RELASZ, TRUE },
5867     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5868 };
5869
5870 /* Process the reloc section.  */
5871
5872 static int
5873 process_relocs (FILE * file)
5874 {
5875   unsigned long rel_size;
5876   unsigned long rel_offset;
5877
5878
5879   if (!do_reloc)
5880     return 1;
5881
5882   if (do_using_dynamic)
5883     {
5884       int is_rela;
5885       const char * name;
5886       int has_dynamic_reloc;
5887       unsigned int i;
5888
5889       has_dynamic_reloc = 0;
5890
5891       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5892         {
5893           is_rela = dynamic_relocations [i].rela;
5894           name = dynamic_relocations [i].name;
5895           rel_size = dynamic_info [dynamic_relocations [i].size];
5896           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5897
5898           has_dynamic_reloc |= rel_size;
5899
5900           if (is_rela == UNKNOWN)
5901             {
5902               if (dynamic_relocations [i].reloc == DT_JMPREL)
5903                 switch (dynamic_info[DT_PLTREL])
5904                   {
5905                   case DT_REL:
5906                     is_rela = FALSE;
5907                     break;
5908                   case DT_RELA:
5909                     is_rela = TRUE;
5910                     break;
5911                   }
5912             }
5913
5914           if (rel_size)
5915             {
5916               printf
5917                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5918                  name, rel_offset, rel_size);
5919
5920               dump_relocations (file,
5921                                 offset_from_vma (file, rel_offset, rel_size),
5922                                 rel_size,
5923                                 dynamic_symbols, num_dynamic_syms,
5924                                 dynamic_strings, dynamic_strings_length, is_rela);
5925             }
5926         }
5927
5928       if (is_ia64_vms ())
5929         has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5930
5931       if (! has_dynamic_reloc)
5932         printf (_("\nThere are no dynamic relocations in this file.\n"));
5933     }
5934   else
5935     {
5936       Elf_Internal_Shdr * section;
5937       unsigned long i;
5938       int found = 0;
5939
5940       for (i = 0, section = section_headers;
5941            i < elf_header.e_shnum;
5942            i++, section++)
5943         {
5944           if (   section->sh_type != SHT_RELA
5945               && section->sh_type != SHT_REL)
5946             continue;
5947
5948           rel_offset = section->sh_offset;
5949           rel_size   = section->sh_size;
5950
5951           if (rel_size)
5952             {
5953               Elf_Internal_Shdr * strsec;
5954               int is_rela;
5955
5956               printf (_("\nRelocation section "));
5957
5958               if (string_table == NULL)
5959                 printf ("%d", section->sh_name);
5960               else
5961                 printf ("'%s'", SECTION_NAME (section));
5962
5963               printf (_(" at offset 0x%lx contains %lu entries:\n"),
5964                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5965
5966               is_rela = section->sh_type == SHT_RELA;
5967
5968               if (section->sh_link != 0
5969                   && section->sh_link < elf_header.e_shnum)
5970                 {
5971                   Elf_Internal_Shdr * symsec;
5972                   Elf_Internal_Sym *  symtab;
5973                   unsigned long nsyms;
5974                   unsigned long strtablen = 0;
5975                   char * strtab = NULL;
5976
5977                   symsec = section_headers + section->sh_link;
5978                   if (symsec->sh_type != SHT_SYMTAB
5979                       && symsec->sh_type != SHT_DYNSYM)
5980                     continue;
5981
5982                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
5983
5984                   if (symtab == NULL)
5985                     continue;
5986
5987                   if (symsec->sh_link != 0
5988                       && symsec->sh_link < elf_header.e_shnum)
5989                     {
5990                       strsec = section_headers + symsec->sh_link;
5991
5992                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5993                                                   1, strsec->sh_size,
5994                                                   _("string table"));
5995                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
5996                     }
5997
5998                   dump_relocations (file, rel_offset, rel_size,
5999                                     symtab, nsyms, strtab, strtablen, is_rela);
6000                   if (strtab)
6001                     free (strtab);
6002                   free (symtab);
6003                 }
6004               else
6005                 dump_relocations (file, rel_offset, rel_size,
6006                                   NULL, 0, NULL, 0, is_rela);
6007
6008               found = 1;
6009             }
6010         }
6011
6012       if (! found)
6013         printf (_("\nThere are no relocations in this file.\n"));
6014     }
6015
6016   return 1;
6017 }
6018
6019 /* Process the unwind section.  */
6020
6021 #include "unwind-ia64.h"
6022
6023 /* An absolute address consists of a section and an offset.  If the
6024    section is NULL, the offset itself is the address, otherwise, the
6025    address equals to LOAD_ADDRESS(section) + offset.  */
6026
6027 struct absaddr
6028   {
6029     unsigned short section;
6030     bfd_vma offset;
6031   };
6032
6033 #define ABSADDR(a) \
6034   ((a).section \
6035    ? section_headers [(a).section].sh_addr + (a).offset \
6036    : (a).offset)
6037
6038 struct ia64_unw_table_entry
6039   {
6040     struct absaddr start;
6041     struct absaddr end;
6042     struct absaddr info;
6043   };
6044
6045 struct ia64_unw_aux_info
6046   {
6047
6048     struct ia64_unw_table_entry *table; /* Unwind table.  */
6049     unsigned long table_len;    /* Length of unwind table.  */
6050     unsigned char * info;       /* Unwind info.  */
6051     unsigned long info_size;    /* Size of unwind info.  */
6052     bfd_vma info_addr;          /* starting address of unwind info.  */
6053     bfd_vma seg_base;           /* Starting address of segment.  */
6054     Elf_Internal_Sym * symtab;  /* The symbol table.  */
6055     unsigned long nsyms;        /* Number of symbols.  */
6056     char * strtab;              /* The string table.  */
6057     unsigned long strtab_size;  /* Size of string table.  */
6058   };
6059
6060 static void
6061 find_symbol_for_address (Elf_Internal_Sym * symtab,
6062                          unsigned long nsyms,
6063                          const char * strtab,
6064                          unsigned long strtab_size,
6065                          struct absaddr addr,
6066                          const char ** symname,
6067                          bfd_vma * offset)
6068 {
6069   bfd_vma dist = 0x100000;
6070   Elf_Internal_Sym * sym;
6071   Elf_Internal_Sym * best = NULL;
6072   unsigned long i;
6073
6074   REMOVE_ARCH_BITS (addr.offset);
6075
6076   for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
6077     {
6078       bfd_vma value = sym->st_value;
6079
6080       REMOVE_ARCH_BITS (value);
6081
6082       if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
6083           && sym->st_name != 0
6084           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6085           && addr.offset >= value
6086           && addr.offset - value < dist)
6087         {
6088           best = sym;
6089           dist = addr.offset - value;
6090           if (!dist)
6091             break;
6092         }
6093     }
6094
6095   if (best)
6096     {
6097       *symname = (best->st_name >= strtab_size
6098                   ? _("<corrupt>") : strtab + best->st_name);
6099       *offset = dist;
6100       return;
6101     }
6102
6103   *symname = NULL;
6104   *offset = addr.offset;
6105 }
6106
6107 static void
6108 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6109 {
6110   struct ia64_unw_table_entry * tp;
6111   int in_body;
6112
6113   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6114     {
6115       bfd_vma stamp;
6116       bfd_vma offset;
6117       const unsigned char * dp;
6118       const unsigned char * head;
6119       const char * procname;
6120
6121       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6122                                aux->strtab_size, tp->start, &procname, &offset);
6123
6124       fputs ("\n<", stdout);
6125
6126       if (procname)
6127         {
6128           fputs (procname, stdout);
6129
6130           if (offset)
6131             printf ("+%lx", (unsigned long) offset);
6132         }
6133
6134       fputs (">: [", stdout);
6135       print_vma (tp->start.offset, PREFIX_HEX);
6136       fputc ('-', stdout);
6137       print_vma (tp->end.offset, PREFIX_HEX);
6138       printf ("], info at +0x%lx\n",
6139               (unsigned long) (tp->info.offset - aux->seg_base));
6140
6141       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6142       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6143
6144       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6145               (unsigned) UNW_VER (stamp),
6146               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6147               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6148               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6149               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6150
6151       if (UNW_VER (stamp) != 1)
6152         {
6153           printf (_("\tUnknown version.\n"));
6154           continue;
6155         }
6156
6157       in_body = 0;
6158       for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
6159         dp = unw_decode (dp, in_body, & in_body);
6160     }
6161 }
6162
6163 static int
6164 slurp_ia64_unwind_table (FILE * file,
6165                          struct ia64_unw_aux_info * aux,
6166                          Elf_Internal_Shdr * sec)
6167 {
6168   unsigned long size, nrelas, i;
6169   Elf_Internal_Phdr * seg;
6170   struct ia64_unw_table_entry * tep;
6171   Elf_Internal_Shdr * relsec;
6172   Elf_Internal_Rela * rela;
6173   Elf_Internal_Rela * rp;
6174   unsigned char * table;
6175   unsigned char * tp;
6176   Elf_Internal_Sym * sym;
6177   const char * relname;
6178
6179   /* First, find the starting address of the segment that includes
6180      this section: */
6181
6182   if (elf_header.e_phnum)
6183     {
6184       if (! get_program_headers (file))
6185           return 0;
6186
6187       for (seg = program_headers;
6188            seg < program_headers + elf_header.e_phnum;
6189            ++seg)
6190         {
6191           if (seg->p_type != PT_LOAD)
6192             continue;
6193
6194           if (sec->sh_addr >= seg->p_vaddr
6195               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6196             {
6197               aux->seg_base = seg->p_vaddr;
6198               break;
6199             }
6200         }
6201     }
6202
6203   /* Second, build the unwind table from the contents of the unwind section:  */
6204   size = sec->sh_size;
6205   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6206                                       _("unwind table"));
6207   if (!table)
6208     return 0;
6209
6210   aux->table = (struct ia64_unw_table_entry *)
6211       xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
6212   tep = aux->table;
6213   for (tp = table; tp < table + size; ++tep)
6214     {
6215       tep->start.section = SHN_UNDEF;
6216       tep->end.section   = SHN_UNDEF;
6217       tep->info.section  = SHN_UNDEF;
6218       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6219       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6220       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6221       tep->start.offset += aux->seg_base;
6222       tep->end.offset   += aux->seg_base;
6223       tep->info.offset  += aux->seg_base;
6224     }
6225   free (table);
6226
6227   /* Third, apply any relocations to the unwind table:  */
6228   for (relsec = section_headers;
6229        relsec < section_headers + elf_header.e_shnum;
6230        ++relsec)
6231     {
6232       if (relsec->sh_type != SHT_RELA
6233           || relsec->sh_info >= elf_header.e_shnum
6234           || section_headers + relsec->sh_info != sec)
6235         continue;
6236
6237       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6238                               & rela, & nrelas))
6239         return 0;
6240
6241       for (rp = rela; rp < rela + nrelas; ++rp)
6242         {
6243           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6244           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6245
6246           if (! const_strneq (relname, "R_IA64_SEGREL"))
6247             {
6248               warn (_("Skipping unexpected relocation type %s\n"), relname);
6249               continue;
6250             }
6251
6252           i = rp->r_offset / (3 * eh_addr_size);
6253
6254           switch (rp->r_offset/eh_addr_size % 3)
6255             {
6256             case 0:
6257               aux->table[i].start.section = sym->st_shndx;
6258               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
6259               break;
6260             case 1:
6261               aux->table[i].end.section   = sym->st_shndx;
6262               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
6263               break;
6264             case 2:
6265               aux->table[i].info.section  = sym->st_shndx;
6266               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
6267               break;
6268             default:
6269               break;
6270             }
6271         }
6272
6273       free (rela);
6274     }
6275
6276   aux->table_len = size / (3 * eh_addr_size);
6277   return 1;
6278 }
6279
6280 static void
6281 ia64_process_unwind (FILE * file)
6282 {
6283   Elf_Internal_Shdr * sec;
6284   Elf_Internal_Shdr * unwsec = NULL;
6285   Elf_Internal_Shdr * strsec;
6286   unsigned long i, unwcount = 0, unwstart = 0;
6287   struct ia64_unw_aux_info aux;
6288
6289   memset (& aux, 0, sizeof (aux));
6290
6291   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6292     {
6293       if (sec->sh_type == SHT_SYMTAB
6294           && sec->sh_link < elf_header.e_shnum)
6295         {
6296           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6297
6298           strsec = section_headers + sec->sh_link;
6299           assert (aux.strtab == NULL);
6300           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6301                                           1, strsec->sh_size,
6302                                           _("string table"));
6303           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6304         }
6305       else if (sec->sh_type == SHT_IA_64_UNWIND)
6306         unwcount++;
6307     }
6308
6309   if (!unwcount)
6310     printf (_("\nThere are no unwind sections in this file.\n"));
6311
6312   while (unwcount-- > 0)
6313     {
6314       char * suffix;
6315       size_t len, len2;
6316
6317       for (i = unwstart, sec = section_headers + unwstart;
6318            i < elf_header.e_shnum; ++i, ++sec)
6319         if (sec->sh_type == SHT_IA_64_UNWIND)
6320           {
6321             unwsec = sec;
6322             break;
6323           }
6324
6325       unwstart = i + 1;
6326       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6327
6328       if ((unwsec->sh_flags & SHF_GROUP) != 0)
6329         {
6330           /* We need to find which section group it is in.  */
6331           struct group_list * g = section_headers_groups [i]->root;
6332
6333           for (; g != NULL; g = g->next)
6334             {
6335               sec = section_headers + g->section_index;
6336
6337               if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6338                 break;
6339             }
6340
6341           if (g == NULL)
6342             i = elf_header.e_shnum;
6343         }
6344       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6345         {
6346           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
6347           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6348           suffix = SECTION_NAME (unwsec) + len;
6349           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6350                ++i, ++sec)
6351             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6352                 && streq (SECTION_NAME (sec) + len2, suffix))
6353               break;
6354         }
6355       else
6356         {
6357           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6358              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
6359           len = sizeof (ELF_STRING_ia64_unwind) - 1;
6360           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6361           suffix = "";
6362           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6363             suffix = SECTION_NAME (unwsec) + len;
6364           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6365                ++i, ++sec)
6366             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6367                 && streq (SECTION_NAME (sec) + len2, suffix))
6368               break;
6369         }
6370
6371       if (i == elf_header.e_shnum)
6372         {
6373           printf (_("\nCould not find unwind info section for "));
6374
6375           if (string_table == NULL)
6376             printf ("%d", unwsec->sh_name);
6377           else
6378             printf (_("'%s'"), SECTION_NAME (unwsec));
6379         }
6380       else
6381         {
6382           aux.info_addr = sec->sh_addr;
6383           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6384                                                  sec->sh_size,
6385                                                  _("unwind info"));
6386           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6387
6388           printf (_("\nUnwind section "));
6389
6390           if (string_table == NULL)
6391             printf ("%d", unwsec->sh_name);
6392           else
6393             printf (_("'%s'"), SECTION_NAME (unwsec));
6394
6395           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6396                   (unsigned long) unwsec->sh_offset,
6397                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6398
6399           (void) slurp_ia64_unwind_table (file, & aux, unwsec);
6400
6401           if (aux.table_len > 0)
6402             dump_ia64_unwind (& aux);
6403
6404           if (aux.table)
6405             free ((char *) aux.table);
6406           if (aux.info)
6407             free ((char *) aux.info);
6408           aux.table = NULL;
6409           aux.info = NULL;
6410         }
6411     }
6412
6413   if (aux.symtab)
6414     free (aux.symtab);
6415   if (aux.strtab)
6416     free ((char *) aux.strtab);
6417 }
6418
6419 struct hppa_unw_table_entry
6420   {
6421     struct absaddr start;
6422     struct absaddr end;
6423     unsigned int Cannot_unwind:1;                       /* 0 */
6424     unsigned int Millicode:1;                   /* 1 */
6425     unsigned int Millicode_save_sr0:1;          /* 2 */
6426     unsigned int Region_description:2;          /* 3..4 */
6427     unsigned int reserved1:1;                   /* 5 */
6428     unsigned int Entry_SR:1;                    /* 6 */
6429     unsigned int Entry_FR:4;     /* number saved */     /* 7..10 */
6430     unsigned int Entry_GR:5;     /* number saved */     /* 11..15 */
6431     unsigned int Args_stored:1;                 /* 16 */
6432     unsigned int Variable_Frame:1;                      /* 17 */
6433     unsigned int Separate_Package_Body:1;               /* 18 */
6434     unsigned int Frame_Extension_Millicode:1;   /* 19 */
6435     unsigned int Stack_Overflow_Check:1;                /* 20 */
6436     unsigned int Two_Instruction_SP_Increment:1;        /* 21 */
6437     unsigned int Ada_Region:1;                  /* 22 */
6438     unsigned int cxx_info:1;                    /* 23 */
6439     unsigned int cxx_try_catch:1;                       /* 24 */
6440     unsigned int sched_entry_seq:1;                     /* 25 */
6441     unsigned int reserved2:1;                   /* 26 */
6442     unsigned int Save_SP:1;                             /* 27 */
6443     unsigned int Save_RP:1;                             /* 28 */
6444     unsigned int Save_MRP_in_frame:1;           /* 29 */
6445     unsigned int extn_ptr_defined:1;            /* 30 */
6446     unsigned int Cleanup_defined:1;                     /* 31 */
6447
6448     unsigned int MPE_XL_interrupt_marker:1;             /* 0 */
6449     unsigned int HP_UX_interrupt_marker:1;              /* 1 */
6450     unsigned int Large_frame:1;                 /* 2 */
6451     unsigned int Pseudo_SP_Set:1;                       /* 3 */
6452     unsigned int reserved4:1;                   /* 4 */
6453     unsigned int Total_frame_size:27;           /* 5..31 */
6454   };
6455
6456 struct hppa_unw_aux_info
6457   {
6458     struct hppa_unw_table_entry *table; /* Unwind table.  */
6459     unsigned long table_len;    /* Length of unwind table.  */
6460     bfd_vma seg_base;           /* Starting address of segment.  */
6461     Elf_Internal_Sym * symtab;  /* The symbol table.  */
6462     unsigned long nsyms;        /* Number of symbols.  */
6463     char * strtab;              /* The string table.  */
6464     unsigned long strtab_size;  /* Size of string table.  */
6465   };
6466
6467 static void
6468 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
6469 {
6470   struct hppa_unw_table_entry * tp;
6471
6472   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6473     {
6474       bfd_vma offset;
6475       const char * procname;
6476
6477       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6478                                aux->strtab_size, tp->start, &procname,
6479                                &offset);
6480
6481       fputs ("\n<", stdout);
6482
6483       if (procname)
6484         {
6485           fputs (procname, stdout);
6486
6487           if (offset)
6488             printf ("+%lx", (unsigned long) offset);
6489         }
6490
6491       fputs (">: [", stdout);
6492       print_vma (tp->start.offset, PREFIX_HEX);
6493       fputc ('-', stdout);
6494       print_vma (tp->end.offset, PREFIX_HEX);
6495       printf ("]\n\t");
6496
6497 #define PF(_m) if (tp->_m) printf (#_m " ");
6498 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6499       PF(Cannot_unwind);
6500       PF(Millicode);
6501       PF(Millicode_save_sr0);
6502       /* PV(Region_description);  */
6503       PF(Entry_SR);
6504       PV(Entry_FR);
6505       PV(Entry_GR);
6506       PF(Args_stored);
6507       PF(Variable_Frame);
6508       PF(Separate_Package_Body);
6509       PF(Frame_Extension_Millicode);
6510       PF(Stack_Overflow_Check);
6511       PF(Two_Instruction_SP_Increment);
6512       PF(Ada_Region);
6513       PF(cxx_info);
6514       PF(cxx_try_catch);
6515       PF(sched_entry_seq);
6516       PF(Save_SP);
6517       PF(Save_RP);
6518       PF(Save_MRP_in_frame);
6519       PF(extn_ptr_defined);
6520       PF(Cleanup_defined);
6521       PF(MPE_XL_interrupt_marker);
6522       PF(HP_UX_interrupt_marker);
6523       PF(Large_frame);
6524       PF(Pseudo_SP_Set);
6525       PV(Total_frame_size);
6526 #undef PF
6527 #undef PV
6528     }
6529
6530   printf ("\n");
6531 }
6532
6533 static int
6534 slurp_hppa_unwind_table (FILE * file,
6535                          struct hppa_unw_aux_info * aux,
6536                          Elf_Internal_Shdr * sec)
6537 {
6538   unsigned long size, unw_ent_size, nentries, nrelas, i;
6539   Elf_Internal_Phdr * seg;
6540   struct hppa_unw_table_entry * tep;
6541   Elf_Internal_Shdr * relsec;
6542   Elf_Internal_Rela * rela;
6543   Elf_Internal_Rela * rp;
6544   unsigned char * table;
6545   unsigned char * tp;
6546   Elf_Internal_Sym * sym;
6547   const char * relname;
6548
6549   /* First, find the starting address of the segment that includes
6550      this section.  */
6551
6552   if (elf_header.e_phnum)
6553     {
6554       if (! get_program_headers (file))
6555         return 0;
6556
6557       for (seg = program_headers;
6558            seg < program_headers + elf_header.e_phnum;
6559            ++seg)
6560         {
6561           if (seg->p_type != PT_LOAD)
6562             continue;
6563
6564           if (sec->sh_addr >= seg->p_vaddr
6565               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6566             {
6567               aux->seg_base = seg->p_vaddr;
6568               break;
6569             }
6570         }
6571     }
6572
6573   /* Second, build the unwind table from the contents of the unwind
6574      section.  */
6575   size = sec->sh_size;
6576   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6577                                       _("unwind table"));
6578   if (!table)
6579     return 0;
6580
6581   unw_ent_size = 16;
6582   nentries = size / unw_ent_size;
6583   size = unw_ent_size * nentries;
6584
6585   tep = aux->table = (struct hppa_unw_table_entry *)
6586       xcmalloc (nentries, sizeof (aux->table[0]));
6587
6588   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6589     {
6590       unsigned int tmp1, tmp2;
6591
6592       tep->start.section = SHN_UNDEF;
6593       tep->end.section   = SHN_UNDEF;
6594
6595       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6596       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6597       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6598       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6599
6600       tep->start.offset += aux->seg_base;
6601       tep->end.offset   += aux->seg_base;
6602
6603       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6604       tep->Millicode = (tmp1 >> 30) & 0x1;
6605       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6606       tep->Region_description = (tmp1 >> 27) & 0x3;
6607       tep->reserved1 = (tmp1 >> 26) & 0x1;
6608       tep->Entry_SR = (tmp1 >> 25) & 0x1;
6609       tep->Entry_FR = (tmp1 >> 21) & 0xf;
6610       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6611       tep->Args_stored = (tmp1 >> 15) & 0x1;
6612       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6613       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6614       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6615       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6616       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6617       tep->Ada_Region = (tmp1 >> 9) & 0x1;
6618       tep->cxx_info = (tmp1 >> 8) & 0x1;
6619       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6620       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6621       tep->reserved2 = (tmp1 >> 5) & 0x1;
6622       tep->Save_SP = (tmp1 >> 4) & 0x1;
6623       tep->Save_RP = (tmp1 >> 3) & 0x1;
6624       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6625       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6626       tep->Cleanup_defined = tmp1 & 0x1;
6627
6628       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6629       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6630       tep->Large_frame = (tmp2 >> 29) & 0x1;
6631       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6632       tep->reserved4 = (tmp2 >> 27) & 0x1;
6633       tep->Total_frame_size = tmp2 & 0x7ffffff;
6634     }
6635   free (table);
6636
6637   /* Third, apply any relocations to the unwind table.  */
6638   for (relsec = section_headers;
6639        relsec < section_headers + elf_header.e_shnum;
6640        ++relsec)
6641     {
6642       if (relsec->sh_type != SHT_RELA
6643           || relsec->sh_info >= elf_header.e_shnum
6644           || section_headers + relsec->sh_info != sec)
6645         continue;
6646
6647       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6648                               & rela, & nrelas))
6649         return 0;
6650
6651       for (rp = rela; rp < rela + nrelas; ++rp)
6652         {
6653           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6654           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6655
6656           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
6657           if (! const_strneq (relname, "R_PARISC_SEGREL"))
6658             {
6659               warn (_("Skipping unexpected relocation type %s\n"), relname);
6660               continue;
6661             }
6662
6663           i = rp->r_offset / unw_ent_size;
6664
6665           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6666             {
6667             case 0:
6668               aux->table[i].start.section = sym->st_shndx;
6669               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
6670               break;
6671             case 1:
6672               aux->table[i].end.section   = sym->st_shndx;
6673               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
6674               break;
6675             default:
6676               break;
6677             }
6678         }
6679
6680       free (rela);
6681     }
6682
6683   aux->table_len = nentries;
6684
6685   return 1;
6686 }
6687
6688 static void
6689 hppa_process_unwind (FILE * file)
6690 {
6691   struct hppa_unw_aux_info aux;
6692   Elf_Internal_Shdr * unwsec = NULL;
6693   Elf_Internal_Shdr * strsec;
6694   Elf_Internal_Shdr * sec;
6695   unsigned long i;
6696
6697   if (string_table == NULL)
6698     return;
6699
6700   memset (& aux, 0, sizeof (aux));
6701
6702   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6703     {
6704       if (sec->sh_type == SHT_SYMTAB
6705           && sec->sh_link < elf_header.e_shnum)
6706         {
6707           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6708
6709           strsec = section_headers + sec->sh_link;
6710           assert (aux.strtab == NULL);
6711           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6712                                           1, strsec->sh_size,
6713                                           _("string table"));
6714           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6715         }
6716       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6717         unwsec = sec;
6718     }
6719
6720   if (!unwsec)
6721     printf (_("\nThere are no unwind sections in this file.\n"));
6722
6723   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6724     {
6725       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6726         {
6727           printf (_("\nUnwind section "));
6728           printf (_("'%s'"), SECTION_NAME (sec));
6729
6730           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6731                   (unsigned long) sec->sh_offset,
6732                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6733
6734           slurp_hppa_unwind_table (file, &aux, sec);
6735           if (aux.table_len > 0)
6736             dump_hppa_unwind (&aux);
6737
6738           if (aux.table)
6739             free ((char *) aux.table);
6740           aux.table = NULL;
6741         }
6742     }
6743
6744   if (aux.symtab)
6745     free (aux.symtab);
6746   if (aux.strtab)
6747     free ((char *) aux.strtab);
6748 }
6749
6750 struct arm_section
6751 {
6752   unsigned char *      data;            /* The unwind data.  */
6753   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
6754   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
6755   unsigned long        nrelas;          /* The number of relocations.  */
6756   unsigned int         rel_type;        /* REL or RELA ?  */
6757   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
6758 };
6759
6760 struct arm_unw_aux_info
6761 {
6762   FILE *              file;             /* The file containing the unwind sections.  */
6763   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
6764   unsigned long       nsyms;            /* Number of symbols.  */
6765   char *              strtab;           /* The file's string table.  */
6766   unsigned long       strtab_size;      /* Size of string table.  */
6767 };
6768
6769 static const char *
6770 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6771                         bfd_vma fn, struct absaddr addr)
6772 {
6773   const char *procname;
6774   bfd_vma sym_offset;
6775
6776   if (addr.section == SHN_UNDEF)
6777     addr.offset = fn;
6778
6779   find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6780                            aux->strtab_size, addr, &procname,
6781                            &sym_offset);
6782
6783   print_vma (fn, PREFIX_HEX);
6784
6785   if (procname)
6786     {
6787       fputs (" <", stdout);
6788       fputs (procname, stdout);
6789
6790       if (sym_offset)
6791         printf ("+0x%lx", (unsigned long) sym_offset);
6792       fputc ('>', stdout);
6793     }
6794
6795   return procname;
6796 }
6797
6798 static void
6799 arm_free_section (struct arm_section *arm_sec)
6800 {
6801   if (arm_sec->data != NULL)
6802     free (arm_sec->data);
6803
6804   if (arm_sec->rela != NULL)
6805     free (arm_sec->rela);
6806 }
6807
6808 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6809       cached section and install SEC instead.
6810    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6811       and return its valued in * WORDP, relocating if necessary.
6812    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6813       relocation's offset in ADDR.
6814    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6815       into the string table of the symbol associated with the reloc.  If no
6816       reloc was applied store -1 there.
6817    5) Return TRUE upon success, FALSE otherwise.  */
6818
6819 static bfd_boolean
6820 get_unwind_section_word (struct arm_unw_aux_info *  aux,
6821                          struct arm_section *       arm_sec,
6822                          Elf_Internal_Shdr *        sec,
6823                          bfd_vma                    word_offset,
6824                          unsigned int *             wordp,
6825                          struct absaddr *           addr,
6826                          bfd_vma *                  sym_name)
6827 {
6828   Elf_Internal_Rela *rp;
6829   Elf_Internal_Sym *sym;
6830   const char * relname;
6831   unsigned int word;
6832   bfd_boolean wrapped;
6833
6834   addr->section = SHN_UNDEF;
6835   addr->offset = 0;
6836
6837   if (sym_name != NULL)
6838     *sym_name = (bfd_vma) -1;
6839
6840   /* If necessary, update the section cache.  */
6841   if (sec != arm_sec->sec)
6842     {
6843       Elf_Internal_Shdr *relsec;
6844
6845       arm_free_section (arm_sec);
6846
6847       arm_sec->sec = sec;
6848       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6849                                 sec->sh_size, _("unwind data"));
6850       arm_sec->rela = NULL;
6851       arm_sec->nrelas = 0;
6852
6853       for (relsec = section_headers;
6854            relsec < section_headers + elf_header.e_shnum;
6855            ++relsec)
6856         {
6857           if (relsec->sh_info >= elf_header.e_shnum
6858               || section_headers + relsec->sh_info != sec
6859               /* PR 15745: Check the section type as well.  */
6860               || (relsec->sh_type != SHT_REL
6861                   && relsec->sh_type != SHT_RELA))
6862             continue;
6863
6864           arm_sec->rel_type = relsec->sh_type;
6865           if (relsec->sh_type == SHT_REL)
6866             {
6867               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6868                                      relsec->sh_size,
6869                                      & arm_sec->rela, & arm_sec->nrelas))
6870                 return FALSE;
6871             }
6872           else /* relsec->sh_type == SHT_RELA */
6873             {
6874               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6875                                       relsec->sh_size,
6876                                       & arm_sec->rela, & arm_sec->nrelas))
6877                 return FALSE;
6878             }
6879           break;
6880         }
6881
6882       arm_sec->next_rela = arm_sec->rela;
6883     }
6884
6885   /* If there is no unwind data we can do nothing.  */
6886   if (arm_sec->data == NULL)
6887     return FALSE;
6888
6889   /* Get the word at the required offset.  */
6890   word = byte_get (arm_sec->data + word_offset, 4);
6891
6892   /* Look through the relocs to find the one that applies to the provided offset.  */
6893   wrapped = FALSE;
6894   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6895     {
6896       bfd_vma prelval, offset;
6897
6898       if (rp->r_offset > word_offset && !wrapped)
6899         {
6900           rp = arm_sec->rela;
6901           wrapped = TRUE;
6902         }
6903       if (rp->r_offset > word_offset)
6904         break;
6905
6906       if (rp->r_offset & 3)
6907         {
6908           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6909                 (unsigned long) rp->r_offset);
6910           continue;
6911         }
6912
6913       if (rp->r_offset < word_offset)
6914         continue;
6915
6916       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6917
6918       if (arm_sec->rel_type == SHT_REL)
6919         {
6920           offset = word & 0x7fffffff;
6921           if (offset & 0x40000000)
6922             offset |= ~ (bfd_vma) 0x7fffffff;
6923         }
6924       else if (arm_sec->rel_type == SHT_RELA)
6925         offset = rp->r_addend;
6926       else
6927         abort ();
6928
6929       offset += sym->st_value;
6930       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6931
6932       /* Check that we are processing the expected reloc type.  */
6933       if (elf_header.e_machine == EM_ARM)
6934         {
6935           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6936
6937           if (streq (relname, "R_ARM_NONE"))
6938               continue;
6939
6940           if (! streq (relname, "R_ARM_PREL31"))
6941             {
6942               warn (_("Skipping unexpected relocation type %s\n"), relname);
6943               continue;
6944             }
6945         }
6946       else if (elf_header.e_machine == EM_TI_C6000)
6947         {
6948           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6949
6950           if (streq (relname, "R_C6000_NONE"))
6951             continue;
6952
6953           if (! streq (relname, "R_C6000_PREL31"))
6954             {
6955               warn (_("Skipping unexpected relocation type %s\n"), relname);
6956               continue;
6957             }
6958
6959           prelval >>= 1;
6960         }
6961       else
6962         /* This function currently only supports ARM and TI unwinders.  */
6963         abort ();
6964
6965       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6966       addr->section = sym->st_shndx;
6967       addr->offset = offset;
6968       if (sym_name)
6969         * sym_name = sym->st_name;
6970       break;
6971     }
6972
6973   *wordp = word;
6974   arm_sec->next_rela = rp;
6975
6976   return TRUE;
6977 }
6978
6979 static const char *tic6x_unwind_regnames[16] =
6980 {
6981   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6982   "A14", "A13", "A12", "A11", "A10",
6983   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6984 };
6985
6986 static void
6987 decode_tic6x_unwind_regmask (unsigned int mask)
6988 {
6989   int i;
6990
6991   for (i = 12; mask; mask >>= 1, i--)
6992     {
6993       if (mask & 1)
6994         {
6995           fputs (tic6x_unwind_regnames[i], stdout);
6996           if (mask > 1)
6997             fputs (", ", stdout);
6998         }
6999     }
7000 }
7001
7002 #define ADVANCE                                                 \
7003   if (remaining == 0 && more_words)                             \
7004     {                                                           \
7005       data_offset += 4;                                         \
7006       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
7007                                      data_offset, & word, & addr, NULL))        \
7008         return;                                                 \
7009       remaining = 4;                                            \
7010       more_words--;                                             \
7011     }                                                           \
7012
7013 #define GET_OP(OP)                      \
7014   ADVANCE;                              \
7015   if (remaining)                        \
7016     {                                   \
7017       remaining--;                      \
7018       (OP) = word >> 24;                \
7019       word <<= 8;                       \
7020     }                                   \
7021   else                                  \
7022     {                                   \
7023       printf (_("[Truncated opcode]\n"));       \
7024       return;                           \
7025     }                                   \
7026   printf ("0x%02x ", OP)
7027
7028 static void
7029 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
7030                             unsigned int word, unsigned int remaining,
7031                             unsigned int more_words,
7032                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7033                             struct arm_section *data_arm_sec)
7034 {
7035   struct absaddr addr;
7036
7037   /* Decode the unwinding instructions.  */
7038   while (1)
7039     {
7040       unsigned int op, op2;
7041
7042       ADVANCE;
7043       if (remaining == 0)
7044         break;
7045       remaining--;
7046       op = word >> 24;
7047       word <<= 8;
7048
7049       printf ("  0x%02x ", op);
7050
7051       if ((op & 0xc0) == 0x00)
7052         {
7053           int offset = ((op & 0x3f) << 2) + 4;
7054
7055           printf ("     vsp = vsp + %d", offset);
7056         }
7057       else if ((op & 0xc0) == 0x40)
7058         {
7059           int offset = ((op & 0x3f) << 2) + 4;
7060
7061           printf ("     vsp = vsp - %d", offset);
7062         }
7063       else if ((op & 0xf0) == 0x80)
7064         {
7065           GET_OP (op2);
7066           if (op == 0x80 && op2 == 0)
7067             printf (_("Refuse to unwind"));
7068           else
7069             {
7070               unsigned int mask = ((op & 0x0f) << 8) | op2;
7071               int first = 1;
7072               int i;
7073
7074               printf ("pop {");
7075               for (i = 0; i < 12; i++)
7076                 if (mask & (1 << i))
7077                   {
7078                     if (first)
7079                       first = 0;
7080                     else
7081                       printf (", ");
7082                     printf ("r%d", 4 + i);
7083                   }
7084               printf ("}");
7085             }
7086         }
7087       else if ((op & 0xf0) == 0x90)
7088         {
7089           if (op == 0x9d || op == 0x9f)
7090             printf (_("     [Reserved]"));
7091           else
7092             printf ("     vsp = r%d", op & 0x0f);
7093         }
7094       else if ((op & 0xf0) == 0xa0)
7095         {
7096           int end = 4 + (op & 0x07);
7097           int first = 1;
7098           int i;
7099
7100           printf ("     pop {");
7101           for (i = 4; i <= end; i++)
7102             {
7103               if (first)
7104                 first = 0;
7105               else
7106                 printf (", ");
7107               printf ("r%d", i);
7108             }
7109           if (op & 0x08)
7110             {
7111               if (!first)
7112                 printf (", ");
7113               printf ("r14");
7114             }
7115           printf ("}");
7116         }
7117       else if (op == 0xb0)
7118         printf (_("     finish"));
7119       else if (op == 0xb1)
7120         {
7121           GET_OP (op2);
7122           if (op2 == 0 || (op2 & 0xf0) != 0)
7123             printf (_("[Spare]"));
7124           else
7125             {
7126               unsigned int mask = op2 & 0x0f;
7127               int first = 1;
7128               int i;
7129
7130               printf ("pop {");
7131               for (i = 0; i < 12; i++)
7132                 if (mask & (1 << i))
7133                   {
7134                     if (first)
7135                       first = 0;
7136                     else
7137                       printf (", ");
7138                     printf ("r%d", i);
7139                   }
7140               printf ("}");
7141             }
7142         }
7143       else if (op == 0xb2)
7144         {
7145           unsigned char buf[9];
7146           unsigned int i, len;
7147           unsigned long offset;
7148
7149           for (i = 0; i < sizeof (buf); i++)
7150             {
7151               GET_OP (buf[i]);
7152               if ((buf[i] & 0x80) == 0)
7153                 break;
7154             }
7155           assert (i < sizeof (buf));
7156           offset = read_uleb128 (buf, &len, buf + i + 1);
7157           assert (len == i + 1);
7158           offset = offset * 4 + 0x204;
7159           printf ("vsp = vsp + %ld", offset);
7160         }
7161       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
7162         {
7163           unsigned int first, last;
7164
7165           GET_OP (op2);
7166           first = op2 >> 4;
7167           last = op2 & 0x0f;
7168           if (op == 0xc8)
7169             first = first + 16;
7170           printf ("pop {D%d", first);
7171           if (last)
7172             printf ("-D%d", first + last);
7173           printf ("}");
7174         }
7175       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7176         {
7177           unsigned int count = op & 0x07;
7178
7179           printf ("pop {D8");
7180           if (count)
7181             printf ("-D%d", 8 + count);
7182           printf ("}");
7183         }
7184       else if (op >= 0xc0 && op <= 0xc5)
7185         {
7186           unsigned int count = op & 0x07;
7187
7188           printf ("     pop {wR10");
7189           if (count)
7190             printf ("-wR%d", 10 + count);
7191           printf ("}");
7192         }
7193       else if (op == 0xc6)
7194         {
7195           unsigned int first, last;
7196
7197           GET_OP (op2);
7198           first = op2 >> 4;
7199           last = op2 & 0x0f;
7200           printf ("pop {wR%d", first);
7201           if (last)
7202             printf ("-wR%d", first + last);
7203           printf ("}");
7204         }
7205       else if (op == 0xc7)
7206         {
7207           GET_OP (op2);
7208           if (op2 == 0 || (op2 & 0xf0) != 0)
7209             printf (_("[Spare]"));
7210           else
7211             {
7212               unsigned int mask = op2 & 0x0f;
7213               int first = 1;
7214               int i;
7215
7216               printf ("pop {");
7217               for (i = 0; i < 4; i++)
7218                 if (mask & (1 << i))
7219                   {
7220                     if (first)
7221                       first = 0;
7222                     else
7223                       printf (", ");
7224                     printf ("wCGR%d", i);
7225                   }
7226               printf ("}");
7227             }
7228         }
7229       else
7230         printf (_("     [unsupported opcode]"));
7231       printf ("\n");
7232     }
7233 }
7234
7235 static void
7236 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7237                             unsigned int word, unsigned int remaining,
7238                             unsigned int more_words,
7239                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7240                             struct arm_section *data_arm_sec)
7241 {
7242   struct absaddr addr;
7243
7244   /* Decode the unwinding instructions.  */
7245   while (1)
7246     {
7247       unsigned int op, op2;
7248
7249       ADVANCE;
7250       if (remaining == 0)
7251         break;
7252       remaining--;
7253       op = word >> 24;
7254       word <<= 8;
7255
7256       printf ("  0x%02x ", op);
7257
7258       if ((op & 0xc0) == 0x00)
7259         {
7260           int offset = ((op & 0x3f) << 3) + 8;
7261           printf ("     sp = sp + %d", offset);
7262         }
7263       else if ((op & 0xc0) == 0x80)
7264         {
7265           GET_OP (op2);
7266           if (op == 0x80 && op2 == 0)
7267             printf (_("Refuse to unwind"));
7268           else
7269             {
7270               unsigned int mask = ((op & 0x1f) << 8) | op2;
7271               if (op & 0x20)
7272                 printf ("pop compact {");
7273               else
7274                 printf ("pop {");
7275
7276               decode_tic6x_unwind_regmask (mask);
7277               printf("}");
7278             }
7279         }
7280       else if ((op & 0xf0) == 0xc0)
7281         {
7282           unsigned int reg;
7283           unsigned int nregs;
7284           unsigned int i;
7285           const char *name;
7286           struct
7287           {
7288               unsigned int offset;
7289               unsigned int reg;
7290           } regpos[16];
7291
7292           /* Scan entire instruction first so that GET_OP output is not
7293              interleaved with disassembly.  */
7294           nregs = 0;
7295           for (i = 0; nregs < (op & 0xf); i++)
7296             {
7297               GET_OP (op2);
7298               reg = op2 >> 4;
7299               if (reg != 0xf)
7300                 {
7301                   regpos[nregs].offset = i * 2;
7302                   regpos[nregs].reg = reg;
7303                   nregs++;
7304                 }
7305
7306               reg = op2 & 0xf;
7307               if (reg != 0xf)
7308                 {
7309                   regpos[nregs].offset = i * 2 + 1;
7310                   regpos[nregs].reg = reg;
7311                   nregs++;
7312                 }
7313             }
7314
7315           printf (_("pop frame {"));
7316           reg = nregs - 1;
7317           for (i = i * 2; i > 0; i--)
7318             {
7319               if (regpos[reg].offset == i - 1)
7320                 {
7321                   name = tic6x_unwind_regnames[regpos[reg].reg];
7322                   if (reg > 0)
7323                     reg--;
7324                 }
7325               else
7326                 name = _("[pad]");
7327
7328               fputs (name, stdout);
7329               if (i > 1)
7330                 printf (", ");
7331             }
7332
7333           printf ("}");
7334         }
7335       else if (op == 0xd0)
7336         printf ("     MOV FP, SP");
7337       else if (op == 0xd1)
7338         printf ("     __c6xabi_pop_rts");
7339       else if (op == 0xd2)
7340         {
7341           unsigned char buf[9];
7342           unsigned int i, len;
7343           unsigned long offset;
7344
7345           for (i = 0; i < sizeof (buf); i++)
7346             {
7347               GET_OP (buf[i]);
7348               if ((buf[i] & 0x80) == 0)
7349                 break;
7350             }
7351           assert (i < sizeof (buf));
7352           offset = read_uleb128 (buf, &len, buf + i + 1);
7353           assert (len == i + 1);
7354           offset = offset * 8 + 0x408;
7355           printf (_("sp = sp + %ld"), offset);
7356         }
7357       else if ((op & 0xf0) == 0xe0)
7358         {
7359           if ((op & 0x0f) == 7)
7360             printf ("     RETURN");
7361           else
7362             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7363         }
7364       else
7365         {
7366           printf (_("     [unsupported opcode]"));
7367         }
7368       putchar ('\n');
7369     }
7370 }
7371
7372 static bfd_vma
7373 arm_expand_prel31 (bfd_vma word, bfd_vma where)
7374 {
7375   bfd_vma offset;
7376
7377   offset = word & 0x7fffffff;
7378   if (offset & 0x40000000)
7379     offset |= ~ (bfd_vma) 0x7fffffff;
7380
7381   if (elf_header.e_machine == EM_TI_C6000)
7382     offset <<= 1;
7383
7384   return offset + where;
7385 }
7386
7387 static void
7388 decode_arm_unwind (struct arm_unw_aux_info *  aux,
7389                    unsigned int               word,
7390                    unsigned int               remaining,
7391                    bfd_vma                    data_offset,
7392                    Elf_Internal_Shdr *        data_sec,
7393                    struct arm_section *       data_arm_sec)
7394 {
7395   int per_index;
7396   unsigned int more_words = 0;
7397   struct absaddr addr;
7398   bfd_vma sym_name = (bfd_vma) -1;
7399
7400   if (remaining == 0)
7401     {
7402       /* Fetch the first word.
7403          Note - when decoding an object file the address extracted
7404          here will always be 0.  So we also pass in the sym_name
7405          parameter so that we can find the symbol associated with
7406          the personality routine.  */
7407       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7408                                      & word, & addr, & sym_name))
7409         return;
7410
7411       remaining = 4;
7412     }
7413
7414   if ((word & 0x80000000) == 0)
7415     {
7416       /* Expand prel31 for personality routine.  */
7417       bfd_vma fn;
7418       const char *procname;
7419
7420       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
7421       printf (_("  Personality routine: "));
7422       if (fn == 0
7423           && addr.section == SHN_UNDEF && addr.offset == 0
7424           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7425         {
7426           procname = aux->strtab + sym_name;
7427           print_vma (fn, PREFIX_HEX);
7428           if (procname)
7429             {
7430               fputs (" <", stdout);
7431               fputs (procname, stdout);
7432               fputc ('>', stdout);
7433             }
7434         }
7435       else
7436         procname = arm_print_vma_and_name (aux, fn, addr);
7437       fputc ('\n', stdout);
7438
7439       /* The GCC personality routines use the standard compact
7440          encoding, starting with one byte giving the number of
7441          words.  */
7442       if (procname != NULL
7443           && (const_strneq (procname, "__gcc_personality_v0")
7444               || const_strneq (procname, "__gxx_personality_v0")
7445               || const_strneq (procname, "__gcj_personality_v0")
7446               || const_strneq (procname, "__gnu_objc_personality_v0")))
7447         {
7448           remaining = 0;
7449           more_words = 1;
7450           ADVANCE;
7451           if (!remaining)
7452             {
7453               printf (_("  [Truncated data]\n"));
7454               return;
7455             }
7456           more_words = word >> 24;
7457           word <<= 8;
7458           remaining--;
7459           per_index = -1;
7460         }
7461       else
7462         return;
7463     }
7464   else
7465     {
7466       /* ARM EHABI Section 6.3:
7467
7468          An exception-handling table entry for the compact model looks like:
7469
7470            31 30-28 27-24 23-0
7471            -- ----- ----- ----
7472             1   0   index Data for personalityRoutine[index]    */
7473
7474       if (elf_header.e_machine == EM_ARM
7475           && (word & 0x70000000))
7476         warn (_("Corrupt ARM compact model table entry: %x \n"), word);
7477
7478       per_index = (word >> 24) & 0x7f;
7479       printf (_("  Compact model index: %d\n"), per_index);
7480       if (per_index == 0)
7481         {
7482           more_words = 0;
7483           word <<= 8;
7484           remaining--;
7485         }
7486       else if (per_index < 3)
7487         {
7488           more_words = (word >> 16) & 0xff;
7489           word <<= 16;
7490           remaining -= 2;
7491         }
7492     }
7493
7494   switch (elf_header.e_machine)
7495     {
7496     case EM_ARM:
7497       if (per_index < 3)
7498         {
7499           decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7500                                       data_offset, data_sec, data_arm_sec);
7501         }
7502       else
7503         {
7504           warn (_("Unknown ARM compact model index encountered\n"));
7505           printf (_("  [reserved]\n"));
7506         }
7507       break;
7508
7509     case EM_TI_C6000:
7510       if (per_index < 3)
7511         {
7512           decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
7513                                         data_offset, data_sec, data_arm_sec);
7514         }
7515       else if (per_index < 5)
7516         {
7517           if (((word >> 17) & 0x7f) == 0x7f)
7518             printf (_("  Restore stack from frame pointer\n"));
7519           else
7520             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
7521           printf (_("  Registers restored: "));
7522           if (per_index == 4)
7523             printf (" (compact) ");
7524           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7525           putchar ('\n');
7526           printf (_("  Return register: %s\n"),
7527                   tic6x_unwind_regnames[word & 0xf]);
7528         }
7529       else
7530         printf (_("  [reserved (%d)]\n"), per_index);
7531       break;
7532
7533     default:
7534       error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7535              elf_header.e_machine);
7536     }
7537
7538   /* Decode the descriptors.  Not implemented.  */
7539 }
7540
7541 static void
7542 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7543 {
7544   struct arm_section exidx_arm_sec, extab_arm_sec;
7545   unsigned int i, exidx_len;
7546
7547   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7548   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7549   exidx_len = exidx_sec->sh_size / 8;
7550
7551   for (i = 0; i < exidx_len; i++)
7552     {
7553       unsigned int exidx_fn, exidx_entry;
7554       struct absaddr fn_addr, entry_addr;
7555       bfd_vma fn;
7556
7557       fputc ('\n', stdout);
7558
7559       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7560                                      8 * i, & exidx_fn, & fn_addr, NULL)
7561           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7562                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
7563         {
7564           arm_free_section (& exidx_arm_sec);
7565           arm_free_section (& extab_arm_sec);
7566           return;
7567         }
7568
7569       /* ARM EHABI, Section 5:
7570          An index table entry consists of 2 words.
7571          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
7572       if (exidx_fn & 0x80000000)
7573         warn (_("corrupt index table entry: %x\n"), exidx_fn);
7574
7575       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
7576
7577       arm_print_vma_and_name (aux, fn, fn_addr);
7578       fputs (": ", stdout);
7579
7580       if (exidx_entry == 1)
7581         {
7582           print_vma (exidx_entry, PREFIX_HEX);
7583           fputs (" [cantunwind]\n", stdout);
7584         }
7585       else if (exidx_entry & 0x80000000)
7586         {
7587           print_vma (exidx_entry, PREFIX_HEX);
7588           fputc ('\n', stdout);
7589           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7590         }
7591       else
7592         {
7593           bfd_vma table, table_offset = 0;
7594           Elf_Internal_Shdr *table_sec;
7595
7596           fputs ("@", stdout);
7597           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
7598           print_vma (table, PREFIX_HEX);
7599           printf ("\n");
7600
7601           /* Locate the matching .ARM.extab.  */
7602           if (entry_addr.section != SHN_UNDEF
7603               && entry_addr.section < elf_header.e_shnum)
7604             {
7605               table_sec = section_headers + entry_addr.section;
7606               table_offset = entry_addr.offset;
7607             }
7608           else
7609             {
7610               table_sec = find_section_by_address (table);
7611               if (table_sec != NULL)
7612                 table_offset = table - table_sec->sh_addr;
7613             }
7614           if (table_sec == NULL)
7615             {
7616               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7617                     (unsigned long) table);
7618               continue;
7619             }
7620           decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7621                              &extab_arm_sec);
7622         }
7623     }
7624
7625   printf ("\n");
7626
7627   arm_free_section (&exidx_arm_sec);
7628   arm_free_section (&extab_arm_sec);
7629 }
7630
7631 /* Used for both ARM and C6X unwinding tables.  */
7632
7633 static void
7634 arm_process_unwind (FILE *file)
7635 {
7636   struct arm_unw_aux_info aux;
7637   Elf_Internal_Shdr *unwsec = NULL;
7638   Elf_Internal_Shdr *strsec;
7639   Elf_Internal_Shdr *sec;
7640   unsigned long i;
7641   unsigned int sec_type;
7642
7643   switch (elf_header.e_machine)
7644     {
7645     case EM_ARM:
7646       sec_type = SHT_ARM_EXIDX;
7647       break;
7648
7649     case EM_TI_C6000:
7650       sec_type = SHT_C6000_UNWIND;
7651       break;
7652
7653     default:
7654       error (_("Unsupported architecture type %d encountered when processing unwind table"),
7655              elf_header.e_machine);
7656       return;
7657     }
7658
7659   if (string_table == NULL)
7660     return;
7661
7662   memset (& aux, 0, sizeof (aux));
7663   aux.file = file;
7664
7665   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7666     {
7667       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7668         {
7669           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7670
7671           strsec = section_headers + sec->sh_link;
7672           assert (aux.strtab == NULL);
7673           aux.strtab = get_data (NULL, file, strsec->sh_offset,
7674                                  1, strsec->sh_size, _("string table"));
7675           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7676         }
7677       else if (sec->sh_type == sec_type)
7678         unwsec = sec;
7679     }
7680
7681   if (unwsec == NULL)
7682     printf (_("\nThere are no unwind sections in this file.\n"));
7683   else
7684     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7685       {
7686         if (sec->sh_type == sec_type)
7687           {
7688             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7689                     SECTION_NAME (sec),
7690                     (unsigned long) sec->sh_offset,
7691                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7692
7693             dump_arm_unwind (&aux, sec);
7694           }
7695       }
7696
7697   if (aux.symtab)
7698     free (aux.symtab);
7699   if (aux.strtab)
7700     free ((char *) aux.strtab);
7701 }
7702
7703 static void
7704 process_unwind (FILE * file)
7705 {
7706   struct unwind_handler
7707   {
7708     int machtype;
7709     void (* handler)(FILE *);
7710   } handlers[] =
7711   {
7712     { EM_ARM, arm_process_unwind },
7713     { EM_IA_64, ia64_process_unwind },
7714     { EM_PARISC, hppa_process_unwind },
7715     { EM_TI_C6000, arm_process_unwind },
7716     { 0, 0 }
7717   };
7718   int i;
7719
7720   if (!do_unwind)
7721     return;
7722
7723   for (i = 0; handlers[i].handler != NULL; i++)
7724     if (elf_header.e_machine == handlers[i].machtype)
7725       {
7726         handlers[i].handler (file);
7727         return;
7728       }
7729
7730   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7731           get_machine_name (elf_header.e_machine));
7732 }
7733
7734 static void
7735 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
7736 {
7737   switch (entry->d_tag)
7738     {
7739     case DT_MIPS_FLAGS:
7740       if (entry->d_un.d_val == 0)
7741         printf (_("NONE"));
7742       else
7743         {
7744           static const char * opts[] =
7745           {
7746             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7747             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7748             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7749             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7750             "RLD_ORDER_SAFE"
7751           };
7752           unsigned int cnt;
7753           int first = 1;
7754
7755           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
7756             if (entry->d_un.d_val & (1 << cnt))
7757               {
7758                 printf ("%s%s", first ? "" : " ", opts[cnt]);
7759                 first = 0;
7760               }
7761         }
7762       break;
7763
7764     case DT_MIPS_IVERSION:
7765       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7766         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
7767       else
7768         printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
7769       break;
7770
7771     case DT_MIPS_TIME_STAMP:
7772       {
7773         char timebuf[20];
7774         struct tm * tmp;
7775
7776         time_t atime = entry->d_un.d_val;
7777         tmp = gmtime (&atime);
7778         snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7779                   tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7780                   tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7781         printf (_("Time Stamp: %s"), timebuf);
7782       }
7783       break;
7784
7785     case DT_MIPS_RLD_VERSION:
7786     case DT_MIPS_LOCAL_GOTNO:
7787     case DT_MIPS_CONFLICTNO:
7788     case DT_MIPS_LIBLISTNO:
7789     case DT_MIPS_SYMTABNO:
7790     case DT_MIPS_UNREFEXTNO:
7791     case DT_MIPS_HIPAGENO:
7792     case DT_MIPS_DELTA_CLASS_NO:
7793     case DT_MIPS_DELTA_INSTANCE_NO:
7794     case DT_MIPS_DELTA_RELOC_NO:
7795     case DT_MIPS_DELTA_SYM_NO:
7796     case DT_MIPS_DELTA_CLASSSYM_NO:
7797     case DT_MIPS_COMPACT_SIZE:
7798       print_vma (entry->d_un.d_ptr, DEC);
7799       break;
7800
7801     default:
7802       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7803     }
7804     putchar ('\n');
7805 }
7806
7807 static void
7808 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
7809 {
7810   switch (entry->d_tag)
7811     {
7812     case DT_HP_DLD_FLAGS:
7813       {
7814         static struct
7815         {
7816           long int bit;
7817           const char * str;
7818         }
7819         flags[] =
7820         {
7821           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7822           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7823           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7824           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7825           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7826           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7827           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7828           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7829           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7830           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
7831           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7832           { DT_HP_GST, "HP_GST" },
7833           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7834           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7835           { DT_HP_NODELETE, "HP_NODELETE" },
7836           { DT_HP_GROUP, "HP_GROUP" },
7837           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
7838         };
7839         int first = 1;
7840         size_t cnt;
7841         bfd_vma val = entry->d_un.d_val;
7842
7843         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
7844           if (val & flags[cnt].bit)
7845             {
7846               if (! first)
7847                 putchar (' ');
7848               fputs (flags[cnt].str, stdout);
7849               first = 0;
7850               val ^= flags[cnt].bit;
7851             }
7852
7853         if (val != 0 || first)
7854           {
7855             if (! first)
7856               putchar (' ');
7857             print_vma (val, HEX);
7858           }
7859       }
7860       break;
7861
7862     default:
7863       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7864       break;
7865     }
7866   putchar ('\n');
7867 }
7868
7869 #ifdef BFD64
7870
7871 /* VMS vs Unix time offset and factor.  */
7872
7873 #define VMS_EPOCH_OFFSET 35067168000000000LL
7874 #define VMS_GRANULARITY_FACTOR 10000000
7875
7876 /* Display a VMS time in a human readable format.  */
7877
7878 static void
7879 print_vms_time (bfd_int64_t vmstime)
7880 {
7881   struct tm *tm;
7882   time_t unxtime;
7883
7884   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7885   tm = gmtime (&unxtime);
7886   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7887           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7888           tm->tm_hour, tm->tm_min, tm->tm_sec);
7889 }
7890 #endif /* BFD64 */
7891
7892 static void
7893 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
7894 {
7895   switch (entry->d_tag)
7896     {
7897     case DT_IA_64_PLT_RESERVE:
7898       /* First 3 slots reserved.  */
7899       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7900       printf (" -- ");
7901       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
7902       break;
7903
7904     case DT_IA_64_VMS_LINKTIME:
7905 #ifdef BFD64
7906       print_vms_time (entry->d_un.d_val);
7907 #endif
7908       break;
7909
7910     case DT_IA_64_VMS_LNKFLAGS:
7911       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7912       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7913         printf (" CALL_DEBUG");
7914       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7915         printf (" NOP0BUFS");
7916       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7917         printf (" P0IMAGE");
7918       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7919         printf (" MKTHREADS");
7920       if (entry->d_un.d_val & VMS_LF_UPCALLS)
7921         printf (" UPCALLS");
7922       if (entry->d_un.d_val & VMS_LF_IMGSTA)
7923         printf (" IMGSTA");
7924       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7925         printf (" INITIALIZE");
7926       if (entry->d_un.d_val & VMS_LF_MAIN)
7927         printf (" MAIN");
7928       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7929         printf (" EXE_INIT");
7930       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7931         printf (" TBK_IN_IMG");
7932       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7933         printf (" DBG_IN_IMG");
7934       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7935         printf (" TBK_IN_DSF");
7936       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7937         printf (" DBG_IN_DSF");
7938       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7939         printf (" SIGNATURES");
7940       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7941         printf (" REL_SEG_OFF");
7942       break;
7943
7944     default:
7945       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7946       break;
7947     }
7948   putchar ('\n');
7949 }
7950
7951 static int
7952 get_32bit_dynamic_section (FILE * file)
7953 {
7954   Elf32_External_Dyn * edyn;
7955   Elf32_External_Dyn * ext;
7956   Elf_Internal_Dyn * entry;
7957
7958   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7959                                           dynamic_size, _("dynamic section"));
7960   if (!edyn)
7961     return 0;
7962
7963 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7964    might not have the luxury of section headers.  Look for the DT_NULL
7965    terminator to determine the number of entries.  */
7966   for (ext = edyn, dynamic_nent = 0;
7967        (char *) ext < (char *) edyn + dynamic_size;
7968        ext++)
7969     {
7970       dynamic_nent++;
7971       if (BYTE_GET (ext->d_tag) == DT_NULL)
7972         break;
7973     }
7974
7975   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7976                                                   sizeof (* entry));
7977   if (dynamic_section == NULL)
7978     {
7979       error (_("Out of memory\n"));
7980       free (edyn);
7981       return 0;
7982     }
7983
7984   for (ext = edyn, entry = dynamic_section;
7985        entry < dynamic_section + dynamic_nent;
7986        ext++, entry++)
7987     {
7988       entry->d_tag      = BYTE_GET (ext->d_tag);
7989       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7990     }
7991
7992   free (edyn);
7993
7994   return 1;
7995 }
7996
7997 static int
7998 get_64bit_dynamic_section (FILE * file)
7999 {
8000   Elf64_External_Dyn * edyn;
8001   Elf64_External_Dyn * ext;
8002   Elf_Internal_Dyn * entry;
8003
8004   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8005                                           dynamic_size, _("dynamic section"));
8006   if (!edyn)
8007     return 0;
8008
8009 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8010    might not have the luxury of section headers.  Look for the DT_NULL
8011    terminator to determine the number of entries.  */
8012   for (ext = edyn, dynamic_nent = 0;
8013        (char *) ext < (char *) edyn + dynamic_size;
8014        ext++)
8015     {
8016       dynamic_nent++;
8017       if (BYTE_GET (ext->d_tag) == DT_NULL)
8018         break;
8019     }
8020
8021   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8022                                                   sizeof (* entry));
8023   if (dynamic_section == NULL)
8024     {
8025       error (_("Out of memory\n"));
8026       free (edyn);
8027       return 0;
8028     }
8029
8030   for (ext = edyn, entry = dynamic_section;
8031        entry < dynamic_section + dynamic_nent;
8032        ext++, entry++)
8033     {
8034       entry->d_tag      = BYTE_GET (ext->d_tag);
8035       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8036     }
8037
8038   free (edyn);
8039
8040   return 1;
8041 }
8042
8043 static void
8044 print_dynamic_flags (bfd_vma flags)
8045 {
8046   int first = 1;
8047
8048   while (flags)
8049     {
8050       bfd_vma flag;
8051
8052       flag = flags & - flags;
8053       flags &= ~ flag;
8054
8055       if (first)
8056         first = 0;
8057       else
8058         putc (' ', stdout);
8059
8060       switch (flag)
8061         {
8062         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
8063         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
8064         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
8065         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
8066         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
8067         default:                fputs (_("unknown"), stdout); break;
8068         }
8069     }
8070   puts ("");
8071 }
8072
8073 /* Parse and display the contents of the dynamic section.  */
8074
8075 static int
8076 process_dynamic_section (FILE * file)
8077 {
8078   Elf_Internal_Dyn * entry;
8079
8080   if (dynamic_size == 0)
8081     {
8082       if (do_dynamic)
8083         printf (_("\nThere is no dynamic section in this file.\n"));
8084
8085       return 1;
8086     }
8087
8088   if (is_32bit_elf)
8089     {
8090       if (! get_32bit_dynamic_section (file))
8091         return 0;
8092     }
8093   else if (! get_64bit_dynamic_section (file))
8094     return 0;
8095
8096   /* Find the appropriate symbol table.  */
8097   if (dynamic_symbols == NULL)
8098     {
8099       for (entry = dynamic_section;
8100            entry < dynamic_section + dynamic_nent;
8101            ++entry)
8102         {
8103           Elf_Internal_Shdr section;
8104
8105           if (entry->d_tag != DT_SYMTAB)
8106             continue;
8107
8108           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8109
8110           /* Since we do not know how big the symbol table is,
8111              we default to reading in the entire file (!) and
8112              processing that.  This is overkill, I know, but it
8113              should work.  */
8114           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8115
8116           if (archive_file_offset != 0)
8117             section.sh_size = archive_file_size - section.sh_offset;
8118           else
8119             {
8120               if (fseek (file, 0, SEEK_END))
8121                 error (_("Unable to seek to end of file!\n"));
8122
8123               section.sh_size = ftell (file) - section.sh_offset;
8124             }
8125
8126           if (is_32bit_elf)
8127             section.sh_entsize = sizeof (Elf32_External_Sym);
8128           else
8129             section.sh_entsize = sizeof (Elf64_External_Sym);
8130
8131           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
8132           if (num_dynamic_syms < 1)
8133             {
8134               error (_("Unable to determine the number of symbols to load\n"));
8135               continue;
8136             }
8137         }
8138     }
8139
8140   /* Similarly find a string table.  */
8141   if (dynamic_strings == NULL)
8142     {
8143       for (entry = dynamic_section;
8144            entry < dynamic_section + dynamic_nent;
8145            ++entry)
8146         {
8147           unsigned long offset;
8148           long str_tab_len;
8149
8150           if (entry->d_tag != DT_STRTAB)
8151             continue;
8152
8153           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8154
8155           /* Since we do not know how big the string table is,
8156              we default to reading in the entire file (!) and
8157              processing that.  This is overkill, I know, but it
8158              should work.  */
8159
8160           offset = offset_from_vma (file, entry->d_un.d_val, 0);
8161
8162           if (archive_file_offset != 0)
8163             str_tab_len = archive_file_size - offset;
8164           else
8165             {
8166               if (fseek (file, 0, SEEK_END))
8167                 error (_("Unable to seek to end of file\n"));
8168               str_tab_len = ftell (file) - offset;
8169             }
8170
8171           if (str_tab_len < 1)
8172             {
8173               error
8174                 (_("Unable to determine the length of the dynamic string table\n"));
8175               continue;
8176             }
8177
8178           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8179                                                str_tab_len,
8180                                                _("dynamic string table"));
8181           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
8182           break;
8183         }
8184     }
8185
8186   /* And find the syminfo section if available.  */
8187   if (dynamic_syminfo == NULL)
8188     {
8189       unsigned long syminsz = 0;
8190
8191       for (entry = dynamic_section;
8192            entry < dynamic_section + dynamic_nent;
8193            ++entry)
8194         {
8195           if (entry->d_tag == DT_SYMINENT)
8196             {
8197               /* Note: these braces are necessary to avoid a syntax
8198                  error from the SunOS4 C compiler.  */
8199               assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
8200             }
8201           else if (entry->d_tag == DT_SYMINSZ)
8202             syminsz = entry->d_un.d_val;
8203           else if (entry->d_tag == DT_SYMINFO)
8204             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8205                                                       syminsz);
8206         }
8207
8208       if (dynamic_syminfo_offset != 0 && syminsz != 0)
8209         {
8210           Elf_External_Syminfo * extsyminfo;
8211           Elf_External_Syminfo * extsym;
8212           Elf_Internal_Syminfo * syminfo;
8213
8214           /* There is a syminfo section.  Read the data.  */
8215           extsyminfo = (Elf_External_Syminfo *)
8216               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8217                         _("symbol information"));
8218           if (!extsyminfo)
8219             return 0;
8220
8221           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
8222           if (dynamic_syminfo == NULL)
8223             {
8224               error (_("Out of memory\n"));
8225               return 0;
8226             }
8227
8228           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
8229           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8230                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8231                ++syminfo, ++extsym)
8232             {
8233               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8234               syminfo->si_flags = BYTE_GET (extsym->si_flags);
8235             }
8236
8237           free (extsyminfo);
8238         }
8239     }
8240
8241   if (do_dynamic && dynamic_addr)
8242     printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
8243             dynamic_addr, dynamic_nent);
8244   if (do_dynamic)
8245     printf (_("  Tag        Type                         Name/Value\n"));
8246
8247   for (entry = dynamic_section;
8248        entry < dynamic_section + dynamic_nent;
8249        entry++)
8250     {
8251       if (do_dynamic)
8252         {
8253           const char * dtype;
8254
8255           putchar (' ');
8256           print_vma (entry->d_tag, FULL_HEX);
8257           dtype = get_dynamic_type (entry->d_tag);
8258           printf (" (%s)%*s", dtype,
8259                   ((is_32bit_elf ? 27 : 19)
8260                    - (int) strlen (dtype)),
8261                   " ");
8262         }
8263
8264       switch (entry->d_tag)
8265         {
8266         case DT_FLAGS:
8267           if (do_dynamic)
8268             print_dynamic_flags (entry->d_un.d_val);
8269           break;
8270
8271         case DT_AUXILIARY:
8272         case DT_FILTER:
8273         case DT_CONFIG:
8274         case DT_DEPAUDIT:
8275         case DT_AUDIT:
8276           if (do_dynamic)
8277             {
8278               switch (entry->d_tag)
8279                 {
8280                 case DT_AUXILIARY:
8281                   printf (_("Auxiliary library"));
8282                   break;
8283
8284                 case DT_FILTER:
8285                   printf (_("Filter library"));
8286                   break;
8287
8288                 case DT_CONFIG:
8289                   printf (_("Configuration file"));
8290                   break;
8291
8292                 case DT_DEPAUDIT:
8293                   printf (_("Dependency audit library"));
8294                   break;
8295
8296                 case DT_AUDIT:
8297                   printf (_("Audit library"));
8298                   break;
8299                 }
8300
8301               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8302                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
8303               else
8304                 {
8305                   printf (": ");
8306                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8307                   putchar ('\n');
8308                 }
8309             }
8310           break;
8311
8312         case DT_FEATURE:
8313           if (do_dynamic)
8314             {
8315               printf (_("Flags:"));
8316
8317               if (entry->d_un.d_val == 0)
8318                 printf (_(" None\n"));
8319               else
8320                 {
8321                   unsigned long int val = entry->d_un.d_val;
8322
8323                   if (val & DTF_1_PARINIT)
8324                     {
8325                       printf (" PARINIT");
8326                       val ^= DTF_1_PARINIT;
8327                     }
8328                   if (val & DTF_1_CONFEXP)
8329                     {
8330                       printf (" CONFEXP");
8331                       val ^= DTF_1_CONFEXP;
8332                     }
8333                   if (val != 0)
8334                     printf (" %lx", val);
8335                   puts ("");
8336                 }
8337             }
8338           break;
8339
8340         case DT_POSFLAG_1:
8341           if (do_dynamic)
8342             {
8343               printf (_("Flags:"));
8344
8345               if (entry->d_un.d_val == 0)
8346                 printf (_(" None\n"));
8347               else
8348                 {
8349                   unsigned long int val = entry->d_un.d_val;
8350
8351                   if (val & DF_P1_LAZYLOAD)
8352                     {
8353                       printf (" LAZYLOAD");
8354                       val ^= DF_P1_LAZYLOAD;
8355                     }
8356                   if (val & DF_P1_GROUPPERM)
8357                     {
8358                       printf (" GROUPPERM");
8359                       val ^= DF_P1_GROUPPERM;
8360                     }
8361                   if (val != 0)
8362                     printf (" %lx", val);
8363                   puts ("");
8364                 }
8365             }
8366           break;
8367
8368         case DT_FLAGS_1:
8369           if (do_dynamic)
8370             {
8371               printf (_("Flags:"));
8372               if (entry->d_un.d_val == 0)
8373                 printf (_(" None\n"));
8374               else
8375                 {
8376                   unsigned long int val = entry->d_un.d_val;
8377
8378                   if (val & DF_1_NOW)
8379                     {
8380                       printf (" NOW");
8381                       val ^= DF_1_NOW;
8382                     }
8383                   if (val & DF_1_GLOBAL)
8384                     {
8385                       printf (" GLOBAL");
8386                       val ^= DF_1_GLOBAL;
8387                     }
8388                   if (val & DF_1_GROUP)
8389                     {
8390                       printf (" GROUP");
8391                       val ^= DF_1_GROUP;
8392                     }
8393                   if (val & DF_1_NODELETE)
8394                     {
8395                       printf (" NODELETE");
8396                       val ^= DF_1_NODELETE;
8397                     }
8398                   if (val & DF_1_LOADFLTR)
8399                     {
8400                       printf (" LOADFLTR");
8401                       val ^= DF_1_LOADFLTR;
8402                     }
8403                   if (val & DF_1_INITFIRST)
8404                     {
8405                       printf (" INITFIRST");
8406                       val ^= DF_1_INITFIRST;
8407                     }
8408                   if (val & DF_1_NOOPEN)
8409                     {
8410                       printf (" NOOPEN");
8411                       val ^= DF_1_NOOPEN;
8412                     }
8413                   if (val & DF_1_ORIGIN)
8414                     {
8415                       printf (" ORIGIN");
8416                       val ^= DF_1_ORIGIN;
8417                     }
8418                   if (val & DF_1_DIRECT)
8419                     {
8420                       printf (" DIRECT");
8421                       val ^= DF_1_DIRECT;
8422                     }
8423                   if (val & DF_1_TRANS)
8424                     {
8425                       printf (" TRANS");
8426                       val ^= DF_1_TRANS;
8427                     }
8428                   if (val & DF_1_INTERPOSE)
8429                     {
8430                       printf (" INTERPOSE");
8431                       val ^= DF_1_INTERPOSE;
8432                     }
8433                   if (val & DF_1_NODEFLIB)
8434                     {
8435                       printf (" NODEFLIB");
8436                       val ^= DF_1_NODEFLIB;
8437                     }
8438                   if (val & DF_1_NODUMP)
8439                     {
8440                       printf (" NODUMP");
8441                       val ^= DF_1_NODUMP;
8442                     }
8443                   if (val & DF_1_CONFALT)
8444                     {
8445                       printf (" CONFALT");
8446                       val ^= DF_1_CONFALT;
8447                     }
8448                   if (val & DF_1_ENDFILTEE)
8449                     {
8450                       printf (" ENDFILTEE");
8451                       val ^= DF_1_ENDFILTEE;
8452                     }
8453                   if (val & DF_1_DISPRELDNE)
8454                     {
8455                       printf (" DISPRELDNE");
8456                       val ^= DF_1_DISPRELDNE;
8457                     }
8458                   if (val & DF_1_DISPRELPND)
8459                     {
8460                       printf (" DISPRELPND");
8461                       val ^= DF_1_DISPRELPND;
8462                     }
8463                   if (val & DF_1_NODIRECT)
8464                     {
8465                       printf (" NODIRECT");
8466                       val ^= DF_1_NODIRECT;
8467                     }
8468                   if (val & DF_1_IGNMULDEF)
8469                     {
8470                       printf (" IGNMULDEF");
8471                       val ^= DF_1_IGNMULDEF;
8472                     }
8473                   if (val & DF_1_NOKSYMS)
8474                     {
8475                       printf (" NOKSYMS");
8476                       val ^= DF_1_NOKSYMS;
8477                     }
8478                   if (val & DF_1_NOHDR)
8479                     {
8480                       printf (" NOHDR");
8481                       val ^= DF_1_NOHDR;
8482                     }
8483                   if (val & DF_1_EDITED)
8484                     {
8485                       printf (" EDITED");
8486                       val ^= DF_1_EDITED;
8487                     }
8488                   if (val & DF_1_NORELOC)
8489                     {
8490                       printf (" NORELOC");
8491                       val ^= DF_1_NORELOC;
8492                     }
8493                   if (val & DF_1_SYMINTPOSE)
8494                     {
8495                       printf (" SYMINTPOSE");
8496                       val ^= DF_1_SYMINTPOSE;
8497                     }
8498                   if (val & DF_1_GLOBAUDIT)
8499                     {
8500                       printf (" GLOBAUDIT");
8501                       val ^= DF_1_GLOBAUDIT;
8502                     }
8503                   if (val & DF_1_SINGLETON)
8504                     {
8505                       printf (" SINGLETON");
8506                       val ^= DF_1_SINGLETON;
8507                     }
8508                   if (val != 0)
8509                     printf (" %lx", val);
8510                   puts ("");
8511                 }
8512             }
8513           break;
8514
8515         case DT_PLTREL:
8516           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8517           if (do_dynamic)
8518             puts (get_dynamic_type (entry->d_un.d_val));
8519           break;
8520
8521         case DT_NULL    :
8522         case DT_NEEDED  :
8523         case DT_PLTGOT  :
8524         case DT_HASH    :
8525         case DT_STRTAB  :
8526         case DT_SYMTAB  :
8527         case DT_RELA    :
8528         case DT_INIT    :
8529         case DT_FINI    :
8530         case DT_SONAME  :
8531         case DT_RPATH   :
8532         case DT_SYMBOLIC:
8533         case DT_REL     :
8534         case DT_DEBUG   :
8535         case DT_TEXTREL :
8536         case DT_JMPREL  :
8537         case DT_RUNPATH :
8538           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8539
8540           if (do_dynamic)
8541             {
8542               char * name;
8543
8544               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8545                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8546               else
8547                 name = NULL;
8548
8549               if (name)
8550                 {
8551                   switch (entry->d_tag)
8552                     {
8553                     case DT_NEEDED:
8554                       printf (_("Shared library: [%s]"), name);
8555
8556                       if (streq (name, program_interpreter))
8557                         printf (_(" program interpreter"));
8558                       break;
8559
8560                     case DT_SONAME:
8561                       printf (_("Library soname: [%s]"), name);
8562                       break;
8563
8564                     case DT_RPATH:
8565                       printf (_("Library rpath: [%s]"), name);
8566                       break;
8567
8568                     case DT_RUNPATH:
8569                       printf (_("Library runpath: [%s]"), name);
8570                       break;
8571
8572                     default:
8573                       print_vma (entry->d_un.d_val, PREFIX_HEX);
8574                       break;
8575                     }
8576                 }
8577               else
8578                 print_vma (entry->d_un.d_val, PREFIX_HEX);
8579
8580               putchar ('\n');
8581             }
8582           break;
8583
8584         case DT_PLTRELSZ:
8585         case DT_RELASZ  :
8586         case DT_STRSZ   :
8587         case DT_RELSZ   :
8588         case DT_RELAENT :
8589         case DT_SYMENT  :
8590         case DT_RELENT  :
8591           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8592         case DT_PLTPADSZ:
8593         case DT_MOVEENT :
8594         case DT_MOVESZ  :
8595         case DT_INIT_ARRAYSZ:
8596         case DT_FINI_ARRAYSZ:
8597         case DT_GNU_CONFLICTSZ:
8598         case DT_GNU_LIBLISTSZ:
8599           if (do_dynamic)
8600             {
8601               print_vma (entry->d_un.d_val, UNSIGNED);
8602               printf (_(" (bytes)\n"));
8603             }
8604           break;
8605
8606         case DT_VERDEFNUM:
8607         case DT_VERNEEDNUM:
8608         case DT_RELACOUNT:
8609         case DT_RELCOUNT:
8610           if (do_dynamic)
8611             {
8612               print_vma (entry->d_un.d_val, UNSIGNED);
8613               putchar ('\n');
8614             }
8615           break;
8616
8617         case DT_SYMINSZ:
8618         case DT_SYMINENT:
8619         case DT_SYMINFO:
8620         case DT_USED:
8621         case DT_INIT_ARRAY:
8622         case DT_FINI_ARRAY:
8623           if (do_dynamic)
8624             {
8625               if (entry->d_tag == DT_USED
8626                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
8627                 {
8628                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8629
8630                   if (*name)
8631                     {
8632                       printf (_("Not needed object: [%s]\n"), name);
8633                       break;
8634                     }
8635                 }
8636
8637               print_vma (entry->d_un.d_val, PREFIX_HEX);
8638               putchar ('\n');
8639             }
8640           break;
8641
8642         case DT_BIND_NOW:
8643           /* The value of this entry is ignored.  */
8644           if (do_dynamic)
8645             putchar ('\n');
8646           break;
8647
8648         case DT_GNU_PRELINKED:
8649           if (do_dynamic)
8650             {
8651               struct tm * tmp;
8652               time_t atime = entry->d_un.d_val;
8653
8654               tmp = gmtime (&atime);
8655               printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8656                       tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8657                       tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8658
8659             }
8660           break;
8661
8662         case DT_GNU_HASH:
8663           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8664           if (do_dynamic)
8665             {
8666               print_vma (entry->d_un.d_val, PREFIX_HEX);
8667               putchar ('\n');
8668             }
8669           break;
8670
8671         default:
8672           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
8673             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
8674               entry->d_un.d_val;
8675
8676           if (do_dynamic)
8677             {
8678               switch (elf_header.e_machine)
8679                 {
8680                 case EM_MIPS:
8681                 case EM_MIPS_RS3_LE:
8682                   dynamic_section_mips_val (entry);
8683                   break;
8684                 case EM_PARISC:
8685                   dynamic_section_parisc_val (entry);
8686                   break;
8687                 case EM_IA_64:
8688                   dynamic_section_ia64_val (entry);
8689                   break;
8690                 default:
8691                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8692                   putchar ('\n');
8693                 }
8694             }
8695           break;
8696         }
8697     }
8698
8699   return 1;
8700 }
8701
8702 static char *
8703 get_ver_flags (unsigned int flags)
8704 {
8705   static char buff[32];
8706
8707   buff[0] = 0;
8708
8709   if (flags == 0)
8710     return _("none");
8711
8712   if (flags & VER_FLG_BASE)
8713     strcat (buff, "BASE ");
8714
8715   if (flags & VER_FLG_WEAK)
8716     {
8717       if (flags & VER_FLG_BASE)
8718         strcat (buff, "| ");
8719
8720       strcat (buff, "WEAK ");
8721     }
8722
8723   if (flags & VER_FLG_INFO)
8724     {
8725       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8726         strcat (buff, "| ");
8727
8728       strcat (buff, "INFO ");
8729     }
8730
8731   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
8732     strcat (buff, _("| <unknown>"));
8733
8734   return buff;
8735 }
8736
8737 /* Display the contents of the version sections.  */
8738
8739 static int
8740 process_version_sections (FILE * file)
8741 {
8742   Elf_Internal_Shdr * section;
8743   unsigned i;
8744   int found = 0;
8745
8746   if (! do_version)
8747     return 1;
8748
8749   for (i = 0, section = section_headers;
8750        i < elf_header.e_shnum;
8751        i++, section++)
8752     {
8753       switch (section->sh_type)
8754         {
8755         case SHT_GNU_verdef:
8756           {
8757             Elf_External_Verdef * edefs;
8758             unsigned int idx;
8759             unsigned int cnt;
8760             char * endbuf;
8761
8762             found = 1;
8763
8764             printf
8765               (_("\nVersion definition section '%s' contains %u entries:\n"),
8766                SECTION_NAME (section), section->sh_info);
8767
8768             printf (_("  Addr: 0x"));
8769             printf_vma (section->sh_addr);
8770             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8771                     (unsigned long) section->sh_offset, section->sh_link,
8772                     section->sh_link < elf_header.e_shnum
8773                     ? SECTION_NAME (section_headers + section->sh_link)
8774                     : _("<corrupt>"));
8775
8776             edefs = (Elf_External_Verdef *)
8777                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8778                           _("version definition section"));
8779             if (!edefs)
8780               break;
8781             endbuf = (char *) edefs + section->sh_size;
8782
8783             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8784               {
8785                 char * vstart;
8786                 Elf_External_Verdef * edef;
8787                 Elf_Internal_Verdef ent;
8788                 Elf_External_Verdaux * eaux;
8789                 Elf_Internal_Verdaux aux;
8790                 int j;
8791                 int isum;
8792
8793                 /* Check for very large indicies.  */
8794                 if (idx > (size_t) (endbuf - (char *) edefs))
8795                   break;
8796
8797                 vstart = ((char *) edefs) + idx;
8798                 if (vstart + sizeof (*edef) > endbuf)
8799                   break;
8800
8801                 edef = (Elf_External_Verdef *) vstart;
8802
8803                 ent.vd_version = BYTE_GET (edef->vd_version);
8804                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
8805                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
8806                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
8807                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
8808                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
8809                 ent.vd_next    = BYTE_GET (edef->vd_next);
8810
8811                 printf (_("  %#06x: Rev: %d  Flags: %s"),
8812                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8813
8814                 printf (_("  Index: %d  Cnt: %d  "),
8815                         ent.vd_ndx, ent.vd_cnt);
8816
8817                 /* Check for overflow.  */
8818                 if (ent.vd_aux > (size_t) (endbuf - vstart))
8819                   break;
8820
8821                 vstart += ent.vd_aux;
8822
8823                 eaux = (Elf_External_Verdaux *) vstart;
8824
8825                 aux.vda_name = BYTE_GET (eaux->vda_name);
8826                 aux.vda_next = BYTE_GET (eaux->vda_next);
8827
8828                 if (VALID_DYNAMIC_NAME (aux.vda_name))
8829                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
8830                 else
8831                   printf (_("Name index: %ld\n"), aux.vda_name);
8832
8833                 isum = idx + ent.vd_aux;
8834
8835                 for (j = 1; j < ent.vd_cnt; j++)
8836                   {
8837                     /* Check for overflow.  */
8838                     if (aux.vda_next > (size_t) (endbuf - vstart))
8839                       break;
8840
8841                     isum   += aux.vda_next;
8842                     vstart += aux.vda_next;
8843
8844                     eaux = (Elf_External_Verdaux *) vstart;
8845                     if (vstart + sizeof (*eaux) > endbuf)
8846                       break;
8847
8848                     aux.vda_name = BYTE_GET (eaux->vda_name);
8849                     aux.vda_next = BYTE_GET (eaux->vda_next);
8850
8851                     if (VALID_DYNAMIC_NAME (aux.vda_name))
8852                       printf (_("  %#06x: Parent %d: %s\n"),
8853                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
8854                     else
8855                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
8856                               isum, j, aux.vda_name);
8857                   }
8858
8859                 if (j < ent.vd_cnt)
8860                   printf (_("  Version def aux past end of section\n"));
8861
8862                 idx += ent.vd_next;
8863               }
8864
8865             if (cnt < section->sh_info)
8866               printf (_("  Version definition past end of section\n"));
8867
8868             free (edefs);
8869           }
8870           break;
8871
8872         case SHT_GNU_verneed:
8873           {
8874             Elf_External_Verneed * eneed;
8875             unsigned int idx;
8876             unsigned int cnt;
8877             char * endbuf;
8878
8879             found = 1;
8880
8881             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8882                     SECTION_NAME (section), section->sh_info);
8883
8884             printf (_(" Addr: 0x"));
8885             printf_vma (section->sh_addr);
8886             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8887                     (unsigned long) section->sh_offset, section->sh_link,
8888                     section->sh_link < elf_header.e_shnum
8889                     ? SECTION_NAME (section_headers + section->sh_link)
8890                     : _("<corrupt>"));
8891
8892             eneed = (Elf_External_Verneed *) get_data (NULL, file,
8893                                                        section->sh_offset, 1,
8894                                                        section->sh_size,
8895                                                        _("Version Needs section"));
8896             if (!eneed)
8897               break;
8898             endbuf = (char *) eneed + section->sh_size;
8899
8900             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8901               {
8902                 Elf_External_Verneed * entry;
8903                 Elf_Internal_Verneed ent;
8904                 int j;
8905                 int isum;
8906                 char * vstart;
8907
8908                 if (idx > (size_t) (endbuf - (char *) eneed))
8909                   break;
8910
8911                 vstart = ((char *) eneed) + idx;
8912                 if (vstart + sizeof (*entry) > endbuf)
8913                   break;
8914
8915                 entry = (Elf_External_Verneed *) vstart;
8916
8917                 ent.vn_version = BYTE_GET (entry->vn_version);
8918                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
8919                 ent.vn_file    = BYTE_GET (entry->vn_file);
8920                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
8921                 ent.vn_next    = BYTE_GET (entry->vn_next);
8922
8923                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
8924
8925                 if (VALID_DYNAMIC_NAME (ent.vn_file))
8926                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
8927                 else
8928                   printf (_("  File: %lx"), ent.vn_file);
8929
8930                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
8931
8932                 /* Check for overflow.  */
8933                 if (ent.vn_aux > (size_t) (endbuf - vstart))
8934                   break;
8935
8936                 vstart += ent.vn_aux;
8937
8938                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8939                   {
8940                     Elf_External_Vernaux * eaux;
8941                     Elf_Internal_Vernaux aux;
8942
8943                     if (vstart + sizeof (*eaux) > endbuf)
8944                       break;
8945                     eaux = (Elf_External_Vernaux *) vstart;
8946
8947                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
8948                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
8949                     aux.vna_other = BYTE_GET (eaux->vna_other);
8950                     aux.vna_name  = BYTE_GET (eaux->vna_name);
8951                     aux.vna_next  = BYTE_GET (eaux->vna_next);
8952
8953                     if (VALID_DYNAMIC_NAME (aux.vna_name))
8954                       printf (_("  %#06x:   Name: %s"),
8955                               isum, GET_DYNAMIC_NAME (aux.vna_name));
8956                     else
8957                       printf (_("  %#06x:   Name index: %lx"),
8958                               isum, aux.vna_name);
8959
8960                     printf (_("  Flags: %s  Version: %d\n"),
8961                             get_ver_flags (aux.vna_flags), aux.vna_other);
8962
8963                     /* Check for overflow.  */
8964                     if (aux.vna_next > (size_t) (endbuf - vstart))
8965                       break;
8966
8967                     isum   += aux.vna_next;
8968                     vstart += aux.vna_next;
8969                   }
8970
8971                 if (j < ent.vn_cnt)
8972                   warn (_("Missing Version Needs auxillary information\n"));
8973
8974                 if (ent.vn_next == 0 && cnt < section->sh_info)
8975                   {
8976                     warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
8977                     cnt = section->sh_info;
8978                     break;
8979                   }
8980                 idx += ent.vn_next;
8981               }
8982
8983             if (cnt < section->sh_info)
8984               warn (_("Missing Version Needs information\n"));
8985
8986             free (eneed);
8987           }
8988           break;
8989
8990         case SHT_GNU_versym:
8991           {
8992             Elf_Internal_Shdr * link_section;
8993             int total;
8994             int cnt;
8995             unsigned char * edata;
8996             unsigned short * data;
8997             char * strtab;
8998             Elf_Internal_Sym * symbols;
8999             Elf_Internal_Shdr * string_sec;
9000             unsigned long num_syms;
9001             long off;
9002
9003             if (section->sh_link >= elf_header.e_shnum)
9004               break;
9005
9006             link_section = section_headers + section->sh_link;
9007             total = section->sh_size / sizeof (Elf_External_Versym);
9008
9009             if (link_section->sh_link >= elf_header.e_shnum)
9010               break;
9011
9012             found = 1;
9013
9014             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9015             if (symbols == NULL)
9016               break;
9017
9018             string_sec = section_headers + link_section->sh_link;
9019
9020             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9021                                         string_sec->sh_size,
9022                                         _("version string table"));
9023             if (!strtab)
9024               {
9025                 free (symbols);
9026                 break;
9027               }
9028
9029             printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
9030                     SECTION_NAME (section), total);
9031
9032             printf (_(" Addr: "));
9033             printf_vma (section->sh_addr);
9034             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9035                     (unsigned long) section->sh_offset, section->sh_link,
9036                     SECTION_NAME (link_section));
9037
9038             off = offset_from_vma (file,
9039                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9040                                    total * sizeof (short));
9041             edata = (unsigned char *) get_data (NULL, file, off, total,
9042                                                 sizeof (short),
9043                                                 _("version symbol data"));
9044             if (!edata)
9045               {
9046                 free (strtab);
9047                 free (symbols);
9048                 break;
9049               }
9050
9051             data = (short unsigned int *) cmalloc (total, sizeof (short));
9052
9053             for (cnt = total; cnt --;)
9054               data[cnt] = byte_get (edata + cnt * sizeof (short),
9055                                     sizeof (short));
9056
9057             free (edata);
9058
9059             for (cnt = 0; cnt < total; cnt += 4)
9060               {
9061                 int j, nn;
9062                 int check_def, check_need;
9063                 char * name;
9064
9065                 printf ("  %03x:", cnt);
9066
9067                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
9068                   switch (data[cnt + j])
9069                     {
9070                     case 0:
9071                       fputs (_("   0 (*local*)    "), stdout);
9072                       break;
9073
9074                     case 1:
9075                       fputs (_("   1 (*global*)   "), stdout);
9076                       break;
9077
9078                     default:
9079                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9080                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
9081
9082                       /* If this index value is greater than the size of the symbols
9083                          array, break to avoid an out-of-bounds read.  */
9084                       if ((unsigned long)(cnt + j) >= num_syms)
9085                         {
9086                           warn (_("invalid index into symbol array\n"));
9087                           break;
9088                         }
9089
9090                       check_def = 1;
9091                       check_need = 1;
9092                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9093                           || section_headers[symbols[cnt + j].st_shndx].sh_type
9094                              != SHT_NOBITS)
9095                         {
9096                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
9097                             check_def = 0;
9098                           else
9099                             check_need = 0;
9100                         }
9101
9102                       if (check_need
9103                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
9104                         {
9105                           Elf_Internal_Verneed ivn;
9106                           unsigned long offset;
9107
9108                           offset = offset_from_vma
9109                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9110                              sizeof (Elf_External_Verneed));
9111
9112                           do
9113                             {
9114                               Elf_Internal_Vernaux ivna;
9115                               Elf_External_Verneed evn;
9116                               Elf_External_Vernaux evna;
9117                               unsigned long a_off;
9118
9119                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9120                                             _("version need")) == NULL)
9121                                 break;
9122
9123                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9124                               ivn.vn_next = BYTE_GET (evn.vn_next);
9125
9126                               a_off = offset + ivn.vn_aux;
9127
9128                               do
9129                                 {
9130                                   if (get_data (&evna, file, a_off, sizeof (evna),
9131                                                 1, _("version need aux (2)")) == NULL)
9132                                     {
9133                                       ivna.vna_next  = 0;
9134                                       ivna.vna_other = 0;
9135                                     }
9136                                   else
9137                                     {
9138                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
9139                                       ivna.vna_other = BYTE_GET (evna.vna_other);
9140                                     }
9141
9142                                   a_off += ivna.vna_next;
9143                                 }
9144                               while (ivna.vna_other != data[cnt + j]
9145                                      && ivna.vna_next != 0);
9146
9147                               if (ivna.vna_other == data[cnt + j])
9148                                 {
9149                                   ivna.vna_name = BYTE_GET (evna.vna_name);
9150
9151                                   if (ivna.vna_name >= string_sec->sh_size)
9152                                     name = _("*invalid*");
9153                                   else
9154                                     name = strtab + ivna.vna_name;
9155                                   nn += printf ("(%s%-*s",
9156                                                 name,
9157                                                 12 - (int) strlen (name),
9158                                                 ")");
9159                                   check_def = 0;
9160                                   break;
9161                                 }
9162
9163                               offset += ivn.vn_next;
9164                             }
9165                           while (ivn.vn_next);
9166                         }
9167
9168                       if (check_def && data[cnt + j] != 0x8001
9169                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9170                         {
9171                           Elf_Internal_Verdef ivd;
9172                           Elf_External_Verdef evd;
9173                           unsigned long offset;
9174
9175                           offset = offset_from_vma
9176                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9177                              sizeof evd);
9178
9179                           do
9180                             {
9181                               if (get_data (&evd, file, offset, sizeof (evd), 1,
9182                                             _("version def")) == NULL)
9183                                 {
9184                                   ivd.vd_next = 0;
9185                                   ivd.vd_ndx  = 0;
9186                                 }
9187                               else
9188                                 {
9189                                   ivd.vd_next = BYTE_GET (evd.vd_next);
9190                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
9191                                 }
9192
9193                               offset += ivd.vd_next;
9194                             }
9195                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
9196                                  && ivd.vd_next != 0);
9197
9198                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
9199                             {
9200                               Elf_External_Verdaux evda;
9201                               Elf_Internal_Verdaux ivda;
9202
9203                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
9204
9205                               if (get_data (&evda, file,
9206                                             offset - ivd.vd_next + ivd.vd_aux,
9207                                             sizeof (evda), 1,
9208                                             _("version def aux")) == NULL)
9209                                 break;
9210
9211                               ivda.vda_name = BYTE_GET (evda.vda_name);
9212
9213                               if (ivda.vda_name >= string_sec->sh_size)
9214                                 name = _("*invalid*");
9215                               else
9216                                 name = strtab + ivda.vda_name;
9217                               nn += printf ("(%s%-*s",
9218                                             name,
9219                                             12 - (int) strlen (name),
9220                                             ")");
9221                             }
9222                         }
9223
9224                       if (nn < 18)
9225                         printf ("%*c", 18 - nn, ' ');
9226                     }
9227
9228                 putchar ('\n');
9229               }
9230
9231             free (data);
9232             free (strtab);
9233             free (symbols);
9234           }
9235           break;
9236
9237         default:
9238           break;
9239         }
9240     }
9241
9242   if (! found)
9243     printf (_("\nNo version information found in this file.\n"));
9244
9245   return 1;
9246 }
9247
9248 static const char *
9249 get_symbol_binding (unsigned int binding)
9250 {
9251   static char buff[32];
9252
9253   switch (binding)
9254     {
9255     case STB_LOCAL:     return "LOCAL";
9256     case STB_GLOBAL:    return "GLOBAL";
9257     case STB_WEAK:      return "WEAK";
9258     default:
9259       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
9260         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9261                   binding);
9262       else if (binding >= STB_LOOS && binding <= STB_HIOS)
9263         {
9264           if (binding == STB_GNU_UNIQUE
9265               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9266                   /* GNU is still using the default value 0.  */
9267                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9268             return "UNIQUE";
9269           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9270         }
9271       else
9272         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
9273       return buff;
9274     }
9275 }
9276
9277 static const char *
9278 get_symbol_type (unsigned int type)
9279 {
9280   static char buff[32];
9281
9282   switch (type)
9283     {
9284     case STT_NOTYPE:    return "NOTYPE";
9285     case STT_OBJECT:    return "OBJECT";
9286     case STT_FUNC:      return "FUNC";
9287     case STT_SECTION:   return "SECTION";
9288     case STT_FILE:      return "FILE";
9289     case STT_COMMON:    return "COMMON";
9290     case STT_TLS:       return "TLS";
9291     case STT_RELC:      return "RELC";
9292     case STT_SRELC:     return "SRELC";
9293     default:
9294       if (type >= STT_LOPROC && type <= STT_HIPROC)
9295         {
9296           if (elf_header.e_machine == EM_ARM)
9297             {
9298               if (type == STT_ARM_TFUNC)
9299                 return "THUMB_FUNC";
9300               if (type == STT_ARM_16BIT)
9301                 return "THUMB_LABEL";
9302             }
9303
9304           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
9305             return "REGISTER";
9306
9307           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9308             return "PARISC_MILLI";
9309
9310           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
9311         }
9312       else if (type >= STT_LOOS && type <= STT_HIOS)
9313         {
9314           if (elf_header.e_machine == EM_PARISC)
9315             {
9316               if (type == STT_HP_OPAQUE)
9317                 return "HP_OPAQUE";
9318               if (type == STT_HP_STUB)
9319                 return "HP_STUB";
9320             }
9321
9322           if (type == STT_GNU_IFUNC
9323               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9324                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9325                   /* GNU is still using the default value 0.  */
9326                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9327             return "IFUNC";
9328
9329           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
9330         }
9331       else
9332         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
9333       return buff;
9334     }
9335 }
9336
9337 static const char *
9338 get_symbol_visibility (unsigned int visibility)
9339 {
9340   switch (visibility)
9341     {
9342     case STV_DEFAULT:   return "DEFAULT";
9343     case STV_INTERNAL:  return "INTERNAL";
9344     case STV_HIDDEN:    return "HIDDEN";
9345     case STV_PROTECTED: return "PROTECTED";
9346     default: abort ();
9347     }
9348 }
9349
9350 static const char *
9351 get_mips_symbol_other (unsigned int other)
9352 {
9353   switch (other)
9354     {
9355     case STO_OPTIONAL:
9356       return "OPTIONAL";
9357     case STO_MIPS_PLT:
9358       return "MIPS PLT";
9359     case STO_MIPS_PIC:
9360       return "MIPS PIC";
9361     case STO_MICROMIPS:
9362       return "MICROMIPS";
9363     case STO_MICROMIPS | STO_MIPS_PIC:
9364       return "MICROMIPS, MIPS PIC";
9365     case STO_MIPS16:
9366       return "MIPS16";
9367     default:
9368       return NULL;
9369     }
9370 }
9371
9372 static const char *
9373 get_ia64_symbol_other (unsigned int other)
9374 {
9375   if (is_ia64_vms ())
9376     {
9377       static char res[32];
9378
9379       res[0] = 0;
9380
9381       /* Function types is for images and .STB files only.  */
9382       switch (elf_header.e_type)
9383         {
9384         case ET_DYN:
9385         case ET_EXEC:
9386           switch (VMS_ST_FUNC_TYPE (other))
9387             {
9388             case VMS_SFT_CODE_ADDR:
9389               strcat (res, " CA");
9390               break;
9391             case VMS_SFT_SYMV_IDX:
9392               strcat (res, " VEC");
9393               break;
9394             case VMS_SFT_FD:
9395               strcat (res, " FD");
9396               break;
9397             case VMS_SFT_RESERVE:
9398               strcat (res, " RSV");
9399               break;
9400             default:
9401               abort ();
9402             }
9403           break;
9404         default:
9405           break;
9406         }
9407       switch (VMS_ST_LINKAGE (other))
9408         {
9409         case VMS_STL_IGNORE:
9410           strcat (res, " IGN");
9411           break;
9412         case VMS_STL_RESERVE:
9413           strcat (res, " RSV");
9414           break;
9415         case VMS_STL_STD:
9416           strcat (res, " STD");
9417           break;
9418         case VMS_STL_LNK:
9419           strcat (res, " LNK");
9420           break;
9421         default:
9422           abort ();
9423         }
9424
9425       if (res[0] != 0)
9426         return res + 1;
9427       else
9428         return res;
9429     }
9430   return NULL;
9431 }
9432
9433 static const char *
9434 get_ppc64_symbol_other (unsigned int other)
9435 {
9436   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
9437     {
9438       static char buf[32];
9439       snprintf (buf, sizeof buf, _("<localentry>: %d"),
9440                 PPC64_LOCAL_ENTRY_OFFSET (other));
9441       return buf;
9442     }
9443   return NULL;
9444 }
9445
9446 static const char *
9447 get_symbol_other (unsigned int other)
9448 {
9449   const char * result = NULL;
9450   static char buff [32];
9451
9452   if (other == 0)
9453     return "";
9454
9455   switch (elf_header.e_machine)
9456     {
9457     case EM_MIPS:
9458       result = get_mips_symbol_other (other);
9459       break;
9460     case EM_IA_64:
9461       result = get_ia64_symbol_other (other);
9462       break;
9463     case EM_PPC64:
9464       result = get_ppc64_symbol_other (other);
9465       break;
9466     default:
9467       break;
9468     }
9469
9470   if (result)
9471     return result;
9472
9473   snprintf (buff, sizeof buff, _("<other>: %x"), other);
9474   return buff;
9475 }
9476
9477 static const char *
9478 get_symbol_index_type (unsigned int type)
9479 {
9480   static char buff[32];
9481
9482   switch (type)
9483     {
9484     case SHN_UNDEF:     return "UND";
9485     case SHN_ABS:       return "ABS";
9486     case SHN_COMMON:    return "COM";
9487     default:
9488       if (type == SHN_IA_64_ANSI_COMMON
9489           && elf_header.e_machine == EM_IA_64
9490           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9491         return "ANSI_COM";
9492       else if ((elf_header.e_machine == EM_X86_64
9493                 || elf_header.e_machine == EM_L1OM
9494                 || elf_header.e_machine == EM_K1OM)
9495                && type == SHN_X86_64_LCOMMON)
9496         return "LARGE_COM";
9497       else if ((type == SHN_MIPS_SCOMMON
9498                 && elf_header.e_machine == EM_MIPS)
9499                || (type == SHN_TIC6X_SCOMMON
9500                    && elf_header.e_machine == EM_TI_C6000))
9501         return "SCOM";
9502       else if (type == SHN_MIPS_SUNDEFINED
9503                && elf_header.e_machine == EM_MIPS)
9504         return "SUND";
9505       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
9506         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
9507       else if (type >= SHN_LOOS && type <= SHN_HIOS)
9508         sprintf (buff, "OS [0x%04x]", type & 0xffff);
9509       else if (type >= SHN_LORESERVE)
9510         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
9511       else if (type >= elf_header.e_shnum)
9512         sprintf (buff, "bad section index[%3d]", type);
9513       else
9514         sprintf (buff, "%3d", type);
9515       break;
9516     }
9517
9518   return buff;
9519 }
9520
9521 static bfd_vma *
9522 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
9523 {
9524   unsigned char * e_data;
9525   bfd_vma * i_data;
9526
9527   e_data = (unsigned char *) cmalloc (number, ent_size);
9528
9529   if (e_data == NULL)
9530     {
9531       error (_("Out of memory\n"));
9532       return NULL;
9533     }
9534
9535   if (fread (e_data, ent_size, number, file) != number)
9536     {
9537       error (_("Unable to read in dynamic data\n"));
9538       return NULL;
9539     }
9540
9541   i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
9542
9543   if (i_data == NULL)
9544     {
9545       error (_("Out of memory\n"));
9546       free (e_data);
9547       return NULL;
9548     }
9549
9550   while (number--)
9551     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
9552
9553   free (e_data);
9554
9555   return i_data;
9556 }
9557
9558 static void
9559 print_dynamic_symbol (bfd_vma si, unsigned long hn)
9560 {
9561   Elf_Internal_Sym * psym;
9562   int n;
9563
9564   psym = dynamic_symbols + si;
9565
9566   n = print_vma (si, DEC_5);
9567   if (n < 5)
9568     fputs (&"     "[n], stdout);
9569   printf (" %3lu: ", hn);
9570   print_vma (psym->st_value, LONG_HEX);
9571   putchar (' ');
9572   print_vma (psym->st_size, DEC_5);
9573
9574   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9575   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9576   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9577   /* Check to see if any other bits in the st_other field are set.
9578      Note - displaying this information disrupts the layout of the
9579      table being generated, but for the moment this case is very
9580      rare.  */
9581   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9582     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9583   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9584   if (VALID_DYNAMIC_NAME (psym->st_name))
9585     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9586   else
9587     printf (_(" <corrupt: %14ld>"), psym->st_name);
9588   putchar ('\n');
9589 }
9590
9591 /* Dump the symbol table.  */
9592 static int
9593 process_symbol_table (FILE * file)
9594 {
9595   Elf_Internal_Shdr * section;
9596   bfd_vma nbuckets = 0;
9597   bfd_vma nchains = 0;
9598   bfd_vma * buckets = NULL;
9599   bfd_vma * chains = NULL;
9600   bfd_vma ngnubuckets = 0;
9601   bfd_vma * gnubuckets = NULL;
9602   bfd_vma * gnuchains = NULL;
9603   bfd_vma gnusymidx = 0;
9604
9605   if (!do_syms && !do_dyn_syms && !do_histogram)
9606     return 1;
9607
9608   if (dynamic_info[DT_HASH]
9609       && (do_histogram
9610           || (do_using_dynamic
9611               && !do_dyn_syms
9612               && dynamic_strings != NULL)))
9613     {
9614       unsigned char nb[8];
9615       unsigned char nc[8];
9616       int hash_ent_size = 4;
9617
9618       if ((elf_header.e_machine == EM_ALPHA
9619            || elf_header.e_machine == EM_S390
9620            || elf_header.e_machine == EM_S390_OLD)
9621           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9622         hash_ent_size = 8;
9623
9624       if (fseek (file,
9625                  (archive_file_offset
9626                   + offset_from_vma (file, dynamic_info[DT_HASH],
9627                                      sizeof nb + sizeof nc)),
9628                  SEEK_SET))
9629         {
9630           error (_("Unable to seek to start of dynamic information\n"));
9631           goto no_hash;
9632         }
9633
9634       if (fread (nb, hash_ent_size, 1, file) != 1)
9635         {
9636           error (_("Failed to read in number of buckets\n"));
9637           goto no_hash;
9638         }
9639
9640       if (fread (nc, hash_ent_size, 1, file) != 1)
9641         {
9642           error (_("Failed to read in number of chains\n"));
9643           goto no_hash;
9644         }
9645
9646       nbuckets = byte_get (nb, hash_ent_size);
9647       nchains  = byte_get (nc, hash_ent_size);
9648
9649       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9650       chains  = get_dynamic_data (file, nchains, hash_ent_size);
9651
9652     no_hash:
9653       if (buckets == NULL || chains == NULL)
9654         {
9655           if (do_using_dynamic)
9656             return 0;
9657           free (buckets);
9658           free (chains);
9659           buckets = NULL;
9660           chains = NULL;
9661           nbuckets = 0;
9662           nchains = 0;
9663         }
9664     }
9665
9666   if (dynamic_info_DT_GNU_HASH
9667       && (do_histogram
9668           || (do_using_dynamic
9669               && !do_dyn_syms
9670               && dynamic_strings != NULL)))
9671     {
9672       unsigned char nb[16];
9673       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9674       bfd_vma buckets_vma;
9675
9676       if (fseek (file,
9677                  (archive_file_offset
9678                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9679                                      sizeof nb)),
9680                  SEEK_SET))
9681         {
9682           error (_("Unable to seek to start of dynamic information\n"));
9683           goto no_gnu_hash;
9684         }
9685
9686       if (fread (nb, 16, 1, file) != 1)
9687         {
9688           error (_("Failed to read in number of buckets\n"));
9689           goto no_gnu_hash;
9690         }
9691
9692       ngnubuckets = byte_get (nb, 4);
9693       gnusymidx = byte_get (nb + 4, 4);
9694       bitmaskwords = byte_get (nb + 8, 4);
9695       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
9696       if (is_32bit_elf)
9697         buckets_vma += bitmaskwords * 4;
9698       else
9699         buckets_vma += bitmaskwords * 8;
9700
9701       if (fseek (file,
9702                  (archive_file_offset
9703                   + offset_from_vma (file, buckets_vma, 4)),
9704                  SEEK_SET))
9705         {
9706           error (_("Unable to seek to start of dynamic information\n"));
9707           goto no_gnu_hash;
9708         }
9709
9710       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
9711
9712       if (gnubuckets == NULL)
9713         goto no_gnu_hash;
9714
9715       for (i = 0; i < ngnubuckets; i++)
9716         if (gnubuckets[i] != 0)
9717           {
9718             if (gnubuckets[i] < gnusymidx)
9719               return 0;
9720
9721             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9722               maxchain = gnubuckets[i];
9723           }
9724
9725       if (maxchain == 0xffffffff)
9726         goto no_gnu_hash;
9727
9728       maxchain -= gnusymidx;
9729
9730       if (fseek (file,
9731                  (archive_file_offset
9732                   + offset_from_vma (file, buckets_vma
9733                                            + 4 * (ngnubuckets + maxchain), 4)),
9734                  SEEK_SET))
9735         {
9736           error (_("Unable to seek to start of dynamic information\n"));
9737           goto no_gnu_hash;
9738         }
9739
9740       do
9741         {
9742           if (fread (nb, 4, 1, file) != 1)
9743             {
9744               error (_("Failed to determine last chain length\n"));
9745               goto no_gnu_hash;
9746             }
9747
9748           if (maxchain + 1 == 0)
9749             goto no_gnu_hash;
9750
9751           ++maxchain;
9752         }
9753       while ((byte_get (nb, 4) & 1) == 0);
9754
9755       if (fseek (file,
9756                  (archive_file_offset
9757                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9758                  SEEK_SET))
9759         {
9760           error (_("Unable to seek to start of dynamic information\n"));
9761           goto no_gnu_hash;
9762         }
9763
9764       gnuchains = get_dynamic_data (file, maxchain, 4);
9765
9766     no_gnu_hash:
9767       if (gnuchains == NULL)
9768         {
9769           free (gnubuckets);
9770           gnubuckets = NULL;
9771           ngnubuckets = 0;
9772           if (do_using_dynamic)
9773             return 0;
9774         }
9775     }
9776
9777   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9778       && do_syms
9779       && do_using_dynamic
9780       && dynamic_strings != NULL)
9781     {
9782       unsigned long hn;
9783
9784       if (dynamic_info[DT_HASH])
9785         {
9786           bfd_vma si;
9787
9788           printf (_("\nSymbol table for image:\n"));
9789           if (is_32bit_elf)
9790             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9791           else
9792             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9793
9794           for (hn = 0; hn < nbuckets; hn++)
9795             {
9796               if (! buckets[hn])
9797                 continue;
9798
9799               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9800                 print_dynamic_symbol (si, hn);
9801             }
9802         }
9803
9804       if (dynamic_info_DT_GNU_HASH)
9805         {
9806           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9807           if (is_32bit_elf)
9808             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9809           else
9810             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9811
9812           for (hn = 0; hn < ngnubuckets; ++hn)
9813             if (gnubuckets[hn] != 0)
9814               {
9815                 bfd_vma si = gnubuckets[hn];
9816                 bfd_vma off = si - gnusymidx;
9817
9818                 do
9819                   {
9820                     print_dynamic_symbol (si, hn);
9821                     si++;
9822                   }
9823                 while ((gnuchains[off++] & 1) == 0);
9824               }
9825         }
9826     }
9827   else if (do_dyn_syms || (do_syms && !do_using_dynamic))
9828     {
9829       unsigned int i;
9830
9831       for (i = 0, section = section_headers;
9832            i < elf_header.e_shnum;
9833            i++, section++)
9834         {
9835           unsigned int si;
9836           char * strtab = NULL;
9837           unsigned long int strtab_size = 0;
9838           Elf_Internal_Sym * symtab;
9839           Elf_Internal_Sym * psym;
9840           unsigned long num_syms;
9841
9842           if ((section->sh_type != SHT_SYMTAB
9843                && section->sh_type != SHT_DYNSYM)
9844               || (!do_syms
9845                   && section->sh_type == SHT_SYMTAB))
9846             continue;
9847
9848           if (section->sh_entsize == 0)
9849             {
9850               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9851                       SECTION_NAME (section));
9852               continue;
9853             }
9854
9855           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9856                   SECTION_NAME (section),
9857                   (unsigned long) (section->sh_size / section->sh_entsize));
9858
9859           if (is_32bit_elf)
9860             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
9861           else
9862             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
9863
9864           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
9865           if (symtab == NULL)
9866             continue;
9867
9868           if (section->sh_link == elf_header.e_shstrndx)
9869             {
9870               strtab = string_table;
9871               strtab_size = string_table_length;
9872             }
9873           else if (section->sh_link < elf_header.e_shnum)
9874             {
9875               Elf_Internal_Shdr * string_sec;
9876
9877               string_sec = section_headers + section->sh_link;
9878
9879               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9880                                           1, string_sec->sh_size,
9881                                           _("string table"));
9882               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
9883             }
9884
9885           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
9886             {
9887               printf ("%6d: ", si);
9888               print_vma (psym->st_value, LONG_HEX);
9889               putchar (' ');
9890               print_vma (psym->st_size, DEC_5);
9891               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9892               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9893               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9894               /* Check to see if any other bits in the st_other field are set.
9895                  Note - displaying this information disrupts the layout of the
9896                  table being generated, but for the moment this case is very rare.  */
9897               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9898                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9899               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
9900               print_symbol (25, psym->st_name < strtab_size
9901                             ? strtab + psym->st_name : _("<corrupt>"));
9902
9903               if (section->sh_type == SHT_DYNSYM
9904                   && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9905                 {
9906                   unsigned char data[2];
9907                   unsigned short vers_data;
9908                   unsigned long offset;
9909                   int is_nobits;
9910                   int check_def;
9911
9912                   offset = offset_from_vma
9913                     (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9914                      sizeof data + si * sizeof (vers_data));
9915
9916                   if (get_data (&data, file, offset + si * sizeof (vers_data),
9917                                 sizeof (data), 1, _("version data")) == NULL)
9918                     break;
9919
9920                   vers_data = byte_get (data, 2);
9921
9922                   is_nobits = (psym->st_shndx < elf_header.e_shnum
9923                                && section_headers[psym->st_shndx].sh_type
9924                                   == SHT_NOBITS);
9925
9926                   check_def = (psym->st_shndx != SHN_UNDEF);
9927
9928                   if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
9929                     {
9930                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
9931                           && (is_nobits || ! check_def))
9932                         {
9933                           Elf_External_Verneed evn;
9934                           Elf_Internal_Verneed ivn;
9935                           Elf_Internal_Vernaux ivna;
9936
9937                           /* We must test both.  */
9938                           offset = offset_from_vma
9939                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9940                              sizeof evn);
9941
9942                           do
9943                             {
9944                               unsigned long vna_off;
9945
9946                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9947                                             _("version need")) == NULL)
9948                                 {
9949                                   ivna.vna_next = 0;
9950                                   ivna.vna_other = 0;
9951                                   ivna.vna_name = 0;
9952                                   break;
9953                                 }
9954
9955                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9956                               ivn.vn_next = BYTE_GET (evn.vn_next);
9957
9958                               vna_off = offset + ivn.vn_aux;
9959
9960                               do
9961                                 {
9962                                   Elf_External_Vernaux evna;
9963
9964                                   if (get_data (&evna, file, vna_off,
9965                                                 sizeof (evna), 1,
9966                                                 _("version need aux (3)")) == NULL)
9967                                     {
9968                                       ivna.vna_next = 0;
9969                                       ivna.vna_other = 0;
9970                                       ivna.vna_name = 0;
9971                                     }
9972                                   else
9973                                     {
9974                                       ivna.vna_other = BYTE_GET (evna.vna_other);
9975                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
9976                                       ivna.vna_name  = BYTE_GET (evna.vna_name);
9977                                     }
9978
9979                                   vna_off += ivna.vna_next;
9980                                 }
9981                               while (ivna.vna_other != vers_data
9982                                      && ivna.vna_next != 0);
9983
9984                               if (ivna.vna_other == vers_data)
9985                                 break;
9986
9987                               offset += ivn.vn_next;
9988                             }
9989                           while (ivn.vn_next != 0);
9990
9991                           if (ivna.vna_other == vers_data)
9992                             {
9993                               printf ("@%s (%d)",
9994                                       ivna.vna_name < strtab_size
9995                                       ? strtab + ivna.vna_name : _("<corrupt>"),
9996                                       ivna.vna_other);
9997                               check_def = 0;
9998                             }
9999                           else if (! is_nobits)
10000                             error (_("bad dynamic symbol\n"));
10001                           else
10002                             check_def = 1;
10003                         }
10004
10005                       if (check_def)
10006                         {
10007                           if (vers_data != 0x8001
10008                               && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10009                             {
10010                               Elf_Internal_Verdef ivd;
10011                               Elf_Internal_Verdaux ivda;
10012                               Elf_External_Verdaux evda;
10013                               unsigned long off;
10014
10015                               off = offset_from_vma
10016                                 (file,
10017                                  version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10018                                  sizeof (Elf_External_Verdef));
10019
10020                               do
10021                                 {
10022                                   Elf_External_Verdef evd;
10023
10024                                   if (get_data (&evd, file, off, sizeof (evd),
10025                                                 1, _("version def")) == NULL)
10026                                     {
10027                                       ivd.vd_ndx = 0;
10028                                       ivd.vd_aux = 0;
10029                                       ivd.vd_next = 0;
10030                                     }
10031                                   else
10032                                     {
10033                                       ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10034                                       ivd.vd_aux = BYTE_GET (evd.vd_aux);
10035                                       ivd.vd_next = BYTE_GET (evd.vd_next);
10036                                     }
10037
10038                                   off += ivd.vd_next;
10039                                 }
10040                               while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10041                                      && ivd.vd_next != 0);
10042
10043                               off -= ivd.vd_next;
10044                               off += ivd.vd_aux;
10045
10046                               if (get_data (&evda, file, off, sizeof (evda),
10047                                             1, _("version def aux")) == NULL)
10048                                 break;
10049
10050                               ivda.vda_name = BYTE_GET (evda.vda_name);
10051
10052                               if (psym->st_name != ivda.vda_name)
10053                                 printf ((vers_data & VERSYM_HIDDEN)
10054                                         ? "@%s" : "@@%s",
10055                                         ivda.vda_name < strtab_size
10056                                         ? strtab + ivda.vda_name : _("<corrupt>"));
10057                             }
10058                         }
10059                     }
10060                 }
10061
10062               putchar ('\n');
10063             }
10064
10065           free (symtab);
10066           if (strtab != string_table)
10067             free (strtab);
10068         }
10069     }
10070   else if (do_syms)
10071     printf
10072       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10073
10074   if (do_histogram && buckets != NULL)
10075     {
10076       unsigned long * lengths;
10077       unsigned long * counts;
10078       unsigned long hn;
10079       bfd_vma si;
10080       unsigned long maxlength = 0;
10081       unsigned long nzero_counts = 0;
10082       unsigned long nsyms = 0;
10083
10084       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10085               (unsigned long) nbuckets);
10086       printf (_(" Length  Number     %% of total  Coverage\n"));
10087
10088       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
10089       if (lengths == NULL)
10090         {
10091           error (_("Out of memory\n"));
10092           return 0;
10093         }
10094       for (hn = 0; hn < nbuckets; ++hn)
10095         {
10096           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
10097             {
10098               ++nsyms;
10099               if (maxlength < ++lengths[hn])
10100                 ++maxlength;
10101             }
10102         }
10103
10104       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10105       if (counts == NULL)
10106         {
10107           free (lengths);
10108           error (_("Out of memory\n"));
10109           return 0;
10110         }
10111
10112       for (hn = 0; hn < nbuckets; ++hn)
10113         ++counts[lengths[hn]];
10114
10115       if (nbuckets > 0)
10116         {
10117           unsigned long i;
10118           printf ("      0  %-10lu (%5.1f%%)\n",
10119                   counts[0], (counts[0] * 100.0) / nbuckets);
10120           for (i = 1; i <= maxlength; ++i)
10121             {
10122               nzero_counts += counts[i] * i;
10123               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
10124                       i, counts[i], (counts[i] * 100.0) / nbuckets,
10125                       (nzero_counts * 100.0) / nsyms);
10126             }
10127         }
10128
10129       free (counts);
10130       free (lengths);
10131     }
10132
10133   if (buckets != NULL)
10134     {
10135       free (buckets);
10136       free (chains);
10137     }
10138
10139   if (do_histogram && gnubuckets != NULL)
10140     {
10141       unsigned long * lengths;
10142       unsigned long * counts;
10143       unsigned long hn;
10144       unsigned long maxlength = 0;
10145       unsigned long nzero_counts = 0;
10146       unsigned long nsyms = 0;
10147
10148       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
10149       if (lengths == NULL)
10150         {
10151           error (_("Out of memory\n"));
10152           return 0;
10153         }
10154
10155       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10156               (unsigned long) ngnubuckets);
10157       printf (_(" Length  Number     %% of total  Coverage\n"));
10158
10159       for (hn = 0; hn < ngnubuckets; ++hn)
10160         if (gnubuckets[hn] != 0)
10161           {
10162             bfd_vma off, length = 1;
10163
10164             for (off = gnubuckets[hn] - gnusymidx;
10165                  (gnuchains[off] & 1) == 0; ++off)
10166               ++length;
10167             lengths[hn] = length;
10168             if (length > maxlength)
10169               maxlength = length;
10170             nsyms += length;
10171           }
10172
10173       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10174       if (counts == NULL)
10175         {
10176           free (lengths);
10177           error (_("Out of memory\n"));
10178           return 0;
10179         }
10180
10181       for (hn = 0; hn < ngnubuckets; ++hn)
10182         ++counts[lengths[hn]];
10183
10184       if (ngnubuckets > 0)
10185         {
10186           unsigned long j;
10187           printf ("      0  %-10lu (%5.1f%%)\n",
10188                   counts[0], (counts[0] * 100.0) / ngnubuckets);
10189           for (j = 1; j <= maxlength; ++j)
10190             {
10191               nzero_counts += counts[j] * j;
10192               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
10193                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10194                       (nzero_counts * 100.0) / nsyms);
10195             }
10196         }
10197
10198       free (counts);
10199       free (lengths);
10200       free (gnubuckets);
10201       free (gnuchains);
10202     }
10203
10204   return 1;
10205 }
10206
10207 static int
10208 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
10209 {
10210   unsigned int i;
10211
10212   if (dynamic_syminfo == NULL
10213       || !do_dynamic)
10214     /* No syminfo, this is ok.  */
10215     return 1;
10216
10217   /* There better should be a dynamic symbol section.  */
10218   if (dynamic_symbols == NULL || dynamic_strings == NULL)
10219     return 0;
10220
10221   if (dynamic_addr)
10222     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10223             dynamic_syminfo_offset, dynamic_syminfo_nent);
10224
10225   printf (_(" Num: Name                           BoundTo     Flags\n"));
10226   for (i = 0; i < dynamic_syminfo_nent; ++i)
10227     {
10228       unsigned short int flags = dynamic_syminfo[i].si_flags;
10229
10230       printf ("%4d: ", i);
10231       if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
10232         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10233       else
10234         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
10235       putchar (' ');
10236
10237       switch (dynamic_syminfo[i].si_boundto)
10238         {
10239         case SYMINFO_BT_SELF:
10240           fputs ("SELF       ", stdout);
10241           break;
10242         case SYMINFO_BT_PARENT:
10243           fputs ("PARENT     ", stdout);
10244           break;
10245         default:
10246           if (dynamic_syminfo[i].si_boundto > 0
10247               && dynamic_syminfo[i].si_boundto < dynamic_nent
10248               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
10249             {
10250               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
10251               putchar (' ' );
10252             }
10253           else
10254             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10255           break;
10256         }
10257
10258       if (flags & SYMINFO_FLG_DIRECT)
10259         printf (" DIRECT");
10260       if (flags & SYMINFO_FLG_PASSTHRU)
10261         printf (" PASSTHRU");
10262       if (flags & SYMINFO_FLG_COPY)
10263         printf (" COPY");
10264       if (flags & SYMINFO_FLG_LAZYLOAD)
10265         printf (" LAZYLOAD");
10266
10267       puts ("");
10268     }
10269
10270   return 1;
10271 }
10272
10273 /* Check to see if the given reloc needs to be handled in a target specific
10274    manner.  If so then process the reloc and return TRUE otherwise return
10275    FALSE.  */
10276
10277 static bfd_boolean
10278 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10279                                 unsigned char *     start,
10280                                 Elf_Internal_Sym *  symtab)
10281 {
10282   unsigned int reloc_type = get_reloc_type (reloc->r_info);
10283
10284   switch (elf_header.e_machine)
10285     {
10286     case EM_MSP430:
10287     case EM_MSP430_OLD:
10288       {
10289         static Elf_Internal_Sym * saved_sym = NULL;
10290
10291         switch (reloc_type)
10292           {
10293           case 10: /* R_MSP430_SYM_DIFF */
10294             if (uses_msp430x_relocs ())
10295               break;
10296           case 21: /* R_MSP430X_SYM_DIFF */
10297             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10298             return TRUE;
10299
10300           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10301           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10302             goto handle_sym_diff;
10303
10304           case 5: /* R_MSP430_16_BYTE */
10305           case 9: /* R_MSP430_8 */
10306             if (uses_msp430x_relocs ())
10307               break;
10308             goto handle_sym_diff;
10309
10310           case 2: /* R_MSP430_ABS16 */
10311           case 15: /* R_MSP430X_ABS16 */
10312             if (! uses_msp430x_relocs ())
10313               break;
10314             goto handle_sym_diff;
10315
10316           handle_sym_diff:
10317             if (saved_sym != NULL)
10318               {
10319                 bfd_vma value;
10320
10321                 value = reloc->r_addend
10322                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10323                      - saved_sym->st_value);
10324
10325                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10326
10327                 saved_sym = NULL;
10328                 return TRUE;
10329               }
10330             break;
10331
10332           default:
10333             if (saved_sym != NULL)
10334               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc"));
10335             break;
10336           }
10337         break;
10338       }
10339
10340     case EM_MN10300:
10341     case EM_CYGNUS_MN10300:
10342       {
10343         static Elf_Internal_Sym * saved_sym = NULL;
10344
10345         switch (reloc_type)
10346           {
10347           case 34: /* R_MN10300_ALIGN */
10348             return TRUE;
10349           case 33: /* R_MN10300_SYM_DIFF */
10350             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10351             return TRUE;
10352           case 1: /* R_MN10300_32 */
10353           case 2: /* R_MN10300_16 */
10354             if (saved_sym != NULL)
10355               {
10356                 bfd_vma value;
10357
10358                 value = reloc->r_addend
10359                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10360                      - saved_sym->st_value);
10361
10362                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10363
10364                 saved_sym = NULL;
10365                 return TRUE;
10366               }
10367             break;
10368           default:
10369             if (saved_sym != NULL)
10370               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10371             break;
10372           }
10373         break;
10374       }
10375     }
10376
10377   return FALSE;
10378 }
10379
10380 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10381    DWARF debug sections.  This is a target specific test.  Note - we do not
10382    go through the whole including-target-headers-multiple-times route, (as
10383    we have already done with <elf/h8.h>) because this would become very
10384    messy and even then this function would have to contain target specific
10385    information (the names of the relocs instead of their numeric values).
10386    FIXME: This is not the correct way to solve this problem.  The proper way
10387    is to have target specific reloc sizing and typing functions created by
10388    the reloc-macros.h header, in the same way that it already creates the
10389    reloc naming functions.  */
10390
10391 static bfd_boolean
10392 is_32bit_abs_reloc (unsigned int reloc_type)
10393 {
10394   switch (elf_header.e_machine)
10395     {
10396     case EM_386:
10397     case EM_486:
10398       return reloc_type == 1; /* R_386_32.  */
10399     case EM_68K:
10400       return reloc_type == 1; /* R_68K_32.  */
10401     case EM_860:
10402       return reloc_type == 1; /* R_860_32.  */
10403     case EM_960:
10404       return reloc_type == 2; /* R_960_32.  */
10405     case EM_AARCH64:
10406       return reloc_type == 258; /* R_AARCH64_ABS32 */
10407     case EM_ALPHA:
10408       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
10409     case EM_ARC:
10410       return reloc_type == 1; /* R_ARC_32.  */
10411     case EM_ARM:
10412       return reloc_type == 2; /* R_ARM_ABS32 */
10413     case EM_AVR_OLD:
10414     case EM_AVR:
10415       return reloc_type == 1;
10416     case EM_ADAPTEVA_EPIPHANY:
10417       return reloc_type == 3;
10418     case EM_BLACKFIN:
10419       return reloc_type == 0x12; /* R_byte4_data.  */
10420     case EM_CRIS:
10421       return reloc_type == 3; /* R_CRIS_32.  */
10422     case EM_CR16:
10423       return reloc_type == 3; /* R_CR16_NUM32.  */
10424     case EM_CRX:
10425       return reloc_type == 15; /* R_CRX_NUM32.  */
10426     case EM_CYGNUS_FRV:
10427       return reloc_type == 1;
10428     case EM_CYGNUS_D10V:
10429     case EM_D10V:
10430       return reloc_type == 6; /* R_D10V_32.  */
10431     case EM_CYGNUS_D30V:
10432     case EM_D30V:
10433       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
10434     case EM_DLX:
10435       return reloc_type == 3; /* R_DLX_RELOC_32.  */
10436     case EM_CYGNUS_FR30:
10437     case EM_FR30:
10438       return reloc_type == 3; /* R_FR30_32.  */
10439     case EM_H8S:
10440     case EM_H8_300:
10441     case EM_H8_300H:
10442       return reloc_type == 1; /* R_H8_DIR32.  */
10443     case EM_IA_64:
10444       return reloc_type == 0x65; /* R_IA64_SECREL32LSB.  */
10445     case EM_IP2K_OLD:
10446     case EM_IP2K:
10447       return reloc_type == 2; /* R_IP2K_32.  */
10448     case EM_IQ2000:
10449       return reloc_type == 2; /* R_IQ2000_32.  */
10450     case EM_LATTICEMICO32:
10451       return reloc_type == 3; /* R_LM32_32.  */
10452     case EM_M32C_OLD:
10453     case EM_M32C:
10454       return reloc_type == 3; /* R_M32C_32.  */
10455     case EM_M32R:
10456       return reloc_type == 34; /* R_M32R_32_RELA.  */
10457     case EM_MCORE:
10458       return reloc_type == 1; /* R_MCORE_ADDR32.  */
10459     case EM_CYGNUS_MEP:
10460       return reloc_type == 4; /* R_MEP_32.  */
10461     case EM_METAG:
10462       return reloc_type == 2; /* R_METAG_ADDR32.  */
10463     case EM_MICROBLAZE:
10464       return reloc_type == 1; /* R_MICROBLAZE_32.  */
10465     case EM_MIPS:
10466       return reloc_type == 2; /* R_MIPS_32.  */
10467     case EM_MMIX:
10468       return reloc_type == 4; /* R_MMIX_32.  */
10469     case EM_CYGNUS_MN10200:
10470     case EM_MN10200:
10471       return reloc_type == 1; /* R_MN10200_32.  */
10472     case EM_CYGNUS_MN10300:
10473     case EM_MN10300:
10474       return reloc_type == 1; /* R_MN10300_32.  */
10475     case EM_MOXIE:
10476       return reloc_type == 1; /* R_MOXIE_32.  */
10477     case EM_MSP430_OLD:
10478     case EM_MSP430:
10479       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
10480     case EM_MT:
10481       return reloc_type == 2; /* R_MT_32.  */
10482     case EM_NDS32:
10483       return reloc_type == 20; /* R_NDS32_RELA.  */
10484     case EM_ALTERA_NIOS2:
10485       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
10486     case EM_NIOS32:
10487       return reloc_type == 1; /* R_NIOS_32.  */
10488     case EM_OPENRISC:
10489     case EM_OR32:
10490       return reloc_type == 1; /* R_OR32_32.  */
10491     case EM_PARISC:
10492       return (reloc_type == 1 /* R_PARISC_DIR32.  */
10493               || reloc_type == 41); /* R_PARISC_SECREL32.  */
10494     case EM_PJ:
10495     case EM_PJ_OLD:
10496       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
10497     case EM_PPC64:
10498       return reloc_type == 1; /* R_PPC64_ADDR32.  */
10499     case EM_PPC:
10500       return reloc_type == 1; /* R_PPC_ADDR32.  */
10501     case EM_RL78:
10502       return reloc_type == 1; /* R_RL78_DIR32.  */
10503     case EM_RX:
10504       return reloc_type == 1; /* R_RX_DIR32.  */
10505     case EM_S370:
10506       return reloc_type == 1; /* R_I370_ADDR31.  */
10507     case EM_S390_OLD:
10508     case EM_S390:
10509       return reloc_type == 4; /* R_S390_32.  */
10510     case EM_SCORE:
10511       return reloc_type == 8; /* R_SCORE_ABS32.  */
10512     case EM_SH:
10513       return reloc_type == 1; /* R_SH_DIR32.  */
10514     case EM_SPARC32PLUS:
10515     case EM_SPARCV9:
10516     case EM_SPARC:
10517       return reloc_type == 3 /* R_SPARC_32.  */
10518         || reloc_type == 23; /* R_SPARC_UA32.  */
10519     case EM_SPU:
10520       return reloc_type == 6; /* R_SPU_ADDR32 */
10521     case EM_TI_C6000:
10522       return reloc_type == 1; /* R_C6000_ABS32.  */
10523     case EM_TILEGX:
10524       return reloc_type == 2; /* R_TILEGX_32.  */
10525     case EM_TILEPRO:
10526       return reloc_type == 1; /* R_TILEPRO_32.  */
10527     case EM_CYGNUS_V850:
10528     case EM_V850:
10529       return reloc_type == 6; /* R_V850_ABS32.  */
10530     case EM_V800:
10531       return reloc_type == 0x33; /* R_V810_WORD.  */
10532     case EM_VAX:
10533       return reloc_type == 1; /* R_VAX_32.  */
10534     case EM_X86_64:
10535     case EM_L1OM:
10536     case EM_K1OM:
10537       return reloc_type == 10; /* R_X86_64_32.  */
10538     case EM_XC16X:
10539     case EM_C166:
10540       return reloc_type == 3; /* R_XC16C_ABS_32.  */
10541     case EM_XGATE:
10542       return reloc_type == 4; /* R_XGATE_32.  */
10543     case EM_XSTORMY16:
10544       return reloc_type == 1; /* R_XSTROMY16_32.  */
10545     case EM_XTENSA_OLD:
10546     case EM_XTENSA:
10547       return reloc_type == 1; /* R_XTENSA_32.  */
10548     default:
10549       error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10550              elf_header.e_machine);
10551       abort ();
10552     }
10553 }
10554
10555 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10556    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
10557
10558 static bfd_boolean
10559 is_32bit_pcrel_reloc (unsigned int reloc_type)
10560 {
10561   switch (elf_header.e_machine)
10562     {
10563     case EM_386:
10564     case EM_486:
10565       return reloc_type == 2;  /* R_386_PC32.  */
10566     case EM_68K:
10567       return reloc_type == 4;  /* R_68K_PC32.  */
10568     case EM_AARCH64:
10569       return reloc_type == 261; /* R_AARCH64_PREL32 */
10570     case EM_ADAPTEVA_EPIPHANY:
10571       return reloc_type == 6;
10572     case EM_ALPHA:
10573       return reloc_type == 10; /* R_ALPHA_SREL32.  */
10574     case EM_ARM:
10575       return reloc_type == 3;  /* R_ARM_REL32 */
10576     case EM_MICROBLAZE:
10577       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
10578     case EM_PARISC:
10579       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
10580     case EM_PPC:
10581       return reloc_type == 26; /* R_PPC_REL32.  */
10582     case EM_PPC64:
10583       return reloc_type == 26; /* R_PPC64_REL32.  */
10584     case EM_S390_OLD:
10585     case EM_S390:
10586       return reloc_type == 5;  /* R_390_PC32.  */
10587     case EM_SH:
10588       return reloc_type == 2;  /* R_SH_REL32.  */
10589     case EM_SPARC32PLUS:
10590     case EM_SPARCV9:
10591     case EM_SPARC:
10592       return reloc_type == 6;  /* R_SPARC_DISP32.  */
10593     case EM_SPU:
10594       return reloc_type == 13; /* R_SPU_REL32.  */
10595     case EM_TILEGX:
10596       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
10597     case EM_TILEPRO:
10598       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
10599     case EM_X86_64:
10600     case EM_L1OM:
10601     case EM_K1OM:
10602       return reloc_type == 2;  /* R_X86_64_PC32.  */
10603     case EM_XTENSA_OLD:
10604     case EM_XTENSA:
10605       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
10606     default:
10607       /* Do not abort or issue an error message here.  Not all targets use
10608          pc-relative 32-bit relocs in their DWARF debug information and we
10609          have already tested for target coverage in is_32bit_abs_reloc.  A
10610          more helpful warning message will be generated by apply_relocations
10611          anyway, so just return.  */
10612       return FALSE;
10613     }
10614 }
10615
10616 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10617    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
10618
10619 static bfd_boolean
10620 is_64bit_abs_reloc (unsigned int reloc_type)
10621 {
10622   switch (elf_header.e_machine)
10623     {
10624     case EM_AARCH64:
10625       return reloc_type == 257; /* R_AARCH64_ABS64.  */
10626     case EM_ALPHA:
10627       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
10628     case EM_IA_64:
10629       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
10630     case EM_PARISC:
10631       return reloc_type == 80; /* R_PARISC_DIR64.  */
10632     case EM_PPC64:
10633       return reloc_type == 38; /* R_PPC64_ADDR64.  */
10634     case EM_SPARC32PLUS:
10635     case EM_SPARCV9:
10636     case EM_SPARC:
10637       return reloc_type == 54; /* R_SPARC_UA64.  */
10638     case EM_X86_64:
10639     case EM_L1OM:
10640     case EM_K1OM:
10641       return reloc_type == 1; /* R_X86_64_64.  */
10642     case EM_S390_OLD:
10643     case EM_S390:
10644       return reloc_type == 22;  /* R_S390_64.  */
10645     case EM_TILEGX:
10646       return reloc_type == 1; /* R_TILEGX_64.  */
10647     case EM_MIPS:
10648       return reloc_type == 18;  /* R_MIPS_64.  */
10649     default:
10650       return FALSE;
10651     }
10652 }
10653
10654 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10655    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
10656
10657 static bfd_boolean
10658 is_64bit_pcrel_reloc (unsigned int reloc_type)
10659 {
10660   switch (elf_header.e_machine)
10661     {
10662     case EM_AARCH64:
10663       return reloc_type == 260; /* R_AARCH64_PREL64.  */
10664     case EM_ALPHA:
10665       return reloc_type == 11; /* R_ALPHA_SREL64.  */
10666     case EM_IA_64:
10667       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
10668     case EM_PARISC:
10669       return reloc_type == 72; /* R_PARISC_PCREL64.  */
10670     case EM_PPC64:
10671       return reloc_type == 44; /* R_PPC64_REL64.  */
10672     case EM_SPARC32PLUS:
10673     case EM_SPARCV9:
10674     case EM_SPARC:
10675       return reloc_type == 46; /* R_SPARC_DISP64.  */
10676     case EM_X86_64:
10677     case EM_L1OM:
10678     case EM_K1OM:
10679       return reloc_type == 24; /* R_X86_64_PC64.  */
10680     case EM_S390_OLD:
10681     case EM_S390:
10682       return reloc_type == 23;  /* R_S390_PC64.  */
10683     case EM_TILEGX:
10684       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
10685     default:
10686       return FALSE;
10687     }
10688 }
10689
10690 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10691    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
10692
10693 static bfd_boolean
10694 is_24bit_abs_reloc (unsigned int reloc_type)
10695 {
10696   switch (elf_header.e_machine)
10697     {
10698     case EM_CYGNUS_MN10200:
10699     case EM_MN10200:
10700       return reloc_type == 4; /* R_MN10200_24.  */
10701     default:
10702       return FALSE;
10703     }
10704 }
10705
10706 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10707    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
10708
10709 static bfd_boolean
10710 is_16bit_abs_reloc (unsigned int reloc_type)
10711 {
10712   switch (elf_header.e_machine)
10713     {
10714     case EM_AVR_OLD:
10715     case EM_AVR:
10716       return reloc_type == 4; /* R_AVR_16.  */
10717     case EM_ADAPTEVA_EPIPHANY:
10718       return reloc_type == 5;
10719     case EM_CYGNUS_D10V:
10720     case EM_D10V:
10721       return reloc_type == 3; /* R_D10V_16.  */
10722     case EM_H8S:
10723     case EM_H8_300:
10724     case EM_H8_300H:
10725       return reloc_type == R_H8_DIR16;
10726     case EM_IP2K_OLD:
10727     case EM_IP2K:
10728       return reloc_type == 1; /* R_IP2K_16.  */
10729     case EM_M32C_OLD:
10730     case EM_M32C:
10731       return reloc_type == 1; /* R_M32C_16 */
10732     case EM_MSP430:
10733       if (uses_msp430x_relocs ())
10734         return reloc_type == 2; /* R_MSP430_ABS16.  */
10735     case EM_MSP430_OLD:
10736       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
10737     case EM_NDS32:
10738       return reloc_type == 19; /* R_NDS32_RELA.  */
10739     case EM_ALTERA_NIOS2:
10740       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
10741     case EM_NIOS32:
10742       return reloc_type == 9; /* R_NIOS_16.  */
10743     case EM_TI_C6000:
10744       return reloc_type == 2; /* R_C6000_ABS16.  */
10745     case EM_XC16X:
10746     case EM_C166:
10747       return reloc_type == 2; /* R_XC16C_ABS_16.  */
10748     case EM_CYGNUS_MN10200:
10749     case EM_MN10200:
10750       return reloc_type == 2; /* R_MN10200_16.  */
10751     case EM_CYGNUS_MN10300:
10752     case EM_MN10300:
10753       return reloc_type == 2; /* R_MN10300_16.  */
10754     case EM_XGATE:
10755       return reloc_type == 3; /* R_XGATE_16.  */
10756     default:
10757       return FALSE;
10758     }
10759 }
10760
10761 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10762    relocation entries (possibly formerly used for SHT_GROUP sections).  */
10763
10764 static bfd_boolean
10765 is_none_reloc (unsigned int reloc_type)
10766 {
10767   switch (elf_header.e_machine)
10768     {
10769     case EM_68K:     /* R_68K_NONE.  */
10770     case EM_386:     /* R_386_NONE.  */
10771     case EM_SPARC32PLUS:
10772     case EM_SPARCV9:
10773     case EM_SPARC:   /* R_SPARC_NONE.  */
10774     case EM_MIPS:    /* R_MIPS_NONE.  */
10775     case EM_PARISC:  /* R_PARISC_NONE.  */
10776     case EM_ALPHA:   /* R_ALPHA_NONE.  */
10777     case EM_ADAPTEVA_EPIPHANY:
10778     case EM_PPC:     /* R_PPC_NONE.  */
10779     case EM_PPC64:   /* R_PPC64_NONE.  */
10780     case EM_ARM:     /* R_ARM_NONE.  */
10781     case EM_IA_64:   /* R_IA64_NONE.  */
10782     case EM_SH:      /* R_SH_NONE.  */
10783     case EM_S390_OLD:
10784     case EM_S390:    /* R_390_NONE.  */
10785     case EM_CRIS:    /* R_CRIS_NONE.  */
10786     case EM_X86_64:  /* R_X86_64_NONE.  */
10787     case EM_L1OM:    /* R_X86_64_NONE.  */
10788     case EM_K1OM:    /* R_X86_64_NONE.  */
10789     case EM_MN10300: /* R_MN10300_NONE.  */
10790     case EM_MOXIE:   /* R_MOXIE_NONE.  */
10791     case EM_M32R:    /* R_M32R_NONE.  */
10792     case EM_TI_C6000:/* R_C6000_NONE.  */
10793     case EM_TILEGX:  /* R_TILEGX_NONE.  */
10794     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
10795     case EM_XC16X:
10796     case EM_C166:    /* R_XC16X_NONE.  */
10797     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
10798     case EM_NIOS32:  /* R_NIOS_NONE.  */
10799       return reloc_type == 0;
10800     case EM_AARCH64:
10801       return reloc_type == 0 || reloc_type == 256;
10802     case EM_NDS32:
10803       return (reloc_type == 0       /* R_XTENSA_NONE.  */
10804               || reloc_type == 204  /* R_NDS32_DIFF8.  */
10805               || reloc_type == 205  /* R_NDS32_DIFF16.  */
10806               || reloc_type == 206  /* R_NDS32_DIFF32.  */
10807               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
10808     case EM_XTENSA_OLD:
10809     case EM_XTENSA:
10810       return (reloc_type == 0      /* R_XTENSA_NONE.  */
10811               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
10812               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
10813               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
10814     case EM_METAG:
10815       return reloc_type == 3; /* R_METAG_NONE.  */
10816     }
10817   return FALSE;
10818 }
10819
10820 /* Apply relocations to a section.
10821    Note: So far support has been added only for those relocations
10822    which can be found in debug sections.
10823    FIXME: Add support for more relocations ?  */
10824
10825 static void
10826 apply_relocations (void * file,
10827                    Elf_Internal_Shdr * section,
10828                    unsigned char * start)
10829 {
10830   Elf_Internal_Shdr * relsec;
10831   unsigned char * end = start + section->sh_size;
10832
10833   if (elf_header.e_type != ET_REL)
10834     return;
10835
10836   /* Find the reloc section associated with the section.  */
10837   for (relsec = section_headers;
10838        relsec < section_headers + elf_header.e_shnum;
10839        ++relsec)
10840     {
10841       bfd_boolean is_rela;
10842       unsigned long num_relocs;
10843       Elf_Internal_Rela * relocs;
10844       Elf_Internal_Rela * rp;
10845       Elf_Internal_Shdr * symsec;
10846       Elf_Internal_Sym * symtab;
10847       unsigned long num_syms;
10848       Elf_Internal_Sym * sym;
10849
10850       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10851           || relsec->sh_info >= elf_header.e_shnum
10852           || section_headers + relsec->sh_info != section
10853           || relsec->sh_size == 0
10854           || relsec->sh_link >= elf_header.e_shnum)
10855         continue;
10856
10857       is_rela = relsec->sh_type == SHT_RELA;
10858
10859       if (is_rela)
10860         {
10861           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10862                                   relsec->sh_size, & relocs, & num_relocs))
10863             return;
10864         }
10865       else
10866         {
10867           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10868                                  relsec->sh_size, & relocs, & num_relocs))
10869             return;
10870         }
10871
10872       /* SH uses RELA but uses in place value instead of the addend field.  */
10873       if (elf_header.e_machine == EM_SH)
10874         is_rela = FALSE;
10875
10876       symsec = section_headers + relsec->sh_link;
10877       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
10878
10879       for (rp = relocs; rp < relocs + num_relocs; ++rp)
10880         {
10881           bfd_vma         addend;
10882           unsigned int    reloc_type;
10883           unsigned int    reloc_size;
10884           unsigned char * rloc;
10885           unsigned long   sym_index;
10886
10887           reloc_type = get_reloc_type (rp->r_info);
10888
10889           if (target_specific_reloc_handling (rp, start, symtab))
10890             continue;
10891           else if (is_none_reloc (reloc_type))
10892             continue;
10893           else if (is_32bit_abs_reloc (reloc_type)
10894                    || is_32bit_pcrel_reloc (reloc_type))
10895             reloc_size = 4;
10896           else if (is_64bit_abs_reloc (reloc_type)
10897                    || is_64bit_pcrel_reloc (reloc_type))
10898             reloc_size = 8;
10899           else if (is_24bit_abs_reloc (reloc_type))
10900             reloc_size = 3;
10901           else if (is_16bit_abs_reloc (reloc_type))
10902             reloc_size = 2;
10903           else
10904             {
10905               warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10906                     reloc_type, SECTION_NAME (section));
10907               continue;
10908             }
10909
10910           rloc = start + rp->r_offset;
10911           if ((rloc + reloc_size) > end || (rloc < start))
10912             {
10913               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10914                     (unsigned long) rp->r_offset,
10915                     SECTION_NAME (section));
10916               continue;
10917             }
10918
10919           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10920           if (sym_index >= num_syms)
10921             {
10922               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10923                     sym_index, SECTION_NAME (section));
10924               continue;
10925             }
10926           sym = symtab + sym_index;
10927
10928           /* If the reloc has a symbol associated with it,
10929              make sure that it is of an appropriate type.
10930
10931              Relocations against symbols without type can happen.
10932              Gcc -feliminate-dwarf2-dups may generate symbols
10933              without type for debug info.
10934
10935              Icc generates relocations against function symbols
10936              instead of local labels.
10937
10938              Relocations against object symbols can happen, eg when
10939              referencing a global array.  For an example of this see
10940              the _clz.o binary in libgcc.a.  */
10941           if (sym != symtab
10942               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
10943             {
10944               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10945                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
10946                     (long int)(rp - relocs),
10947                     SECTION_NAME (relsec));
10948               continue;
10949             }
10950
10951           addend = 0;
10952           if (is_rela)
10953             addend += rp->r_addend;
10954           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10955              partial_inplace.  */
10956           if (!is_rela
10957               || (elf_header.e_machine == EM_XTENSA
10958                   && reloc_type == 1)
10959               || ((elf_header.e_machine == EM_PJ
10960                    || elf_header.e_machine == EM_PJ_OLD)
10961                   && reloc_type == 1)
10962               || ((elf_header.e_machine == EM_D30V
10963                    || elf_header.e_machine == EM_CYGNUS_D30V)
10964                   && reloc_type == 12))
10965             addend += byte_get (rloc, reloc_size);
10966
10967           if (is_32bit_pcrel_reloc (reloc_type)
10968               || is_64bit_pcrel_reloc (reloc_type))
10969             {
10970               /* On HPPA, all pc-relative relocations are biased by 8.  */
10971               if (elf_header.e_machine == EM_PARISC)
10972                 addend -= 8;
10973               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
10974                         reloc_size);
10975             }
10976           else
10977             byte_put (rloc, addend + sym->st_value, reloc_size);
10978         }
10979
10980       free (symtab);
10981       free (relocs);
10982       break;
10983     }
10984 }
10985
10986 #ifdef SUPPORT_DISASSEMBLY
10987 static int
10988 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10989 {
10990   printf (_("\nAssembly dump of section %s\n"),
10991           SECTION_NAME (section));
10992
10993   /* XXX -- to be done --- XXX */
10994
10995   return 1;
10996 }
10997 #endif
10998
10999 /* Reads in the contents of SECTION from FILE, returning a pointer
11000    to a malloc'ed buffer or NULL if something went wrong.  */
11001
11002 static char *
11003 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11004 {
11005   bfd_size_type num_bytes;
11006
11007   num_bytes = section->sh_size;
11008
11009   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11010     {
11011       printf (_("\nSection '%s' has no data to dump.\n"),
11012               SECTION_NAME (section));
11013       return NULL;
11014     }
11015
11016   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11017                              _("section contents"));
11018 }
11019
11020
11021 static void
11022 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11023 {
11024   Elf_Internal_Shdr * relsec;
11025   bfd_size_type num_bytes;
11026   char * data;
11027   char * end;
11028   char * start;
11029   char * name = SECTION_NAME (section);
11030   bfd_boolean some_strings_shown;
11031
11032   start = get_section_contents (section, file);
11033   if (start == NULL)
11034     return;
11035
11036   printf (_("\nString dump of section '%s':\n"), name);
11037
11038   /* If the section being dumped has relocations against it the user might
11039      be expecting these relocations to have been applied.  Check for this
11040      case and issue a warning message in order to avoid confusion.
11041      FIXME: Maybe we ought to have an option that dumps a section with
11042      relocs applied ?  */
11043   for (relsec = section_headers;
11044        relsec < section_headers + elf_header.e_shnum;
11045        ++relsec)
11046     {
11047       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11048           || relsec->sh_info >= elf_header.e_shnum
11049           || section_headers + relsec->sh_info != section
11050           || relsec->sh_size == 0
11051           || relsec->sh_link >= elf_header.e_shnum)
11052         continue;
11053
11054       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11055       break;
11056     }
11057
11058   num_bytes = section->sh_size;
11059   data = start;
11060   end  = start + num_bytes;
11061   some_strings_shown = FALSE;
11062
11063   while (data < end)
11064     {
11065       while (!ISPRINT (* data))
11066         if (++ data >= end)
11067           break;
11068
11069       if (data < end)
11070         {
11071 #ifndef __MSVCRT__
11072           /* PR 11128: Use two separate invocations in order to work
11073              around bugs in the Solaris 8 implementation of printf.  */
11074           printf ("  [%6tx]  ", data - start);
11075           printf ("%s\n", data);
11076 #else
11077           printf ("  [%6Ix]  %s\n", (size_t) (data - start), data);
11078 #endif
11079           data += strlen (data);
11080           some_strings_shown = TRUE;
11081         }
11082     }
11083
11084   if (! some_strings_shown)
11085     printf (_("  No strings found in this section."));
11086
11087   free (start);
11088
11089   putchar ('\n');
11090 }
11091
11092 static void
11093 dump_section_as_bytes (Elf_Internal_Shdr * section,
11094                        FILE * file,
11095                        bfd_boolean relocate)
11096 {
11097   Elf_Internal_Shdr * relsec;
11098   bfd_size_type bytes;
11099   bfd_vma addr;
11100   unsigned char * data;
11101   unsigned char * start;
11102
11103   start = (unsigned char *) get_section_contents (section, file);
11104   if (start == NULL)
11105     return;
11106
11107   printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
11108
11109   if (relocate)
11110     {
11111       apply_relocations (file, section, start);
11112     }
11113   else
11114     {
11115       /* If the section being dumped has relocations against it the user might
11116          be expecting these relocations to have been applied.  Check for this
11117          case and issue a warning message in order to avoid confusion.
11118          FIXME: Maybe we ought to have an option that dumps a section with
11119          relocs applied ?  */
11120       for (relsec = section_headers;
11121            relsec < section_headers + elf_header.e_shnum;
11122            ++relsec)
11123         {
11124           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11125               || relsec->sh_info >= elf_header.e_shnum
11126               || section_headers + relsec->sh_info != section
11127               || relsec->sh_size == 0
11128               || relsec->sh_link >= elf_header.e_shnum)
11129             continue;
11130
11131           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11132           break;
11133         }
11134     }
11135
11136   addr = section->sh_addr;
11137   bytes = section->sh_size;
11138   data = start;
11139
11140   while (bytes)
11141     {
11142       int j;
11143       int k;
11144       int lbytes;
11145
11146       lbytes = (bytes > 16 ? 16 : bytes);
11147
11148       printf ("  0x%8.8lx ", (unsigned long) addr);
11149
11150       for (j = 0; j < 16; j++)
11151         {
11152           if (j < lbytes)
11153             printf ("%2.2x", data[j]);
11154           else
11155             printf ("  ");
11156
11157           if ((j & 3) == 3)
11158             printf (" ");
11159         }
11160
11161       for (j = 0; j < lbytes; j++)
11162         {
11163           k = data[j];
11164           if (k >= ' ' && k < 0x7f)
11165             printf ("%c", k);
11166           else
11167             printf (".");
11168         }
11169
11170       putchar ('\n');
11171
11172       data  += lbytes;
11173       addr  += lbytes;
11174       bytes -= lbytes;
11175     }
11176
11177   free (start);
11178
11179   putchar ('\n');
11180 }
11181
11182 /* Uncompresses a section that was compressed using zlib, in place.  */
11183
11184 static int
11185 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11186                              dwarf_size_type *size ATTRIBUTE_UNUSED)
11187 {
11188 #ifndef HAVE_ZLIB_H
11189   return FALSE;
11190 #else
11191   dwarf_size_type compressed_size = *size;
11192   unsigned char * compressed_buffer = *buffer;
11193   dwarf_size_type uncompressed_size;
11194   unsigned char * uncompressed_buffer;
11195   z_stream strm;
11196   int rc;
11197   dwarf_size_type header_size = 12;
11198
11199   /* Read the zlib header.  In this case, it should be "ZLIB" followed
11200      by the uncompressed section size, 8 bytes in big-endian order.  */
11201   if (compressed_size < header_size
11202       || ! streq ((char *) compressed_buffer, "ZLIB"))
11203     return 0;
11204
11205   uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11206   uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11207   uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11208   uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11209   uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11210   uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11211   uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11212   uncompressed_size += compressed_buffer[11];
11213
11214   /* It is possible the section consists of several compressed
11215      buffers concatenated together, so we uncompress in a loop.  */
11216   strm.zalloc = NULL;
11217   strm.zfree = NULL;
11218   strm.opaque = NULL;
11219   strm.avail_in = compressed_size - header_size;
11220   strm.next_in = (Bytef *) compressed_buffer + header_size;
11221   strm.avail_out = uncompressed_size;
11222   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
11223
11224   rc = inflateInit (& strm);
11225   while (strm.avail_in > 0)
11226     {
11227       if (rc != Z_OK)
11228         goto fail;
11229       strm.next_out = ((Bytef *) uncompressed_buffer
11230                        + (uncompressed_size - strm.avail_out));
11231       rc = inflate (&strm, Z_FINISH);
11232       if (rc != Z_STREAM_END)
11233         goto fail;
11234       rc = inflateReset (& strm);
11235     }
11236   rc = inflateEnd (& strm);
11237   if (rc != Z_OK
11238       || strm.avail_out != 0)
11239     goto fail;
11240
11241   free (compressed_buffer);
11242   *buffer = uncompressed_buffer;
11243   *size = uncompressed_size;
11244   return 1;
11245
11246  fail:
11247   free (uncompressed_buffer);
11248   /* Indicate decompression failure.  */
11249   *buffer = NULL;
11250   return 0;
11251 #endif  /* HAVE_ZLIB_H */
11252 }
11253
11254 static int
11255 load_specific_debug_section (enum dwarf_section_display_enum debug,
11256                              Elf_Internal_Shdr * sec, void * file)
11257 {
11258   struct dwarf_section * section = &debug_displays [debug].section;
11259   char buf [64];
11260
11261   /* If it is already loaded, do nothing.  */
11262   if (section->start != NULL)
11263     return 1;
11264
11265   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11266   section->address = sec->sh_addr;
11267   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11268                                                sec->sh_offset, 1,
11269                                                sec->sh_size, buf);
11270   if (section->start == NULL)
11271     section->size = 0;
11272   else
11273     {
11274       section->size = sec->sh_size;
11275       if (uncompress_section_contents (&section->start, &section->size))
11276         sec->sh_size = section->size;
11277     }
11278
11279   if (section->start == NULL)
11280     return 0;
11281
11282   if (debug_displays [debug].relocate)
11283     apply_relocations ((FILE *) file, sec, section->start);
11284
11285   return 1;
11286 }
11287
11288 /* If this is not NULL, load_debug_section will only look for sections
11289    within the list of sections given here.  */
11290 unsigned int *section_subset = NULL;
11291
11292 int
11293 load_debug_section (enum dwarf_section_display_enum debug, void * file)
11294 {
11295   struct dwarf_section * section = &debug_displays [debug].section;
11296   Elf_Internal_Shdr * sec;
11297
11298   /* Locate the debug section.  */
11299   sec = find_section_in_set (section->uncompressed_name, section_subset);
11300   if (sec != NULL)
11301     section->name = section->uncompressed_name;
11302   else
11303     {
11304       sec = find_section_in_set (section->compressed_name, section_subset);
11305       if (sec != NULL)
11306         section->name = section->compressed_name;
11307     }
11308   if (sec == NULL)
11309     return 0;
11310
11311   /* If we're loading from a subset of sections, and we've loaded
11312      a section matching this name before, it's likely that it's a
11313      different one.  */
11314   if (section_subset != NULL)
11315     free_debug_section (debug);
11316
11317   return load_specific_debug_section (debug, sec, (FILE *) file);
11318 }
11319
11320 void
11321 free_debug_section (enum dwarf_section_display_enum debug)
11322 {
11323   struct dwarf_section * section = &debug_displays [debug].section;
11324
11325   if (section->start == NULL)
11326     return;
11327
11328   free ((char *) section->start);
11329   section->start = NULL;
11330   section->address = 0;
11331   section->size = 0;
11332 }
11333
11334 static int
11335 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
11336 {
11337   char * name = SECTION_NAME (section);
11338   bfd_size_type length;
11339   int result = 1;
11340   int i;
11341
11342   length = section->sh_size;
11343   if (length == 0)
11344     {
11345       printf (_("\nSection '%s' has no debugging data.\n"), name);
11346       return 0;
11347     }
11348   if (section->sh_type == SHT_NOBITS)
11349     {
11350       /* There is no point in dumping the contents of a debugging section
11351          which has the NOBITS type - the bits in the file will be random.
11352          This can happen when a file containing a .eh_frame section is
11353          stripped with the --only-keep-debug command line option.  */
11354       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
11355       return 0;
11356     }
11357
11358   if (const_strneq (name, ".gnu.linkonce.wi."))
11359     name = ".debug_info";
11360
11361   /* See if we know how to display the contents of this section.  */
11362   for (i = 0; i < max; i++)
11363     if (streq (debug_displays[i].section.uncompressed_name, name)
11364         || (i == line && const_strneq (name, ".debug_line."))
11365         || streq (debug_displays[i].section.compressed_name, name))
11366       {
11367         struct dwarf_section * sec = &debug_displays [i].section;
11368         int secondary = (section != find_section (name));
11369
11370         if (secondary)
11371           free_debug_section ((enum dwarf_section_display_enum) i);
11372
11373         if (i == line && const_strneq (name, ".debug_line."))
11374           sec->name = name;
11375         else if (streq (sec->uncompressed_name, name))
11376           sec->name = sec->uncompressed_name;
11377         else
11378           sec->name = sec->compressed_name;
11379         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
11380                                          section, file))
11381           {
11382             /* If this debug section is part of a CU/TU set in a .dwp file,
11383                restrict load_debug_section to the sections in that set.  */
11384             section_subset = find_cu_tu_set (file, shndx);
11385
11386             result &= debug_displays[i].display (sec, file);
11387
11388             section_subset = NULL;
11389
11390             if (secondary || (i != info && i != abbrev))
11391               free_debug_section ((enum dwarf_section_display_enum) i);
11392           }
11393
11394         break;
11395       }
11396
11397   if (i == max)
11398     {
11399       printf (_("Unrecognized debug section: %s\n"), name);
11400       result = 0;
11401     }
11402
11403   return result;
11404 }
11405
11406 /* Set DUMP_SECTS for all sections where dumps were requested
11407    based on section name.  */
11408
11409 static void
11410 initialise_dumps_byname (void)
11411 {
11412   struct dump_list_entry * cur;
11413
11414   for (cur = dump_sects_byname; cur; cur = cur->next)
11415     {
11416       unsigned int i;
11417       int any;
11418
11419       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11420         if (streq (SECTION_NAME (section_headers + i), cur->name))
11421           {
11422             request_dump_bynumber (i, cur->type);
11423             any = 1;
11424           }
11425
11426       if (!any)
11427         warn (_("Section '%s' was not dumped because it does not exist!\n"),
11428               cur->name);
11429     }
11430 }
11431
11432 static void
11433 process_section_contents (FILE * file)
11434 {
11435   Elf_Internal_Shdr * section;
11436   unsigned int i;
11437
11438   if (! do_dump)
11439     return;
11440
11441   initialise_dumps_byname ();
11442
11443   for (i = 0, section = section_headers;
11444        i < elf_header.e_shnum && i < num_dump_sects;
11445        i++, section++)
11446     {
11447 #ifdef SUPPORT_DISASSEMBLY
11448       if (dump_sects[i] & DISASS_DUMP)
11449         disassemble_section (section, file);
11450 #endif
11451       if (dump_sects[i] & HEX_DUMP)
11452         dump_section_as_bytes (section, file, FALSE);
11453
11454       if (dump_sects[i] & RELOC_DUMP)
11455         dump_section_as_bytes (section, file, TRUE);
11456
11457       if (dump_sects[i] & STRING_DUMP)
11458         dump_section_as_strings (section, file);
11459
11460       if (dump_sects[i] & DEBUG_DUMP)
11461         display_debug_section (i, section, file);
11462     }
11463
11464   /* Check to see if the user requested a
11465      dump of a section that does not exist.  */
11466   while (i++ < num_dump_sects)
11467     if (dump_sects[i])
11468       warn (_("Section %d was not dumped because it does not exist!\n"), i);
11469 }
11470
11471 static void
11472 process_mips_fpe_exception (int mask)
11473 {
11474   if (mask)
11475     {
11476       int first = 1;
11477       if (mask & OEX_FPU_INEX)
11478         fputs ("INEX", stdout), first = 0;
11479       if (mask & OEX_FPU_UFLO)
11480         printf ("%sUFLO", first ? "" : "|"), first = 0;
11481       if (mask & OEX_FPU_OFLO)
11482         printf ("%sOFLO", first ? "" : "|"), first = 0;
11483       if (mask & OEX_FPU_DIV0)
11484         printf ("%sDIV0", first ? "" : "|"), first = 0;
11485       if (mask & OEX_FPU_INVAL)
11486         printf ("%sINVAL", first ? "" : "|");
11487     }
11488   else
11489     fputs ("0", stdout);
11490 }
11491
11492 /* Display's the value of TAG at location P.  If TAG is
11493    greater than 0 it is assumed to be an unknown tag, and
11494    a message is printed to this effect.  Otherwise it is
11495    assumed that a message has already been printed.
11496
11497    If the bottom bit of TAG is set it assumed to have a
11498    string value, otherwise it is assumed to have an integer
11499    value.
11500
11501    Returns an updated P pointing to the first unread byte
11502    beyond the end of TAG's value.
11503
11504    Reads at or beyond END will not be made.  */
11505
11506 static unsigned char *
11507 display_tag_value (int tag,
11508                    unsigned char * p,
11509                    const unsigned char * const end)
11510 {
11511   unsigned long val;
11512
11513   if (tag > 0)
11514     printf ("  Tag_unknown_%d: ", tag);
11515
11516   if (p >= end)
11517     {
11518       warn (_("corrupt tag\n"));
11519     }
11520   else if (tag & 1)
11521     {
11522       /* FIXME: we could read beyond END here.  */
11523       printf ("\"%s\"\n", p);
11524       p += strlen ((char *) p) + 1;
11525     }
11526   else
11527     {
11528       unsigned int len;
11529
11530       val = read_uleb128 (p, &len, end);
11531       p += len;
11532       printf ("%ld (0x%lx)\n", val, val);
11533     }
11534
11535   return p;
11536 }
11537
11538 /* ARM EABI attributes section.  */
11539 typedef struct
11540 {
11541   int tag;
11542   const char * name;
11543   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
11544   int type;
11545   const char ** table;
11546 } arm_attr_public_tag;
11547
11548 static const char * arm_attr_tag_CPU_arch[] =
11549   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11550    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11551 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11552 static const char * arm_attr_tag_THUMB_ISA_use[] =
11553   {"No", "Thumb-1", "Thumb-2"};
11554 static const char * arm_attr_tag_FP_arch[] =
11555   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11556    "FP for ARMv8"};
11557 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
11558 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
11559   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11560 static const char * arm_attr_tag_PCS_config[] =
11561   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11562    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11563 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11564   {"V6", "SB", "TLS", "Unused"};
11565 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11566   {"Absolute", "PC-relative", "SB-relative", "None"};
11567 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11568   {"Absolute", "PC-relative", "None"};
11569 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11570   {"None", "direct", "GOT-indirect"};
11571 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11572   {"None", "??? 1", "2", "??? 3", "4"};
11573 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11574 static const char * arm_attr_tag_ABI_FP_denormal[] =
11575   {"Unused", "Needed", "Sign only"};
11576 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11577 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11578 static const char * arm_attr_tag_ABI_FP_number_model[] =
11579   {"Unused", "Finite", "RTABI", "IEEE 754"};
11580 static const char * arm_attr_tag_ABI_enum_size[] =
11581   {"Unused", "small", "int", "forced to int"};
11582 static const char * arm_attr_tag_ABI_HardFP_use[] =
11583   {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11584 static const char * arm_attr_tag_ABI_VFP_args[] =
11585   {"AAPCS", "VFP registers", "custom"};
11586 static const char * arm_attr_tag_ABI_WMMX_args[] =
11587   {"AAPCS", "WMMX registers", "custom"};
11588 static const char * arm_attr_tag_ABI_optimization_goals[] =
11589   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11590     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11591 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11592   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11593     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11594 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
11595 static const char * arm_attr_tag_FP_HP_extension[] =
11596   {"Not Allowed", "Allowed"};
11597 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
11598   {"None", "IEEE 754", "Alternative Format"};
11599 static const char * arm_attr_tag_MPextension_use[] =
11600   {"Not Allowed", "Allowed"};
11601 static const char * arm_attr_tag_DIV_use[] =
11602   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11603     "Allowed in v7-A with integer division extension"};
11604 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11605 static const char * arm_attr_tag_Virtualization_use[] =
11606   {"Not Allowed", "TrustZone", "Virtualization Extensions",
11607     "TrustZone and Virtualization Extensions"};
11608 static const char * arm_attr_tag_MPextension_use_legacy[] =
11609   {"Not Allowed", "Allowed"};
11610
11611 #define LOOKUP(id, name) \
11612   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11613 static arm_attr_public_tag arm_attr_public_tags[] =
11614 {
11615   {4, "CPU_raw_name", 1, NULL},
11616   {5, "CPU_name", 1, NULL},
11617   LOOKUP(6, CPU_arch),
11618   {7, "CPU_arch_profile", 0, NULL},
11619   LOOKUP(8, ARM_ISA_use),
11620   LOOKUP(9, THUMB_ISA_use),
11621   LOOKUP(10, FP_arch),
11622   LOOKUP(11, WMMX_arch),
11623   LOOKUP(12, Advanced_SIMD_arch),
11624   LOOKUP(13, PCS_config),
11625   LOOKUP(14, ABI_PCS_R9_use),
11626   LOOKUP(15, ABI_PCS_RW_data),
11627   LOOKUP(16, ABI_PCS_RO_data),
11628   LOOKUP(17, ABI_PCS_GOT_use),
11629   LOOKUP(18, ABI_PCS_wchar_t),
11630   LOOKUP(19, ABI_FP_rounding),
11631   LOOKUP(20, ABI_FP_denormal),
11632   LOOKUP(21, ABI_FP_exceptions),
11633   LOOKUP(22, ABI_FP_user_exceptions),
11634   LOOKUP(23, ABI_FP_number_model),
11635   {24, "ABI_align_needed", 0, NULL},
11636   {25, "ABI_align_preserved", 0, NULL},
11637   LOOKUP(26, ABI_enum_size),
11638   LOOKUP(27, ABI_HardFP_use),
11639   LOOKUP(28, ABI_VFP_args),
11640   LOOKUP(29, ABI_WMMX_args),
11641   LOOKUP(30, ABI_optimization_goals),
11642   LOOKUP(31, ABI_FP_optimization_goals),
11643   {32, "compatibility", 0, NULL},
11644   LOOKUP(34, CPU_unaligned_access),
11645   LOOKUP(36, FP_HP_extension),
11646   LOOKUP(38, ABI_FP_16bit_format),
11647   LOOKUP(42, MPextension_use),
11648   LOOKUP(44, DIV_use),
11649   {64, "nodefaults", 0, NULL},
11650   {65, "also_compatible_with", 0, NULL},
11651   LOOKUP(66, T2EE_use),
11652   {67, "conformance", 1, NULL},
11653   LOOKUP(68, Virtualization_use),
11654   LOOKUP(70, MPextension_use_legacy)
11655 };
11656 #undef LOOKUP
11657
11658 static unsigned char *
11659 display_arm_attribute (unsigned char * p,
11660                        const unsigned char * const end)
11661 {
11662   int tag;
11663   unsigned int len;
11664   int val;
11665   arm_attr_public_tag * attr;
11666   unsigned i;
11667   int type;
11668
11669   tag = read_uleb128 (p, &len, end);
11670   p += len;
11671   attr = NULL;
11672   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11673     {
11674       if (arm_attr_public_tags[i].tag == tag)
11675         {
11676           attr = &arm_attr_public_tags[i];
11677           break;
11678         }
11679     }
11680
11681   if (attr)
11682     {
11683       printf ("  Tag_%s: ", attr->name);
11684       switch (attr->type)
11685         {
11686         case 0:
11687           switch (tag)
11688             {
11689             case 7: /* Tag_CPU_arch_profile.  */
11690               val = read_uleb128 (p, &len, end);
11691               p += len;
11692               switch (val)
11693                 {
11694                 case 0: printf (_("None\n")); break;
11695                 case 'A': printf (_("Application\n")); break;
11696                 case 'R': printf (_("Realtime\n")); break;
11697                 case 'M': printf (_("Microcontroller\n")); break;
11698                 case 'S': printf (_("Application or Realtime\n")); break;
11699                 default: printf ("??? (%d)\n", val); break;
11700                 }
11701               break;
11702
11703             case 24: /* Tag_align_needed.  */
11704               val = read_uleb128 (p, &len, end);
11705               p += len;
11706               switch (val)
11707                 {
11708                 case 0: printf (_("None\n")); break;
11709                 case 1: printf (_("8-byte\n")); break;
11710                 case 2: printf (_("4-byte\n")); break;
11711                 case 3: printf ("??? 3\n"); break;
11712                 default:
11713                   if (val <= 12)
11714                     printf (_("8-byte and up to %d-byte extended\n"),
11715                             1 << val);
11716                   else
11717                     printf ("??? (%d)\n", val);
11718                   break;
11719                 }
11720               break;
11721
11722             case 25: /* Tag_align_preserved.  */
11723               val = read_uleb128 (p, &len, end);
11724               p += len;
11725               switch (val)
11726                 {
11727                 case 0: printf (_("None\n")); break;
11728                 case 1: printf (_("8-byte, except leaf SP\n")); break;
11729                 case 2: printf (_("8-byte\n")); break;
11730                 case 3: printf ("??? 3\n"); break;
11731                 default:
11732                   if (val <= 12)
11733                     printf (_("8-byte and up to %d-byte extended\n"),
11734                             1 << val);
11735                   else
11736                     printf ("??? (%d)\n", val);
11737                   break;
11738                 }
11739               break;
11740
11741             case 32: /* Tag_compatibility.  */
11742               val = read_uleb128 (p, &len, end);
11743               p += len;
11744               printf (_("flag = %d, vendor = %s\n"), val, p);
11745               p += strlen ((char *) p) + 1;
11746               break;
11747
11748             case 64: /* Tag_nodefaults.  */
11749               p++;
11750               printf (_("True\n"));
11751               break;
11752
11753             case 65: /* Tag_also_compatible_with.  */
11754               val = read_uleb128 (p, &len, end);
11755               p += len;
11756               if (val == 6 /* Tag_CPU_arch.  */)
11757                 {
11758                   val = read_uleb128 (p, &len, end);
11759                   p += len;
11760                   if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
11761                     printf ("??? (%d)\n", val);
11762                   else
11763                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11764                 }
11765               else
11766                 printf ("???\n");
11767               while (*(p++) != '\0' /* NUL terminator.  */);
11768               break;
11769
11770             default:
11771               abort ();
11772             }
11773           return p;
11774
11775         case 1:
11776           return display_tag_value (-1, p, end);
11777         case 2:
11778           return display_tag_value (0, p, end);
11779
11780         default:
11781           assert (attr->type & 0x80);
11782           val = read_uleb128 (p, &len, end);
11783           p += len;
11784           type = attr->type & 0x7f;
11785           if (val >= type)
11786             printf ("??? (%d)\n", val);
11787           else
11788             printf ("%s\n", attr->table[val]);
11789           return p;
11790         }
11791     }
11792
11793   return display_tag_value (tag, p, end);
11794 }
11795
11796 static unsigned char *
11797 display_gnu_attribute (unsigned char * p,
11798                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
11799                        const unsigned char * const end)
11800 {
11801   int tag;
11802   unsigned int len;
11803   int val;
11804
11805   tag = read_uleb128 (p, &len, end);
11806   p += len;
11807
11808   /* Tag_compatibility is the only generic GNU attribute defined at
11809      present.  */
11810   if (tag == 32)
11811     {
11812       val = read_uleb128 (p, &len, end);
11813       p += len;
11814       if (p == end)
11815         {
11816           printf (_("flag = %d, vendor = <corrupt>\n"), val);
11817           warn (_("corrupt vendor attribute\n"));
11818         }
11819       else
11820         {
11821           printf (_("flag = %d, vendor = %s\n"), val, p);
11822           p += strlen ((char *) p) + 1;
11823         }
11824       return p;
11825     }
11826
11827   if ((tag & 2) == 0 && display_proc_gnu_attribute)
11828     return display_proc_gnu_attribute (p, tag, end);
11829
11830   return display_tag_value (tag, p, end);
11831 }
11832
11833 static unsigned char *
11834 display_power_gnu_attribute (unsigned char * p,
11835                              int tag,
11836                              const unsigned char * const end)
11837 {
11838   unsigned int len;
11839   int val;
11840
11841   if (tag == Tag_GNU_Power_ABI_FP)
11842     {
11843       val = read_uleb128 (p, &len, end);
11844       p += len;
11845       printf ("  Tag_GNU_Power_ABI_FP: ");
11846
11847       switch (val)
11848         {
11849         case 0:
11850           printf (_("Hard or soft float\n"));
11851           break;
11852         case 1:
11853           printf (_("Hard float\n"));
11854           break;
11855         case 2:
11856           printf (_("Soft float\n"));
11857           break;
11858         case 3:
11859           printf (_("Single-precision hard float\n"));
11860           break;
11861         default:
11862           printf ("??? (%d)\n", val);
11863           break;
11864         }
11865       return p;
11866    }
11867
11868   if (tag == Tag_GNU_Power_ABI_Vector)
11869     {
11870       val = read_uleb128 (p, &len, end);
11871       p += len;
11872       printf ("  Tag_GNU_Power_ABI_Vector: ");
11873       switch (val)
11874         {
11875         case 0:
11876           printf (_("Any\n"));
11877           break;
11878         case 1:
11879           printf (_("Generic\n"));
11880           break;
11881         case 2:
11882           printf ("AltiVec\n");
11883           break;
11884         case 3:
11885           printf ("SPE\n");
11886           break;
11887         default:
11888           printf ("??? (%d)\n", val);
11889           break;
11890         }
11891       return p;
11892    }
11893
11894   if (tag == Tag_GNU_Power_ABI_Struct_Return)
11895     {
11896       if (p == end)
11897         {
11898           warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
11899           return p;
11900         }
11901
11902       val = read_uleb128 (p, &len, end);
11903       p += len;
11904       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
11905       switch (val)
11906        {
11907        case 0:
11908          printf (_("Any\n"));
11909          break;
11910        case 1:
11911          printf ("r3/r4\n");
11912          break;
11913        case 2:
11914          printf (_("Memory\n"));
11915          break;
11916        default:
11917          printf ("??? (%d)\n", val);
11918          break;
11919        }
11920       return p;
11921     }
11922
11923   return display_tag_value (tag & 1, p, end);
11924 }
11925
11926 static void
11927 display_sparc_hwcaps (int mask)
11928 {
11929   if (mask)
11930     {
11931       int first = 1;
11932       if (mask & ELF_SPARC_HWCAP_MUL32)
11933         fputs ("mul32", stdout), first = 0;
11934       if (mask & ELF_SPARC_HWCAP_DIV32)
11935         printf ("%sdiv32", first ? "" : "|"), first = 0;
11936       if (mask & ELF_SPARC_HWCAP_FSMULD)
11937         printf ("%sfsmuld", first ? "" : "|"), first = 0;
11938       if (mask & ELF_SPARC_HWCAP_V8PLUS)
11939         printf ("%sv8plus", first ? "" : "|"), first = 0;
11940       if (mask & ELF_SPARC_HWCAP_POPC)
11941         printf ("%spopc", first ? "" : "|"), first = 0;
11942       if (mask & ELF_SPARC_HWCAP_VIS)
11943         printf ("%svis", first ? "" : "|"), first = 0;
11944       if (mask & ELF_SPARC_HWCAP_VIS2)
11945         printf ("%svis2", first ? "" : "|"), first = 0;
11946       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11947         printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11948       if (mask & ELF_SPARC_HWCAP_FMAF)
11949         printf ("%sfmaf", first ? "" : "|"), first = 0;
11950       if (mask & ELF_SPARC_HWCAP_VIS3)
11951         printf ("%svis3", first ? "" : "|"), first = 0;
11952       if (mask & ELF_SPARC_HWCAP_HPC)
11953         printf ("%shpc", first ? "" : "|"), first = 0;
11954       if (mask & ELF_SPARC_HWCAP_RANDOM)
11955         printf ("%srandom", first ? "" : "|"), first = 0;
11956       if (mask & ELF_SPARC_HWCAP_TRANS)
11957         printf ("%strans", first ? "" : "|"), first = 0;
11958       if (mask & ELF_SPARC_HWCAP_FJFMAU)
11959         printf ("%sfjfmau", first ? "" : "|"), first = 0;
11960       if (mask & ELF_SPARC_HWCAP_IMA)
11961         printf ("%sima", first ? "" : "|"), first = 0;
11962       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11963         printf ("%scspare", first ? "" : "|"), first = 0;
11964     }
11965   else
11966     fputc('0', stdout);
11967   fputc('\n', stdout);
11968 }
11969
11970 static unsigned char *
11971 display_sparc_gnu_attribute (unsigned char * p,
11972                              int tag,
11973                              const unsigned char * const end)
11974 {
11975   if (tag == Tag_GNU_Sparc_HWCAPS)
11976     {
11977       unsigned int len;
11978       int val;
11979
11980       val = read_uleb128 (p, &len, end);
11981       p += len;
11982       printf ("  Tag_GNU_Sparc_HWCAPS: ");
11983       display_sparc_hwcaps (val);
11984       return p;
11985    }
11986
11987   return display_tag_value (tag, p, end);
11988 }
11989
11990 static unsigned char *
11991 display_mips_gnu_attribute (unsigned char * p,
11992                             int tag,
11993                             const unsigned char * const end)
11994 {
11995   if (tag == Tag_GNU_MIPS_ABI_FP)
11996     {
11997       unsigned int len;
11998       int val;
11999
12000       val = read_uleb128 (p, &len, end);
12001       p += len;
12002       printf ("  Tag_GNU_MIPS_ABI_FP: ");
12003
12004       switch (val)
12005         {
12006         case Val_GNU_MIPS_ABI_FP_ANY:
12007           printf (_("Hard or soft float\n"));
12008           break;
12009         case Val_GNU_MIPS_ABI_FP_DOUBLE:
12010           printf (_("Hard float (double precision)\n"));
12011           break;
12012         case Val_GNU_MIPS_ABI_FP_SINGLE:
12013           printf (_("Hard float (single precision)\n"));
12014           break;
12015         case Val_GNU_MIPS_ABI_FP_SOFT:
12016           printf (_("Soft float\n"));
12017           break;
12018         case Val_GNU_MIPS_ABI_FP_64:
12019           printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
12020           break;
12021         default:
12022           printf ("??? (%d)\n", val);
12023           break;
12024         }
12025       return p;
12026    }
12027
12028   if (tag == Tag_GNU_MIPS_ABI_MSA)
12029     {
12030       unsigned int len;
12031       int val;
12032
12033       val = read_uleb128 (p, &len, end);
12034       p += len;
12035       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
12036
12037       switch (val)
12038         {
12039         case Val_GNU_MIPS_ABI_MSA_ANY:
12040           printf (_("Any MSA or not\n"));
12041           break;
12042         case Val_GNU_MIPS_ABI_MSA_128:
12043           printf (_("128-bit MSA\n"));
12044           break;
12045         default:
12046           printf ("??? (%d)\n", val);
12047           break;
12048         }
12049       return p;
12050     }
12051
12052   return display_tag_value (tag & 1, p, end);
12053 }
12054
12055 static unsigned char *
12056 display_tic6x_attribute (unsigned char * p,
12057                          const unsigned char * const end)
12058 {
12059   int tag;
12060   unsigned int len;
12061   int val;
12062
12063   tag = read_uleb128 (p, &len, end);
12064   p += len;
12065
12066   switch (tag)
12067     {
12068     case Tag_ISA:
12069       val = read_uleb128 (p, &len, end);
12070       p += len;
12071       printf ("  Tag_ISA: ");
12072
12073       switch (val)
12074         {
12075         case C6XABI_Tag_ISA_none:
12076           printf (_("None\n"));
12077           break;
12078         case C6XABI_Tag_ISA_C62X:
12079           printf ("C62x\n");
12080           break;
12081         case C6XABI_Tag_ISA_C67X:
12082           printf ("C67x\n");
12083           break;
12084         case C6XABI_Tag_ISA_C67XP:
12085           printf ("C67x+\n");
12086           break;
12087         case C6XABI_Tag_ISA_C64X:
12088           printf ("C64x\n");
12089           break;
12090         case C6XABI_Tag_ISA_C64XP:
12091           printf ("C64x+\n");
12092           break;
12093         case C6XABI_Tag_ISA_C674X:
12094           printf ("C674x\n");
12095           break;
12096         default:
12097           printf ("??? (%d)\n", val);
12098           break;
12099         }
12100       return p;
12101
12102     case Tag_ABI_wchar_t:
12103       val = read_uleb128 (p, &len, end);
12104       p += len;
12105       printf ("  Tag_ABI_wchar_t: ");
12106       switch (val)
12107         {
12108         case 0:
12109           printf (_("Not used\n"));
12110           break;
12111         case 1:
12112           printf (_("2 bytes\n"));
12113           break;
12114         case 2:
12115           printf (_("4 bytes\n"));
12116           break;
12117         default:
12118           printf ("??? (%d)\n", val);
12119           break;
12120         }
12121       return p;
12122
12123     case Tag_ABI_stack_align_needed:
12124       val = read_uleb128 (p, &len, end);
12125       p += len;
12126       printf ("  Tag_ABI_stack_align_needed: ");
12127       switch (val)
12128         {
12129         case 0:
12130           printf (_("8-byte\n"));
12131           break;
12132         case 1:
12133           printf (_("16-byte\n"));
12134           break;
12135         default:
12136           printf ("??? (%d)\n", val);
12137           break;
12138         }
12139       return p;
12140
12141     case Tag_ABI_stack_align_preserved:
12142       val = read_uleb128 (p, &len, end);
12143       p += len;
12144       printf ("  Tag_ABI_stack_align_preserved: ");
12145       switch (val)
12146         {
12147         case 0:
12148           printf (_("8-byte\n"));
12149           break;
12150         case 1:
12151           printf (_("16-byte\n"));
12152           break;
12153         default:
12154           printf ("??? (%d)\n", val);
12155           break;
12156         }
12157       return p;
12158
12159     case Tag_ABI_DSBT:
12160       val = read_uleb128 (p, &len, end);
12161       p += len;
12162       printf ("  Tag_ABI_DSBT: ");
12163       switch (val)
12164         {
12165         case 0:
12166           printf (_("DSBT addressing not used\n"));
12167           break;
12168         case 1:
12169           printf (_("DSBT addressing used\n"));
12170           break;
12171         default:
12172           printf ("??? (%d)\n", val);
12173           break;
12174         }
12175       return p;
12176
12177     case Tag_ABI_PID:
12178       val = read_uleb128 (p, &len, end);
12179       p += len;
12180       printf ("  Tag_ABI_PID: ");
12181       switch (val)
12182         {
12183         case 0:
12184           printf (_("Data addressing position-dependent\n"));
12185           break;
12186         case 1:
12187           printf (_("Data addressing position-independent, GOT near DP\n"));
12188           break;
12189         case 2:
12190           printf (_("Data addressing position-independent, GOT far from DP\n"));
12191           break;
12192         default:
12193           printf ("??? (%d)\n", val);
12194           break;
12195         }
12196       return p;
12197
12198     case Tag_ABI_PIC:
12199       val = read_uleb128 (p, &len, end);
12200       p += len;
12201       printf ("  Tag_ABI_PIC: ");
12202       switch (val)
12203         {
12204         case 0:
12205           printf (_("Code addressing position-dependent\n"));
12206           break;
12207         case 1:
12208           printf (_("Code addressing position-independent\n"));
12209           break;
12210         default:
12211           printf ("??? (%d)\n", val);
12212           break;
12213         }
12214       return p;
12215
12216     case Tag_ABI_array_object_alignment:
12217       val = read_uleb128 (p, &len, end);
12218       p += len;
12219       printf ("  Tag_ABI_array_object_alignment: ");
12220       switch (val)
12221         {
12222         case 0:
12223           printf (_("8-byte\n"));
12224           break;
12225         case 1:
12226           printf (_("4-byte\n"));
12227           break;
12228         case 2:
12229           printf (_("16-byte\n"));
12230           break;
12231         default:
12232           printf ("??? (%d)\n", val);
12233           break;
12234         }
12235       return p;
12236
12237     case Tag_ABI_array_object_align_expected:
12238       val = read_uleb128 (p, &len, end);
12239       p += len;
12240       printf ("  Tag_ABI_array_object_align_expected: ");
12241       switch (val)
12242         {
12243         case 0:
12244           printf (_("8-byte\n"));
12245           break;
12246         case 1:
12247           printf (_("4-byte\n"));
12248           break;
12249         case 2:
12250           printf (_("16-byte\n"));
12251           break;
12252         default:
12253           printf ("??? (%d)\n", val);
12254           break;
12255         }
12256       return p;
12257
12258     case Tag_ABI_compatibility:
12259       val = read_uleb128 (p, &len, end);
12260       p += len;
12261       printf ("  Tag_ABI_compatibility: ");
12262       printf (_("flag = %d, vendor = %s\n"), val, p);
12263       p += strlen ((char *) p) + 1;
12264       return p;
12265
12266     case Tag_ABI_conformance:
12267       printf ("  Tag_ABI_conformance: ");
12268       printf ("\"%s\"\n", p);
12269       p += strlen ((char *) p) + 1;
12270       return p;
12271     }
12272
12273   return display_tag_value (tag, p, end);
12274 }
12275
12276 static void
12277 display_raw_attribute (unsigned char * p, unsigned char * end)
12278 {
12279   unsigned long addr = 0;
12280   size_t bytes = end - p;
12281
12282   while (bytes)
12283     {
12284       int j;
12285       int k;
12286       int lbytes = (bytes > 16 ? 16 : bytes);
12287
12288       printf ("  0x%8.8lx ", addr);
12289
12290       for (j = 0; j < 16; j++)
12291         {
12292           if (j < lbytes)
12293             printf ("%2.2x", p[j]);
12294           else
12295             printf ("  ");
12296
12297           if ((j & 3) == 3)
12298             printf (" ");
12299         }
12300
12301       for (j = 0; j < lbytes; j++)
12302         {
12303           k = p[j];
12304           if (k >= ' ' && k < 0x7f)
12305             printf ("%c", k);
12306           else
12307             printf (".");
12308         }
12309
12310       putchar ('\n');
12311
12312       p  += lbytes;
12313       bytes -= lbytes;
12314       addr += lbytes;
12315     }
12316
12317   putchar ('\n');
12318 }
12319
12320 static unsigned char *
12321 display_msp430x_attribute (unsigned char * p,
12322                            const unsigned char * const end)
12323 {
12324   unsigned int len;
12325   int val;
12326   int tag;
12327
12328   tag = read_uleb128 (p, & len, end);
12329   p += len;
12330
12331   switch (tag)
12332     {
12333     case OFBA_MSPABI_Tag_ISA:
12334       val = read_uleb128 (p, &len, end);
12335       p += len;
12336       printf ("  Tag_ISA: ");
12337       switch (val)
12338         {
12339         case 0: printf (_("None\n")); break;
12340         case 1: printf (_("MSP430\n")); break;
12341         case 2: printf (_("MSP430X\n")); break;
12342         default: printf ("??? (%d)\n", val); break;
12343         }
12344       break;
12345
12346     case OFBA_MSPABI_Tag_Code_Model:
12347       val = read_uleb128 (p, &len, end);
12348       p += len;
12349       printf ("  Tag_Code_Model: ");
12350       switch (val)
12351         {
12352         case 0: printf (_("None\n")); break;
12353         case 1: printf (_("Small\n")); break;
12354         case 2: printf (_("Large\n")); break;
12355         default: printf ("??? (%d)\n", val); break;
12356         }
12357       break;
12358
12359     case OFBA_MSPABI_Tag_Data_Model:
12360       val = read_uleb128 (p, &len, end);
12361       p += len;
12362       printf ("  Tag_Data_Model: ");
12363       switch (val)
12364         {
12365         case 0: printf (_("None\n")); break;
12366         case 1: printf (_("Small\n")); break;
12367         case 2: printf (_("Large\n")); break;
12368         case 3: printf (_("Restricted Large\n")); break;
12369         default: printf ("??? (%d)\n", val); break;
12370         }
12371       break;
12372
12373     default:
12374       printf (_("  <unknown tag %d>: "), tag);
12375
12376       if (tag & 1)
12377         {
12378           printf ("\"%s\"\n", p);
12379           p += strlen ((char *) p) + 1;
12380         }
12381       else
12382         {
12383           val = read_uleb128 (p, &len, end);
12384           p += len;
12385           printf ("%d (0x%x)\n", val, val);
12386         }
12387       break;
12388    }
12389
12390   return p;
12391 }
12392
12393 static int
12394 process_attributes (FILE * file,
12395                     const char * public_name,
12396                     unsigned int proc_type,
12397                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
12398                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
12399 {
12400   Elf_Internal_Shdr * sect;
12401   unsigned char * contents;
12402   unsigned char * p;
12403   unsigned char * end;
12404   bfd_vma section_len;
12405   bfd_vma len;
12406   unsigned i;
12407
12408   /* Find the section header so that we get the size.  */
12409   for (i = 0, sect = section_headers;
12410        i < elf_header.e_shnum;
12411        i++, sect++)
12412     {
12413       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
12414         continue;
12415
12416       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
12417                                              sect->sh_size, _("attributes"));
12418       if (contents == NULL)
12419         continue;
12420
12421       p = contents;
12422       if (*p == 'A')
12423         {
12424           len = sect->sh_size - 1;
12425           p++;
12426
12427           while (len > 0)
12428             {
12429               unsigned int namelen;
12430               bfd_boolean public_section;
12431               bfd_boolean gnu_section;
12432
12433               section_len = byte_get (p, 4);
12434               p += 4;
12435
12436               if (section_len > len)
12437                 {
12438                   error (_("Length of attribute (%u) greater than length of section (%u)\n"),
12439                           (unsigned) section_len, (unsigned) len);
12440                   section_len = len;
12441                 }
12442
12443               len -= section_len;
12444               section_len -= 4;
12445
12446               namelen = strnlen ((char *) p, section_len) + 1;
12447               if (namelen == 0 || namelen >= section_len)
12448                 {
12449                   error (_("Corrupt attribute section name\n"));
12450                   break;
12451                 }
12452
12453               printf (_("Attribute Section: %s\n"), p);
12454
12455               if (public_name && streq ((char *) p, public_name))
12456                 public_section = TRUE;
12457               else
12458                 public_section = FALSE;
12459
12460               if (streq ((char *) p, "gnu"))
12461                 gnu_section = TRUE;
12462               else
12463                 gnu_section = FALSE;
12464
12465               p += namelen;
12466               section_len -= namelen;
12467               while (section_len > 0)
12468                 {
12469                   int tag = *(p++);
12470                   int val;
12471                   bfd_vma size;
12472
12473                   size = byte_get (p, 4);
12474                   if (size > section_len)
12475                     {
12476                       error (_("Bad subsection length (%u > %u)\n"),
12477                               (unsigned) size, (unsigned) section_len);
12478                       size = section_len;
12479                     }
12480
12481                   section_len -= size;
12482                   end = p + size - 1;
12483                   p += 4;
12484
12485                   switch (tag)
12486                     {
12487                     case 1:
12488                       printf (_("File Attributes\n"));
12489                       break;
12490                     case 2:
12491                       printf (_("Section Attributes:"));
12492                       goto do_numlist;
12493                     case 3:
12494                       printf (_("Symbol Attributes:"));
12495                     do_numlist:
12496                       for (;;)
12497                         {
12498                           unsigned int j;
12499
12500                           val = read_uleb128 (p, &j, end);
12501                           p += j;
12502                           if (val == 0)
12503                             break;
12504                           printf (" %d", val);
12505                         }
12506                       printf ("\n");
12507                       break;
12508                     default:
12509                       printf (_("Unknown tag: %d\n"), tag);
12510                       public_section = FALSE;
12511                       break;
12512                     }
12513
12514                   if (public_section)
12515                     {
12516                       while (p < end)
12517                         p = display_pub_attribute (p, end);
12518                     }
12519                   else if (gnu_section)
12520                     {
12521                       while (p < end)
12522                         p = display_gnu_attribute (p,
12523                                                    display_proc_gnu_attribute,
12524                                                    end);
12525                     }
12526                   else
12527                     {
12528                       printf (_("  Unknown section contexts\n"));
12529                       display_raw_attribute (p, end);
12530                       p = end;
12531                     }
12532                 }
12533             }
12534         }
12535       else
12536         printf (_("Unknown format '%c' (%d)\n"), *p, *p);
12537
12538       free (contents);
12539     }
12540   return 1;
12541 }
12542
12543 static int
12544 process_arm_specific (FILE * file)
12545 {
12546   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
12547                              display_arm_attribute, NULL);
12548 }
12549
12550 static int
12551 process_power_specific (FILE * file)
12552 {
12553   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12554                              display_power_gnu_attribute);
12555 }
12556
12557 static int
12558 process_sparc_specific (FILE * file)
12559 {
12560   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12561                              display_sparc_gnu_attribute);
12562 }
12563
12564 static int
12565 process_tic6x_specific (FILE * file)
12566 {
12567   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
12568                              display_tic6x_attribute, NULL);
12569 }
12570
12571 static int
12572 process_msp430x_specific (FILE * file)
12573 {
12574   return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
12575                              display_msp430x_attribute, NULL);
12576 }
12577
12578 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12579    Print the Address, Access and Initial fields of an entry at VMA ADDR
12580    and return the VMA of the next entry.  */
12581
12582 static bfd_vma
12583 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12584 {
12585   printf ("  ");
12586   print_vma (addr, LONG_HEX);
12587   printf (" ");
12588   if (addr < pltgot + 0xfff0)
12589     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
12590   else
12591     printf ("%10s", "");
12592   printf (" ");
12593   if (data == NULL)
12594     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12595   else
12596     {
12597       bfd_vma entry;
12598
12599       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12600       print_vma (entry, LONG_HEX);
12601     }
12602   return addr + (is_32bit_elf ? 4 : 8);
12603 }
12604
12605 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12606    PLTGOT.  Print the Address and Initial fields of an entry at VMA
12607    ADDR and return the VMA of the next entry.  */
12608
12609 static bfd_vma
12610 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12611 {
12612   printf ("  ");
12613   print_vma (addr, LONG_HEX);
12614   printf (" ");
12615   if (data == NULL)
12616     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12617   else
12618     {
12619       bfd_vma entry;
12620
12621       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12622       print_vma (entry, LONG_HEX);
12623     }
12624   return addr + (is_32bit_elf ? 4 : 8);
12625 }
12626
12627 static int
12628 process_mips_specific (FILE * file)
12629 {
12630   Elf_Internal_Dyn * entry;
12631   size_t liblist_offset = 0;
12632   size_t liblistno = 0;
12633   size_t conflictsno = 0;
12634   size_t options_offset = 0;
12635   size_t conflicts_offset = 0;
12636   size_t pltrelsz = 0;
12637   size_t pltrel = 0;
12638   bfd_vma pltgot = 0;
12639   bfd_vma mips_pltgot = 0;
12640   bfd_vma jmprel = 0;
12641   bfd_vma local_gotno = 0;
12642   bfd_vma gotsym = 0;
12643   bfd_vma symtabno = 0;
12644
12645   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12646                       display_mips_gnu_attribute);
12647
12648   /* We have a lot of special sections.  Thanks SGI!  */
12649   if (dynamic_section == NULL)
12650     /* No information available.  */
12651     return 0;
12652
12653   for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
12654     switch (entry->d_tag)
12655       {
12656       case DT_MIPS_LIBLIST:
12657         liblist_offset
12658           = offset_from_vma (file, entry->d_un.d_val,
12659                              liblistno * sizeof (Elf32_External_Lib));
12660         break;
12661       case DT_MIPS_LIBLISTNO:
12662         liblistno = entry->d_un.d_val;
12663         break;
12664       case DT_MIPS_OPTIONS:
12665         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
12666         break;
12667       case DT_MIPS_CONFLICT:
12668         conflicts_offset
12669           = offset_from_vma (file, entry->d_un.d_val,
12670                              conflictsno * sizeof (Elf32_External_Conflict));
12671         break;
12672       case DT_MIPS_CONFLICTNO:
12673         conflictsno = entry->d_un.d_val;
12674         break;
12675       case DT_PLTGOT:
12676         pltgot = entry->d_un.d_ptr;
12677         break;
12678       case DT_MIPS_LOCAL_GOTNO:
12679         local_gotno = entry->d_un.d_val;
12680         break;
12681       case DT_MIPS_GOTSYM:
12682         gotsym = entry->d_un.d_val;
12683         break;
12684       case DT_MIPS_SYMTABNO:
12685         symtabno = entry->d_un.d_val;
12686         break;
12687       case DT_MIPS_PLTGOT:
12688         mips_pltgot = entry->d_un.d_ptr;
12689         break;
12690       case DT_PLTREL:
12691         pltrel = entry->d_un.d_val;
12692         break;
12693       case DT_PLTRELSZ:
12694         pltrelsz = entry->d_un.d_val;
12695         break;
12696       case DT_JMPREL:
12697         jmprel = entry->d_un.d_ptr;
12698         break;
12699       default:
12700         break;
12701       }
12702
12703   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
12704     {
12705       Elf32_External_Lib * elib;
12706       size_t cnt;
12707
12708       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
12709                                               liblistno,
12710                                               sizeof (Elf32_External_Lib),
12711                                               _("liblist section data"));
12712       if (elib)
12713         {
12714           printf (_("\nSection '.liblist' contains %lu entries:\n"),
12715                   (unsigned long) liblistno);
12716           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
12717                  stdout);
12718
12719           for (cnt = 0; cnt < liblistno; ++cnt)
12720             {
12721               Elf32_Lib liblist;
12722               time_t atime;
12723               char timebuf[20];
12724               struct tm * tmp;
12725
12726               liblist.l_name = BYTE_GET (elib[cnt].l_name);
12727               atime = BYTE_GET (elib[cnt].l_time_stamp);
12728               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12729               liblist.l_version = BYTE_GET (elib[cnt].l_version);
12730               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12731
12732               tmp = gmtime (&atime);
12733               snprintf (timebuf, sizeof (timebuf),
12734                         "%04u-%02u-%02uT%02u:%02u:%02u",
12735                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12736                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12737
12738               printf ("%3lu: ", (unsigned long) cnt);
12739               if (VALID_DYNAMIC_NAME (liblist.l_name))
12740                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
12741               else
12742                 printf (_("<corrupt: %9ld>"), liblist.l_name);
12743               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
12744                       liblist.l_version);
12745
12746               if (liblist.l_flags == 0)
12747                 puts (_(" NONE"));
12748               else
12749                 {
12750                   static const struct
12751                   {
12752                     const char * name;
12753                     int bit;
12754                   }
12755                   l_flags_vals[] =
12756                   {
12757                     { " EXACT_MATCH", LL_EXACT_MATCH },
12758                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
12759                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
12760                     { " EXPORTS", LL_EXPORTS },
12761                     { " DELAY_LOAD", LL_DELAY_LOAD },
12762                     { " DELTA", LL_DELTA }
12763                   };
12764                   int flags = liblist.l_flags;
12765                   size_t fcnt;
12766
12767                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
12768                     if ((flags & l_flags_vals[fcnt].bit) != 0)
12769                       {
12770                         fputs (l_flags_vals[fcnt].name, stdout);
12771                         flags ^= l_flags_vals[fcnt].bit;
12772                       }
12773                   if (flags != 0)
12774                     printf (" %#x", (unsigned int) flags);
12775
12776                   puts ("");
12777                 }
12778             }
12779
12780           free (elib);
12781         }
12782     }
12783
12784   if (options_offset != 0)
12785     {
12786       Elf_External_Options * eopt;
12787       Elf_Internal_Shdr * sect = section_headers;
12788       Elf_Internal_Options * iopt;
12789       Elf_Internal_Options * option;
12790       size_t offset;
12791       int cnt;
12792
12793       /* Find the section header so that we get the size.  */
12794       while (sect->sh_type != SHT_MIPS_OPTIONS)
12795         ++sect;
12796
12797       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
12798                                                 sect->sh_size, _("options"));
12799       if (eopt)
12800         {
12801           iopt = (Elf_Internal_Options *)
12802               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
12803           if (iopt == NULL)
12804             {
12805               error (_("Out of memory\n"));
12806               return 0;
12807             }
12808
12809           offset = cnt = 0;
12810           option = iopt;
12811
12812           while (offset < sect->sh_size)
12813             {
12814               Elf_External_Options * eoption;
12815
12816               eoption = (Elf_External_Options *) ((char *) eopt + offset);
12817
12818               option->kind = BYTE_GET (eoption->kind);
12819               option->size = BYTE_GET (eoption->size);
12820               option->section = BYTE_GET (eoption->section);
12821               option->info = BYTE_GET (eoption->info);
12822
12823               offset += option->size;
12824
12825               ++option;
12826               ++cnt;
12827             }
12828
12829           printf (_("\nSection '%s' contains %d entries:\n"),
12830                   SECTION_NAME (sect), cnt);
12831
12832           option = iopt;
12833
12834           while (cnt-- > 0)
12835             {
12836               size_t len;
12837
12838               switch (option->kind)
12839                 {
12840                 case ODK_NULL:
12841                   /* This shouldn't happen.  */
12842                   printf (" NULL       %d %lx", option->section, option->info);
12843                   break;
12844                 case ODK_REGINFO:
12845                   printf (" REGINFO    ");
12846                   if (elf_header.e_machine == EM_MIPS)
12847                     {
12848                       /* 32bit form.  */
12849                       Elf32_External_RegInfo * ereg;
12850                       Elf32_RegInfo reginfo;
12851
12852                       ereg = (Elf32_External_RegInfo *) (option + 1);
12853                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12854                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12855                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12856                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12857                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12858                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12859
12860                       printf ("GPR %08lx  GP 0x%lx\n",
12861                               reginfo.ri_gprmask,
12862                               (unsigned long) reginfo.ri_gp_value);
12863                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
12864                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12865                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12866                     }
12867                   else
12868                     {
12869                       /* 64 bit form.  */
12870                       Elf64_External_RegInfo * ereg;
12871                       Elf64_Internal_RegInfo reginfo;
12872
12873                       ereg = (Elf64_External_RegInfo *) (option + 1);
12874                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
12875                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12876                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12877                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12878                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12879                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
12880
12881                       printf ("GPR %08lx  GP 0x",
12882                               reginfo.ri_gprmask);
12883                       printf_vma (reginfo.ri_gp_value);
12884                       printf ("\n");
12885
12886                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
12887                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12888                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12889                     }
12890                   ++option;
12891                   continue;
12892                 case ODK_EXCEPTIONS:
12893                   fputs (" EXCEPTIONS fpe_min(", stdout);
12894                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12895                   fputs (") fpe_max(", stdout);
12896                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12897                   fputs (")", stdout);
12898
12899                   if (option->info & OEX_PAGE0)
12900                     fputs (" PAGE0", stdout);
12901                   if (option->info & OEX_SMM)
12902                     fputs (" SMM", stdout);
12903                   if (option->info & OEX_FPDBUG)
12904                     fputs (" FPDBUG", stdout);
12905                   if (option->info & OEX_DISMISS)
12906                     fputs (" DISMISS", stdout);
12907                   break;
12908                 case ODK_PAD:
12909                   fputs (" PAD       ", stdout);
12910                   if (option->info & OPAD_PREFIX)
12911                     fputs (" PREFIX", stdout);
12912                   if (option->info & OPAD_POSTFIX)
12913                     fputs (" POSTFIX", stdout);
12914                   if (option->info & OPAD_SYMBOL)
12915                     fputs (" SYMBOL", stdout);
12916                   break;
12917                 case ODK_HWPATCH:
12918                   fputs (" HWPATCH   ", stdout);
12919                   if (option->info & OHW_R4KEOP)
12920                     fputs (" R4KEOP", stdout);
12921                   if (option->info & OHW_R8KPFETCH)
12922                     fputs (" R8KPFETCH", stdout);
12923                   if (option->info & OHW_R5KEOP)
12924                     fputs (" R5KEOP", stdout);
12925                   if (option->info & OHW_R5KCVTL)
12926                     fputs (" R5KCVTL", stdout);
12927                   break;
12928                 case ODK_FILL:
12929                   fputs (" FILL       ", stdout);
12930                   /* XXX Print content of info word?  */
12931                   break;
12932                 case ODK_TAGS:
12933                   fputs (" TAGS       ", stdout);
12934                   /* XXX Print content of info word?  */
12935                   break;
12936                 case ODK_HWAND:
12937                   fputs (" HWAND     ", stdout);
12938                   if (option->info & OHWA0_R4KEOP_CHECKED)
12939                     fputs (" R4KEOP_CHECKED", stdout);
12940                   if (option->info & OHWA0_R4KEOP_CLEAN)
12941                     fputs (" R4KEOP_CLEAN", stdout);
12942                   break;
12943                 case ODK_HWOR:
12944                   fputs (" HWOR      ", stdout);
12945                   if (option->info & OHWA0_R4KEOP_CHECKED)
12946                     fputs (" R4KEOP_CHECKED", stdout);
12947                   if (option->info & OHWA0_R4KEOP_CLEAN)
12948                     fputs (" R4KEOP_CLEAN", stdout);
12949                   break;
12950                 case ODK_GP_GROUP:
12951                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
12952                           option->info & OGP_GROUP,
12953                           (option->info & OGP_SELF) >> 16);
12954                   break;
12955                 case ODK_IDENT:
12956                   printf (" IDENT     %#06lx  self-contained %#06lx",
12957                           option->info & OGP_GROUP,
12958                           (option->info & OGP_SELF) >> 16);
12959                   break;
12960                 default:
12961                   /* This shouldn't happen.  */
12962                   printf (" %3d ???     %d %lx",
12963                           option->kind, option->section, option->info);
12964                   break;
12965                 }
12966
12967               len = sizeof (* eopt);
12968               while (len < option->size)
12969                 if (((char *) option)[len] >= ' '
12970                     && ((char *) option)[len] < 0x7f)
12971                   printf ("%c", ((char *) option)[len++]);
12972                 else
12973                   printf ("\\%03o", ((char *) option)[len++]);
12974
12975               fputs ("\n", stdout);
12976               ++option;
12977             }
12978
12979           free (eopt);
12980         }
12981     }
12982
12983   if (conflicts_offset != 0 && conflictsno != 0)
12984     {
12985       Elf32_Conflict * iconf;
12986       size_t cnt;
12987
12988       if (dynamic_symbols == NULL)
12989         {
12990           error (_("conflict list found without a dynamic symbol table\n"));
12991           return 0;
12992         }
12993
12994       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
12995       if (iconf == NULL)
12996         {
12997           error (_("Out of memory\n"));
12998           return 0;
12999         }
13000
13001       if (is_32bit_elf)
13002         {
13003           Elf32_External_Conflict * econf32;
13004
13005           econf32 = (Elf32_External_Conflict *)
13006               get_data (NULL, file, conflicts_offset, conflictsno,
13007                         sizeof (* econf32), _("conflict"));
13008           if (!econf32)
13009             return 0;
13010
13011           for (cnt = 0; cnt < conflictsno; ++cnt)
13012             iconf[cnt] = BYTE_GET (econf32[cnt]);
13013
13014           free (econf32);
13015         }
13016       else
13017         {
13018           Elf64_External_Conflict * econf64;
13019
13020           econf64 = (Elf64_External_Conflict *)
13021               get_data (NULL, file, conflicts_offset, conflictsno,
13022                         sizeof (* econf64), _("conflict"));
13023           if (!econf64)
13024             return 0;
13025
13026           for (cnt = 0; cnt < conflictsno; ++cnt)
13027             iconf[cnt] = BYTE_GET (econf64[cnt]);
13028
13029           free (econf64);
13030         }
13031
13032       printf (_("\nSection '.conflict' contains %lu entries:\n"),
13033               (unsigned long) conflictsno);
13034       puts (_("  Num:    Index       Value  Name"));
13035
13036       for (cnt = 0; cnt < conflictsno; ++cnt)
13037         {
13038           Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
13039
13040           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
13041           print_vma (psym->st_value, FULL_HEX);
13042           putchar (' ');
13043           if (VALID_DYNAMIC_NAME (psym->st_name))
13044             print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
13045           else
13046             printf (_("<corrupt: %14ld>"), psym->st_name);
13047           putchar ('\n');
13048         }
13049
13050       free (iconf);
13051     }
13052
13053   if (pltgot != 0 && local_gotno != 0)
13054     {
13055       bfd_vma ent, local_end, global_end;
13056       size_t i, offset;
13057       unsigned char * data;
13058       int addr_size;
13059
13060       ent = pltgot;
13061       addr_size = (is_32bit_elf ? 4 : 8);
13062       local_end = pltgot + local_gotno * addr_size;
13063       global_end = local_end + (symtabno - gotsym) * addr_size;
13064
13065       offset = offset_from_vma (file, pltgot, global_end - pltgot);
13066       data = (unsigned char *) get_data (NULL, file, offset,
13067                                          global_end - pltgot, 1,
13068                                          _("Global Offset Table data"));
13069       if (data == NULL)
13070         return 0;
13071
13072       printf (_("\nPrimary GOT:\n"));
13073       printf (_(" Canonical gp value: "));
13074       print_vma (pltgot + 0x7ff0, LONG_HEX);
13075       printf ("\n\n");
13076
13077       printf (_(" Reserved entries:\n"));
13078       printf (_("  %*s %10s %*s Purpose\n"),
13079               addr_size * 2, _("Address"), _("Access"),
13080               addr_size * 2, _("Initial"));
13081       ent = print_mips_got_entry (data, pltgot, ent);
13082       printf (_(" Lazy resolver\n"));
13083       if (data
13084           && (byte_get (data + ent - pltgot, addr_size)
13085               >> (addr_size * 8 - 1)) != 0)
13086         {
13087           ent = print_mips_got_entry (data, pltgot, ent);
13088           printf (_(" Module pointer (GNU extension)\n"));
13089         }
13090       printf ("\n");
13091
13092       if (ent < local_end)
13093         {
13094           printf (_(" Local entries:\n"));
13095           printf ("  %*s %10s %*s\n",
13096                   addr_size * 2, _("Address"), _("Access"),
13097                   addr_size * 2, _("Initial"));
13098           while (ent < local_end)
13099             {
13100               ent = print_mips_got_entry (data, pltgot, ent);
13101               printf ("\n");
13102             }
13103           printf ("\n");
13104         }
13105
13106       if (gotsym < symtabno)
13107         {
13108           int sym_width;
13109
13110           printf (_(" Global entries:\n"));
13111           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
13112                   addr_size * 2, _("Address"),
13113                   _("Access"),
13114                   addr_size * 2, _("Initial"),
13115                   addr_size * 2, _("Sym.Val."),
13116                   _("Type"),
13117                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
13118                   _("Ndx"), _("Name"));
13119
13120           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
13121           for (i = gotsym; i < symtabno; i++)
13122             {
13123               Elf_Internal_Sym * psym;
13124
13125               psym = dynamic_symbols + i;
13126               ent = print_mips_got_entry (data, pltgot, ent);
13127               printf (" ");
13128               print_vma (psym->st_value, LONG_HEX);
13129               printf (" %-7s %3s ",
13130                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13131                       get_symbol_index_type (psym->st_shndx));
13132               if (VALID_DYNAMIC_NAME (psym->st_name))
13133                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13134               else
13135                 printf (_("<corrupt: %14ld>"), psym->st_name);
13136               printf ("\n");
13137             }
13138           printf ("\n");
13139         }
13140
13141       if (data)
13142         free (data);
13143     }
13144
13145   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
13146     {
13147       bfd_vma ent, end;
13148       size_t offset, rel_offset;
13149       unsigned long count, i;
13150       unsigned char * data;
13151       int addr_size, sym_width;
13152       Elf_Internal_Rela * rels;
13153
13154       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
13155       if (pltrel == DT_RELA)
13156         {
13157           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
13158             return 0;
13159         }
13160       else
13161         {
13162           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
13163             return 0;
13164         }
13165
13166       ent = mips_pltgot;
13167       addr_size = (is_32bit_elf ? 4 : 8);
13168       end = mips_pltgot + (2 + count) * addr_size;
13169
13170       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
13171       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
13172                                          1, _("Procedure Linkage Table data"));
13173       if (data == NULL)
13174         return 0;
13175
13176       printf ("\nPLT GOT:\n\n");
13177       printf (_(" Reserved entries:\n"));
13178       printf (_("  %*s %*s Purpose\n"),
13179               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
13180       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
13181       printf (_(" PLT lazy resolver\n"));
13182       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
13183       printf (_(" Module pointer\n"));
13184       printf ("\n");
13185
13186       printf (_(" Entries:\n"));
13187       printf ("  %*s %*s %*s %-7s %3s %s\n",
13188               addr_size * 2, _("Address"),
13189               addr_size * 2, _("Initial"),
13190               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
13191       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
13192       for (i = 0; i < count; i++)
13193         {
13194           Elf_Internal_Sym * psym;
13195
13196           psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
13197           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
13198           printf (" ");
13199           print_vma (psym->st_value, LONG_HEX);
13200           printf (" %-7s %3s ",
13201                   get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13202                   get_symbol_index_type (psym->st_shndx));
13203           if (VALID_DYNAMIC_NAME (psym->st_name))
13204             print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13205           else
13206             printf (_("<corrupt: %14ld>"), psym->st_name);
13207           printf ("\n");
13208         }
13209       printf ("\n");
13210
13211       if (data)
13212         free (data);
13213       free (rels);
13214     }
13215
13216   return 1;
13217 }
13218
13219 static int
13220 process_nds32_specific (FILE * file)
13221 {
13222   Elf_Internal_Shdr *sect = NULL;
13223
13224   sect = find_section (".nds32_e_flags");
13225   if (sect != NULL)
13226     {
13227       unsigned int *flag;
13228
13229       printf ("\nNDS32 elf flags section:\n");
13230       flag = get_data (NULL, file, sect->sh_offset, 1,
13231                        sect->sh_size, _("NDS32 elf flags section"));
13232
13233       switch ((*flag) & 0x3)
13234         {
13235         case 0:
13236           printf ("(VEC_SIZE):\tNo entry.\n");
13237           break;
13238         case 1:
13239           printf ("(VEC_SIZE):\t4 bytes\n");
13240           break;
13241         case 2:
13242           printf ("(VEC_SIZE):\t16 bytes\n");
13243           break;
13244         case 3:
13245           printf ("(VEC_SIZE):\treserved\n");
13246           break;
13247         }
13248     }
13249
13250   return TRUE;
13251 }
13252
13253 static int
13254 process_gnu_liblist (FILE * file)
13255 {
13256   Elf_Internal_Shdr * section;
13257   Elf_Internal_Shdr * string_sec;
13258   Elf32_External_Lib * elib;
13259   char * strtab;
13260   size_t strtab_size;
13261   size_t cnt;
13262   unsigned i;
13263
13264   if (! do_arch)
13265     return 0;
13266
13267   for (i = 0, section = section_headers;
13268        i < elf_header.e_shnum;
13269        i++, section++)
13270     {
13271       switch (section->sh_type)
13272         {
13273         case SHT_GNU_LIBLIST:
13274           if (section->sh_link >= elf_header.e_shnum)
13275             break;
13276
13277           elib = (Elf32_External_Lib *)
13278               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
13279                         _("liblist section data"));
13280
13281           if (elib == NULL)
13282             break;
13283           string_sec = section_headers + section->sh_link;
13284
13285           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
13286                                       string_sec->sh_size,
13287                                       _("liblist string table"));
13288           if (strtab == NULL
13289               || section->sh_entsize != sizeof (Elf32_External_Lib))
13290             {
13291               free (elib);
13292               free (strtab);
13293               break;
13294             }
13295           strtab_size = string_sec->sh_size;
13296
13297           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
13298                   SECTION_NAME (section),
13299                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
13300
13301           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
13302
13303           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
13304                ++cnt)
13305             {
13306               Elf32_Lib liblist;
13307               time_t atime;
13308               char timebuf[20];
13309               struct tm * tmp;
13310
13311               liblist.l_name = BYTE_GET (elib[cnt].l_name);
13312               atime = BYTE_GET (elib[cnt].l_time_stamp);
13313               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13314               liblist.l_version = BYTE_GET (elib[cnt].l_version);
13315               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13316
13317               tmp = gmtime (&atime);
13318               snprintf (timebuf, sizeof (timebuf),
13319                         "%04u-%02u-%02uT%02u:%02u:%02u",
13320                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13321                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
13322
13323               printf ("%3lu: ", (unsigned long) cnt);
13324               if (do_wide)
13325                 printf ("%-20s", liblist.l_name < strtab_size
13326                         ? strtab + liblist.l_name : _("<corrupt>"));
13327               else
13328                 printf ("%-20.20s", liblist.l_name < strtab_size
13329                         ? strtab + liblist.l_name : _("<corrupt>"));
13330               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
13331                       liblist.l_version, liblist.l_flags);
13332             }
13333
13334           free (elib);
13335           free (strtab);
13336         }
13337     }
13338
13339   return 1;
13340 }
13341
13342 static const char *
13343 get_note_type (unsigned e_type)
13344 {
13345   static char buff[64];
13346
13347   if (elf_header.e_type == ET_CORE)
13348     switch (e_type)
13349       {
13350       case NT_AUXV:
13351         return _("NT_AUXV (auxiliary vector)");
13352       case NT_PRSTATUS:
13353         return _("NT_PRSTATUS (prstatus structure)");
13354       case NT_FPREGSET:
13355         return _("NT_FPREGSET (floating point registers)");
13356       case NT_PRPSINFO:
13357         return _("NT_PRPSINFO (prpsinfo structure)");
13358       case NT_TASKSTRUCT:
13359         return _("NT_TASKSTRUCT (task structure)");
13360       case NT_PRXFPREG:
13361         return _("NT_PRXFPREG (user_xfpregs structure)");
13362       case NT_PPC_VMX:
13363         return _("NT_PPC_VMX (ppc Altivec registers)");
13364       case NT_PPC_VSX:
13365         return _("NT_PPC_VSX (ppc VSX registers)");
13366       case NT_386_TLS:
13367         return _("NT_386_TLS (x86 TLS information)");
13368       case NT_386_IOPERM:
13369         return _("NT_386_IOPERM (x86 I/O permissions)");
13370       case NT_X86_XSTATE:
13371         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
13372       case NT_S390_HIGH_GPRS:
13373         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
13374       case NT_S390_TIMER:
13375         return _("NT_S390_TIMER (s390 timer register)");
13376       case NT_S390_TODCMP:
13377         return _("NT_S390_TODCMP (s390 TOD comparator register)");
13378       case NT_S390_TODPREG:
13379         return _("NT_S390_TODPREG (s390 TOD programmable register)");
13380       case NT_S390_CTRS:
13381         return _("NT_S390_CTRS (s390 control registers)");
13382       case NT_S390_PREFIX:
13383         return _("NT_S390_PREFIX (s390 prefix register)");
13384       case NT_S390_LAST_BREAK:
13385         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
13386       case NT_S390_SYSTEM_CALL:
13387         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
13388       case NT_S390_TDB:
13389         return _("NT_S390_TDB (s390 transaction diagnostic block)");
13390       case NT_ARM_VFP:
13391         return _("NT_ARM_VFP (arm VFP registers)");
13392       case NT_ARM_TLS:
13393         return _("NT_ARM_TLS (AArch TLS registers)");
13394       case NT_ARM_HW_BREAK:
13395         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
13396       case NT_ARM_HW_WATCH:
13397         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
13398       case NT_PSTATUS:
13399         return _("NT_PSTATUS (pstatus structure)");
13400       case NT_FPREGS:
13401         return _("NT_FPREGS (floating point registers)");
13402       case NT_PSINFO:
13403         return _("NT_PSINFO (psinfo structure)");
13404       case NT_LWPSTATUS:
13405         return _("NT_LWPSTATUS (lwpstatus_t structure)");
13406       case NT_LWPSINFO:
13407         return _("NT_LWPSINFO (lwpsinfo_t structure)");
13408       case NT_WIN32PSTATUS:
13409         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
13410       case NT_SIGINFO:
13411         return _("NT_SIGINFO (siginfo_t data)");
13412       case NT_FILE:
13413         return _("NT_FILE (mapped files)");
13414       default:
13415         break;
13416       }
13417   else
13418     switch (e_type)
13419       {
13420       case NT_VERSION:
13421         return _("NT_VERSION (version)");
13422       case NT_ARCH:
13423         return _("NT_ARCH (architecture)");
13424       default:
13425         break;
13426       }
13427
13428   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13429   return buff;
13430 }
13431
13432 static int
13433 print_core_note (Elf_Internal_Note *pnote)
13434 {
13435   unsigned int addr_size = is_32bit_elf ? 4 : 8;
13436   bfd_vma count, page_size;
13437   unsigned char *descdata, *filenames, *descend;
13438
13439   if (pnote->type != NT_FILE)
13440     return 1;
13441
13442 #ifndef BFD64
13443   if (!is_32bit_elf)
13444     {
13445       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
13446       /* Still "successful".  */
13447       return 1;
13448     }
13449 #endif
13450
13451   if (pnote->descsz < 2 * addr_size)
13452     {
13453       printf (_("    Malformed note - too short for header\n"));
13454       return 0;
13455     }
13456
13457   descdata = (unsigned char *) pnote->descdata;
13458   descend = descdata + pnote->descsz;
13459
13460   if (descdata[pnote->descsz - 1] != '\0')
13461     {
13462       printf (_("    Malformed note - does not end with \\0\n"));
13463       return 0;
13464     }
13465
13466   count = byte_get (descdata, addr_size);
13467   descdata += addr_size;
13468
13469   page_size = byte_get (descdata, addr_size);
13470   descdata += addr_size;
13471
13472   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
13473     {
13474       printf (_("    Malformed note - too short for supplied file count\n"));
13475       return 0;
13476     }
13477
13478   printf (_("    Page size: "));
13479   print_vma (page_size, DEC);
13480   printf ("\n");
13481
13482   printf (_("    %*s%*s%*s\n"),
13483           (int) (2 + 2 * addr_size), _("Start"),
13484           (int) (4 + 2 * addr_size), _("End"),
13485           (int) (4 + 2 * addr_size), _("Page Offset"));
13486   filenames = descdata + count * 3 * addr_size;
13487   while (--count > 0)
13488     {
13489       bfd_vma start, end, file_ofs;
13490
13491       if (filenames == descend)
13492         {
13493           printf (_("    Malformed note - filenames end too early\n"));
13494           return 0;
13495         }
13496
13497       start = byte_get (descdata, addr_size);
13498       descdata += addr_size;
13499       end = byte_get (descdata, addr_size);
13500       descdata += addr_size;
13501       file_ofs = byte_get (descdata, addr_size);
13502       descdata += addr_size;
13503
13504       printf ("    ");
13505       print_vma (start, FULL_HEX);
13506       printf ("  ");
13507       print_vma (end, FULL_HEX);
13508       printf ("  ");
13509       print_vma (file_ofs, FULL_HEX);
13510       printf ("\n        %s\n", filenames);
13511
13512       filenames += 1 + strlen ((char *) filenames);
13513     }
13514
13515   return 1;
13516 }
13517
13518 static const char *
13519 get_gnu_elf_note_type (unsigned e_type)
13520 {
13521   static char buff[64];
13522
13523   switch (e_type)
13524     {
13525     case NT_GNU_ABI_TAG:
13526       return _("NT_GNU_ABI_TAG (ABI version tag)");
13527     case NT_GNU_HWCAP:
13528       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
13529     case NT_GNU_BUILD_ID:
13530       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
13531     case NT_GNU_GOLD_VERSION:
13532       return _("NT_GNU_GOLD_VERSION (gold version)");
13533     default:
13534       break;
13535     }
13536
13537   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13538   return buff;
13539 }
13540
13541 static int
13542 print_gnu_note (Elf_Internal_Note *pnote)
13543 {
13544   switch (pnote->type)
13545     {
13546     case NT_GNU_BUILD_ID:
13547       {
13548         unsigned long i;
13549
13550         printf (_("    Build ID: "));
13551         for (i = 0; i < pnote->descsz; ++i)
13552           printf ("%02x", pnote->descdata[i] & 0xff);
13553         printf ("\n");
13554       }
13555       break;
13556
13557     case NT_GNU_ABI_TAG:
13558       {
13559         unsigned long os, major, minor, subminor;
13560         const char *osname;
13561
13562         os = byte_get ((unsigned char *) pnote->descdata, 4);
13563         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
13564         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
13565         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
13566
13567         switch (os)
13568           {
13569           case GNU_ABI_TAG_LINUX:
13570             osname = "Linux";
13571             break;
13572           case GNU_ABI_TAG_HURD:
13573             osname = "Hurd";
13574             break;
13575           case GNU_ABI_TAG_SOLARIS:
13576             osname = "Solaris";
13577             break;
13578           case GNU_ABI_TAG_FREEBSD:
13579             osname = "FreeBSD";
13580             break;
13581           case GNU_ABI_TAG_NETBSD:
13582             osname = "NetBSD";
13583             break;
13584           default:
13585             osname = "Unknown";
13586             break;
13587           }
13588
13589         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
13590                 major, minor, subminor);
13591       }
13592       break;
13593
13594     case NT_GNU_GOLD_VERSION:
13595       {
13596         unsigned long i;
13597
13598         printf (_("    Version: "));
13599         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
13600           printf ("%c", pnote->descdata[i]);
13601         printf ("\n");
13602       }
13603       break;
13604     }
13605
13606   return 1;
13607 }
13608
13609 static const char *
13610 get_netbsd_elfcore_note_type (unsigned e_type)
13611 {
13612   static char buff[64];
13613
13614   if (e_type == NT_NETBSDCORE_PROCINFO)
13615     {
13616       /* NetBSD core "procinfo" structure.  */
13617       return _("NetBSD procinfo structure");
13618     }
13619
13620   /* As of Jan 2002 there are no other machine-independent notes
13621      defined for NetBSD core files.  If the note type is less
13622      than the start of the machine-dependent note types, we don't
13623      understand it.  */
13624
13625   if (e_type < NT_NETBSDCORE_FIRSTMACH)
13626     {
13627       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13628       return buff;
13629     }
13630
13631   switch (elf_header.e_machine)
13632     {
13633     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13634        and PT_GETFPREGS == mach+2.  */
13635
13636     case EM_OLD_ALPHA:
13637     case EM_ALPHA:
13638     case EM_SPARC:
13639     case EM_SPARC32PLUS:
13640     case EM_SPARCV9:
13641       switch (e_type)
13642         {
13643         case NT_NETBSDCORE_FIRSTMACH + 0:
13644           return _("PT_GETREGS (reg structure)");
13645         case NT_NETBSDCORE_FIRSTMACH + 2:
13646           return _("PT_GETFPREGS (fpreg structure)");
13647         default:
13648           break;
13649         }
13650       break;
13651
13652     /* On all other arch's, PT_GETREGS == mach+1 and
13653        PT_GETFPREGS == mach+3.  */
13654     default:
13655       switch (e_type)
13656         {
13657         case NT_NETBSDCORE_FIRSTMACH + 1:
13658           return _("PT_GETREGS (reg structure)");
13659         case NT_NETBSDCORE_FIRSTMACH + 3:
13660           return _("PT_GETFPREGS (fpreg structure)");
13661         default:
13662           break;
13663         }
13664     }
13665
13666   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
13667             e_type - NT_NETBSDCORE_FIRSTMACH);
13668   return buff;
13669 }
13670
13671 static const char *
13672 get_stapsdt_note_type (unsigned e_type)
13673 {
13674   static char buff[64];
13675
13676   switch (e_type)
13677     {
13678     case NT_STAPSDT:
13679       return _("NT_STAPSDT (SystemTap probe descriptors)");
13680
13681     default:
13682       break;
13683     }
13684
13685   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13686   return buff;
13687 }
13688
13689 static int
13690 print_stapsdt_note (Elf_Internal_Note *pnote)
13691 {
13692   int addr_size = is_32bit_elf ? 4 : 8;
13693   char *data = pnote->descdata;
13694   char *data_end = pnote->descdata + pnote->descsz;
13695   bfd_vma pc, base_addr, semaphore;
13696   char *provider, *probe, *arg_fmt;
13697
13698   pc = byte_get ((unsigned char *) data, addr_size);
13699   data += addr_size;
13700   base_addr = byte_get ((unsigned char *) data, addr_size);
13701   data += addr_size;
13702   semaphore = byte_get ((unsigned char *) data, addr_size);
13703   data += addr_size;
13704
13705   provider = data;
13706   data += strlen (data) + 1;
13707   probe = data;
13708   data += strlen (data) + 1;
13709   arg_fmt = data;
13710   data += strlen (data) + 1;
13711
13712   printf (_("    Provider: %s\n"), provider);
13713   printf (_("    Name: %s\n"), probe);
13714   printf (_("    Location: "));
13715   print_vma (pc, FULL_HEX);
13716   printf (_(", Base: "));
13717   print_vma (base_addr, FULL_HEX);
13718   printf (_(", Semaphore: "));
13719   print_vma (semaphore, FULL_HEX);
13720   printf ("\n");
13721   printf (_("    Arguments: %s\n"), arg_fmt);
13722
13723   return data == data_end;
13724 }
13725
13726 static const char *
13727 get_ia64_vms_note_type (unsigned e_type)
13728 {
13729   static char buff[64];
13730
13731   switch (e_type)
13732     {
13733     case NT_VMS_MHD:
13734       return _("NT_VMS_MHD (module header)");
13735     case NT_VMS_LNM:
13736       return _("NT_VMS_LNM (language name)");
13737     case NT_VMS_SRC:
13738       return _("NT_VMS_SRC (source files)");
13739     case NT_VMS_TITLE:
13740       return "NT_VMS_TITLE";
13741     case NT_VMS_EIDC:
13742       return _("NT_VMS_EIDC (consistency check)");
13743     case NT_VMS_FPMODE:
13744       return _("NT_VMS_FPMODE (FP mode)");
13745     case NT_VMS_LINKTIME:
13746       return "NT_VMS_LINKTIME";
13747     case NT_VMS_IMGNAM:
13748       return _("NT_VMS_IMGNAM (image name)");
13749     case NT_VMS_IMGID:
13750       return _("NT_VMS_IMGID (image id)");
13751     case NT_VMS_LINKID:
13752       return _("NT_VMS_LINKID (link id)");
13753     case NT_VMS_IMGBID:
13754       return _("NT_VMS_IMGBID (build id)");
13755     case NT_VMS_GSTNAM:
13756       return _("NT_VMS_GSTNAM (sym table name)");
13757     case NT_VMS_ORIG_DYN:
13758       return "NT_VMS_ORIG_DYN";
13759     case NT_VMS_PATCHTIME:
13760       return "NT_VMS_PATCHTIME";
13761     default:
13762       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13763       return buff;
13764     }
13765 }
13766
13767 static int
13768 print_ia64_vms_note (Elf_Internal_Note * pnote)
13769 {
13770   switch (pnote->type)
13771     {
13772     case NT_VMS_MHD:
13773       if (pnote->descsz > 36)
13774         {
13775           size_t l = strlen (pnote->descdata + 34);
13776           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
13777           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
13778           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
13779           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
13780         }
13781       else
13782         printf (_("    Invalid size\n"));
13783       break;
13784     case NT_VMS_LNM:
13785       printf (_("   Language: %s\n"), pnote->descdata);
13786       break;
13787 #ifdef BFD64
13788     case NT_VMS_FPMODE:
13789       printf (_("   Floating Point mode: "));
13790       printf ("0x%016" BFD_VMA_FMT "x\n",
13791               (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
13792       break;
13793     case NT_VMS_LINKTIME:
13794       printf (_("   Link time: "));
13795       print_vms_time
13796         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13797       printf ("\n");
13798       break;
13799     case NT_VMS_PATCHTIME:
13800       printf (_("   Patch time: "));
13801       print_vms_time
13802         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13803       printf ("\n");
13804       break;
13805     case NT_VMS_ORIG_DYN:
13806       printf (_("   Major id: %u,  minor id: %u\n"),
13807               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
13808               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
13809       printf (_("   Last modified  : "));
13810       print_vms_time
13811         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
13812       printf (_("\n   Link flags  : "));
13813       printf ("0x%016" BFD_VMA_FMT "x\n",
13814               (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
13815       printf (_("   Header flags: 0x%08x\n"),
13816               (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
13817       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
13818       break;
13819 #endif
13820     case NT_VMS_IMGNAM:
13821       printf (_("    Image name: %s\n"), pnote->descdata);
13822       break;
13823     case NT_VMS_GSTNAM:
13824       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
13825       break;
13826     case NT_VMS_IMGID:
13827       printf (_("    Image id: %s\n"), pnote->descdata);
13828       break;
13829     case NT_VMS_LINKID:
13830       printf (_("    Linker id: %s\n"), pnote->descdata);
13831       break;
13832     default:
13833       break;
13834     }
13835   return 1;
13836 }
13837
13838 /* Note that by the ELF standard, the name field is already null byte
13839    terminated, and namesz includes the terminating null byte.
13840    I.E. the value of namesz for the name "FSF" is 4.
13841
13842    If the value of namesz is zero, there is no name present.  */
13843 static int
13844 process_note (Elf_Internal_Note * pnote)
13845 {
13846   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
13847   const char * nt;
13848
13849   if (pnote->namesz == 0)
13850     /* If there is no note name, then use the default set of
13851        note type strings.  */
13852     nt = get_note_type (pnote->type);
13853
13854   else if (const_strneq (pnote->namedata, "GNU"))
13855     /* GNU-specific object file notes.  */
13856     nt = get_gnu_elf_note_type (pnote->type);
13857
13858   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
13859     /* NetBSD-specific core file notes.  */
13860     nt = get_netbsd_elfcore_note_type (pnote->type);
13861
13862   else if (strneq (pnote->namedata, "SPU/", 4))
13863     {
13864       /* SPU-specific core file notes.  */
13865       nt = pnote->namedata + 4;
13866       name = "SPU";
13867     }
13868
13869   else if (const_strneq (pnote->namedata, "IPF/VMS"))
13870     /* VMS/ia64-specific file notes.  */
13871     nt = get_ia64_vms_note_type (pnote->type);
13872
13873   else if (const_strneq (pnote->namedata, "stapsdt"))
13874     nt = get_stapsdt_note_type (pnote->type);
13875
13876   else
13877     /* Don't recognize this note name; just use the default set of
13878        note type strings.  */
13879     nt = get_note_type (pnote->type);
13880
13881   printf ("  %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
13882
13883   if (const_strneq (pnote->namedata, "IPF/VMS"))
13884     return print_ia64_vms_note (pnote);
13885   else if (const_strneq (pnote->namedata, "GNU"))
13886     return print_gnu_note (pnote);
13887   else if (const_strneq (pnote->namedata, "stapsdt"))
13888     return print_stapsdt_note (pnote);
13889   else if (const_strneq (pnote->namedata, "CORE"))
13890     return print_core_note (pnote);
13891   else
13892     return 1;
13893 }
13894
13895
13896 static int
13897 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
13898 {
13899   Elf_External_Note * pnotes;
13900   Elf_External_Note * external;
13901   int res = 1;
13902
13903   if (length <= 0)
13904     return 0;
13905
13906   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
13907                                            _("notes"));
13908   if (pnotes == NULL)
13909     return 0;
13910
13911   external = pnotes;
13912
13913   printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
13914           (unsigned long) offset, (unsigned long) length);
13915   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
13916
13917   while ((char *) external < (char *) pnotes + length)
13918     {
13919       Elf_Internal_Note inote;
13920       size_t min_notesz;
13921       char *next;
13922       char * temp = NULL;
13923       size_t data_remaining = ((char *) pnotes + length) - (char *) external;
13924
13925       if (!is_ia64_vms ())
13926         {
13927           /* PR binutils/15191
13928              Make sure that there is enough data to read.  */
13929           min_notesz = offsetof (Elf_External_Note, name);
13930           if (data_remaining < min_notesz)
13931             {
13932               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13933                     (int) data_remaining);
13934               break;
13935             }
13936           inote.type     = BYTE_GET (external->type);
13937           inote.namesz   = BYTE_GET (external->namesz);
13938           inote.namedata = external->name;
13939           inote.descsz   = BYTE_GET (external->descsz);
13940           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
13941           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
13942           next = inote.descdata + align_power (inote.descsz, 2);
13943         }
13944       else
13945         {
13946           Elf64_External_VMS_Note *vms_external;
13947
13948           /* PR binutils/15191
13949              Make sure that there is enough data to read.  */
13950           min_notesz = offsetof (Elf64_External_VMS_Note, name);
13951           if (data_remaining < min_notesz)
13952             {
13953               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13954                     (int) data_remaining);
13955               break;
13956             }
13957
13958           vms_external = (Elf64_External_VMS_Note *) external;
13959           inote.type     = BYTE_GET (vms_external->type);
13960           inote.namesz   = BYTE_GET (vms_external->namesz);
13961           inote.namedata = vms_external->name;
13962           inote.descsz   = BYTE_GET (vms_external->descsz);
13963           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
13964           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
13965           next = inote.descdata + align_power (inote.descsz, 3);
13966         }
13967
13968       if (inote.descdata < (char *) external + min_notesz
13969           || next < (char *) external + min_notesz
13970           || data_remaining < (size_t)(next - (char *) external))
13971         {
13972           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
13973                 (unsigned long) ((char *) external - (char *) pnotes));
13974           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
13975                 inote.type, inote.namesz, inote.descsz);
13976           break;
13977         }
13978
13979       external = (Elf_External_Note *) next;
13980
13981       /* Verify that name is null terminated.  It appears that at least
13982          one version of Linux (RedHat 6.0) generates corefiles that don't
13983          comply with the ELF spec by failing to include the null byte in
13984          namesz.  */
13985       if (inote.namedata[inote.namesz - 1] != '\0')
13986         {
13987           temp = (char *) malloc (inote.namesz + 1);
13988
13989           if (temp == NULL)
13990             {
13991               error (_("Out of memory\n"));
13992               res = 0;
13993               break;
13994             }
13995
13996           strncpy (temp, inote.namedata, inote.namesz);
13997           temp[inote.namesz] = 0;
13998
13999           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
14000           inote.namedata = temp;
14001         }
14002
14003       res &= process_note (& inote);
14004
14005       if (temp != NULL)
14006         {
14007           free (temp);
14008           temp = NULL;
14009         }
14010     }
14011
14012   free (pnotes);
14013
14014   return res;
14015 }
14016
14017 static int
14018 process_corefile_note_segments (FILE * file)
14019 {
14020   Elf_Internal_Phdr * segment;
14021   unsigned int i;
14022   int res = 1;
14023
14024   if (! get_program_headers (file))
14025       return 0;
14026
14027   for (i = 0, segment = program_headers;
14028        i < elf_header.e_phnum;
14029        i++, segment++)
14030     {
14031       if (segment->p_type == PT_NOTE)
14032         res &= process_corefile_note_segment (file,
14033                                               (bfd_vma) segment->p_offset,
14034                                               (bfd_vma) segment->p_filesz);
14035     }
14036
14037   return res;
14038 }
14039
14040 static int
14041 process_note_sections (FILE * file)
14042 {
14043   Elf_Internal_Shdr * section;
14044   unsigned long i;
14045   int res = 1;
14046
14047   for (i = 0, section = section_headers;
14048        i < elf_header.e_shnum && section != NULL;
14049        i++, section++)
14050     if (section->sh_type == SHT_NOTE)
14051       res &= process_corefile_note_segment (file,
14052                                             (bfd_vma) section->sh_offset,
14053                                             (bfd_vma) section->sh_size);
14054
14055   return res;
14056 }
14057
14058 static int
14059 process_notes (FILE * file)
14060 {
14061   /* If we have not been asked to display the notes then do nothing.  */
14062   if (! do_notes)
14063     return 1;
14064
14065   if (elf_header.e_type != ET_CORE)
14066     return process_note_sections (file);
14067
14068   /* No program headers means no NOTE segment.  */
14069   if (elf_header.e_phnum > 0)
14070     return process_corefile_note_segments (file);
14071
14072   printf (_("No note segments present in the core file.\n"));
14073   return 1;
14074 }
14075
14076 static int
14077 process_arch_specific (FILE * file)
14078 {
14079   if (! do_arch)
14080     return 1;
14081
14082   switch (elf_header.e_machine)
14083     {
14084     case EM_ARM:
14085       return process_arm_specific (file);
14086     case EM_MIPS:
14087     case EM_MIPS_RS3_LE:
14088       return process_mips_specific (file);
14089       break;
14090     case EM_NDS32:
14091       return process_nds32_specific (file);
14092       break;
14093     case EM_PPC:
14094       return process_power_specific (file);
14095       break;
14096     case EM_SPARC:
14097     case EM_SPARC32PLUS:
14098     case EM_SPARCV9:
14099       return process_sparc_specific (file);
14100       break;
14101     case EM_TI_C6000:
14102       return process_tic6x_specific (file);
14103       break;
14104     case EM_MSP430:
14105       return process_msp430x_specific (file);
14106     default:
14107       break;
14108     }
14109   return 1;
14110 }
14111
14112 static int
14113 get_file_header (FILE * file)
14114 {
14115   /* Read in the identity array.  */
14116   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
14117     return 0;
14118
14119   /* Determine how to read the rest of the header.  */
14120   switch (elf_header.e_ident[EI_DATA])
14121     {
14122     default: /* fall through */
14123     case ELFDATANONE: /* fall through */
14124     case ELFDATA2LSB:
14125       byte_get = byte_get_little_endian;
14126       byte_put = byte_put_little_endian;
14127       break;
14128     case ELFDATA2MSB:
14129       byte_get = byte_get_big_endian;
14130       byte_put = byte_put_big_endian;
14131       break;
14132     }
14133
14134   /* For now we only support 32 bit and 64 bit ELF files.  */
14135   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
14136
14137   /* Read in the rest of the header.  */
14138   if (is_32bit_elf)
14139     {
14140       Elf32_External_Ehdr ehdr32;
14141
14142       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
14143         return 0;
14144
14145       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
14146       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
14147       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
14148       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
14149       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
14150       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
14151       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
14152       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
14153       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
14154       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
14155       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
14156       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
14157       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
14158     }
14159   else
14160     {
14161       Elf64_External_Ehdr ehdr64;
14162
14163       /* If we have been compiled with sizeof (bfd_vma) == 4, then
14164          we will not be able to cope with the 64bit data found in
14165          64 ELF files.  Detect this now and abort before we start
14166          overwriting things.  */
14167       if (sizeof (bfd_vma) < 8)
14168         {
14169           error (_("This instance of readelf has been built without support for a\n\
14170 64 bit data type and so it cannot read 64 bit ELF files.\n"));
14171           return 0;
14172         }
14173
14174       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
14175         return 0;
14176
14177       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
14178       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
14179       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
14180       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
14181       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
14182       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
14183       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
14184       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
14185       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
14186       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
14187       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
14188       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
14189       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
14190     }
14191
14192   if (elf_header.e_shoff)
14193     {
14194       /* There may be some extensions in the first section header.  Don't
14195          bomb if we can't read it.  */
14196       if (is_32bit_elf)
14197         get_32bit_section_headers (file, 1);
14198       else
14199         get_64bit_section_headers (file, 1);
14200     }
14201
14202   return 1;
14203 }
14204
14205 /* Process one ELF object file according to the command line options.
14206    This file may actually be stored in an archive.  The file is
14207    positioned at the start of the ELF object.  */
14208
14209 static int
14210 process_object (char * file_name, FILE * file)
14211 {
14212   unsigned int i;
14213
14214   if (! get_file_header (file))
14215     {
14216       error (_("%s: Failed to read file header\n"), file_name);
14217       return 1;
14218     }
14219
14220   /* Initialise per file variables.  */
14221   for (i = ARRAY_SIZE (version_info); i--;)
14222     version_info[i] = 0;
14223
14224   for (i = ARRAY_SIZE (dynamic_info); i--;)
14225     dynamic_info[i] = 0;
14226   dynamic_info_DT_GNU_HASH = 0;
14227
14228   /* Process the file.  */
14229   if (show_name)
14230     printf (_("\nFile: %s\n"), file_name);
14231
14232   /* Initialise the dump_sects array from the cmdline_dump_sects array.
14233      Note we do this even if cmdline_dump_sects is empty because we
14234      must make sure that the dump_sets array is zeroed out before each
14235      object file is processed.  */
14236   if (num_dump_sects > num_cmdline_dump_sects)
14237     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
14238
14239   if (num_cmdline_dump_sects > 0)
14240     {
14241       if (num_dump_sects == 0)
14242         /* A sneaky way of allocating the dump_sects array.  */
14243         request_dump_bynumber (num_cmdline_dump_sects, 0);
14244
14245       assert (num_dump_sects >= num_cmdline_dump_sects);
14246       memcpy (dump_sects, cmdline_dump_sects,
14247               num_cmdline_dump_sects * sizeof (* dump_sects));
14248     }
14249
14250   if (! process_file_header ())
14251     return 1;
14252
14253   if (! process_section_headers (file))
14254     {
14255       /* Without loaded section headers we cannot process lots of
14256          things.  */
14257       do_unwind = do_version = do_dump = do_arch = 0;
14258
14259       if (! do_using_dynamic)
14260         do_syms = do_dyn_syms = do_reloc = 0;
14261     }
14262
14263   if (! process_section_groups (file))
14264     {
14265       /* Without loaded section groups we cannot process unwind.  */
14266       do_unwind = 0;
14267     }
14268
14269   if (process_program_headers (file))
14270     process_dynamic_section (file);
14271
14272   process_relocs (file);
14273
14274   process_unwind (file);
14275
14276   process_symbol_table (file);
14277
14278   process_syminfo (file);
14279
14280   process_version_sections (file);
14281
14282   process_section_contents (file);
14283
14284   process_notes (file);
14285
14286   process_gnu_liblist (file);
14287
14288   process_arch_specific (file);
14289
14290   if (program_headers)
14291     {
14292       free (program_headers);
14293       program_headers = NULL;
14294     }
14295
14296   if (section_headers)
14297     {
14298       free (section_headers);
14299       section_headers = NULL;
14300     }
14301
14302   if (string_table)
14303     {
14304       free (string_table);
14305       string_table = NULL;
14306       string_table_length = 0;
14307     }
14308
14309   if (dynamic_strings)
14310     {
14311       free (dynamic_strings);
14312       dynamic_strings = NULL;
14313       dynamic_strings_length = 0;
14314     }
14315
14316   if (dynamic_symbols)
14317     {
14318       free (dynamic_symbols);
14319       dynamic_symbols = NULL;
14320       num_dynamic_syms = 0;
14321     }
14322
14323   if (dynamic_syminfo)
14324     {
14325       free (dynamic_syminfo);
14326       dynamic_syminfo = NULL;
14327     }
14328
14329   if (dynamic_section)
14330     {
14331       free (dynamic_section);
14332       dynamic_section = NULL;
14333     }
14334
14335   if (section_headers_groups)
14336     {
14337       free (section_headers_groups);
14338       section_headers_groups = NULL;
14339     }
14340
14341   if (section_groups)
14342     {
14343       struct group_list * g;
14344       struct group_list * next;
14345
14346       for (i = 0; i < group_count; i++)
14347         {
14348           for (g = section_groups [i].root; g != NULL; g = next)
14349             {
14350               next = g->next;
14351               free (g);
14352             }
14353         }
14354
14355       free (section_groups);
14356       section_groups = NULL;
14357     }
14358
14359   free_debug_memory ();
14360
14361   return 0;
14362 }
14363
14364 /* Process an ELF archive.
14365    On entry the file is positioned just after the ARMAG string.  */
14366
14367 static int
14368 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
14369 {
14370   struct archive_info arch;
14371   struct archive_info nested_arch;
14372   size_t got;
14373   int ret;
14374
14375   show_name = 1;
14376
14377   /* The ARCH structure is used to hold information about this archive.  */
14378   arch.file_name = NULL;
14379   arch.file = NULL;
14380   arch.index_array = NULL;
14381   arch.sym_table = NULL;
14382   arch.longnames = NULL;
14383
14384   /* The NESTED_ARCH structure is used as a single-item cache of information
14385      about a nested archive (when members of a thin archive reside within
14386      another regular archive file).  */
14387   nested_arch.file_name = NULL;
14388   nested_arch.file = NULL;
14389   nested_arch.index_array = NULL;
14390   nested_arch.sym_table = NULL;
14391   nested_arch.longnames = NULL;
14392
14393   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
14394     {
14395       ret = 1;
14396       goto out;
14397     }
14398
14399   if (do_archive_index)
14400     {
14401       if (arch.sym_table == NULL)
14402         error (_("%s: unable to dump the index as none was found\n"), file_name);
14403       else
14404         {
14405           unsigned int i, l;
14406           unsigned long current_pos;
14407
14408           printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
14409                   file_name, (long) arch.index_num, arch.sym_size);
14410           current_pos = ftell (file);
14411
14412           for (i = l = 0; i < arch.index_num; i++)
14413             {
14414               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
14415                 {
14416                   char * member_name;
14417
14418                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
14419
14420                   if (member_name != NULL)
14421                     {
14422                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
14423
14424                       if (qualified_name != NULL)
14425                         {
14426                           printf (_("Contents of binary %s at offset "), qualified_name);
14427                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
14428                           putchar ('\n');
14429                           free (qualified_name);
14430                         }
14431                     }
14432                 }
14433
14434               if (l >= arch.sym_size)
14435                 {
14436                   error (_("%s: end of the symbol table reached before the end of the index\n"),
14437                          file_name);
14438                   break;
14439                 }
14440               printf ("\t%s\n", arch.sym_table + l);
14441               l += strlen (arch.sym_table + l) + 1;
14442             }
14443
14444           if (arch.uses_64bit_indicies)
14445             l = (l + 7) & ~ 7;
14446           else
14447             l += l & 1;
14448
14449           if (l < arch.sym_size)
14450             error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
14451                    file_name, arch.sym_size - l);
14452
14453           if (fseek (file, current_pos, SEEK_SET) != 0)
14454             {
14455               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
14456               ret = 1;
14457               goto out;
14458             }
14459         }
14460
14461       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
14462           && !do_segments && !do_header && !do_dump && !do_version
14463           && !do_histogram && !do_debugging && !do_arch && !do_notes
14464           && !do_section_groups && !do_dyn_syms)
14465         {
14466           ret = 0; /* Archive index only.  */
14467           goto out;
14468         }
14469     }
14470
14471   ret = 0;
14472
14473   while (1)
14474     {
14475       char * name;
14476       size_t namelen;
14477       char * qualified_name;
14478
14479       /* Read the next archive header.  */
14480       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
14481         {
14482           error (_("%s: failed to seek to next archive header\n"), file_name);
14483           return 1;
14484         }
14485       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
14486       if (got != sizeof arch.arhdr)
14487         {
14488           if (got == 0)
14489             break;
14490           error (_("%s: failed to read archive header\n"), file_name);
14491           ret = 1;
14492           break;
14493         }
14494       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
14495         {
14496           error (_("%s: did not find a valid archive header\n"), arch.file_name);
14497           ret = 1;
14498           break;
14499         }
14500
14501       arch.next_arhdr_offset += sizeof arch.arhdr;
14502
14503       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
14504       if (archive_file_size & 01)
14505         ++archive_file_size;
14506
14507       name = get_archive_member_name (&arch, &nested_arch);
14508       if (name == NULL)
14509         {
14510           error (_("%s: bad archive file name\n"), file_name);
14511           ret = 1;
14512           break;
14513         }
14514       namelen = strlen (name);
14515
14516       qualified_name = make_qualified_name (&arch, &nested_arch, name);
14517       if (qualified_name == NULL)
14518         {
14519           error (_("%s: bad archive file name\n"), file_name);
14520           ret = 1;
14521           break;
14522         }
14523
14524       if (is_thin_archive && arch.nested_member_origin == 0)
14525         {
14526           /* This is a proxy for an external member of a thin archive.  */
14527           FILE * member_file;
14528           char * member_file_name = adjust_relative_path (file_name, name, namelen);
14529           if (member_file_name == NULL)
14530             {
14531               ret = 1;
14532               break;
14533             }
14534
14535           member_file = fopen (member_file_name, "rb");
14536           if (member_file == NULL)
14537             {
14538               error (_("Input file '%s' is not readable.\n"), member_file_name);
14539               free (member_file_name);
14540               ret = 1;
14541               break;
14542             }
14543
14544           archive_file_offset = arch.nested_member_origin;
14545
14546           ret |= process_object (qualified_name, member_file);
14547
14548           fclose (member_file);
14549           free (member_file_name);
14550         }
14551       else if (is_thin_archive)
14552         {
14553           /* PR 15140: Allow for corrupt thin archives.  */
14554           if (nested_arch.file == NULL)
14555             {
14556               error (_("%s: contains corrupt thin archive: %s\n"),
14557                      file_name, name);
14558               ret = 1;
14559               break;
14560             }
14561
14562           /* This is a proxy for a member of a nested archive.  */
14563           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
14564
14565           /* The nested archive file will have been opened and setup by
14566              get_archive_member_name.  */
14567           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
14568             {
14569               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
14570               ret = 1;
14571               break;
14572             }
14573
14574           ret |= process_object (qualified_name, nested_arch.file);
14575         }
14576       else
14577         {
14578           archive_file_offset = arch.next_arhdr_offset;
14579           arch.next_arhdr_offset += archive_file_size;
14580
14581           ret |= process_object (qualified_name, file);
14582         }
14583
14584       if (dump_sects != NULL)
14585         {
14586           free (dump_sects);
14587           dump_sects = NULL;
14588           num_dump_sects = 0;
14589         }
14590
14591       free (qualified_name);
14592     }
14593
14594  out:
14595   if (nested_arch.file != NULL)
14596     fclose (nested_arch.file);
14597   release_archive (&nested_arch);
14598   release_archive (&arch);
14599
14600   return ret;
14601 }
14602
14603 static int
14604 process_file (char * file_name)
14605 {
14606   FILE * file;
14607   struct stat statbuf;
14608   char armag[SARMAG];
14609   int ret;
14610
14611   if (stat (file_name, &statbuf) < 0)
14612     {
14613       if (errno == ENOENT)
14614         error (_("'%s': No such file\n"), file_name);
14615       else
14616         error (_("Could not locate '%s'.  System error message: %s\n"),
14617                file_name, strerror (errno));
14618       return 1;
14619     }
14620
14621   if (! S_ISREG (statbuf.st_mode))
14622     {
14623       error (_("'%s' is not an ordinary file\n"), file_name);
14624       return 1;
14625     }
14626
14627   file = fopen (file_name, "rb");
14628   if (file == NULL)
14629     {
14630       error (_("Input file '%s' is not readable.\n"), file_name);
14631       return 1;
14632     }
14633
14634   if (fread (armag, SARMAG, 1, file) != 1)
14635     {
14636       error (_("%s: Failed to read file's magic number\n"), file_name);
14637       fclose (file);
14638       return 1;
14639     }
14640
14641   if (memcmp (armag, ARMAG, SARMAG) == 0)
14642     ret = process_archive (file_name, file, FALSE);
14643   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
14644     ret = process_archive (file_name, file, TRUE);
14645   else
14646     {
14647       if (do_archive_index)
14648         error (_("File %s is not an archive so its index cannot be displayed.\n"),
14649                file_name);
14650
14651       rewind (file);
14652       archive_file_size = archive_file_offset = 0;
14653       ret = process_object (file_name, file);
14654     }
14655
14656   fclose (file);
14657
14658   return ret;
14659 }
14660
14661 #ifdef SUPPORT_DISASSEMBLY
14662 /* Needed by the i386 disassembler.  For extra credit, someone could
14663    fix this so that we insert symbolic addresses here, esp for GOT/PLT
14664    symbols.  */
14665
14666 void
14667 print_address (unsigned int addr, FILE * outfile)
14668 {
14669   fprintf (outfile,"0x%8.8x", addr);
14670 }
14671
14672 /* Needed by the i386 disassembler.  */
14673 void
14674 db_task_printsym (unsigned int addr)
14675 {
14676   print_address (addr, stderr);
14677 }
14678 #endif
14679
14680 int
14681 main (int argc, char ** argv)
14682 {
14683   int err;
14684
14685 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14686   setlocale (LC_MESSAGES, "");
14687 #endif
14688 #if defined (HAVE_SETLOCALE)
14689   setlocale (LC_CTYPE, "");
14690 #endif
14691   bindtextdomain (PACKAGE, LOCALEDIR);
14692   textdomain (PACKAGE);
14693
14694   expandargv (&argc, &argv);
14695
14696   parse_args (argc, argv);
14697
14698   if (num_dump_sects > 0)
14699     {
14700       /* Make a copy of the dump_sects array.  */
14701       cmdline_dump_sects = (dump_type *)
14702           malloc (num_dump_sects * sizeof (* dump_sects));
14703       if (cmdline_dump_sects == NULL)
14704         error (_("Out of memory allocating dump request table.\n"));
14705       else
14706         {
14707           memcpy (cmdline_dump_sects, dump_sects,
14708                   num_dump_sects * sizeof (* dump_sects));
14709           num_cmdline_dump_sects = num_dump_sects;
14710         }
14711     }
14712
14713   if (optind < (argc - 1))
14714     show_name = 1;
14715
14716   err = 0;
14717   while (optind < argc)
14718     err |= process_file (argv[optind++]);
14719
14720   if (dump_sects != NULL)
14721     free (dump_sects);
14722   if (cmdline_dump_sects != NULL)
14723     free (cmdline_dump_sects);
14724
14725   return err;
14726 }