binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright 1998-2013 Free Software Foundation, Inc.
   3
   4    Originally developed by Eric Youngdale <eric@andante.jic.com>
   5    Modifications by Nick Clifton <nickc@redhat.com>
   6
   7    This file is part of GNU Binutils.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  22    02110-1301, USA.  */
  23 \f
  24 /* The difference between readelf and objdump:
  25
  26   Both programs are capable of displaying the contents of ELF format files,
  27   so why does the binutils project have two file dumpers ?
  28
  29   The reason is that objdump sees an ELF file through a BFD filter of the
  30   world; if BFD has a bug where, say, it disagrees about a machine constant
  31   in e_flags, then the odds are good that it will remain internally
  32   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
  33   GAS sees it the BFD way.  There was need for a tool to go find out what
  34   the file actually says.
  35
  36   This is why the readelf program does not link against the BFD library - it
  37   exists as an independent program to help verify the correct working of BFD.
  38
  39   There is also the case that readelf can provide more information about an
  40   ELF file than is provided by objdump.  In particular it can display DWARF
  41   debugging information which (at the moment) objdump cannot.  */
  42 \f
  43 #include "sysdep.h"
  44 #include <assert.h>
  45 #include <time.h>
  46 #ifdef HAVE_ZLIB_H
  47 #include <zlib.h>
  48 #endif
  49 #ifdef HAVE_WCHAR_H
  50 #include <wchar.h>
  51 #endif
  52
  53 #if __GNUC__ >= 2
  54 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  55    as this will allow us to read in and parse 64bit and 32bit ELF files.
  56    Only do this if we believe that the compiler can support a 64 bit
  57    data type.  For now we only rely on GCC being able to do this.  */
  58 #define BFD64
  59 #endif
  60
  61 #include "bfd.h"
  62 #include "bucomm.h"
  63 #include "elfcomm.h"
  64 #include "dwarf.h"
  65
  66 #include "elf/common.h"
  67 #include "elf/external.h"
  68 #include "elf/internal.h"
  69
  70
  71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  72    we can obtain the H8 reloc numbers.  We need these for the
  73    get_reloc_size() function.  We include h8.h again after defining
  74    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  75
  76 #include "elf/h8.h"
  77 #undef _ELF_H8_H
  78
  79 /* Undo the effects of #including reloc-macros.h.  */
  80
  81 #undef START_RELOC_NUMBERS
  82 #undef RELOC_NUMBER
  83 #undef FAKE_RELOC
  84 #undef EMPTY_RELOC
  85 #undef END_RELOC_NUMBERS
  86 #undef _RELOC_MACROS_H
  87
  88 /* The following headers use the elf/reloc-macros.h file to
  89    automatically generate relocation recognition functions
  90    such as elf_mips_reloc_type()  */
  91
  92 #define RELOC_MACROS_GEN_FUNC
  93
  94 #include "elf/aarch64.h"
  95 #include "elf/alpha.h"
  96 #include "elf/arc.h"
  97 #include "elf/arm.h"
  98 #include "elf/avr.h"
  99 #include "elf/bfin.h"
 100 #include "elf/cr16.h"
 101 #include "elf/cris.h"
 102 #include "elf/crx.h"
 103 #include "elf/d10v.h"
 104 #include "elf/d30v.h"
 105 #include "elf/dlx.h"
 106 #include "elf/epiphany.h"
 107 #include "elf/fr30.h"
 108 #include "elf/frv.h"
 109 #include "elf/h8.h"
 110 #include "elf/hppa.h"
 111 #include "elf/i386.h"
 112 #include "elf/i370.h"
 113 #include "elf/i860.h"
 114 #include "elf/i960.h"
 115 #include "elf/ia64.h"
 116 #include "elf/ip2k.h"
 117 #include "elf/lm32.h"
 118 #include "elf/iq2000.h"
 119 #include "elf/m32c.h"
 120 #include "elf/m32r.h"
 121 #include "elf/m68k.h"
 122 #include "elf/m68hc11.h"
 123 #include "elf/mcore.h"
 124 #include "elf/mep.h"
 125 #include "elf/metag.h"
 126 #include "elf/microblaze.h"
 127 #include "elf/mips.h"
 128 #include "elf/mmix.h"
 129 #include "elf/mn10200.h"
 130 #include "elf/mn10300.h"
 131 #include "elf/moxie.h"
 132 #include "elf/mt.h"
 133 #include "elf/msp430.h"
 134 #include "elf/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_XLR:  strcat (buf, ", xlr"); break;
2812             case 0:
2813             /* We simply ignore the field in this case to avoid confusion:
2814                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2815                extension.  */
2816               break;
2817             default: strcat (buf, _(", unknown CPU")); break;
2818             }
2819
2820           switch ((e_flags & EF_MIPS_ABI))
2821             {
2822             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2823             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2824             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2825             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2826             case 0:
2827             /* We simply ignore the field in this case to avoid confusion:
2828                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2829                This means it is likely to be an o32 file, but not for
2830                sure.  */
2831               break;
2832             default: strcat (buf, _(", unknown ABI")); break;
2833             }
2834
2835           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2836             strcat (buf, ", mdmx");
2837
2838           if (e_flags & EF_MIPS_ARCH_ASE_M16)
2839             strcat (buf, ", mips16");
2840
2841           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2842             strcat (buf, ", micromips");
2843
2844           switch ((e_flags & EF_MIPS_ARCH))
2845             {
2846             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2847             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2848             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2849             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2850             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2851             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2852             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2853             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2854             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2855             default: strcat (buf, _(", unknown ISA")); break;
2856             }
2857           break;
2858
2859         case EM_NDS32:
2860           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
2861           break;
2862
2863         case EM_SH:
2864           switch ((e_flags & EF_SH_MACH_MASK))
2865             {
2866             case EF_SH1: strcat (buf, ", sh1"); break;
2867             case EF_SH2: strcat (buf, ", sh2"); break;
2868             case EF_SH3: strcat (buf, ", sh3"); break;
2869             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2870             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2871             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2872             case EF_SH3E: strcat (buf, ", sh3e"); break;
2873             case EF_SH4: strcat (buf, ", sh4"); break;
2874             case EF_SH5: strcat (buf, ", sh5"); break;
2875             case EF_SH2E: strcat (buf, ", sh2e"); break;
2876             case EF_SH4A: strcat (buf, ", sh4a"); break;
2877             case EF_SH2A: strcat (buf, ", sh2a"); break;
2878             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2879             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2880             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2881             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2882             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2883             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2884             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2885             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2886             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2887             default: strcat (buf, _(", unknown ISA")); break;
2888             }
2889
2890           if (e_flags & EF_SH_PIC)
2891             strcat (buf, ", pic");
2892
2893           if (e_flags & EF_SH_FDPIC)
2894             strcat (buf, ", fdpic");
2895           break;
2896
2897         case EM_SPARCV9:
2898           if (e_flags & EF_SPARC_32PLUS)
2899             strcat (buf, ", v8+");
2900
2901           if (e_flags & EF_SPARC_SUN_US1)
2902             strcat (buf, ", ultrasparcI");
2903
2904           if (e_flags & EF_SPARC_SUN_US3)
2905             strcat (buf, ", ultrasparcIII");
2906
2907           if (e_flags & EF_SPARC_HAL_R1)
2908             strcat (buf, ", halr1");
2909
2910           if (e_flags & EF_SPARC_LEDATA)
2911             strcat (buf, ", ledata");
2912
2913           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2914             strcat (buf, ", tso");
2915
2916           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2917             strcat (buf, ", pso");
2918
2919           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2920             strcat (buf, ", rmo");
2921           break;
2922
2923         case EM_PARISC:
2924           switch (e_flags & EF_PARISC_ARCH)
2925             {
2926             case EFA_PARISC_1_0:
2927               strcpy (buf, ", PA-RISC 1.0");
2928               break;
2929             case EFA_PARISC_1_1:
2930               strcpy (buf, ", PA-RISC 1.1");
2931               break;
2932             case EFA_PARISC_2_0:
2933               strcpy (buf, ", PA-RISC 2.0");
2934               break;
2935             default:
2936               break;
2937             }
2938           if (e_flags & EF_PARISC_TRAPNIL)
2939             strcat (buf, ", trapnil");
2940           if (e_flags & EF_PARISC_EXT)
2941             strcat (buf, ", ext");
2942           if (e_flags & EF_PARISC_LSB)
2943             strcat (buf, ", lsb");
2944           if (e_flags & EF_PARISC_WIDE)
2945             strcat (buf, ", wide");
2946           if (e_flags & EF_PARISC_NO_KABP)
2947             strcat (buf, ", no kabp");
2948           if (e_flags & EF_PARISC_LAZYSWAP)
2949             strcat (buf, ", lazyswap");
2950           break;
2951
2952         case EM_PJ:
2953         case EM_PJ_OLD:
2954           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2955             strcat (buf, ", new calling convention");
2956
2957           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2958             strcat (buf, ", gnu calling convention");
2959           break;
2960
2961         case EM_IA_64:
2962           if ((e_flags & EF_IA_64_ABI64))
2963             strcat (buf, ", 64-bit");
2964           else
2965             strcat (buf, ", 32-bit");
2966           if ((e_flags & EF_IA_64_REDUCEDFP))
2967             strcat (buf, ", reduced fp model");
2968           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2969             strcat (buf, ", no function descriptors, constant gp");
2970           else if ((e_flags & EF_IA_64_CONS_GP))
2971             strcat (buf, ", constant gp");
2972           if ((e_flags & EF_IA_64_ABSOLUTE))
2973             strcat (buf, ", absolute");
2974           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2975             {
2976               if ((e_flags & EF_IA_64_VMS_LINKAGES))
2977                 strcat (buf, ", vms_linkages");
2978               switch ((e_flags & EF_IA_64_VMS_COMCOD))
2979                 {
2980                 case EF_IA_64_VMS_COMCOD_SUCCESS:
2981                   break;
2982                 case EF_IA_64_VMS_COMCOD_WARNING:
2983                   strcat (buf, ", warning");
2984                   break;
2985                 case EF_IA_64_VMS_COMCOD_ERROR:
2986                   strcat (buf, ", error");
2987                   break;
2988                 case EF_IA_64_VMS_COMCOD_ABORT:
2989                   strcat (buf, ", abort");
2990                   break;
2991                 default:
2992                   abort ();
2993                 }
2994             }
2995           break;
2996
2997         case EM_VAX:
2998           if ((e_flags & EF_VAX_NONPIC))
2999             strcat (buf, ", non-PIC");
3000           if ((e_flags & EF_VAX_DFLOAT))
3001             strcat (buf, ", D-Float");
3002           if ((e_flags & EF_VAX_GFLOAT))
3003             strcat (buf, ", G-Float");
3004           break;
3005
3006         case EM_RL78:
3007           if (e_flags & E_FLAG_RL78_G10)
3008             strcat (buf, ", G10");
3009           break;
3010
3011         case EM_RX:
3012           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3013             strcat (buf, ", 64-bit doubles");
3014           if (e_flags & E_FLAG_RX_DSP)
3015             strcat (buf, ", dsp");
3016           if (e_flags & E_FLAG_RX_PID)
3017             strcat (buf, ", pid");
3018           if (e_flags & E_FLAG_RX_ABI)
3019             strcat (buf, ", RX ABI");
3020           break;
3021
3022         case EM_S390:
3023           if (e_flags & EF_S390_HIGH_GPRS)
3024             strcat (buf, ", highgprs");
3025           break;
3026
3027         case EM_TI_C6000:
3028           if ((e_flags & EF_C6000_REL))
3029             strcat (buf, ", relocatable module");
3030           break;
3031
3032         case EM_MSP430:
3033           strcat (buf, _(": architecture variant: "));
3034           switch (e_flags & EF_MSP430_MACH)
3035             {
3036             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3037             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3038             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3039             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3040             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3041             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3042             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3043             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3044             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3045             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3046             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3047             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3048             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3049             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3050             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3051             default:
3052               strcat (buf, _(": unknown")); break;
3053             }
3054
3055           if (e_flags & ~ EF_MSP430_MACH)
3056             strcat (buf, _(": unknown extra flag bits also present"));
3057         }
3058     }
3059
3060   return buf;
3061 }
3062
3063 static const char *
3064 get_osabi_name (unsigned int osabi)
3065 {
3066   static char buff[32];
3067
3068   switch (osabi)
3069     {
3070     case ELFOSABI_NONE:         return "UNIX - System V";
3071     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3072     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3073     case ELFOSABI_GNU:          return "UNIX - GNU";
3074     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3075     case ELFOSABI_AIX:          return "UNIX - AIX";
3076     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3077     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3078     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3079     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3080     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3081     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3082     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3083     case ELFOSABI_AROS:         return "AROS";
3084     case ELFOSABI_FENIXOS:      return "FenixOS";
3085     default:
3086       if (osabi >= 64)
3087         switch (elf_header.e_machine)
3088           {
3089           case EM_ARM:
3090             switch (osabi)
3091               {
3092               case ELFOSABI_ARM:        return "ARM";
3093               default:
3094                 break;
3095               }
3096             break;
3097
3098           case EM_MSP430:
3099           case EM_MSP430_OLD:
3100             switch (osabi)
3101               {
3102               case ELFOSABI_STANDALONE: return _("Standalone App");
3103               default:
3104                 break;
3105               }
3106             break;
3107
3108           case EM_TI_C6000:
3109             switch (osabi)
3110               {
3111               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3112               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3113               default:
3114                 break;
3115               }
3116             break;
3117
3118           default:
3119             break;
3120           }
3121       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3122       return buff;
3123     }
3124 }
3125
3126 static const char *
3127 get_aarch64_segment_type (unsigned long type)
3128 {
3129   switch (type)
3130     {
3131     case PT_AARCH64_ARCHEXT:
3132       return "AARCH64_ARCHEXT";
3133     default:
3134       break;
3135     }
3136
3137   return NULL;
3138 }
3139
3140 static const char *
3141 get_arm_segment_type (unsigned long type)
3142 {
3143   switch (type)
3144     {
3145     case PT_ARM_EXIDX:
3146       return "EXIDX";
3147     default:
3148       break;
3149     }
3150
3151   return NULL;
3152 }
3153
3154 static const char *
3155 get_mips_segment_type (unsigned long type)
3156 {
3157   switch (type)
3158     {
3159     case PT_MIPS_REGINFO:
3160       return "REGINFO";
3161     case PT_MIPS_RTPROC:
3162       return "RTPROC";
3163     case PT_MIPS_OPTIONS:
3164       return "OPTIONS";
3165     default:
3166       break;
3167     }
3168
3169   return NULL;
3170 }
3171
3172 static const char *
3173 get_parisc_segment_type (unsigned long type)
3174 {
3175   switch (type)
3176     {
3177     case PT_HP_TLS:             return "HP_TLS";
3178     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3179     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3180     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3181     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3182     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3183     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3184     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3185     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3186     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3187     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3188     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3189     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3190     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3191     case PT_HP_STACK:           return "HP_STACK";
3192     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3193     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3194     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3195     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3196     default:
3197       break;
3198     }
3199
3200   return NULL;
3201 }
3202
3203 static const char *
3204 get_ia64_segment_type (unsigned long type)
3205 {
3206   switch (type)
3207     {
3208     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3209     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3210     case PT_HP_TLS:             return "HP_TLS";
3211     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3212     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3213     case PT_IA_64_HP_STACK:     return "HP_STACK";
3214     default:
3215       break;
3216     }
3217
3218   return NULL;
3219 }
3220
3221 static const char *
3222 get_tic6x_segment_type (unsigned long type)
3223 {
3224   switch (type)
3225     {
3226     case PT_C6000_PHATTR:       return "C6000_PHATTR";
3227     default:
3228       break;
3229     }
3230
3231   return NULL;
3232 }
3233
3234 static const char *
3235 get_segment_type (unsigned long p_type)
3236 {
3237   static char buff[32];
3238
3239   switch (p_type)
3240     {
3241     case PT_NULL:       return "NULL";
3242     case PT_LOAD:       return "LOAD";
3243     case PT_DYNAMIC:    return "DYNAMIC";
3244     case PT_INTERP:     return "INTERP";
3245     case PT_NOTE:       return "NOTE";
3246     case PT_SHLIB:      return "SHLIB";
3247     case PT_PHDR:       return "PHDR";
3248     case PT_TLS:        return "TLS";
3249
3250     case PT_GNU_EH_FRAME:
3251                         return "GNU_EH_FRAME";
3252     case PT_GNU_STACK:  return "GNU_STACK";
3253     case PT_GNU_RELRO:  return "GNU_RELRO";
3254
3255     default:
3256       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3257         {
3258           const char * result;
3259
3260           switch (elf_header.e_machine)
3261             {
3262             case EM_AARCH64:
3263               result = get_aarch64_segment_type (p_type);
3264               break;
3265             case EM_ARM:
3266               result = get_arm_segment_type (p_type);
3267               break;
3268             case EM_MIPS:
3269             case EM_MIPS_RS3_LE:
3270               result = get_mips_segment_type (p_type);
3271               break;
3272             case EM_PARISC:
3273               result = get_parisc_segment_type (p_type);
3274               break;
3275             case EM_IA_64:
3276               result = get_ia64_segment_type (p_type);
3277               break;
3278             case EM_TI_C6000:
3279               result = get_tic6x_segment_type (p_type);
3280               break;
3281             default:
3282               result = NULL;
3283               break;
3284             }
3285
3286           if (result != NULL)
3287             return result;
3288
3289           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3290         }
3291       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3292         {
3293           const char * result;
3294
3295           switch (elf_header.e_machine)
3296             {
3297             case EM_PARISC:
3298               result = get_parisc_segment_type (p_type);
3299               break;
3300             case EM_IA_64:
3301               result = get_ia64_segment_type (p_type);
3302               break;
3303             default:
3304               result = NULL;
3305               break;
3306             }
3307
3308           if (result != NULL)
3309             return result;
3310
3311           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3312         }
3313       else
3314         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3315
3316       return buff;
3317     }
3318 }
3319
3320 static const char *
3321 get_mips_section_type_name (unsigned int sh_type)
3322 {
3323   switch (sh_type)
3324     {
3325     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3326     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3327     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3328     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3329     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3330     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3331     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3332     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3333     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3334     case SHT_MIPS_RELD:          return "MIPS_RELD";
3335     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3336     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3337     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3338     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3339     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3340     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3341     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3342     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3343     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3344     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3345     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3346     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3347     case SHT_MIPS_LINE:          return "MIPS_LINE";
3348     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3349     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3350     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3351     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3352     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3353     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3354     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3355     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3356     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3357     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3358     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3359     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3360     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3361     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3362     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3363     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3364     default:
3365       break;
3366     }
3367   return NULL;
3368 }
3369
3370 static const char *
3371 get_parisc_section_type_name (unsigned int sh_type)
3372 {
3373   switch (sh_type)
3374     {
3375     case SHT_PARISC_EXT:        return "PARISC_EXT";
3376     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
3377     case SHT_PARISC_DOC:        return "PARISC_DOC";
3378     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
3379     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
3380     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
3381     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
3382     default:
3383       break;
3384     }
3385   return NULL;
3386 }
3387
3388 static const char *
3389 get_ia64_section_type_name (unsigned int sh_type)
3390 {
3391   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
3392   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3393     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3394
3395   switch (sh_type)
3396     {
3397     case SHT_IA_64_EXT:                return "IA_64_EXT";
3398     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
3399     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
3400     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
3401     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3402     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
3403     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
3404     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
3405     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
3406     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
3407     default:
3408       break;
3409     }
3410   return NULL;
3411 }
3412
3413 static const char *
3414 get_x86_64_section_type_name (unsigned int sh_type)
3415 {
3416   switch (sh_type)
3417     {
3418     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
3419     default:
3420       break;
3421     }
3422   return NULL;
3423 }
3424
3425 static const char *
3426 get_aarch64_section_type_name (unsigned int sh_type)
3427 {
3428   switch (sh_type)
3429     {
3430     case SHT_AARCH64_ATTRIBUTES:
3431       return "AARCH64_ATTRIBUTES";
3432     default:
3433       break;
3434     }
3435   return NULL;
3436 }
3437
3438 static const char *
3439 get_arm_section_type_name (unsigned int sh_type)
3440 {
3441   switch (sh_type)
3442     {
3443     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
3444     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
3445     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
3446     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
3447     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
3448     default:
3449       break;
3450     }
3451   return NULL;
3452 }
3453
3454 static const char *
3455 get_tic6x_section_type_name (unsigned int sh_type)
3456 {
3457   switch (sh_type)
3458     {
3459     case SHT_C6000_UNWIND:
3460       return "C6000_UNWIND";
3461     case SHT_C6000_PREEMPTMAP:
3462       return "C6000_PREEMPTMAP";
3463     case SHT_C6000_ATTRIBUTES:
3464       return "C6000_ATTRIBUTES";
3465     case SHT_TI_ICODE:
3466       return "TI_ICODE";
3467     case SHT_TI_XREF:
3468       return "TI_XREF";
3469     case SHT_TI_HANDLER:
3470       return "TI_HANDLER";
3471     case SHT_TI_INITINFO:
3472       return "TI_INITINFO";
3473     case SHT_TI_PHATTRS:
3474       return "TI_PHATTRS";
3475     default:
3476       break;
3477     }
3478   return NULL;
3479 }
3480
3481 static const char *
3482 get_msp430x_section_type_name (unsigned int sh_type)
3483 {
3484   switch (sh_type)
3485     {
3486     case SHT_MSP430_SEC_FLAGS:   return "MSP430_SEC_FLAGS";
3487     case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3488     case SHT_MSP430_ATTRIBUTES:  return "MSP430_ATTRIBUTES";
3489     default: return NULL;
3490     }
3491 }
3492
3493 static const char *
3494 get_section_type_name (unsigned int sh_type)
3495 {
3496   static char buff[32];
3497
3498   switch (sh_type)
3499     {
3500     case SHT_NULL:              return "NULL";
3501     case SHT_PROGBITS:          return "PROGBITS";
3502     case SHT_SYMTAB:            return "SYMTAB";
3503     case SHT_STRTAB:            return "STRTAB";
3504     case SHT_RELA:              return "RELA";
3505     case SHT_HASH:              return "HASH";
3506     case SHT_DYNAMIC:           return "DYNAMIC";
3507     case SHT_NOTE:              return "NOTE";
3508     case SHT_NOBITS:            return "NOBITS";
3509     case SHT_REL:               return "REL";
3510     case SHT_SHLIB:             return "SHLIB";
3511     case SHT_DYNSYM:            return "DYNSYM";
3512     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
3513     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
3514     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
3515     case SHT_GNU_HASH:          return "GNU_HASH";
3516     case SHT_GROUP:             return "GROUP";
3517     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
3518     case SHT_GNU_verdef:        return "VERDEF";
3519     case SHT_GNU_verneed:       return "VERNEED";
3520     case SHT_GNU_versym:        return "VERSYM";
3521     case 0x6ffffff0:            return "VERSYM";
3522     case 0x6ffffffc:            return "VERDEF";
3523     case 0x7ffffffd:            return "AUXILIARY";
3524     case 0x7fffffff:            return "FILTER";
3525     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
3526
3527     default:
3528       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3529         {
3530           const char * result;
3531
3532           switch (elf_header.e_machine)
3533             {
3534             case EM_MIPS:
3535             case EM_MIPS_RS3_LE:
3536               result = get_mips_section_type_name (sh_type);
3537               break;
3538             case EM_PARISC:
3539               result = get_parisc_section_type_name (sh_type);
3540               break;
3541             case EM_IA_64:
3542               result = get_ia64_section_type_name (sh_type);
3543               break;
3544             case EM_X86_64:
3545             case EM_L1OM:
3546             case EM_K1OM:
3547               result = get_x86_64_section_type_name (sh_type);
3548               break;
3549             case EM_AARCH64:
3550               result = get_aarch64_section_type_name (sh_type);
3551               break;
3552             case EM_ARM:
3553               result = get_arm_section_type_name (sh_type);
3554               break;
3555             case EM_TI_C6000:
3556               result = get_tic6x_section_type_name (sh_type);
3557               break;
3558             case EM_MSP430:
3559               result = get_msp430x_section_type_name (sh_type);
3560               break;
3561             default:
3562               result = NULL;
3563               break;
3564             }
3565
3566           if (result != NULL)
3567             return result;
3568
3569           sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3570         }
3571       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3572         {
3573           const char * result;
3574
3575           switch (elf_header.e_machine)
3576             {
3577             case EM_IA_64:
3578               result = get_ia64_section_type_name (sh_type);
3579               break;
3580             default:
3581               result = NULL;
3582               break;
3583             }
3584
3585           if (result != NULL)
3586             return result;
3587
3588           sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3589         }
3590       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3591         sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3592       else
3593         /* This message is probably going to be displayed in a 15
3594            character wide field, so put the hex value first.  */
3595         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3596
3597       return buff;
3598     }
3599 }
3600
3601 #define OPTION_DEBUG_DUMP       512
3602 #define OPTION_DYN_SYMS         513
3603 #define OPTION_DWARF_DEPTH      514
3604 #define OPTION_DWARF_START      515
3605 #define OPTION_DWARF_CHECK      516
3606
3607 static struct option options[] =
3608 {
3609   {"all",              no_argument, 0, 'a'},
3610   {"file-header",      no_argument, 0, 'h'},
3611   {"program-headers",  no_argument, 0, 'l'},
3612   {"headers",          no_argument, 0, 'e'},
3613   {"histogram",        no_argument, 0, 'I'},
3614   {"segments",         no_argument, 0, 'l'},
3615   {"sections",         no_argument, 0, 'S'},
3616   {"section-headers",  no_argument, 0, 'S'},
3617   {"section-groups",   no_argument, 0, 'g'},
3618   {"section-details",  no_argument, 0, 't'},
3619   {"full-section-name",no_argument, 0, 'N'},
3620   {"symbols",          no_argument, 0, 's'},
3621   {"syms",             no_argument, 0, 's'},
3622   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
3623   {"relocs",           no_argument, 0, 'r'},
3624   {"notes",            no_argument, 0, 'n'},
3625   {"dynamic",          no_argument, 0, 'd'},
3626   {"arch-specific",    no_argument, 0, 'A'},
3627   {"version-info",     no_argument, 0, 'V'},
3628   {"use-dynamic",      no_argument, 0, 'D'},
3629   {"unwind",           no_argument, 0, 'u'},
3630   {"archive-index",    no_argument, 0, 'c'},
3631   {"hex-dump",         required_argument, 0, 'x'},
3632   {"relocated-dump",   required_argument, 0, 'R'},
3633   {"string-dump",      required_argument, 0, 'p'},
3634 #ifdef SUPPORT_DISASSEMBLY
3635   {"instruction-dump", required_argument, 0, 'i'},
3636 #endif
3637   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
3638
3639   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
3640   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
3641   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
3642
3643   {"version",          no_argument, 0, 'v'},
3644   {"wide",             no_argument, 0, 'W'},
3645   {"help",             no_argument, 0, 'H'},
3646   {0,                  no_argument, 0, 0}
3647 };
3648
3649 static void
3650 usage (FILE * stream)
3651 {
3652   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3653   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3654   fprintf (stream, _(" Options are:\n\
3655   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3656   -h --file-header       Display the ELF file header\n\
3657   -l --program-headers   Display the program headers\n\
3658      --segments          An alias for --program-headers\n\
3659   -S --section-headers   Display the sections' header\n\
3660      --sections          An alias for --section-headers\n\
3661   -g --section-groups    Display the section groups\n\
3662   -t --section-details   Display the section details\n\
3663   -e --headers           Equivalent to: -h -l -S\n\
3664   -s --syms              Display the symbol table\n\
3665      --symbols           An alias for --syms\n\
3666   --dyn-syms             Display the dynamic symbol table\n\
3667   -n --notes             Display the core notes (if present)\n\
3668   -r --relocs            Display the relocations (if present)\n\
3669   -u --unwind            Display the unwind info (if present)\n\
3670   -d --dynamic           Display the dynamic section (if present)\n\
3671   -V --version-info      Display the version sections (if present)\n\
3672   -A --arch-specific     Display architecture specific information (if any)\n\
3673   -c --archive-index     Display the symbol/file index in an archive\n\
3674   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
3675   -x --hex-dump=<number|name>\n\
3676                          Dump the contents of section <number|name> as bytes\n\
3677   -p --string-dump=<number|name>\n\
3678                          Dump the contents of section <number|name> as strings\n\
3679   -R --relocated-dump=<number|name>\n\
3680                          Dump the contents of section <number|name> as relocated bytes\n\
3681   -w[lLiaprmfFsoRt] or\n\
3682   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3683                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3684                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3685                =addr,=cu_index]\n\
3686                          Display the contents of DWARF2 debug sections\n"));
3687   fprintf (stream, _("\
3688   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
3689   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
3690                          or deeper\n"));
3691 #ifdef SUPPORT_DISASSEMBLY
3692   fprintf (stream, _("\
3693   -i --instruction-dump=<number|name>\n\
3694                          Disassemble the contents of section <number|name>\n"));
3695 #endif
3696   fprintf (stream, _("\
3697   -I --histogram         Display histogram of bucket list lengths\n\
3698   -W --wide              Allow output width to exceed 80 characters\n\
3699   @<file>                Read options from <file>\n\
3700   -H --help              Display this information\n\
3701   -v --version           Display the version number of readelf\n"));
3702
3703   if (REPORT_BUGS_TO[0] && stream == stdout)
3704     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3705
3706   exit (stream == stdout ? 0 : 1);
3707 }
3708
3709 /* Record the fact that the user wants the contents of section number
3710    SECTION to be displayed using the method(s) encoded as flags bits
3711    in TYPE.  Note, TYPE can be zero if we are creating the array for
3712    the first time.  */
3713
3714 static void
3715 request_dump_bynumber (unsigned int section, dump_type type)
3716 {
3717   if (section >= num_dump_sects)
3718     {
3719       dump_type * new_dump_sects;
3720
3721       new_dump_sects = (dump_type *) calloc (section + 1,
3722                                              sizeof (* dump_sects));
3723
3724       if (new_dump_sects == NULL)
3725         error (_("Out of memory allocating dump request table.\n"));
3726       else
3727         {
3728           /* Copy current flag settings.  */
3729           memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3730
3731           free (dump_sects);
3732
3733           dump_sects = new_dump_sects;
3734           num_dump_sects = section + 1;
3735         }
3736     }
3737
3738   if (dump_sects)
3739     dump_sects[section] |= type;
3740
3741   return;
3742 }
3743
3744 /* Request a dump by section name.  */
3745
3746 static void
3747 request_dump_byname (const char * section, dump_type type)
3748 {
3749   struct dump_list_entry * new_request;
3750
3751   new_request = (struct dump_list_entry *)
3752       malloc (sizeof (struct dump_list_entry));
3753   if (!new_request)
3754     error (_("Out of memory allocating dump request table.\n"));
3755
3756   new_request->name = strdup (section);
3757   if (!new_request->name)
3758     error (_("Out of memory allocating dump request table.\n"));
3759
3760   new_request->type = type;
3761
3762   new_request->next = dump_sects_byname;
3763   dump_sects_byname = new_request;
3764 }
3765
3766 static inline void
3767 request_dump (dump_type type)
3768 {
3769   int section;
3770   char * cp;
3771
3772   do_dump++;
3773   section = strtoul (optarg, & cp, 0);
3774
3775   if (! *cp && section >= 0)
3776     request_dump_bynumber (section, type);
3777   else
3778     request_dump_byname (optarg, type);
3779 }
3780
3781
3782 static void
3783 parse_args (int argc, char ** argv)
3784 {
3785   int c;
3786
3787   if (argc < 2)
3788     usage (stderr);
3789
3790   while ((c = getopt_long
3791           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3792     {
3793       switch (c)
3794         {
3795         case 0:
3796           /* Long options.  */
3797           break;
3798         case 'H':
3799           usage (stdout);
3800           break;
3801
3802         case 'a':
3803           do_syms++;
3804           do_reloc++;
3805           do_unwind++;
3806           do_dynamic++;
3807           do_header++;
3808           do_sections++;
3809           do_section_groups++;
3810           do_segments++;
3811           do_version++;
3812           do_histogram++;
3813           do_arch++;
3814           do_notes++;
3815           break;
3816         case 'g':
3817           do_section_groups++;
3818           break;
3819         case 't':
3820         case 'N':
3821           do_sections++;
3822           do_section_details++;
3823           break;
3824         case 'e':
3825           do_header++;
3826           do_sections++;
3827           do_segments++;
3828           break;
3829         case 'A':
3830           do_arch++;
3831           break;
3832         case 'D':
3833           do_using_dynamic++;
3834           break;
3835         case 'r':
3836           do_reloc++;
3837           break;
3838         case 'u':
3839           do_unwind++;
3840           break;
3841         case 'h':
3842           do_header++;
3843           break;
3844         case 'l':
3845           do_segments++;
3846           break;
3847         case 's':
3848           do_syms++;
3849           break;
3850         case 'S':
3851           do_sections++;
3852           break;
3853         case 'd':
3854           do_dynamic++;
3855           break;
3856         case 'I':
3857           do_histogram++;
3858           break;
3859         case 'n':
3860           do_notes++;
3861           break;
3862         case 'c':
3863           do_archive_index++;
3864           break;
3865         case 'x':
3866           request_dump (HEX_DUMP);
3867           break;
3868         case 'p':
3869           request_dump (STRING_DUMP);
3870           break;
3871         case 'R':
3872           request_dump (RELOC_DUMP);
3873           break;
3874         case 'w':
3875           do_dump++;
3876           if (optarg == 0)
3877             {
3878               do_debugging = 1;
3879               dwarf_select_sections_all ();
3880             }
3881           else
3882             {
3883               do_debugging = 0;
3884               dwarf_select_sections_by_letters (optarg);
3885             }
3886           break;
3887         case OPTION_DEBUG_DUMP:
3888           do_dump++;
3889           if (optarg == 0)
3890             do_debugging = 1;
3891           else
3892             {
3893               do_debugging = 0;
3894               dwarf_select_sections_by_names (optarg);
3895             }
3896           break;
3897         case OPTION_DWARF_DEPTH:
3898           {
3899             char *cp;
3900
3901             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3902           }
3903           break;
3904         case OPTION_DWARF_START:
3905           {
3906             char *cp;
3907
3908             dwarf_start_die = strtoul (optarg, & cp, 0);
3909           }
3910           break;
3911         case OPTION_DWARF_CHECK:
3912           dwarf_check = 1;
3913           break;
3914         case OPTION_DYN_SYMS:
3915           do_dyn_syms++;
3916           break;
3917 #ifdef SUPPORT_DISASSEMBLY
3918         case 'i':
3919           request_dump (DISASS_DUMP);
3920           break;
3921 #endif
3922         case 'v':
3923           print_version (program_name);
3924           break;
3925         case 'V':
3926           do_version++;
3927           break;
3928         case 'W':
3929           do_wide++;
3930           break;
3931         default:
3932           /* xgettext:c-format */
3933           error (_("Invalid option '-%c'\n"), c);
3934           /* Drop through.  */
3935         case '?':
3936           usage (stderr);
3937         }
3938     }
3939
3940   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3941       && !do_segments && !do_header && !do_dump && !do_version
3942       && !do_histogram && !do_debugging && !do_arch && !do_notes
3943       && !do_section_groups && !do_archive_index
3944       && !do_dyn_syms)
3945     usage (stderr);
3946   else if (argc < 3)
3947     {
3948       warn (_("Nothing to do.\n"));
3949       usage (stderr);
3950     }
3951 }
3952
3953 static const char *
3954 get_elf_class (unsigned int elf_class)
3955 {
3956   static char buff[32];
3957
3958   switch (elf_class)
3959     {
3960     case ELFCLASSNONE: return _("none");
3961     case ELFCLASS32:   return "ELF32";
3962     case ELFCLASS64:   return "ELF64";
3963     default:
3964       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3965       return buff;
3966     }
3967 }
3968
3969 static const char *
3970 get_data_encoding (unsigned int encoding)
3971 {
3972   static char buff[32];
3973
3974   switch (encoding)
3975     {
3976     case ELFDATANONE: return _("none");
3977     case ELFDATA2LSB: return _("2's complement, little endian");
3978     case ELFDATA2MSB: return _("2's complement, big endian");
3979     default:
3980       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3981       return buff;
3982     }
3983 }
3984
3985 /* Decode the data held in 'elf_header'.  */
3986
3987 static int
3988 process_file_header (void)
3989 {
3990   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
3991       || elf_header.e_ident[EI_MAG1] != ELFMAG1
3992       || elf_header.e_ident[EI_MAG2] != ELFMAG2
3993       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3994     {
3995       error
3996         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3997       return 0;
3998     }
3999
4000   init_dwarf_regnames (elf_header.e_machine);
4001
4002   if (do_header)
4003     {
4004       int i;
4005
4006       printf (_("ELF Header:\n"));
4007       printf (_("  Magic:   "));
4008       for (i = 0; i < EI_NIDENT; i++)
4009         printf ("%2.2x ", elf_header.e_ident[i]);
4010       printf ("\n");
4011       printf (_("  Class:                             %s\n"),
4012               get_elf_class (elf_header.e_ident[EI_CLASS]));
4013       printf (_("  Data:                              %s\n"),
4014               get_data_encoding (elf_header.e_ident[EI_DATA]));
4015       printf (_("  Version:                           %d %s\n"),
4016               elf_header.e_ident[EI_VERSION],
4017               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4018                ? "(current)"
4019                : (elf_header.e_ident[EI_VERSION] != EV_NONE
4020                   ? _("<unknown: %lx>")
4021                   : "")));
4022       printf (_("  OS/ABI:                            %s\n"),
4023               get_osabi_name (elf_header.e_ident[EI_OSABI]));
4024       printf (_("  ABI Version:                       %d\n"),
4025               elf_header.e_ident[EI_ABIVERSION]);
4026       printf (_("  Type:                              %s\n"),
4027               get_file_type (elf_header.e_type));
4028       printf (_("  Machine:                           %s\n"),
4029               get_machine_name (elf_header.e_machine));
4030       printf (_("  Version:                           0x%lx\n"),
4031               (unsigned long) elf_header.e_version);
4032
4033       printf (_("  Entry point address:               "));
4034       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4035       printf (_("\n  Start of program headers:          "));
4036       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4037       printf (_(" (bytes into file)\n  Start of section headers:          "));
4038       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4039       printf (_(" (bytes into file)\n"));
4040
4041       printf (_("  Flags:                             0x%lx%s\n"),
4042               (unsigned long) elf_header.e_flags,
4043               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4044       printf (_("  Size of this header:               %ld (bytes)\n"),
4045               (long) elf_header.e_ehsize);
4046       printf (_("  Size of program headers:           %ld (bytes)\n"),
4047               (long) elf_header.e_phentsize);
4048       printf (_("  Number of program headers:         %ld"),
4049               (long) elf_header.e_phnum);
4050       if (section_headers != NULL
4051           && elf_header.e_phnum == PN_XNUM
4052           && section_headers[0].sh_info != 0)
4053         printf (" (%ld)", (long) section_headers[0].sh_info);
4054       putc ('\n', stdout);
4055       printf (_("  Size of section headers:           %ld (bytes)\n"),
4056               (long) elf_header.e_shentsize);
4057       printf (_("  Number of section headers:         %ld"),
4058               (long) elf_header.e_shnum);
4059       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4060         printf (" (%ld)", (long) section_headers[0].sh_size);
4061       putc ('\n', stdout);
4062       printf (_("  Section header string table index: %ld"),
4063               (long) elf_header.e_shstrndx);
4064       if (section_headers != NULL
4065           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4066         printf (" (%u)", section_headers[0].sh_link);
4067       else if (elf_header.e_shstrndx != SHN_UNDEF
4068                && elf_header.e_shstrndx >= elf_header.e_shnum)
4069         printf (_(" <corrupt: out of range>"));
4070       putc ('\n', stdout);
4071     }
4072
4073   if (section_headers != NULL)
4074     {
4075       if (elf_header.e_phnum == PN_XNUM
4076           && section_headers[0].sh_info != 0)
4077         elf_header.e_phnum = section_headers[0].sh_info;
4078       if (elf_header.e_shnum == SHN_UNDEF)
4079         elf_header.e_shnum = section_headers[0].sh_size;
4080       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4081         elf_header.e_shstrndx = section_headers[0].sh_link;
4082       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4083         elf_header.e_shstrndx = SHN_UNDEF;
4084       free (section_headers);
4085       section_headers = NULL;
4086     }
4087
4088   return 1;
4089 }
4090
4091
4092 static int
4093 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4094 {
4095   Elf32_External_Phdr * phdrs;
4096   Elf32_External_Phdr * external;
4097   Elf_Internal_Phdr *   internal;
4098   unsigned int i;
4099
4100   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4101                                             elf_header.e_phentsize,
4102                                             elf_header.e_phnum,
4103                                             _("program headers"));
4104   if (!phdrs)
4105     return 0;
4106
4107   for (i = 0, internal = pheaders, external = phdrs;
4108        i < elf_header.e_phnum;
4109        i++, internal++, external++)
4110     {
4111       internal->p_type   = BYTE_GET (external->p_type);
4112       internal->p_offset = BYTE_GET (external->p_offset);
4113       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4114       internal->p_paddr  = BYTE_GET (external->p_paddr);
4115       internal->p_filesz = BYTE_GET (external->p_filesz);
4116       internal->p_memsz  = BYTE_GET (external->p_memsz);
4117       internal->p_flags  = BYTE_GET (external->p_flags);
4118       internal->p_align  = BYTE_GET (external->p_align);
4119     }
4120
4121   free (phdrs);
4122
4123   return 1;
4124 }
4125
4126 static int
4127 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4128 {
4129   Elf64_External_Phdr * phdrs;
4130   Elf64_External_Phdr * external;
4131   Elf_Internal_Phdr *   internal;
4132   unsigned int i;
4133
4134   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4135                                             elf_header.e_phentsize,
4136                                             elf_header.e_phnum,
4137                                             _("program headers"));
4138   if (!phdrs)
4139     return 0;
4140
4141   for (i = 0, internal = pheaders, external = phdrs;
4142        i < elf_header.e_phnum;
4143        i++, internal++, external++)
4144     {
4145       internal->p_type   = BYTE_GET (external->p_type);
4146       internal->p_flags  = BYTE_GET (external->p_flags);
4147       internal->p_offset = BYTE_GET (external->p_offset);
4148       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4149       internal->p_paddr  = BYTE_GET (external->p_paddr);
4150       internal->p_filesz = BYTE_GET (external->p_filesz);
4151       internal->p_memsz  = BYTE_GET (external->p_memsz);
4152       internal->p_align  = BYTE_GET (external->p_align);
4153     }
4154
4155   free (phdrs);
4156
4157   return 1;
4158 }
4159
4160 /* Returns 1 if the program headers were read into `program_headers'.  */
4161
4162 static int
4163 get_program_headers (FILE * file)
4164 {
4165   Elf_Internal_Phdr * phdrs;
4166
4167   /* Check cache of prior read.  */
4168   if (program_headers != NULL)
4169     return 1;
4170
4171   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4172                                          sizeof (Elf_Internal_Phdr));
4173
4174   if (phdrs == NULL)
4175     {
4176       error (_("Out of memory\n"));
4177       return 0;
4178     }
4179
4180   if (is_32bit_elf
4181       ? get_32bit_program_headers (file, phdrs)
4182       : get_64bit_program_headers (file, phdrs))
4183     {
4184       program_headers = phdrs;
4185       return 1;
4186     }
4187
4188   free (phdrs);
4189   return 0;
4190 }
4191
4192 /* Returns 1 if the program headers were loaded.  */
4193
4194 static int
4195 process_program_headers (FILE * file)
4196 {
4197   Elf_Internal_Phdr * segment;
4198   unsigned int i;
4199
4200   if (elf_header.e_phnum == 0)
4201     {
4202       /* PR binutils/12467.  */
4203       if (elf_header.e_phoff != 0)
4204         warn (_("possibly corrupt ELF header - it has a non-zero program"
4205                 " header offset, but no program headers"));
4206       else if (do_segments)
4207         printf (_("\nThere are no program headers in this file.\n"));
4208       return 0;
4209     }
4210
4211   if (do_segments && !do_header)
4212     {
4213       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4214       printf (_("Entry point "));
4215       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4216       printf (_("\nThere are %d program headers, starting at offset "),
4217               elf_header.e_phnum);
4218       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4219       printf ("\n");
4220     }
4221
4222   if (! get_program_headers (file))
4223       return 0;
4224
4225   if (do_segments)
4226     {
4227       if (elf_header.e_phnum > 1)
4228         printf (_("\nProgram Headers:\n"));
4229       else
4230         printf (_("\nProgram Headers:\n"));
4231
4232       if (is_32bit_elf)
4233         printf
4234           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4235       else if (do_wide)
4236         printf
4237           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4238       else
4239         {
4240           printf
4241             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4242           printf
4243             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4244         }
4245     }
4246
4247   dynamic_addr = 0;
4248   dynamic_size = 0;
4249
4250   for (i = 0, segment = program_headers;
4251        i < elf_header.e_phnum;
4252        i++, segment++)
4253     {
4254       if (do_segments)
4255         {
4256           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4257
4258           if (is_32bit_elf)
4259             {
4260               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4261               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4262               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4263               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4264               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4265               printf ("%c%c%c ",
4266                       (segment->p_flags & PF_R ? 'R' : ' '),
4267                       (segment->p_flags & PF_W ? 'W' : ' '),
4268                       (segment->p_flags & PF_X ? 'E' : ' '));
4269               printf ("%#lx", (unsigned long) segment->p_align);
4270             }
4271           else if (do_wide)
4272             {
4273               if ((unsigned long) segment->p_offset == segment->p_offset)
4274                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4275               else
4276                 {
4277                   print_vma (segment->p_offset, FULL_HEX);
4278                   putchar (' ');
4279                 }
4280
4281               print_vma (segment->p_vaddr, FULL_HEX);
4282               putchar (' ');
4283               print_vma (segment->p_paddr, FULL_HEX);
4284               putchar (' ');
4285
4286               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4287                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4288               else
4289                 {
4290                   print_vma (segment->p_filesz, FULL_HEX);
4291                   putchar (' ');
4292                 }
4293
4294               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4295                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4296               else
4297                 {
4298                   print_vma (segment->p_memsz, FULL_HEX);
4299                 }
4300
4301               printf (" %c%c%c ",
4302                       (segment->p_flags & PF_R ? 'R' : ' '),
4303                       (segment->p_flags & PF_W ? 'W' : ' '),
4304                       (segment->p_flags & PF_X ? 'E' : ' '));
4305
4306               if ((unsigned long) segment->p_align == segment->p_align)
4307                 printf ("%#lx", (unsigned long) segment->p_align);
4308               else
4309                 {
4310                   print_vma (segment->p_align, PREFIX_HEX);
4311                 }
4312             }
4313           else
4314             {
4315               print_vma (segment->p_offset, FULL_HEX);
4316               putchar (' ');
4317               print_vma (segment->p_vaddr, FULL_HEX);
4318               putchar (' ');
4319               print_vma (segment->p_paddr, FULL_HEX);
4320               printf ("\n                 ");
4321               print_vma (segment->p_filesz, FULL_HEX);
4322               putchar (' ');
4323               print_vma (segment->p_memsz, FULL_HEX);
4324               printf ("  %c%c%c    ",
4325                       (segment->p_flags & PF_R ? 'R' : ' '),
4326                       (segment->p_flags & PF_W ? 'W' : ' '),
4327                       (segment->p_flags & PF_X ? 'E' : ' '));
4328               print_vma (segment->p_align, HEX);
4329             }
4330         }
4331
4332       switch (segment->p_type)
4333         {
4334         case PT_DYNAMIC:
4335           if (dynamic_addr)
4336             error (_("more than one dynamic segment\n"));
4337
4338           /* By default, assume that the .dynamic section is the first
4339              section in the DYNAMIC segment.  */
4340           dynamic_addr = segment->p_offset;
4341           dynamic_size = segment->p_filesz;
4342
4343           /* Try to locate the .dynamic section. If there is
4344              a section header table, we can easily locate it.  */
4345           if (section_headers != NULL)
4346             {
4347               Elf_Internal_Shdr * sec;
4348
4349               sec = find_section (".dynamic");
4350               if (sec == NULL || sec->sh_size == 0)
4351                 {
4352                   /* A corresponding .dynamic section is expected, but on
4353                      IA-64/OpenVMS it is OK for it to be missing.  */
4354                   if (!is_ia64_vms ())
4355                     error (_("no .dynamic section in the dynamic segment\n"));
4356                   break;
4357                 }
4358
4359               if (sec->sh_type == SHT_NOBITS)
4360                 {
4361                   dynamic_size = 0;
4362                   break;
4363                 }
4364
4365               dynamic_addr = sec->sh_offset;
4366               dynamic_size = sec->sh_size;
4367
4368               if (dynamic_addr < segment->p_offset
4369                   || dynamic_addr > segment->p_offset + segment->p_filesz)
4370                 warn (_("the .dynamic section is not contained"
4371                         " within the dynamic segment\n"));
4372               else if (dynamic_addr > segment->p_offset)
4373                 warn (_("the .dynamic section is not the first section"
4374                         " in the dynamic segment.\n"));
4375             }
4376           break;
4377
4378         case PT_INTERP:
4379           if (fseek (file, archive_file_offset + (long) segment->p_offset,
4380                      SEEK_SET))
4381             error (_("Unable to find program interpreter name\n"));
4382           else
4383             {
4384               char fmt [32];
4385               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
4386
4387               if (ret >= (int) sizeof (fmt) || ret < 0)
4388                 error (_("Internal error: failed to create format string to display program interpreter\n"));
4389
4390               program_interpreter[0] = 0;
4391               if (fscanf (file, fmt, program_interpreter) <= 0)
4392                 error (_("Unable to read program interpreter name\n"));
4393
4394               if (do_segments)
4395                 printf (_("\n      [Requesting program interpreter: %s]"),
4396                     program_interpreter);
4397             }
4398           break;
4399         }
4400
4401       if (do_segments)
4402         putc ('\n', stdout);
4403     }
4404
4405   if (do_segments && section_headers != NULL && string_table != NULL)
4406     {
4407       printf (_("\n Section to Segment mapping:\n"));
4408       printf (_("  Segment Sections...\n"));
4409
4410       for (i = 0; i < elf_header.e_phnum; i++)
4411         {
4412           unsigned int j;
4413           Elf_Internal_Shdr * section;
4414
4415           segment = program_headers + i;
4416           section = section_headers + 1;
4417
4418           printf ("   %2.2d     ", i);
4419
4420           for (j = 1; j < elf_header.e_shnum; j++, section++)
4421             {
4422               if (!ELF_TBSS_SPECIAL (section, segment)
4423                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4424                 printf ("%s ", SECTION_NAME (section));
4425             }
4426
4427           putc ('\n',stdout);
4428         }
4429     }
4430
4431   return 1;
4432 }
4433
4434
4435 /* Find the file offset corresponding to VMA by using the program headers.  */
4436
4437 static long
4438 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4439 {
4440   Elf_Internal_Phdr * seg;
4441
4442   if (! get_program_headers (file))
4443     {
4444       warn (_("Cannot interpret virtual addresses without program headers.\n"));
4445       return (long) vma;
4446     }
4447
4448   for (seg = program_headers;
4449        seg < program_headers + elf_header.e_phnum;
4450        ++seg)
4451     {
4452       if (seg->p_type != PT_LOAD)
4453         continue;
4454
4455       if (vma >= (seg->p_vaddr & -seg->p_align)
4456           && vma + size <= seg->p_vaddr + seg->p_filesz)
4457         return vma - seg->p_vaddr + seg->p_offset;
4458     }
4459
4460   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4461         (unsigned long) vma);
4462   return (long) vma;
4463 }
4464
4465
4466 static int
4467 get_32bit_section_headers (FILE * file, unsigned int num)
4468 {
4469   Elf32_External_Shdr * shdrs;
4470   Elf_Internal_Shdr *   internal;
4471   unsigned int i;
4472
4473   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4474                                             elf_header.e_shentsize, num,
4475                                             _("section headers"));
4476   if (!shdrs)
4477     return 0;
4478
4479   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4480                                                    sizeof (Elf_Internal_Shdr));
4481
4482   if (section_headers == NULL)
4483     {
4484       error (_("Out of memory\n"));
4485       return 0;
4486     }
4487
4488   for (i = 0, internal = section_headers;
4489        i < num;
4490        i++, internal++)
4491     {
4492       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4493       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4494       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4495       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4496       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4497       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4498       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4499       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4500       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4501       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4502     }
4503
4504   free (shdrs);
4505
4506   return 1;
4507 }
4508
4509 static int
4510 get_64bit_section_headers (FILE * file, unsigned int num)
4511 {
4512   Elf64_External_Shdr * shdrs;
4513   Elf_Internal_Shdr *   internal;
4514   unsigned int i;
4515
4516   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4517                                             elf_header.e_shentsize, num,
4518                                             _("section headers"));
4519   if (!shdrs)
4520     return 0;
4521
4522   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4523                                                    sizeof (Elf_Internal_Shdr));
4524
4525   if (section_headers == NULL)
4526     {
4527       error (_("Out of memory\n"));
4528       return 0;
4529     }
4530
4531   for (i = 0, internal = section_headers;
4532        i < num;
4533        i++, internal++)
4534     {
4535       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4536       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4537       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4538       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4539       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4540       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4541       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4542       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4543       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4544       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4545     }
4546
4547   free (shdrs);
4548
4549   return 1;
4550 }
4551
4552 static Elf_Internal_Sym *
4553 get_32bit_elf_symbols (FILE * file,
4554                        Elf_Internal_Shdr * section,
4555                        unsigned long * num_syms_return)
4556 {
4557   unsigned long number = 0;
4558   Elf32_External_Sym * esyms = NULL;
4559   Elf_External_Sym_Shndx * shndx = NULL;
4560   Elf_Internal_Sym * isyms = NULL;
4561   Elf_Internal_Sym * psym;
4562   unsigned int j;
4563
4564   /* Run some sanity checks first.  */
4565   if (section->sh_entsize == 0)
4566     {
4567       error (_("sh_entsize is zero\n"));
4568       goto exit_point;
4569     }
4570
4571   number = section->sh_size / section->sh_entsize;
4572
4573   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4574     {
4575       error (_("Invalid sh_entsize\n"));
4576       goto exit_point;
4577     }
4578
4579   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4580                                            section->sh_size, _("symbols"));
4581   if (esyms == NULL)
4582     goto exit_point;
4583
4584   shndx = NULL;
4585   if (symtab_shndx_hdr != NULL
4586       && (symtab_shndx_hdr->sh_link
4587           == (unsigned long) (section - section_headers)))
4588     {
4589       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4590                                                    symtab_shndx_hdr->sh_offset,
4591                                                    1, symtab_shndx_hdr->sh_size,
4592                                                    _("symbol table section indicies"));
4593       if (shndx == NULL)
4594         goto exit_point;
4595     }
4596
4597   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4598
4599   if (isyms == NULL)
4600     {
4601       error (_("Out of memory\n"));
4602       goto exit_point;
4603     }
4604
4605   for (j = 0, psym = isyms; j < number; j++, psym++)
4606     {
4607       psym->st_name  = BYTE_GET (esyms[j].st_name);
4608       psym->st_value = BYTE_GET (esyms[j].st_value);
4609       psym->st_size  = BYTE_GET (esyms[j].st_size);
4610       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4611       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4612         psym->st_shndx
4613           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4614       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4615         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4616       psym->st_info  = BYTE_GET (esyms[j].st_info);
4617       psym->st_other = BYTE_GET (esyms[j].st_other);
4618     }
4619
4620  exit_point:
4621   if (shndx != NULL)
4622     free (shndx);
4623   if (esyms != NULL)
4624     free (esyms);
4625
4626   if (num_syms_return != NULL)
4627     * num_syms_return = isyms == NULL ? 0 : number;
4628
4629   return isyms;
4630 }
4631
4632 static Elf_Internal_Sym *
4633 get_64bit_elf_symbols (FILE * file,
4634                        Elf_Internal_Shdr * section,
4635                        unsigned long * num_syms_return)
4636 {
4637   unsigned long number = 0;
4638   Elf64_External_Sym * esyms = NULL;
4639   Elf_External_Sym_Shndx * shndx = NULL;
4640   Elf_Internal_Sym * isyms = NULL;
4641   Elf_Internal_Sym * psym;
4642   unsigned int j;
4643
4644   /* Run some sanity checks first.  */
4645   if (section->sh_entsize == 0)
4646     {
4647       error (_("sh_entsize is zero\n"));
4648       goto exit_point;
4649     }
4650
4651   number = section->sh_size / section->sh_entsize;
4652
4653   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4654     {
4655       error (_("Invalid sh_entsize\n"));
4656       goto exit_point;
4657     }
4658
4659   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4660                                            section->sh_size, _("symbols"));
4661   if (!esyms)
4662     goto exit_point;
4663
4664   if (symtab_shndx_hdr != NULL
4665       && (symtab_shndx_hdr->sh_link
4666           == (unsigned long) (section - section_headers)))
4667     {
4668       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4669                                                    symtab_shndx_hdr->sh_offset,
4670                                                    1, symtab_shndx_hdr->sh_size,
4671                                                    _("symbol table section indicies"));
4672       if (shndx == NULL)
4673         goto exit_point;
4674     }
4675
4676   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4677
4678   if (isyms == NULL)
4679     {
4680       error (_("Out of memory\n"));
4681       goto exit_point;
4682     }
4683
4684   for (j = 0, psym = isyms; j < number; j++, psym++)
4685     {
4686       psym->st_name  = BYTE_GET (esyms[j].st_name);
4687       psym->st_info  = BYTE_GET (esyms[j].st_info);
4688       psym->st_other = BYTE_GET (esyms[j].st_other);
4689       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4690
4691       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4692         psym->st_shndx
4693           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4694       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4695         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4696
4697       psym->st_value = BYTE_GET (esyms[j].st_value);
4698       psym->st_size  = BYTE_GET (esyms[j].st_size);
4699     }
4700
4701  exit_point:
4702   if (shndx != NULL)
4703     free (shndx);
4704   if (esyms != NULL)
4705     free (esyms);
4706
4707   if (num_syms_return != NULL)
4708     * num_syms_return = isyms == NULL ? 0 : number;
4709
4710   return isyms;
4711 }
4712
4713 static const char *
4714 get_elf_section_flags (bfd_vma sh_flags)
4715 {
4716   static char buff[1024];
4717   char * p = buff;
4718   int field_size = is_32bit_elf ? 8 : 16;
4719   int sindex;
4720   int size = sizeof (buff) - (field_size + 4 + 1);
4721   bfd_vma os_flags = 0;
4722   bfd_vma proc_flags = 0;
4723   bfd_vma unknown_flags = 0;
4724   static const struct
4725     {
4726       const char * str;
4727       int len;
4728     }
4729   flags [] =
4730     {
4731       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
4732       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
4733       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
4734       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
4735       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
4736       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
4737       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4738       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4739       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
4740       /*  9 */ { STRING_COMMA_LEN ("TLS") },
4741       /* IA-64 specific.  */
4742       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4743       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4744       /* IA-64 OpenVMS specific.  */
4745       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4746       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4747       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4748       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4749       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4750       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4751       /* Generic.  */
4752       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4753       /* SPARC specific.  */
4754       /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4755     };
4756
4757   if (do_section_details)
4758     {
4759       sprintf (buff, "[%*.*lx]: ",
4760                field_size, field_size, (unsigned long) sh_flags);
4761       p += field_size + 4;
4762     }
4763
4764   while (sh_flags)
4765     {
4766       bfd_vma flag;
4767
4768       flag = sh_flags & - sh_flags;
4769       sh_flags &= ~ flag;
4770
4771       if (do_section_details)
4772         {
4773           switch (flag)
4774             {
4775             case SHF_WRITE:             sindex = 0; break;
4776             case SHF_ALLOC:             sindex = 1; break;
4777             case SHF_EXECINSTR:         sindex = 2; break;
4778             case SHF_MERGE:             sindex = 3; break;
4779             case SHF_STRINGS:           sindex = 4; break;
4780             case SHF_INFO_LINK:         sindex = 5; break;
4781             case SHF_LINK_ORDER:        sindex = 6; break;
4782             case SHF_OS_NONCONFORMING:  sindex = 7; break;
4783             case SHF_GROUP:             sindex = 8; break;
4784             case SHF_TLS:               sindex = 9; break;
4785             case SHF_EXCLUDE:           sindex = 18; break;
4786
4787             default:
4788               sindex = -1;
4789               switch (elf_header.e_machine)
4790                 {
4791                 case EM_IA_64:
4792                   if (flag == SHF_IA_64_SHORT)
4793                     sindex = 10;
4794                   else if (flag == SHF_IA_64_NORECOV)
4795                     sindex = 11;
4796 #ifdef BFD64
4797                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4798                     switch (flag)
4799                       {
4800                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
4801                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
4802                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
4803                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
4804                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4805                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
4806                       default:                        break;
4807                       }
4808 #endif
4809                   break;
4810
4811                 case EM_386:
4812                 case EM_486:
4813                 case EM_X86_64:
4814                 case EM_L1OM:
4815                 case EM_K1OM:
4816                 case EM_OLD_SPARCV9:
4817                 case EM_SPARC32PLUS:
4818                 case EM_SPARCV9:
4819                 case EM_SPARC:
4820                   if (flag == SHF_ORDERED)
4821                     sindex = 19;
4822                   break;
4823                 default:
4824                   break;
4825                 }
4826             }
4827
4828           if (sindex != -1)
4829             {
4830               if (p != buff + field_size + 4)
4831                 {
4832                   if (size < (10 + 2))
4833                     abort ();
4834                   size -= 2;
4835                   *p++ = ',';
4836                   *p++ = ' ';
4837                 }
4838
4839               size -= flags [sindex].len;
4840               p = stpcpy (p, flags [sindex].str);
4841             }
4842           else if (flag & SHF_MASKOS)
4843             os_flags |= flag;
4844           else if (flag & SHF_MASKPROC)
4845             proc_flags |= flag;
4846           else
4847             unknown_flags |= flag;
4848         }
4849       else
4850         {
4851           switch (flag)
4852             {
4853             case SHF_WRITE:             *p = 'W'; break;
4854             case SHF_ALLOC:             *p = 'A'; break;
4855             case SHF_EXECINSTR:         *p = 'X'; break;
4856             case SHF_MERGE:             *p = 'M'; break;
4857             case SHF_STRINGS:           *p = 'S'; break;
4858             case SHF_INFO_LINK:         *p = 'I'; break;
4859             case SHF_LINK_ORDER:        *p = 'L'; break;
4860             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
4861             case SHF_GROUP:             *p = 'G'; break;
4862             case SHF_TLS:               *p = 'T'; break;
4863             case SHF_EXCLUDE:           *p = 'E'; break;
4864
4865             default:
4866               if ((elf_header.e_machine == EM_X86_64
4867                    || elf_header.e_machine == EM_L1OM
4868                    || elf_header.e_machine == EM_K1OM)
4869                   && flag == SHF_X86_64_LARGE)
4870                 *p = 'l';
4871               else if (flag & SHF_MASKOS)
4872                 {
4873                   *p = 'o';
4874                   sh_flags &= ~ SHF_MASKOS;
4875                 }
4876               else if (flag & SHF_MASKPROC)
4877                 {
4878                   *p = 'p';
4879                   sh_flags &= ~ SHF_MASKPROC;
4880                 }
4881               else
4882                 *p = 'x';
4883               break;
4884             }
4885           p++;
4886         }
4887     }
4888
4889   if (do_section_details)
4890     {
4891       if (os_flags)
4892         {
4893           size -= 5 + field_size;
4894           if (p != buff + field_size + 4)
4895             {
4896               if (size < (2 + 1))
4897                 abort ();
4898               size -= 2;
4899               *p++ = ',';
4900               *p++ = ' ';
4901             }
4902           sprintf (p, "OS (%*.*lx)", field_size, field_size,
4903                    (unsigned long) os_flags);
4904           p += 5 + field_size;
4905         }
4906       if (proc_flags)
4907         {
4908           size -= 7 + field_size;
4909           if (p != buff + field_size + 4)
4910             {
4911               if (size < (2 + 1))
4912                 abort ();
4913               size -= 2;
4914               *p++ = ',';
4915               *p++ = ' ';
4916             }
4917           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4918                    (unsigned long) proc_flags);
4919           p += 7 + field_size;
4920         }
4921       if (unknown_flags)
4922         {
4923           size -= 10 + field_size;
4924           if (p != buff + field_size + 4)
4925             {
4926               if (size < (2 + 1))
4927                 abort ();
4928               size -= 2;
4929               *p++ = ',';
4930               *p++ = ' ';
4931             }
4932           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
4933                    (unsigned long) unknown_flags);
4934           p += 10 + field_size;
4935         }
4936     }
4937
4938   *p = '\0';
4939   return buff;
4940 }
4941
4942 static int
4943 process_section_headers (FILE * file)
4944 {
4945   Elf_Internal_Shdr * section;
4946   unsigned int i;
4947
4948   section_headers = NULL;
4949
4950   if (elf_header.e_shnum == 0)
4951     {
4952       /* PR binutils/12467.  */
4953       if (elf_header.e_shoff != 0)
4954         warn (_("possibly corrupt ELF file header - it has a non-zero"
4955                 " section header offset, but no section headers\n"));
4956       else if (do_sections)
4957         printf (_("\nThere are no sections in this file.\n"));
4958
4959       return 1;
4960     }
4961
4962   if (do_sections && !do_header)
4963     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4964             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4965
4966   if (is_32bit_elf)
4967     {
4968       if (! get_32bit_section_headers (file, elf_header.e_shnum))
4969         return 0;
4970     }
4971   else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4972     return 0;
4973
4974   /* Read in the string table, so that we have names to display.  */
4975   if (elf_header.e_shstrndx != SHN_UNDEF
4976        && elf_header.e_shstrndx < elf_header.e_shnum)
4977     {
4978       section = section_headers + elf_header.e_shstrndx;
4979
4980       if (section->sh_size != 0)
4981         {
4982           string_table = (char *) get_data (NULL, file, section->sh_offset,
4983                                             1, section->sh_size,
4984                                             _("string table"));
4985
4986           string_table_length = string_table != NULL ? section->sh_size : 0;
4987         }
4988     }
4989
4990   /* Scan the sections for the dynamic symbol table
4991      and dynamic string table and debug sections.  */
4992   dynamic_symbols = NULL;
4993   dynamic_strings = NULL;
4994   dynamic_syminfo = NULL;
4995   symtab_shndx_hdr = NULL;
4996
4997   eh_addr_size = is_32bit_elf ? 4 : 8;
4998   switch (elf_header.e_machine)
4999     {
5000     case EM_MIPS:
5001     case EM_MIPS_RS3_LE:
5002       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5003          FDE addresses.  However, the ABI also has a semi-official ILP32
5004          variant for which the normal FDE address size rules apply.
5005
5006          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5007          section, where XX is the size of longs in bits.  Unfortunately,
5008          earlier compilers provided no way of distinguishing ILP32 objects
5009          from LP64 objects, so if there's any doubt, we should assume that
5010          the official LP64 form is being used.  */
5011       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5012           && find_section (".gcc_compiled_long32") == NULL)
5013         eh_addr_size = 8;
5014       break;
5015
5016     case EM_H8_300:
5017     case EM_H8_300H:
5018       switch (elf_header.e_flags & EF_H8_MACH)
5019         {
5020         case E_H8_MACH_H8300:
5021         case E_H8_MACH_H8300HN:
5022         case E_H8_MACH_H8300SN:
5023         case E_H8_MACH_H8300SXN:
5024           eh_addr_size = 2;
5025           break;
5026         case E_H8_MACH_H8300H:
5027         case E_H8_MACH_H8300S:
5028         case E_H8_MACH_H8300SX:
5029           eh_addr_size = 4;
5030           break;
5031         }
5032       break;
5033
5034     case EM_M32C_OLD:
5035     case EM_M32C:
5036       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5037         {
5038         case EF_M32C_CPU_M16C:
5039           eh_addr_size = 2;
5040           break;
5041         }
5042       break;
5043     }
5044
5045 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5046   do                                                                        \
5047     {                                                                       \
5048       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;      \
5049       if (section->sh_entsize != expected_entsize)                          \
5050         {                                                               \
5051           error (_("Section %d has invalid sh_entsize of %" BFD_VMA_FMT "x\n"), \
5052                  i, section->sh_entsize);       \
5053           error (_("(Using the expected size of %d for the rest of this dump)\n"), \
5054                    (int) expected_entsize); \
5055           section->sh_entsize = expected_entsize;                       \
5056         } \
5057     }                                                                       \
5058   while (0)
5059
5060 #define CHECK_ENTSIZE(section, i, type)                                 \
5061   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
5062                         sizeof (Elf64_External_##type))
5063
5064   for (i = 0, section = section_headers;
5065        i < elf_header.e_shnum;
5066        i++, section++)
5067     {
5068       char * name = SECTION_NAME (section);
5069
5070       if (section->sh_type == SHT_DYNSYM)
5071         {
5072           if (dynamic_symbols != NULL)
5073             {
5074               error (_("File contains multiple dynamic symbol tables\n"));
5075               continue;
5076             }
5077
5078           CHECK_ENTSIZE (section, i, Sym);
5079           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5080         }
5081       else if (section->sh_type == SHT_STRTAB
5082                && streq (name, ".dynstr"))
5083         {
5084           if (dynamic_strings != NULL)
5085             {
5086               error (_("File contains multiple dynamic string tables\n"));
5087               continue;
5088             }
5089
5090           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5091                                                1, section->sh_size,
5092                                                _("dynamic strings"));
5093           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5094         }
5095       else if (section->sh_type == SHT_SYMTAB_SHNDX)
5096         {
5097           if (symtab_shndx_hdr != NULL)
5098             {
5099               error (_("File contains multiple symtab shndx tables\n"));
5100               continue;
5101             }
5102           symtab_shndx_hdr = section;
5103         }
5104       else if (section->sh_type == SHT_SYMTAB)
5105         CHECK_ENTSIZE (section, i, Sym);
5106       else if (section->sh_type == SHT_GROUP)
5107         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5108       else if (section->sh_type == SHT_REL)
5109         CHECK_ENTSIZE (section, i, Rel);
5110       else if (section->sh_type == SHT_RELA)
5111         CHECK_ENTSIZE (section, i, Rela);
5112       else if ((do_debugging || do_debug_info || do_debug_abbrevs
5113                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5114                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5115                 || do_debug_str || do_debug_loc || do_debug_ranges
5116                 || do_debug_addr || do_debug_cu_index)
5117                && (const_strneq (name, ".debug_")
5118                    || const_strneq (name, ".zdebug_")))
5119         {
5120           if (name[1] == 'z')
5121             name += sizeof (".zdebug_") - 1;
5122           else
5123             name += sizeof (".debug_") - 1;
5124
5125           if (do_debugging
5126               || (do_debug_info     && const_strneq (name, "info"))
5127               || (do_debug_info     && const_strneq (name, "types"))
5128               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
5129               || (do_debug_lines    && strcmp (name, "line") == 0)
5130               || (do_debug_lines    && const_strneq (name, "line."))
5131               || (do_debug_pubnames && const_strneq (name, "pubnames"))
5132               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5133               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5134               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5135               || (do_debug_aranges  && const_strneq (name, "aranges"))
5136               || (do_debug_ranges   && const_strneq (name, "ranges"))
5137               || (do_debug_frames   && const_strneq (name, "frame"))
5138               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
5139               || (do_debug_macinfo  && const_strneq (name, "macro"))
5140               || (do_debug_str      && const_strneq (name, "str"))
5141               || (do_debug_loc      && const_strneq (name, "loc"))
5142               || (do_debug_addr     && const_strneq (name, "addr"))
5143               || (do_debug_cu_index && const_strneq (name, "cu_index"))
5144               || (do_debug_cu_index && const_strneq (name, "tu_index"))
5145               )
5146             request_dump_bynumber (i, DEBUG_DUMP);
5147         }
5148       /* Linkonce section to be combined with .debug_info at link time.  */
5149       else if ((do_debugging || do_debug_info)
5150                && const_strneq (name, ".gnu.linkonce.wi."))
5151         request_dump_bynumber (i, DEBUG_DUMP);
5152       else if (do_debug_frames && streq (name, ".eh_frame"))
5153         request_dump_bynumber (i, DEBUG_DUMP);
5154       else if (do_gdb_index && streq (name, ".gdb_index"))
5155         request_dump_bynumber (i, DEBUG_DUMP);
5156       /* Trace sections for Itanium VMS.  */
5157       else if ((do_debugging || do_trace_info || do_trace_abbrevs
5158                 || do_trace_aranges)
5159                && const_strneq (name, ".trace_"))
5160         {
5161           name += sizeof (".trace_") - 1;
5162
5163           if (do_debugging
5164               || (do_trace_info     && streq (name, "info"))
5165               || (do_trace_abbrevs  && streq (name, "abbrev"))
5166               || (do_trace_aranges  && streq (name, "aranges"))
5167               )
5168             request_dump_bynumber (i, DEBUG_DUMP);
5169         }
5170
5171     }
5172
5173   if (! do_sections)
5174     return 1;
5175
5176   if (elf_header.e_shnum > 1)
5177     printf (_("\nSection Headers:\n"));
5178   else
5179     printf (_("\nSection Header:\n"));
5180
5181   if (is_32bit_elf)
5182     {
5183       if (do_section_details)
5184         {
5185           printf (_("  [Nr] Name\n"));
5186           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
5187         }
5188       else
5189         printf
5190           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
5191     }
5192   else if (do_wide)
5193     {
5194       if (do_section_details)
5195         {
5196           printf (_("  [Nr] Name\n"));
5197           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
5198         }
5199       else
5200         printf
5201           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
5202     }
5203   else
5204     {
5205       if (do_section_details)
5206         {
5207           printf (_("  [Nr] Name\n"));
5208           printf (_("       Type              Address          Offset            Link\n"));
5209           printf (_("       Size              EntSize          Info              Align\n"));
5210         }
5211       else
5212         {
5213           printf (_("  [Nr] Name              Type             Address           Offset\n"));
5214           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
5215         }
5216     }
5217
5218   if (do_section_details)
5219     printf (_("       Flags\n"));
5220
5221   for (i = 0, section = section_headers;
5222        i < elf_header.e_shnum;
5223        i++, section++)
5224     {
5225       printf ("  [%2u] ", i);
5226       if (do_section_details)
5227         {
5228           print_symbol (INT_MAX, SECTION_NAME (section));
5229           printf ("\n      ");
5230         }
5231       else
5232         {
5233           print_symbol (-17, SECTION_NAME (section));
5234         }
5235
5236       printf (do_wide ? " %-15s " : " %-15.15s ",
5237               get_section_type_name (section->sh_type));
5238
5239       if (is_32bit_elf)
5240         {
5241           const char * link_too_big = NULL;
5242
5243           print_vma (section->sh_addr, LONG_HEX);
5244
5245           printf ( " %6.6lx %6.6lx %2.2lx",
5246                    (unsigned long) section->sh_offset,
5247                    (unsigned long) section->sh_size,
5248                    (unsigned long) section->sh_entsize);
5249
5250           if (do_section_details)
5251             fputs ("  ", stdout);
5252           else
5253             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5254
5255           if (section->sh_link >= elf_header.e_shnum)
5256             {
5257               link_too_big = "";
5258               /* The sh_link value is out of range.  Normally this indicates
5259                  an error but it can have special values in Solaris binaries.  */
5260               switch (elf_header.e_machine)
5261                 {
5262                 case EM_386:
5263                 case EM_486:
5264                 case EM_X86_64:
5265                 case EM_L1OM:
5266                 case EM_K1OM:
5267                 case EM_OLD_SPARCV9:
5268                 case EM_SPARC32PLUS:
5269                 case EM_SPARCV9:
5270                 case EM_SPARC:
5271                   if (section->sh_link == (SHN_BEFORE & 0xffff))
5272                     link_too_big = "BEFORE";
5273                   else if (section->sh_link == (SHN_AFTER & 0xffff))
5274                     link_too_big = "AFTER";
5275                   break;
5276                 default:
5277                   break;
5278                 }
5279             }
5280
5281           if (do_section_details)
5282             {
5283               if (link_too_big != NULL && * link_too_big)
5284                 printf ("<%s> ", link_too_big);
5285               else
5286                 printf ("%2u ", section->sh_link);
5287               printf ("%3u %2lu\n", section->sh_info,
5288                       (unsigned long) section->sh_addralign);
5289             }
5290           else
5291             printf ("%2u %3u %2lu\n",
5292                     section->sh_link,
5293                     section->sh_info,
5294                     (unsigned long) section->sh_addralign);
5295
5296           if (link_too_big && ! * link_too_big)
5297             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5298                   i, section->sh_link);
5299         }
5300       else if (do_wide)
5301         {
5302           print_vma (section->sh_addr, LONG_HEX);
5303
5304           if ((long) section->sh_offset == section->sh_offset)
5305             printf (" %6.6lx", (unsigned long) section->sh_offset);
5306           else
5307             {
5308               putchar (' ');
5309               print_vma (section->sh_offset, LONG_HEX);
5310             }
5311
5312           if ((unsigned long) section->sh_size == section->sh_size)
5313             printf (" %6.6lx", (unsigned long) section->sh_size);
5314           else
5315             {
5316               putchar (' ');
5317               print_vma (section->sh_size, LONG_HEX);
5318             }
5319
5320           if ((unsigned long) section->sh_entsize == section->sh_entsize)
5321             printf (" %2.2lx", (unsigned long) section->sh_entsize);
5322           else
5323             {
5324               putchar (' ');
5325               print_vma (section->sh_entsize, LONG_HEX);
5326             }
5327
5328           if (do_section_details)
5329             fputs ("  ", stdout);
5330           else
5331             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5332
5333           printf ("%2u %3u ", section->sh_link, section->sh_info);
5334
5335           if ((unsigned long) section->sh_addralign == section->sh_addralign)
5336             printf ("%2lu\n", (unsigned long) section->sh_addralign);
5337           else
5338             {
5339               print_vma (section->sh_addralign, DEC);
5340               putchar ('\n');
5341             }
5342         }
5343       else if (do_section_details)
5344         {
5345           printf ("       %-15.15s  ",
5346                   get_section_type_name (section->sh_type));
5347           print_vma (section->sh_addr, LONG_HEX);
5348           if ((long) section->sh_offset == section->sh_offset)
5349             printf ("  %16.16lx", (unsigned long) section->sh_offset);
5350           else
5351             {
5352               printf ("  ");
5353               print_vma (section->sh_offset, LONG_HEX);
5354             }
5355           printf ("  %u\n       ", section->sh_link);
5356           print_vma (section->sh_size, LONG_HEX);
5357           putchar (' ');
5358           print_vma (section->sh_entsize, LONG_HEX);
5359
5360           printf ("  %-16u  %lu\n",
5361                   section->sh_info,
5362                   (unsigned long) section->sh_addralign);
5363         }
5364       else
5365         {
5366           putchar (' ');
5367           print_vma (section->sh_addr, LONG_HEX);
5368           if ((long) section->sh_offset == section->sh_offset)
5369             printf ("  %8.8lx", (unsigned long) section->sh_offset);
5370           else
5371             {
5372               printf ("  ");
5373               print_vma (section->sh_offset, LONG_HEX);
5374             }
5375           printf ("\n       ");
5376           print_vma (section->sh_size, LONG_HEX);
5377           printf ("  ");
5378           print_vma (section->sh_entsize, LONG_HEX);
5379
5380           printf (" %3s ", get_elf_section_flags (section->sh_flags));
5381
5382           printf ("     %2u   %3u     %lu\n",
5383                   section->sh_link,
5384                   section->sh_info,
5385                   (unsigned long) section->sh_addralign);
5386         }
5387
5388       if (do_section_details)
5389         printf ("       %s\n", get_elf_section_flags (section->sh_flags));
5390     }
5391
5392   if (!do_section_details)
5393     {
5394       if (elf_header.e_machine == EM_X86_64
5395           || elf_header.e_machine == EM_L1OM
5396           || elf_header.e_machine == EM_K1OM)
5397         printf (_("Key to Flags:\n\
5398   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5399   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5400   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5401       else
5402         printf (_("Key to Flags:\n\
5403   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5404   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5405   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5406     }
5407
5408   return 1;
5409 }
5410
5411 static const char *
5412 get_group_flags (unsigned int flags)
5413 {
5414   static char buff[32];
5415   switch (flags)
5416     {
5417     case 0:
5418       return "";
5419
5420     case GRP_COMDAT:
5421       return "COMDAT ";
5422
5423    default:
5424       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5425       break;
5426     }
5427   return buff;
5428 }
5429
5430 static int
5431 process_section_groups (FILE * file)
5432 {
5433   Elf_Internal_Shdr * section;
5434   unsigned int i;
5435   struct group * group;
5436   Elf_Internal_Shdr * symtab_sec;
5437   Elf_Internal_Shdr * strtab_sec;
5438   Elf_Internal_Sym * symtab;
5439   unsigned long num_syms;
5440   char * strtab;
5441   size_t strtab_size;
5442
5443   /* Don't process section groups unless needed.  */
5444   if (!do_unwind && !do_section_groups)
5445     return 1;
5446
5447   if (elf_header.e_shnum == 0)
5448     {
5449       if (do_section_groups)
5450         printf (_("\nThere are no sections to group in this file.\n"));
5451
5452       return 1;
5453     }
5454
5455   if (section_headers == NULL)
5456     {
5457       error (_("Section headers are not available!\n"));
5458       /* PR 13622: This can happen with a corrupt ELF header.  */
5459       return 0;
5460     }
5461
5462   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5463                                                      sizeof (struct group *));
5464
5465   if (section_headers_groups == NULL)
5466     {
5467       error (_("Out of memory\n"));
5468       return 0;
5469     }
5470
5471   /* Scan the sections for the group section.  */
5472   group_count = 0;
5473   for (i = 0, section = section_headers;
5474        i < elf_header.e_shnum;
5475        i++, section++)
5476     if (section->sh_type == SHT_GROUP)
5477       group_count++;
5478
5479   if (group_count == 0)
5480     {
5481       if (do_section_groups)
5482         printf (_("\nThere are no section groups in this file.\n"));
5483
5484       return 1;
5485     }
5486
5487   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5488
5489   if (section_groups == NULL)
5490     {
5491       error (_("Out of memory\n"));
5492       return 0;
5493     }
5494
5495   symtab_sec = NULL;
5496   strtab_sec = NULL;
5497   symtab = NULL;
5498   num_syms = 0;
5499   strtab = NULL;
5500   strtab_size = 0;
5501   for (i = 0, section = section_headers, group = section_groups;
5502        i < elf_header.e_shnum;
5503        i++, section++)
5504     {
5505       if (section->sh_type == SHT_GROUP)
5506         {
5507           char * name = SECTION_NAME (section);
5508           char * group_name;
5509           unsigned char * start;
5510           unsigned char * indices;
5511           unsigned int entry, j, size;
5512           Elf_Internal_Shdr * sec;
5513           Elf_Internal_Sym * sym;
5514
5515           /* Get the symbol table.  */
5516           if (section->sh_link >= elf_header.e_shnum
5517               || ((sec = section_headers + section->sh_link)->sh_type
5518                   != SHT_SYMTAB))
5519             {
5520               error (_("Bad sh_link in group section `%s'\n"), name);
5521               continue;
5522             }
5523
5524           if (symtab_sec != sec)
5525             {
5526               symtab_sec = sec;
5527               if (symtab)
5528                 free (symtab);
5529               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5530             }
5531
5532           if (symtab == NULL)
5533             {
5534               error (_("Corrupt header in group section `%s'\n"), name);
5535               continue;
5536             }
5537
5538           if (section->sh_info >= num_syms)
5539             {
5540               error (_("Bad sh_info in group section `%s'\n"), name);
5541               continue;
5542             }
5543
5544           sym = symtab + section->sh_info;
5545
5546           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5547             {
5548               if (sym->st_shndx == 0
5549                   || sym->st_shndx >= elf_header.e_shnum)
5550                 {
5551                   error (_("Bad sh_info in group section `%s'\n"), name);
5552                   continue;
5553                 }
5554
5555               group_name = SECTION_NAME (section_headers + sym->st_shndx);
5556               strtab_sec = NULL;
5557               if (strtab)
5558                 free (strtab);
5559               strtab = NULL;
5560               strtab_size = 0;
5561             }
5562           else
5563             {
5564               /* Get the string table.  */
5565               if (symtab_sec->sh_link >= elf_header.e_shnum)
5566                 {
5567                   strtab_sec = NULL;
5568                   if (strtab)
5569                     free (strtab);
5570                   strtab = NULL;
5571                   strtab_size = 0;
5572                 }
5573               else if (strtab_sec
5574                        != (sec = section_headers + symtab_sec->sh_link))
5575                 {
5576                   strtab_sec = sec;
5577                   if (strtab)
5578                     free (strtab);
5579                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5580                                               1, strtab_sec->sh_size,
5581                                               _("string table"));
5582                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5583                 }
5584               group_name = sym->st_name < strtab_size
5585                 ? strtab + sym->st_name : _("<corrupt>");
5586             }
5587
5588           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5589                                               1, section->sh_size,
5590                                               _("section data"));
5591           if (start == NULL)
5592             continue;
5593
5594           indices = start;
5595           size = (section->sh_size / section->sh_entsize) - 1;
5596           entry = byte_get (indices, 4);
5597           indices += 4;
5598
5599           if (do_section_groups)
5600             {
5601               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5602                       get_group_flags (entry), i, name, group_name, size);
5603
5604               printf (_("   [Index]    Name\n"));
5605             }
5606
5607           group->group_index = i;
5608
5609           for (j = 0; j < size; j++)
5610             {
5611               struct group_list * g;
5612
5613               entry = byte_get (indices, 4);
5614               indices += 4;
5615
5616               if (entry >= elf_header.e_shnum)
5617                 {
5618                   error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5619                          entry, i, elf_header.e_shnum - 1);
5620                   continue;
5621                 }
5622
5623               if (section_headers_groups [entry] != NULL)
5624                 {
5625                   if (entry)
5626                     {
5627                       error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5628                              entry, i,
5629                              section_headers_groups [entry]->group_index);
5630                       continue;
5631                     }
5632                   else
5633                     {
5634                       /* Intel C/C++ compiler may put section 0 in a
5635                          section group. We just warn it the first time
5636                          and ignore it afterwards.  */
5637                       static int warned = 0;
5638                       if (!warned)
5639                         {
5640                           error (_("section 0 in group section [%5u]\n"),
5641                                  section_headers_groups [entry]->group_index);
5642                           warned++;
5643                         }
5644                     }
5645                 }
5646
5647               section_headers_groups [entry] = group;
5648
5649               if (do_section_groups)
5650                 {
5651                   sec = section_headers + entry;
5652                   printf ("   [%5u]   %s\n", entry, SECTION_NAME (sec));
5653                 }
5654
5655               g = (struct group_list *) xmalloc (sizeof (struct group_list));
5656               g->section_index = entry;
5657               g->next = group->root;
5658               group->root = g;
5659             }
5660
5661           if (start)
5662             free (start);
5663
5664           group++;
5665         }
5666     }
5667
5668   if (symtab)
5669     free (symtab);
5670   if (strtab)
5671     free (strtab);
5672   return 1;
5673 }
5674
5675 /* Data used to display dynamic fixups.  */
5676
5677 struct ia64_vms_dynfixup
5678 {
5679   bfd_vma needed_ident;         /* Library ident number.  */
5680   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
5681   bfd_vma fixup_needed;         /* Index of the library.  */
5682   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
5683   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
5684 };
5685
5686 /* Data used to display dynamic relocations.  */
5687
5688 struct ia64_vms_dynimgrela
5689 {
5690   bfd_vma img_rela_cnt;         /* Number of relocations.  */
5691   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
5692 };
5693
5694 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5695    library).  */
5696
5697 static void
5698 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5699                               const char *strtab, unsigned int strtab_sz)
5700 {
5701   Elf64_External_VMS_IMAGE_FIXUP *imfs;
5702   long i;
5703   const char *lib_name;
5704
5705   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5706                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
5707                    _("dynamic section image fixups"));
5708   if (!imfs)
5709     return;
5710
5711   if (fixup->needed < strtab_sz)
5712     lib_name = strtab + fixup->needed;
5713   else
5714     {
5715       warn ("corrupt library name index of 0x%lx found in dynamic entry",
5716             (unsigned long) fixup->needed);
5717       lib_name = "???";
5718     }
5719   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5720           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5721   printf
5722     (_("Seg Offset           Type                             SymVec DataType\n"));
5723
5724   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5725     {
5726       unsigned int type;
5727       const char *rtype;
5728
5729       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5730       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5731       type = BYTE_GET (imfs [i].type);
5732       rtype = elf_ia64_reloc_type (type);
5733       if (rtype == NULL)
5734         printf (" 0x%08x                       ", type);
5735       else
5736         printf (" %-32s ", rtype);
5737       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5738       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5739     }
5740
5741   free (imfs);
5742 }
5743
5744 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
5745
5746 static void
5747 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5748 {
5749   Elf64_External_VMS_IMAGE_RELA *imrs;
5750   long i;
5751
5752   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5753                    1, imgrela->img_rela_cnt * sizeof (*imrs),
5754                    _("dynamic section image relocations"));
5755   if (!imrs)
5756     return;
5757
5758   printf (_("\nImage relocs\n"));
5759   printf
5760     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
5761
5762   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5763     {
5764       unsigned int type;
5765       const char *rtype;
5766
5767       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5768       printf ("%08" BFD_VMA_FMT "x ",
5769               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5770       type = BYTE_GET (imrs [i].type);
5771       rtype = elf_ia64_reloc_type (type);
5772       if (rtype == NULL)
5773         printf ("0x%08x                      ", type);
5774       else
5775         printf ("%-31s ", rtype);
5776       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5777       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5778       printf ("%08" BFD_VMA_FMT "x\n",
5779               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5780     }
5781
5782   free (imrs);
5783 }
5784
5785 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
5786
5787 static int
5788 process_ia64_vms_dynamic_relocs (FILE *file)
5789 {
5790   struct ia64_vms_dynfixup fixup;
5791   struct ia64_vms_dynimgrela imgrela;
5792   Elf_Internal_Dyn *entry;
5793   int res = 0;
5794   bfd_vma strtab_off = 0;
5795   bfd_vma strtab_sz = 0;
5796   char *strtab = NULL;
5797
5798   memset (&fixup, 0, sizeof (fixup));
5799   memset (&imgrela, 0, sizeof (imgrela));
5800
5801   /* Note: the order of the entries is specified by the OpenVMS specs.  */
5802   for (entry = dynamic_section;
5803        entry < dynamic_section + dynamic_nent;
5804        entry++)
5805     {
5806       switch (entry->d_tag)
5807         {
5808         case DT_IA_64_VMS_STRTAB_OFFSET:
5809           strtab_off = entry->d_un.d_val;
5810           break;
5811         case DT_STRSZ:
5812           strtab_sz = entry->d_un.d_val;
5813           if (strtab == NULL)
5814             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5815                                1, strtab_sz, _("dynamic string section"));
5816           break;
5817
5818         case DT_IA_64_VMS_NEEDED_IDENT:
5819           fixup.needed_ident = entry->d_un.d_val;
5820           break;
5821         case DT_NEEDED:
5822           fixup.needed = entry->d_un.d_val;
5823           break;
5824         case DT_IA_64_VMS_FIXUP_NEEDED:
5825           fixup.fixup_needed = entry->d_un.d_val;
5826           break;
5827         case DT_IA_64_VMS_FIXUP_RELA_CNT:
5828           fixup.fixup_rela_cnt = entry->d_un.d_val;
5829           break;
5830         case DT_IA_64_VMS_FIXUP_RELA_OFF:
5831           fixup.fixup_rela_off = entry->d_un.d_val;
5832           res++;
5833           dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5834           break;
5835
5836         case DT_IA_64_VMS_IMG_RELA_CNT:
5837           imgrela.img_rela_cnt = entry->d_un.d_val;
5838           break;
5839         case DT_IA_64_VMS_IMG_RELA_OFF:
5840           imgrela.img_rela_off = entry->d_un.d_val;
5841           res++;
5842           dump_ia64_vms_dynamic_relocs (file, &imgrela);
5843           break;
5844
5845         default:
5846           break;
5847         }
5848     }
5849
5850   if (strtab != NULL)
5851     free (strtab);
5852
5853   return res;
5854 }
5855
5856 static struct
5857 {
5858   const char * name;
5859   int reloc;
5860   int size;
5861   int rela;
5862 } dynamic_relocations [] =
5863 {
5864     { "REL", DT_REL, DT_RELSZ, FALSE },
5865     { "RELA", DT_RELA, DT_RELASZ, TRUE },
5866     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5867 };
5868
5869 /* Process the reloc section.  */
5870
5871 static int
5872 process_relocs (FILE * file)
5873 {
5874   unsigned long rel_size;
5875   unsigned long rel_offset;
5876
5877
5878   if (!do_reloc)
5879     return 1;
5880
5881   if (do_using_dynamic)
5882     {
5883       int is_rela;
5884       const char * name;
5885       int has_dynamic_reloc;
5886       unsigned int i;
5887
5888       has_dynamic_reloc = 0;
5889
5890       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5891         {
5892           is_rela = dynamic_relocations [i].rela;
5893           name = dynamic_relocations [i].name;
5894           rel_size = dynamic_info [dynamic_relocations [i].size];
5895           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5896
5897           has_dynamic_reloc |= rel_size;
5898
5899           if (is_rela == UNKNOWN)
5900             {
5901               if (dynamic_relocations [i].reloc == DT_JMPREL)
5902                 switch (dynamic_info[DT_PLTREL])
5903                   {
5904                   case DT_REL:
5905                     is_rela = FALSE;
5906                     break;
5907                   case DT_RELA:
5908                     is_rela = TRUE;
5909                     break;
5910                   }
5911             }
5912
5913           if (rel_size)
5914             {
5915               printf
5916                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5917                  name, rel_offset, rel_size);
5918
5919               dump_relocations (file,
5920                                 offset_from_vma (file, rel_offset, rel_size),
5921                                 rel_size,
5922                                 dynamic_symbols, num_dynamic_syms,
5923                                 dynamic_strings, dynamic_strings_length, is_rela);
5924             }
5925         }
5926
5927       if (is_ia64_vms ())
5928         has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5929
5930       if (! has_dynamic_reloc)
5931         printf (_("\nThere are no dynamic relocations in this file.\n"));
5932     }
5933   else
5934     {
5935       Elf_Internal_Shdr * section;
5936       unsigned long i;
5937       int found = 0;
5938
5939       for (i = 0, section = section_headers;
5940            i < elf_header.e_shnum;
5941            i++, section++)
5942         {
5943           if (   section->sh_type != SHT_RELA
5944               && section->sh_type != SHT_REL)
5945             continue;
5946
5947           rel_offset = section->sh_offset;
5948           rel_size   = section->sh_size;
5949
5950           if (rel_size)
5951             {
5952               Elf_Internal_Shdr * strsec;
5953               int is_rela;
5954
5955               printf (_("\nRelocation section "));
5956
5957               if (string_table == NULL)
5958                 printf ("%d", section->sh_name);
5959               else
5960                 printf ("'%s'", SECTION_NAME (section));
5961
5962               printf (_(" at offset 0x%lx contains %lu entries:\n"),
5963                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5964
5965               is_rela = section->sh_type == SHT_RELA;
5966
5967               if (section->sh_link != 0
5968                   && section->sh_link < elf_header.e_shnum)
5969                 {
5970                   Elf_Internal_Shdr * symsec;
5971                   Elf_Internal_Sym *  symtab;
5972                   unsigned long nsyms;
5973                   unsigned long strtablen = 0;
5974                   char * strtab = NULL;
5975
5976                   symsec = section_headers + section->sh_link;
5977                   if (symsec->sh_type != SHT_SYMTAB
5978                       && symsec->sh_type != SHT_DYNSYM)
5979                     continue;
5980
5981                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
5982
5983                   if (symtab == NULL)
5984                     continue;
5985
5986                   if (symsec->sh_link != 0
5987                       && symsec->sh_link < elf_header.e_shnum)
5988                     {
5989                       strsec = section_headers + symsec->sh_link;
5990
5991                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5992                                                   1, strsec->sh_size,
5993                                                   _("string table"));
5994                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
5995                     }
5996
5997                   dump_relocations (file, rel_offset, rel_size,
5998                                     symtab, nsyms, strtab, strtablen, is_rela);
5999                   if (strtab)
6000                     free (strtab);
6001                   free (symtab);
6002                 }
6003               else
6004                 dump_relocations (file, rel_offset, rel_size,
6005                                   NULL, 0, NULL, 0, is_rela);
6006
6007               found = 1;
6008             }
6009         }
6010
6011       if (! found)
6012         printf (_("\nThere are no relocations in this file.\n"));
6013     }
6014
6015   return 1;
6016 }
6017
6018 /* Process the unwind section.  */
6019
6020 #include "unwind-ia64.h"
6021
6022 /* An absolute address consists of a section and an offset.  If the
6023    section is NULL, the offset itself is the address, otherwise, the
6024    address equals to LOAD_ADDRESS(section) + offset.  */
6025
6026 struct absaddr
6027   {
6028     unsigned short section;
6029     bfd_vma offset;
6030   };
6031
6032 #define ABSADDR(a) \
6033   ((a).section \
6034    ? section_headers [(a).section].sh_addr + (a).offset \
6035    : (a).offset)
6036
6037 struct ia64_unw_table_entry
6038   {
6039     struct absaddr start;
6040     struct absaddr end;
6041     struct absaddr info;
6042   };
6043
6044 struct ia64_unw_aux_info
6045   {
6046
6047     struct ia64_unw_table_entry *table; /* Unwind table.  */
6048     unsigned long table_len;    /* Length of unwind table.  */
6049     unsigned char * info;       /* Unwind info.  */
6050     unsigned long info_size;    /* Size of unwind info.  */
6051     bfd_vma info_addr;          /* starting address of unwind info.  */
6052     bfd_vma seg_base;           /* Starting address of segment.  */
6053     Elf_Internal_Sym * symtab;  /* The symbol table.  */
6054     unsigned long nsyms;        /* Number of symbols.  */
6055     char * strtab;              /* The string table.  */
6056     unsigned long strtab_size;  /* Size of string table.  */
6057   };
6058
6059 static void
6060 find_symbol_for_address (Elf_Internal_Sym * symtab,
6061                          unsigned long nsyms,
6062                          const char * strtab,
6063                          unsigned long strtab_size,
6064                          struct absaddr addr,
6065                          const char ** symname,
6066                          bfd_vma * offset)
6067 {
6068   bfd_vma dist = 0x100000;
6069   Elf_Internal_Sym * sym;
6070   Elf_Internal_Sym * best = NULL;
6071   unsigned long i;
6072
6073   REMOVE_ARCH_BITS (addr.offset);
6074
6075   for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
6076     {
6077       bfd_vma value = sym->st_value;
6078
6079       REMOVE_ARCH_BITS (value);
6080
6081       if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
6082           && sym->st_name != 0
6083           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6084           && addr.offset >= value
6085           && addr.offset - value < dist)
6086         {
6087           best = sym;
6088           dist = addr.offset - value;
6089           if (!dist)
6090             break;
6091         }
6092     }
6093
6094   if (best)
6095     {
6096       *symname = (best->st_name >= strtab_size
6097                   ? _("<corrupt>") : strtab + best->st_name);
6098       *offset = dist;
6099       return;
6100     }
6101
6102   *symname = NULL;
6103   *offset = addr.offset;
6104 }
6105
6106 static void
6107 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6108 {
6109   struct ia64_unw_table_entry * tp;
6110   int in_body;
6111
6112   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6113     {
6114       bfd_vma stamp;
6115       bfd_vma offset;
6116       const unsigned char * dp;
6117       const unsigned char * head;
6118       const char * procname;
6119
6120       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6121                                aux->strtab_size, tp->start, &procname, &offset);
6122
6123       fputs ("\n<", stdout);
6124
6125       if (procname)
6126         {
6127           fputs (procname, stdout);
6128
6129           if (offset)
6130             printf ("+%lx", (unsigned long) offset);
6131         }
6132
6133       fputs (">: [", stdout);
6134       print_vma (tp->start.offset, PREFIX_HEX);
6135       fputc ('-', stdout);
6136       print_vma (tp->end.offset, PREFIX_HEX);
6137       printf ("], info at +0x%lx\n",
6138               (unsigned long) (tp->info.offset - aux->seg_base));
6139
6140       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6141       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6142
6143       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6144               (unsigned) UNW_VER (stamp),
6145               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6146               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6147               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6148               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6149
6150       if (UNW_VER (stamp) != 1)
6151         {
6152           printf (_("\tUnknown version.\n"));
6153           continue;
6154         }
6155
6156       in_body = 0;
6157       for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
6158         dp = unw_decode (dp, in_body, & in_body);
6159     }
6160 }
6161
6162 static int
6163 slurp_ia64_unwind_table (FILE * file,
6164                          struct ia64_unw_aux_info * aux,
6165                          Elf_Internal_Shdr * sec)
6166 {
6167   unsigned long size, nrelas, i;
6168   Elf_Internal_Phdr * seg;
6169   struct ia64_unw_table_entry * tep;
6170   Elf_Internal_Shdr * relsec;
6171   Elf_Internal_Rela * rela;
6172   Elf_Internal_Rela * rp;
6173   unsigned char * table;
6174   unsigned char * tp;
6175   Elf_Internal_Sym * sym;
6176   const char * relname;
6177
6178   /* First, find the starting address of the segment that includes
6179      this section: */
6180
6181   if (elf_header.e_phnum)
6182     {
6183       if (! get_program_headers (file))
6184           return 0;
6185
6186       for (seg = program_headers;
6187            seg < program_headers + elf_header.e_phnum;
6188            ++seg)
6189         {
6190           if (seg->p_type != PT_LOAD)
6191             continue;
6192
6193           if (sec->sh_addr >= seg->p_vaddr
6194               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6195             {
6196               aux->seg_base = seg->p_vaddr;
6197               break;
6198             }
6199         }
6200     }
6201
6202   /* Second, build the unwind table from the contents of the unwind section:  */
6203   size = sec->sh_size;
6204   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6205                                       _("unwind table"));
6206   if (!table)
6207     return 0;
6208
6209   aux->table = (struct ia64_unw_table_entry *)
6210       xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
6211   tep = aux->table;
6212   for (tp = table; tp < table + size; ++tep)
6213     {
6214       tep->start.section = SHN_UNDEF;
6215       tep->end.section   = SHN_UNDEF;
6216       tep->info.section  = SHN_UNDEF;
6217       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6218       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6219       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6220       tep->start.offset += aux->seg_base;
6221       tep->end.offset   += aux->seg_base;
6222       tep->info.offset  += aux->seg_base;
6223     }
6224   free (table);
6225
6226   /* Third, apply any relocations to the unwind table:  */
6227   for (relsec = section_headers;
6228        relsec < section_headers + elf_header.e_shnum;
6229        ++relsec)
6230     {
6231       if (relsec->sh_type != SHT_RELA
6232           || relsec->sh_info >= elf_header.e_shnum
6233           || section_headers + relsec->sh_info != sec)
6234         continue;
6235
6236       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6237                               & rela, & nrelas))
6238         return 0;
6239
6240       for (rp = rela; rp < rela + nrelas; ++rp)
6241         {
6242           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6243           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6244
6245           if (! const_strneq (relname, "R_IA64_SEGREL"))
6246             {
6247               warn (_("Skipping unexpected relocation type %s\n"), relname);
6248               continue;
6249             }
6250
6251           i = rp->r_offset / (3 * eh_addr_size);
6252
6253           switch (rp->r_offset/eh_addr_size % 3)
6254             {
6255             case 0:
6256               aux->table[i].start.section = sym->st_shndx;
6257               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
6258               break;
6259             case 1:
6260               aux->table[i].end.section   = sym->st_shndx;
6261               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
6262               break;
6263             case 2:
6264               aux->table[i].info.section  = sym->st_shndx;
6265               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
6266               break;
6267             default:
6268               break;
6269             }
6270         }
6271
6272       free (rela);
6273     }
6274
6275   aux->table_len = size / (3 * eh_addr_size);
6276   return 1;
6277 }
6278
6279 static void
6280 ia64_process_unwind (FILE * file)
6281 {
6282   Elf_Internal_Shdr * sec;
6283   Elf_Internal_Shdr * unwsec = NULL;
6284   Elf_Internal_Shdr * strsec;
6285   unsigned long i, unwcount = 0, unwstart = 0;
6286   struct ia64_unw_aux_info aux;
6287
6288   memset (& aux, 0, sizeof (aux));
6289
6290   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6291     {
6292       if (sec->sh_type == SHT_SYMTAB
6293           && sec->sh_link < elf_header.e_shnum)
6294         {
6295           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6296
6297           strsec = section_headers + sec->sh_link;
6298           assert (aux.strtab == NULL);
6299           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6300                                           1, strsec->sh_size,
6301                                           _("string table"));
6302           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6303         }
6304       else if (sec->sh_type == SHT_IA_64_UNWIND)
6305         unwcount++;
6306     }
6307
6308   if (!unwcount)
6309     printf (_("\nThere are no unwind sections in this file.\n"));
6310
6311   while (unwcount-- > 0)
6312     {
6313       char * suffix;
6314       size_t len, len2;
6315
6316       for (i = unwstart, sec = section_headers + unwstart;
6317            i < elf_header.e_shnum; ++i, ++sec)
6318         if (sec->sh_type == SHT_IA_64_UNWIND)
6319           {
6320             unwsec = sec;
6321             break;
6322           }
6323
6324       unwstart = i + 1;
6325       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6326
6327       if ((unwsec->sh_flags & SHF_GROUP) != 0)
6328         {
6329           /* We need to find which section group it is in.  */
6330           struct group_list * g = section_headers_groups [i]->root;
6331
6332           for (; g != NULL; g = g->next)
6333             {
6334               sec = section_headers + g->section_index;
6335
6336               if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6337                 break;
6338             }
6339
6340           if (g == NULL)
6341             i = elf_header.e_shnum;
6342         }
6343       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6344         {
6345           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
6346           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6347           suffix = SECTION_NAME (unwsec) + len;
6348           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6349                ++i, ++sec)
6350             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6351                 && streq (SECTION_NAME (sec) + len2, suffix))
6352               break;
6353         }
6354       else
6355         {
6356           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6357              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
6358           len = sizeof (ELF_STRING_ia64_unwind) - 1;
6359           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6360           suffix = "";
6361           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6362             suffix = SECTION_NAME (unwsec) + len;
6363           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6364                ++i, ++sec)
6365             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6366                 && streq (SECTION_NAME (sec) + len2, suffix))
6367               break;
6368         }
6369
6370       if (i == elf_header.e_shnum)
6371         {
6372           printf (_("\nCould not find unwind info section for "));
6373
6374           if (string_table == NULL)
6375             printf ("%d", unwsec->sh_name);
6376           else
6377             printf (_("'%s'"), SECTION_NAME (unwsec));
6378         }
6379       else
6380         {
6381           aux.info_addr = sec->sh_addr;
6382           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6383                                                  sec->sh_size,
6384                                                  _("unwind info"));
6385           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6386
6387           printf (_("\nUnwind section "));
6388
6389           if (string_table == NULL)
6390             printf ("%d", unwsec->sh_name);
6391           else
6392             printf (_("'%s'"), SECTION_NAME (unwsec));
6393
6394           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6395                   (unsigned long) unwsec->sh_offset,
6396                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6397
6398           (void) slurp_ia64_unwind_table (file, & aux, unwsec);
6399
6400           if (aux.table_len > 0)
6401             dump_ia64_unwind (& aux);
6402
6403           if (aux.table)
6404             free ((char *) aux.table);
6405           if (aux.info)
6406             free ((char *) aux.info);
6407           aux.table = NULL;
6408           aux.info = NULL;
6409         }
6410     }
6411
6412   if (aux.symtab)
6413     free (aux.symtab);
6414   if (aux.strtab)
6415     free ((char *) aux.strtab);
6416 }
6417
6418 struct hppa_unw_table_entry
6419   {
6420     struct absaddr start;
6421     struct absaddr end;
6422     unsigned int Cannot_unwind:1;                       /* 0 */
6423     unsigned int Millicode:1;                   /* 1 */
6424     unsigned int Millicode_save_sr0:1;          /* 2 */
6425     unsigned int Region_description:2;          /* 3..4 */
6426     unsigned int reserved1:1;                   /* 5 */
6427     unsigned int Entry_SR:1;                    /* 6 */
6428     unsigned int Entry_FR:4;     /* number saved */     /* 7..10 */
6429     unsigned int Entry_GR:5;     /* number saved */     /* 11..15 */
6430     unsigned int Args_stored:1;                 /* 16 */
6431     unsigned int Variable_Frame:1;                      /* 17 */
6432     unsigned int Separate_Package_Body:1;               /* 18 */
6433     unsigned int Frame_Extension_Millicode:1;   /* 19 */
6434     unsigned int Stack_Overflow_Check:1;                /* 20 */
6435     unsigned int Two_Instruction_SP_Increment:1;        /* 21 */
6436     unsigned int Ada_Region:1;                  /* 22 */
6437     unsigned int cxx_info:1;                    /* 23 */
6438     unsigned int cxx_try_catch:1;                       /* 24 */
6439     unsigned int sched_entry_seq:1;                     /* 25 */
6440     unsigned int reserved2:1;                   /* 26 */
6441     unsigned int Save_SP:1;                             /* 27 */
6442     unsigned int Save_RP:1;                             /* 28 */
6443     unsigned int Save_MRP_in_frame:1;           /* 29 */
6444     unsigned int extn_ptr_defined:1;            /* 30 */
6445     unsigned int Cleanup_defined:1;                     /* 31 */
6446
6447     unsigned int MPE_XL_interrupt_marker:1;             /* 0 */
6448     unsigned int HP_UX_interrupt_marker:1;              /* 1 */
6449     unsigned int Large_frame:1;                 /* 2 */
6450     unsigned int Pseudo_SP_Set:1;                       /* 3 */
6451     unsigned int reserved4:1;                   /* 4 */
6452     unsigned int Total_frame_size:27;           /* 5..31 */
6453   };
6454
6455 struct hppa_unw_aux_info
6456   {
6457     struct hppa_unw_table_entry *table; /* Unwind table.  */
6458     unsigned long table_len;    /* Length of unwind table.  */
6459     bfd_vma seg_base;           /* Starting address of segment.  */
6460     Elf_Internal_Sym * symtab;  /* The symbol table.  */
6461     unsigned long nsyms;        /* Number of symbols.  */
6462     char * strtab;              /* The string table.  */
6463     unsigned long strtab_size;  /* Size of string table.  */
6464   };
6465
6466 static void
6467 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
6468 {
6469   struct hppa_unw_table_entry * tp;
6470
6471   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6472     {
6473       bfd_vma offset;
6474       const char * procname;
6475
6476       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6477                                aux->strtab_size, tp->start, &procname,
6478                                &offset);
6479
6480       fputs ("\n<", stdout);
6481
6482       if (procname)
6483         {
6484           fputs (procname, stdout);
6485
6486           if (offset)
6487             printf ("+%lx", (unsigned long) offset);
6488         }
6489
6490       fputs (">: [", stdout);
6491       print_vma (tp->start.offset, PREFIX_HEX);
6492       fputc ('-', stdout);
6493       print_vma (tp->end.offset, PREFIX_HEX);
6494       printf ("]\n\t");
6495
6496 #define PF(_m) if (tp->_m) printf (#_m " ");
6497 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6498       PF(Cannot_unwind);
6499       PF(Millicode);
6500       PF(Millicode_save_sr0);
6501       /* PV(Region_description);  */
6502       PF(Entry_SR);
6503       PV(Entry_FR);
6504       PV(Entry_GR);
6505       PF(Args_stored);
6506       PF(Variable_Frame);
6507       PF(Separate_Package_Body);
6508       PF(Frame_Extension_Millicode);
6509       PF(Stack_Overflow_Check);
6510       PF(Two_Instruction_SP_Increment);
6511       PF(Ada_Region);
6512       PF(cxx_info);
6513       PF(cxx_try_catch);
6514       PF(sched_entry_seq);
6515       PF(Save_SP);
6516       PF(Save_RP);
6517       PF(Save_MRP_in_frame);
6518       PF(extn_ptr_defined);
6519       PF(Cleanup_defined);
6520       PF(MPE_XL_interrupt_marker);
6521       PF(HP_UX_interrupt_marker);
6522       PF(Large_frame);
6523       PF(Pseudo_SP_Set);
6524       PV(Total_frame_size);
6525 #undef PF
6526 #undef PV
6527     }
6528
6529   printf ("\n");
6530 }
6531
6532 static int
6533 slurp_hppa_unwind_table (FILE * file,
6534                          struct hppa_unw_aux_info * aux,
6535                          Elf_Internal_Shdr * sec)
6536 {
6537   unsigned long size, unw_ent_size, nentries, nrelas, i;
6538   Elf_Internal_Phdr * seg;
6539   struct hppa_unw_table_entry * tep;
6540   Elf_Internal_Shdr * relsec;
6541   Elf_Internal_Rela * rela;
6542   Elf_Internal_Rela * rp;
6543   unsigned char * table;
6544   unsigned char * tp;
6545   Elf_Internal_Sym * sym;
6546   const char * relname;
6547
6548   /* First, find the starting address of the segment that includes
6549      this section.  */
6550
6551   if (elf_header.e_phnum)
6552     {
6553       if (! get_program_headers (file))
6554         return 0;
6555
6556       for (seg = program_headers;
6557            seg < program_headers + elf_header.e_phnum;
6558            ++seg)
6559         {
6560           if (seg->p_type != PT_LOAD)
6561             continue;
6562
6563           if (sec->sh_addr >= seg->p_vaddr
6564               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6565             {
6566               aux->seg_base = seg->p_vaddr;
6567               break;
6568             }
6569         }
6570     }
6571
6572   /* Second, build the unwind table from the contents of the unwind
6573      section.  */
6574   size = sec->sh_size;
6575   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6576                                       _("unwind table"));
6577   if (!table)
6578     return 0;
6579
6580   unw_ent_size = 16;
6581   nentries = size / unw_ent_size;
6582   size = unw_ent_size * nentries;
6583
6584   tep = aux->table = (struct hppa_unw_table_entry *)
6585       xcmalloc (nentries, sizeof (aux->table[0]));
6586
6587   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6588     {
6589       unsigned int tmp1, tmp2;
6590
6591       tep->start.section = SHN_UNDEF;
6592       tep->end.section   = SHN_UNDEF;
6593
6594       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6595       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6596       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6597       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6598
6599       tep->start.offset += aux->seg_base;
6600       tep->end.offset   += aux->seg_base;
6601
6602       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6603       tep->Millicode = (tmp1 >> 30) & 0x1;
6604       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6605       tep->Region_description = (tmp1 >> 27) & 0x3;
6606       tep->reserved1 = (tmp1 >> 26) & 0x1;
6607       tep->Entry_SR = (tmp1 >> 25) & 0x1;
6608       tep->Entry_FR = (tmp1 >> 21) & 0xf;
6609       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6610       tep->Args_stored = (tmp1 >> 15) & 0x1;
6611       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6612       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6613       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6614       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6615       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6616       tep->Ada_Region = (tmp1 >> 9) & 0x1;
6617       tep->cxx_info = (tmp1 >> 8) & 0x1;
6618       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6619       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6620       tep->reserved2 = (tmp1 >> 5) & 0x1;
6621       tep->Save_SP = (tmp1 >> 4) & 0x1;
6622       tep->Save_RP = (tmp1 >> 3) & 0x1;
6623       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6624       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6625       tep->Cleanup_defined = tmp1 & 0x1;
6626
6627       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6628       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6629       tep->Large_frame = (tmp2 >> 29) & 0x1;
6630       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6631       tep->reserved4 = (tmp2 >> 27) & 0x1;
6632       tep->Total_frame_size = tmp2 & 0x7ffffff;
6633     }
6634   free (table);
6635
6636   /* Third, apply any relocations to the unwind table.  */
6637   for (relsec = section_headers;
6638        relsec < section_headers + elf_header.e_shnum;
6639        ++relsec)
6640     {
6641       if (relsec->sh_type != SHT_RELA
6642           || relsec->sh_info >= elf_header.e_shnum
6643           || section_headers + relsec->sh_info != sec)
6644         continue;
6645
6646       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6647                               & rela, & nrelas))
6648         return 0;
6649
6650       for (rp = rela; rp < rela + nrelas; ++rp)
6651         {
6652           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6653           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6654
6655           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
6656           if (! const_strneq (relname, "R_PARISC_SEGREL"))
6657             {
6658               warn (_("Skipping unexpected relocation type %s\n"), relname);
6659               continue;
6660             }
6661
6662           i = rp->r_offset / unw_ent_size;
6663
6664           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6665             {
6666             case 0:
6667               aux->table[i].start.section = sym->st_shndx;
6668               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
6669               break;
6670             case 1:
6671               aux->table[i].end.section   = sym->st_shndx;
6672               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
6673               break;
6674             default:
6675               break;
6676             }
6677         }
6678
6679       free (rela);
6680     }
6681
6682   aux->table_len = nentries;
6683
6684   return 1;
6685 }
6686
6687 static void
6688 hppa_process_unwind (FILE * file)
6689 {
6690   struct hppa_unw_aux_info aux;
6691   Elf_Internal_Shdr * unwsec = NULL;
6692   Elf_Internal_Shdr * strsec;
6693   Elf_Internal_Shdr * sec;
6694   unsigned long i;
6695
6696   if (string_table == NULL)
6697     return;
6698
6699   memset (& aux, 0, sizeof (aux));
6700
6701   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6702     {
6703       if (sec->sh_type == SHT_SYMTAB
6704           && sec->sh_link < elf_header.e_shnum)
6705         {
6706           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6707
6708           strsec = section_headers + sec->sh_link;
6709           assert (aux.strtab == NULL);
6710           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6711                                           1, strsec->sh_size,
6712                                           _("string table"));
6713           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6714         }
6715       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6716         unwsec = sec;
6717     }
6718
6719   if (!unwsec)
6720     printf (_("\nThere are no unwind sections in this file.\n"));
6721
6722   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6723     {
6724       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6725         {
6726           printf (_("\nUnwind section "));
6727           printf (_("'%s'"), SECTION_NAME (sec));
6728
6729           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6730                   (unsigned long) sec->sh_offset,
6731                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6732
6733           slurp_hppa_unwind_table (file, &aux, sec);
6734           if (aux.table_len > 0)
6735             dump_hppa_unwind (&aux);
6736
6737           if (aux.table)
6738             free ((char *) aux.table);
6739           aux.table = NULL;
6740         }
6741     }
6742
6743   if (aux.symtab)
6744     free (aux.symtab);
6745   if (aux.strtab)
6746     free ((char *) aux.strtab);
6747 }
6748
6749 struct arm_section
6750 {
6751   unsigned char *      data;            /* The unwind data.  */
6752   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
6753   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
6754   unsigned long        nrelas;          /* The number of relocations.  */
6755   unsigned int         rel_type;        /* REL or RELA ?  */
6756   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
6757 };
6758
6759 struct arm_unw_aux_info
6760 {
6761   FILE *              file;             /* The file containing the unwind sections.  */
6762   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
6763   unsigned long       nsyms;            /* Number of symbols.  */
6764   char *              strtab;           /* The file's string table.  */
6765   unsigned long       strtab_size;      /* Size of string table.  */
6766 };
6767
6768 static const char *
6769 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6770                         bfd_vma fn, struct absaddr addr)
6771 {
6772   const char *procname;
6773   bfd_vma sym_offset;
6774
6775   if (addr.section == SHN_UNDEF)
6776     addr.offset = fn;
6777
6778   find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6779                            aux->strtab_size, addr, &procname,
6780                            &sym_offset);
6781
6782   print_vma (fn, PREFIX_HEX);
6783
6784   if (procname)
6785     {
6786       fputs (" <", stdout);
6787       fputs (procname, stdout);
6788
6789       if (sym_offset)
6790         printf ("+0x%lx", (unsigned long) sym_offset);
6791       fputc ('>', stdout);
6792     }
6793
6794   return procname;
6795 }
6796
6797 static void
6798 arm_free_section (struct arm_section *arm_sec)
6799 {
6800   if (arm_sec->data != NULL)
6801     free (arm_sec->data);
6802
6803   if (arm_sec->rela != NULL)
6804     free (arm_sec->rela);
6805 }
6806
6807 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6808       cached section and install SEC instead.
6809    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6810       and return its valued in * WORDP, relocating if necessary.
6811    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6812       relocation's offset in ADDR.
6813    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6814       into the string table of the symbol associated with the reloc.  If no
6815       reloc was applied store -1 there.
6816    5) Return TRUE upon success, FALSE otherwise.  */
6817
6818 static bfd_boolean
6819 get_unwind_section_word (struct arm_unw_aux_info *  aux,
6820                          struct arm_section *       arm_sec,
6821                          Elf_Internal_Shdr *        sec,
6822                          bfd_vma                    word_offset,
6823                          unsigned int *             wordp,
6824                          struct absaddr *           addr,
6825                          bfd_vma *                  sym_name)
6826 {
6827   Elf_Internal_Rela *rp;
6828   Elf_Internal_Sym *sym;
6829   const char * relname;
6830   unsigned int word;
6831   bfd_boolean wrapped;
6832
6833   addr->section = SHN_UNDEF;
6834   addr->offset = 0;
6835
6836   if (sym_name != NULL)
6837     *sym_name = (bfd_vma) -1;
6838
6839   /* If necessary, update the section cache.  */
6840   if (sec != arm_sec->sec)
6841     {
6842       Elf_Internal_Shdr *relsec;
6843
6844       arm_free_section (arm_sec);
6845
6846       arm_sec->sec = sec;
6847       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6848                                 sec->sh_size, _("unwind data"));
6849       arm_sec->rela = NULL;
6850       arm_sec->nrelas = 0;
6851
6852       for (relsec = section_headers;
6853            relsec < section_headers + elf_header.e_shnum;
6854            ++relsec)
6855         {
6856           if (relsec->sh_info >= elf_header.e_shnum
6857               || section_headers + relsec->sh_info != sec
6858               /* PR 15745: Check the section type as well.  */
6859               || (relsec->sh_type != SHT_REL
6860                   && relsec->sh_type != SHT_RELA))
6861             continue;
6862
6863           arm_sec->rel_type = relsec->sh_type;
6864           if (relsec->sh_type == SHT_REL)
6865             {
6866               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6867                                      relsec->sh_size,
6868                                      & arm_sec->rela, & arm_sec->nrelas))
6869                 return FALSE;
6870             }
6871           else /* relsec->sh_type == SHT_RELA */
6872             {
6873               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6874                                       relsec->sh_size,
6875                                       & arm_sec->rela, & arm_sec->nrelas))
6876                 return FALSE;
6877             }
6878           break;
6879         }
6880
6881       arm_sec->next_rela = arm_sec->rela;
6882     }
6883
6884   /* If there is no unwind data we can do nothing.  */
6885   if (arm_sec->data == NULL)
6886     return FALSE;
6887
6888   /* Get the word at the required offset.  */
6889   word = byte_get (arm_sec->data + word_offset, 4);
6890
6891   /* Look through the relocs to find the one that applies to the provided offset.  */
6892   wrapped = FALSE;
6893   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6894     {
6895       bfd_vma prelval, offset;
6896
6897       if (rp->r_offset > word_offset && !wrapped)
6898         {
6899           rp = arm_sec->rela;
6900           wrapped = TRUE;
6901         }
6902       if (rp->r_offset > word_offset)
6903         break;
6904
6905       if (rp->r_offset & 3)
6906         {
6907           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6908                 (unsigned long) rp->r_offset);
6909           continue;
6910         }
6911
6912       if (rp->r_offset < word_offset)
6913         continue;
6914
6915       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6916
6917       if (arm_sec->rel_type == SHT_REL)
6918         {
6919           offset = word & 0x7fffffff;
6920           if (offset & 0x40000000)
6921             offset |= ~ (bfd_vma) 0x7fffffff;
6922         }
6923       else if (arm_sec->rel_type == SHT_RELA)
6924         offset = rp->r_addend;
6925       else
6926         abort ();
6927
6928       offset += sym->st_value;
6929       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6930
6931       /* Check that we are processing the expected reloc type.  */
6932       if (elf_header.e_machine == EM_ARM)
6933         {
6934           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6935
6936           if (streq (relname, "R_ARM_NONE"))
6937               continue;
6938
6939           if (! streq (relname, "R_ARM_PREL31"))
6940             {
6941               warn (_("Skipping unexpected relocation type %s\n"), relname);
6942               continue;
6943             }
6944         }
6945       else if (elf_header.e_machine == EM_TI_C6000)
6946         {
6947           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6948
6949           if (streq (relname, "R_C6000_NONE"))
6950             continue;
6951
6952           if (! streq (relname, "R_C6000_PREL31"))
6953             {
6954               warn (_("Skipping unexpected relocation type %s\n"), relname);
6955               continue;
6956             }
6957
6958           prelval >>= 1;
6959         }
6960       else
6961         /* This function currently only supports ARM and TI unwinders.  */
6962         abort ();
6963
6964       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6965       addr->section = sym->st_shndx;
6966       addr->offset = offset;
6967       if (sym_name)
6968         * sym_name = sym->st_name;
6969       break;
6970     }
6971
6972   *wordp = word;
6973   arm_sec->next_rela = rp;
6974
6975   return TRUE;
6976 }
6977
6978 static const char *tic6x_unwind_regnames[16] =
6979 {
6980   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6981   "A14", "A13", "A12", "A11", "A10",
6982   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6983 };
6984
6985 static void
6986 decode_tic6x_unwind_regmask (unsigned int mask)
6987 {
6988   int i;
6989
6990   for (i = 12; mask; mask >>= 1, i--)
6991     {
6992       if (mask & 1)
6993         {
6994           fputs (tic6x_unwind_regnames[i], stdout);
6995           if (mask > 1)
6996             fputs (", ", stdout);
6997         }
6998     }
6999 }
7000
7001 #define ADVANCE                                                 \
7002   if (remaining == 0 && more_words)                             \
7003     {                                                           \
7004       data_offset += 4;                                         \
7005       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
7006                                      data_offset, & word, & addr, NULL))        \
7007         return;                                                 \
7008       remaining = 4;                                            \
7009       more_words--;                                             \
7010     }                                                           \
7011
7012 #define GET_OP(OP)                      \
7013   ADVANCE;                              \
7014   if (remaining)                        \
7015     {                                   \
7016       remaining--;                      \
7017       (OP) = word >> 24;                \
7018       word <<= 8;                       \
7019     }                                   \
7020   else                                  \
7021     {                                   \
7022       printf (_("[Truncated opcode]\n"));       \
7023       return;                           \
7024     }                                   \
7025   printf ("0x%02x ", OP)
7026
7027 static void
7028 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
7029                             unsigned int word, unsigned int remaining,
7030                             unsigned int more_words,
7031                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7032                             struct arm_section *data_arm_sec)
7033 {
7034   struct absaddr addr;
7035
7036   /* Decode the unwinding instructions.  */
7037   while (1)
7038     {
7039       unsigned int op, op2;
7040
7041       ADVANCE;
7042       if (remaining == 0)
7043         break;
7044       remaining--;
7045       op = word >> 24;
7046       word <<= 8;
7047
7048       printf ("  0x%02x ", op);
7049
7050       if ((op & 0xc0) == 0x00)
7051         {
7052           int offset = ((op & 0x3f) << 2) + 4;
7053
7054           printf ("     vsp = vsp + %d", offset);
7055         }
7056       else if ((op & 0xc0) == 0x40)
7057         {
7058           int offset = ((op & 0x3f) << 2) + 4;
7059
7060           printf ("     vsp = vsp - %d", offset);
7061         }
7062       else if ((op & 0xf0) == 0x80)
7063         {
7064           GET_OP (op2);
7065           if (op == 0x80 && op2 == 0)
7066             printf (_("Refuse to unwind"));
7067           else
7068             {
7069               unsigned int mask = ((op & 0x0f) << 8) | op2;
7070               int first = 1;
7071               int i;
7072
7073               printf ("pop {");
7074               for (i = 0; i < 12; i++)
7075                 if (mask & (1 << i))
7076                   {
7077                     if (first)
7078                       first = 0;
7079                     else
7080                       printf (", ");
7081                     printf ("r%d", 4 + i);
7082                   }
7083               printf ("}");
7084             }
7085         }
7086       else if ((op & 0xf0) == 0x90)
7087         {
7088           if (op == 0x9d || op == 0x9f)
7089             printf (_("     [Reserved]"));
7090           else
7091             printf ("     vsp = r%d", op & 0x0f);
7092         }
7093       else if ((op & 0xf0) == 0xa0)
7094         {
7095           int end = 4 + (op & 0x07);
7096           int first = 1;
7097           int i;
7098
7099           printf ("     pop {");
7100           for (i = 4; i <= end; i++)
7101             {
7102               if (first)
7103                 first = 0;
7104               else
7105                 printf (", ");
7106               printf ("r%d", i);
7107             }
7108           if (op & 0x08)
7109             {
7110               if (!first)
7111                 printf (", ");
7112               printf ("r14");
7113             }
7114           printf ("}");
7115         }
7116       else if (op == 0xb0)
7117         printf (_("     finish"));
7118       else if (op == 0xb1)
7119         {
7120           GET_OP (op2);
7121           if (op2 == 0 || (op2 & 0xf0) != 0)
7122             printf (_("[Spare]"));
7123           else
7124             {
7125               unsigned int mask = op2 & 0x0f;
7126               int first = 1;
7127               int i;
7128
7129               printf ("pop {");
7130               for (i = 0; i < 12; i++)
7131                 if (mask & (1 << i))
7132                   {
7133                     if (first)
7134                       first = 0;
7135                     else
7136                       printf (", ");
7137                     printf ("r%d", i);
7138                   }
7139               printf ("}");
7140             }
7141         }
7142       else if (op == 0xb2)
7143         {
7144           unsigned char buf[9];
7145           unsigned int i, len;
7146           unsigned long offset;
7147
7148           for (i = 0; i < sizeof (buf); i++)
7149             {
7150               GET_OP (buf[i]);
7151               if ((buf[i] & 0x80) == 0)
7152                 break;
7153             }
7154           assert (i < sizeof (buf));
7155           offset = read_uleb128 (buf, &len, buf + i + 1);
7156           assert (len == i + 1);
7157           offset = offset * 4 + 0x204;
7158           printf ("vsp = vsp + %ld", offset);
7159         }
7160       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
7161         {
7162           unsigned int first, last;
7163
7164           GET_OP (op2);
7165           first = op2 >> 4;
7166           last = op2 & 0x0f;
7167           if (op == 0xc8)
7168             first = first + 16;
7169           printf ("pop {D%d", first);
7170           if (last)
7171             printf ("-D%d", first + last);
7172           printf ("}");
7173         }
7174       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7175         {
7176           unsigned int count = op & 0x07;
7177
7178           printf ("pop {D8");
7179           if (count)
7180             printf ("-D%d", 8 + count);
7181           printf ("}");
7182         }
7183       else if (op >= 0xc0 && op <= 0xc5)
7184         {
7185           unsigned int count = op & 0x07;
7186
7187           printf ("     pop {wR10");
7188           if (count)
7189             printf ("-wR%d", 10 + count);
7190           printf ("}");
7191         }
7192       else if (op == 0xc6)
7193         {
7194           unsigned int first, last;
7195
7196           GET_OP (op2);
7197           first = op2 >> 4;
7198           last = op2 & 0x0f;
7199           printf ("pop {wR%d", first);
7200           if (last)
7201             printf ("-wR%d", first + last);
7202           printf ("}");
7203         }
7204       else if (op == 0xc7)
7205         {
7206           GET_OP (op2);
7207           if (op2 == 0 || (op2 & 0xf0) != 0)
7208             printf (_("[Spare]"));
7209           else
7210             {
7211               unsigned int mask = op2 & 0x0f;
7212               int first = 1;
7213               int i;
7214
7215               printf ("pop {");
7216               for (i = 0; i < 4; i++)
7217                 if (mask & (1 << i))
7218                   {
7219                     if (first)
7220                       first = 0;
7221                     else
7222                       printf (", ");
7223                     printf ("wCGR%d", i);
7224                   }
7225               printf ("}");
7226             }
7227         }
7228       else
7229         printf (_("     [unsupported opcode]"));
7230       printf ("\n");
7231     }
7232 }
7233
7234 static void
7235 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7236                             unsigned int word, unsigned int remaining,
7237                             unsigned int more_words,
7238                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7239                             struct arm_section *data_arm_sec)
7240 {
7241   struct absaddr addr;
7242
7243   /* Decode the unwinding instructions.  */
7244   while (1)
7245     {
7246       unsigned int op, op2;
7247
7248       ADVANCE;
7249       if (remaining == 0)
7250         break;
7251       remaining--;
7252       op = word >> 24;
7253       word <<= 8;
7254
7255       printf ("  0x%02x ", op);
7256
7257       if ((op & 0xc0) == 0x00)
7258         {
7259           int offset = ((op & 0x3f) << 3) + 8;
7260           printf ("     sp = sp + %d", offset);
7261         }
7262       else if ((op & 0xc0) == 0x80)
7263         {
7264           GET_OP (op2);
7265           if (op == 0x80 && op2 == 0)
7266             printf (_("Refuse to unwind"));
7267           else
7268             {
7269               unsigned int mask = ((op & 0x1f) << 8) | op2;
7270               if (op & 0x20)
7271                 printf ("pop compact {");
7272               else
7273                 printf ("pop {");
7274
7275               decode_tic6x_unwind_regmask (mask);
7276               printf("}");
7277             }
7278         }
7279       else if ((op & 0xf0) == 0xc0)
7280         {
7281           unsigned int reg;
7282           unsigned int nregs;
7283           unsigned int i;
7284           const char *name;
7285           struct
7286           {
7287               unsigned int offset;
7288               unsigned int reg;
7289           } regpos[16];
7290
7291           /* Scan entire instruction first so that GET_OP output is not
7292              interleaved with disassembly.  */
7293           nregs = 0;
7294           for (i = 0; nregs < (op & 0xf); i++)
7295             {
7296               GET_OP (op2);
7297               reg = op2 >> 4;
7298               if (reg != 0xf)
7299                 {
7300                   regpos[nregs].offset = i * 2;
7301                   regpos[nregs].reg = reg;
7302                   nregs++;
7303                 }
7304
7305               reg = op2 & 0xf;
7306               if (reg != 0xf)
7307                 {
7308                   regpos[nregs].offset = i * 2 + 1;
7309                   regpos[nregs].reg = reg;
7310                   nregs++;
7311                 }
7312             }
7313
7314           printf (_("pop frame {"));
7315           reg = nregs - 1;
7316           for (i = i * 2; i > 0; i--)
7317             {
7318               if (regpos[reg].offset == i - 1)
7319                 {
7320                   name = tic6x_unwind_regnames[regpos[reg].reg];
7321                   if (reg > 0)
7322                     reg--;
7323                 }
7324               else
7325                 name = _("[pad]");
7326
7327               fputs (name, stdout);
7328               if (i > 1)
7329                 printf (", ");
7330             }
7331
7332           printf ("}");
7333         }
7334       else if (op == 0xd0)
7335         printf ("     MOV FP, SP");
7336       else if (op == 0xd1)
7337         printf ("     __c6xabi_pop_rts");
7338       else if (op == 0xd2)
7339         {
7340           unsigned char buf[9];
7341           unsigned int i, len;
7342           unsigned long offset;
7343
7344           for (i = 0; i < sizeof (buf); i++)
7345             {
7346               GET_OP (buf[i]);
7347               if ((buf[i] & 0x80) == 0)
7348                 break;
7349             }
7350           assert (i < sizeof (buf));
7351           offset = read_uleb128 (buf, &len, buf + i + 1);
7352           assert (len == i + 1);
7353           offset = offset * 8 + 0x408;
7354           printf (_("sp = sp + %ld"), offset);
7355         }
7356       else if ((op & 0xf0) == 0xe0)
7357         {
7358           if ((op & 0x0f) == 7)
7359             printf ("     RETURN");
7360           else
7361             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7362         }
7363       else
7364         {
7365           printf (_("     [unsupported opcode]"));
7366         }
7367       putchar ('\n');
7368     }
7369 }
7370
7371 static bfd_vma
7372 arm_expand_prel31 (bfd_vma word, bfd_vma where)
7373 {
7374   bfd_vma offset;
7375
7376   offset = word & 0x7fffffff;
7377   if (offset & 0x40000000)
7378     offset |= ~ (bfd_vma) 0x7fffffff;
7379
7380   if (elf_header.e_machine == EM_TI_C6000)
7381     offset <<= 1;
7382
7383   return offset + where;
7384 }
7385
7386 static void
7387 decode_arm_unwind (struct arm_unw_aux_info *  aux,
7388                    unsigned int               word,
7389                    unsigned int               remaining,
7390                    bfd_vma                    data_offset,
7391                    Elf_Internal_Shdr *        data_sec,
7392                    struct arm_section *       data_arm_sec)
7393 {
7394   int per_index;
7395   unsigned int more_words = 0;
7396   struct absaddr addr;
7397   bfd_vma sym_name = (bfd_vma) -1;
7398
7399   if (remaining == 0)
7400     {
7401       /* Fetch the first word.
7402          Note - when decoding an object file the address extracted
7403          here will always be 0.  So we also pass in the sym_name
7404          parameter so that we can find the symbol associated with
7405          the personality routine.  */
7406       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7407                                      & word, & addr, & sym_name))
7408         return;
7409
7410       remaining = 4;
7411     }
7412
7413   if ((word & 0x80000000) == 0)
7414     {
7415       /* Expand prel31 for personality routine.  */
7416       bfd_vma fn;
7417       const char *procname;
7418
7419       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
7420       printf (_("  Personality routine: "));
7421       if (fn == 0
7422           && addr.section == SHN_UNDEF && addr.offset == 0
7423           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7424         {
7425           procname = aux->strtab + sym_name;
7426           print_vma (fn, PREFIX_HEX);
7427           if (procname)
7428             {
7429               fputs (" <", stdout);
7430               fputs (procname, stdout);
7431               fputc ('>', stdout);
7432             }
7433         }
7434       else
7435         procname = arm_print_vma_and_name (aux, fn, addr);
7436       fputc ('\n', stdout);
7437
7438       /* The GCC personality routines use the standard compact
7439          encoding, starting with one byte giving the number of
7440          words.  */
7441       if (procname != NULL
7442           && (const_strneq (procname, "__gcc_personality_v0")
7443               || const_strneq (procname, "__gxx_personality_v0")
7444               || const_strneq (procname, "__gcj_personality_v0")
7445               || const_strneq (procname, "__gnu_objc_personality_v0")))
7446         {
7447           remaining = 0;
7448           more_words = 1;
7449           ADVANCE;
7450           if (!remaining)
7451             {
7452               printf (_("  [Truncated data]\n"));
7453               return;
7454             }
7455           more_words = word >> 24;
7456           word <<= 8;
7457           remaining--;
7458           per_index = -1;
7459         }
7460       else
7461         return;
7462     }
7463   else
7464     {
7465       /* ARM EHABI Section 6.3:
7466
7467          An exception-handling table entry for the compact model looks like:
7468
7469            31 30-28 27-24 23-0
7470            -- ----- ----- ----
7471             1   0   index Data for personalityRoutine[index]    */
7472
7473       if (elf_header.e_machine == EM_ARM
7474           && (word & 0x70000000))
7475         warn (_("Corrupt ARM compact model table entry: %x \n"), word);
7476
7477       per_index = (word >> 24) & 0x7f;
7478       printf (_("  Compact model index: %d\n"), per_index);
7479       if (per_index == 0)
7480         {
7481           more_words = 0;
7482           word <<= 8;
7483           remaining--;
7484         }
7485       else if (per_index < 3)
7486         {
7487           more_words = (word >> 16) & 0xff;
7488           word <<= 16;
7489           remaining -= 2;
7490         }
7491     }
7492
7493   switch (elf_header.e_machine)
7494     {
7495     case EM_ARM:
7496       if (per_index < 3)
7497         {
7498           decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7499                                       data_offset, data_sec, data_arm_sec);
7500         }
7501       else
7502         {
7503           warn (_("Unknown ARM compact model index encountered\n"));
7504           printf (_("  [reserved]\n"));
7505         }
7506       break;
7507
7508     case EM_TI_C6000:
7509       if (per_index < 3)
7510         {
7511           decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
7512                                         data_offset, data_sec, data_arm_sec);
7513         }
7514       else if (per_index < 5)
7515         {
7516           if (((word >> 17) & 0x7f) == 0x7f)
7517             printf (_("  Restore stack from frame pointer\n"));
7518           else
7519             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
7520           printf (_("  Registers restored: "));
7521           if (per_index == 4)
7522             printf (" (compact) ");
7523           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7524           putchar ('\n');
7525           printf (_("  Return register: %s\n"),
7526                   tic6x_unwind_regnames[word & 0xf]);
7527         }
7528       else
7529         printf (_("  [reserved (%d)]\n"), per_index);
7530       break;
7531
7532     default:
7533       error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7534              elf_header.e_machine);
7535     }
7536
7537   /* Decode the descriptors.  Not implemented.  */
7538 }
7539
7540 static void
7541 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7542 {
7543   struct arm_section exidx_arm_sec, extab_arm_sec;
7544   unsigned int i, exidx_len;
7545
7546   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7547   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7548   exidx_len = exidx_sec->sh_size / 8;
7549
7550   for (i = 0; i < exidx_len; i++)
7551     {
7552       unsigned int exidx_fn, exidx_entry;
7553       struct absaddr fn_addr, entry_addr;
7554       bfd_vma fn;
7555
7556       fputc ('\n', stdout);
7557
7558       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7559                                      8 * i, & exidx_fn, & fn_addr, NULL)
7560           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7561                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
7562         {
7563           arm_free_section (& exidx_arm_sec);
7564           arm_free_section (& extab_arm_sec);
7565           return;
7566         }
7567
7568       /* ARM EHABI, Section 5:
7569          An index table entry consists of 2 words.
7570          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
7571       if (exidx_fn & 0x80000000)
7572         warn (_("corrupt index table entry: %x\n"), exidx_fn);
7573
7574       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
7575
7576       arm_print_vma_and_name (aux, fn, fn_addr);
7577       fputs (": ", stdout);
7578
7579       if (exidx_entry == 1)
7580         {
7581           print_vma (exidx_entry, PREFIX_HEX);
7582           fputs (" [cantunwind]\n", stdout);
7583         }
7584       else if (exidx_entry & 0x80000000)
7585         {
7586           print_vma (exidx_entry, PREFIX_HEX);
7587           fputc ('\n', stdout);
7588           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7589         }
7590       else
7591         {
7592           bfd_vma table, table_offset = 0;
7593           Elf_Internal_Shdr *table_sec;
7594
7595           fputs ("@", stdout);
7596           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
7597           print_vma (table, PREFIX_HEX);
7598           printf ("\n");
7599
7600           /* Locate the matching .ARM.extab.  */
7601           if (entry_addr.section != SHN_UNDEF
7602               && entry_addr.section < elf_header.e_shnum)
7603             {
7604               table_sec = section_headers + entry_addr.section;
7605               table_offset = entry_addr.offset;
7606             }
7607           else
7608             {
7609               table_sec = find_section_by_address (table);
7610               if (table_sec != NULL)
7611                 table_offset = table - table_sec->sh_addr;
7612             }
7613           if (table_sec == NULL)
7614             {
7615               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7616                     (unsigned long) table);
7617               continue;
7618             }
7619           decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7620                              &extab_arm_sec);
7621         }
7622     }
7623
7624   printf ("\n");
7625
7626   arm_free_section (&exidx_arm_sec);
7627   arm_free_section (&extab_arm_sec);
7628 }
7629
7630 /* Used for both ARM and C6X unwinding tables.  */
7631
7632 static void
7633 arm_process_unwind (FILE *file)
7634 {
7635   struct arm_unw_aux_info aux;
7636   Elf_Internal_Shdr *unwsec = NULL;
7637   Elf_Internal_Shdr *strsec;
7638   Elf_Internal_Shdr *sec;
7639   unsigned long i;
7640   unsigned int sec_type;
7641
7642   switch (elf_header.e_machine)
7643     {
7644     case EM_ARM:
7645       sec_type = SHT_ARM_EXIDX;
7646       break;
7647
7648     case EM_TI_C6000:
7649       sec_type = SHT_C6000_UNWIND;
7650       break;
7651
7652     default:
7653       error (_("Unsupported architecture type %d encountered when processing unwind table"),
7654              elf_header.e_machine);
7655       return;
7656     }
7657
7658   if (string_table == NULL)
7659     return;
7660
7661   memset (& aux, 0, sizeof (aux));
7662   aux.file = file;
7663
7664   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7665     {
7666       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7667         {
7668           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7669
7670           strsec = section_headers + sec->sh_link;
7671           assert (aux.strtab == NULL);
7672           aux.strtab = get_data (NULL, file, strsec->sh_offset,
7673                                  1, strsec->sh_size, _("string table"));
7674           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7675         }
7676       else if (sec->sh_type == sec_type)
7677         unwsec = sec;
7678     }
7679
7680   if (unwsec == NULL)
7681     printf (_("\nThere are no unwind sections in this file.\n"));
7682   else
7683     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7684       {
7685         if (sec->sh_type == sec_type)
7686           {
7687             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7688                     SECTION_NAME (sec),
7689                     (unsigned long) sec->sh_offset,
7690                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7691
7692             dump_arm_unwind (&aux, sec);
7693           }
7694       }
7695
7696   if (aux.symtab)
7697     free (aux.symtab);
7698   if (aux.strtab)
7699     free ((char *) aux.strtab);
7700 }
7701
7702 static void
7703 process_unwind (FILE * file)
7704 {
7705   struct unwind_handler
7706   {
7707     int machtype;
7708     void (* handler)(FILE *);
7709   } handlers[] =
7710   {
7711     { EM_ARM, arm_process_unwind },
7712     { EM_IA_64, ia64_process_unwind },
7713     { EM_PARISC, hppa_process_unwind },
7714     { EM_TI_C6000, arm_process_unwind },
7715     { 0, 0 }
7716   };
7717   int i;
7718
7719   if (!do_unwind)
7720     return;
7721
7722   for (i = 0; handlers[i].handler != NULL; i++)
7723     if (elf_header.e_machine == handlers[i].machtype)
7724       {
7725         handlers[i].handler (file);
7726         return;
7727       }
7728
7729   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7730           get_machine_name (elf_header.e_machine));
7731 }
7732
7733 static void
7734 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
7735 {
7736   switch (entry->d_tag)
7737     {
7738     case DT_MIPS_FLAGS:
7739       if (entry->d_un.d_val == 0)
7740         printf (_("NONE"));
7741       else
7742         {
7743           static const char * opts[] =
7744           {
7745             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7746             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7747             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7748             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7749             "RLD_ORDER_SAFE"
7750           };
7751           unsigned int cnt;
7752           int first = 1;
7753
7754           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
7755             if (entry->d_un.d_val & (1 << cnt))
7756               {
7757                 printf ("%s%s", first ? "" : " ", opts[cnt]);
7758                 first = 0;
7759               }
7760         }
7761       break;
7762
7763     case DT_MIPS_IVERSION:
7764       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7765         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
7766       else
7767         printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
7768       break;
7769
7770     case DT_MIPS_TIME_STAMP:
7771       {
7772         char timebuf[20];
7773         struct tm * tmp;
7774
7775         time_t atime = entry->d_un.d_val;
7776         tmp = gmtime (&atime);
7777         snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7778                   tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7779                   tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7780         printf (_("Time Stamp: %s"), timebuf);
7781       }
7782       break;
7783
7784     case DT_MIPS_RLD_VERSION:
7785     case DT_MIPS_LOCAL_GOTNO:
7786     case DT_MIPS_CONFLICTNO:
7787     case DT_MIPS_LIBLISTNO:
7788     case DT_MIPS_SYMTABNO:
7789     case DT_MIPS_UNREFEXTNO:
7790     case DT_MIPS_HIPAGENO:
7791     case DT_MIPS_DELTA_CLASS_NO:
7792     case DT_MIPS_DELTA_INSTANCE_NO:
7793     case DT_MIPS_DELTA_RELOC_NO:
7794     case DT_MIPS_DELTA_SYM_NO:
7795     case DT_MIPS_DELTA_CLASSSYM_NO:
7796     case DT_MIPS_COMPACT_SIZE:
7797       print_vma (entry->d_un.d_ptr, DEC);
7798       break;
7799
7800     default:
7801       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7802     }
7803     putchar ('\n');
7804 }
7805
7806 static void
7807 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
7808 {
7809   switch (entry->d_tag)
7810     {
7811     case DT_HP_DLD_FLAGS:
7812       {
7813         static struct
7814         {
7815           long int bit;
7816           const char * str;
7817         }
7818         flags[] =
7819         {
7820           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7821           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7822           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7823           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7824           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7825           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7826           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7827           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7828           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7829           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
7830           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7831           { DT_HP_GST, "HP_GST" },
7832           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7833           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7834           { DT_HP_NODELETE, "HP_NODELETE" },
7835           { DT_HP_GROUP, "HP_GROUP" },
7836           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
7837         };
7838         int first = 1;
7839         size_t cnt;
7840         bfd_vma val = entry->d_un.d_val;
7841
7842         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
7843           if (val & flags[cnt].bit)
7844             {
7845               if (! first)
7846                 putchar (' ');
7847               fputs (flags[cnt].str, stdout);
7848               first = 0;
7849               val ^= flags[cnt].bit;
7850             }
7851
7852         if (val != 0 || first)
7853           {
7854             if (! first)
7855               putchar (' ');
7856             print_vma (val, HEX);
7857           }
7858       }
7859       break;
7860
7861     default:
7862       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7863       break;
7864     }
7865   putchar ('\n');
7866 }
7867
7868 #ifdef BFD64
7869
7870 /* VMS vs Unix time offset and factor.  */
7871
7872 #define VMS_EPOCH_OFFSET 35067168000000000LL
7873 #define VMS_GRANULARITY_FACTOR 10000000
7874
7875 /* Display a VMS time in a human readable format.  */
7876
7877 static void
7878 print_vms_time (bfd_int64_t vmstime)
7879 {
7880   struct tm *tm;
7881   time_t unxtime;
7882
7883   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7884   tm = gmtime (&unxtime);
7885   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7886           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7887           tm->tm_hour, tm->tm_min, tm->tm_sec);
7888 }
7889 #endif /* BFD64 */
7890
7891 static void
7892 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
7893 {
7894   switch (entry->d_tag)
7895     {
7896     case DT_IA_64_PLT_RESERVE:
7897       /* First 3 slots reserved.  */
7898       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7899       printf (" -- ");
7900       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
7901       break;
7902
7903     case DT_IA_64_VMS_LINKTIME:
7904 #ifdef BFD64
7905       print_vms_time (entry->d_un.d_val);
7906 #endif
7907       break;
7908
7909     case DT_IA_64_VMS_LNKFLAGS:
7910       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7911       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7912         printf (" CALL_DEBUG");
7913       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7914         printf (" NOP0BUFS");
7915       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7916         printf (" P0IMAGE");
7917       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7918         printf (" MKTHREADS");
7919       if (entry->d_un.d_val & VMS_LF_UPCALLS)
7920         printf (" UPCALLS");
7921       if (entry->d_un.d_val & VMS_LF_IMGSTA)
7922         printf (" IMGSTA");
7923       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7924         printf (" INITIALIZE");
7925       if (entry->d_un.d_val & VMS_LF_MAIN)
7926         printf (" MAIN");
7927       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7928         printf (" EXE_INIT");
7929       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7930         printf (" TBK_IN_IMG");
7931       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7932         printf (" DBG_IN_IMG");
7933       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7934         printf (" TBK_IN_DSF");
7935       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7936         printf (" DBG_IN_DSF");
7937       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7938         printf (" SIGNATURES");
7939       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7940         printf (" REL_SEG_OFF");
7941       break;
7942
7943     default:
7944       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7945       break;
7946     }
7947   putchar ('\n');
7948 }
7949
7950 static int
7951 get_32bit_dynamic_section (FILE * file)
7952 {
7953   Elf32_External_Dyn * edyn;
7954   Elf32_External_Dyn * ext;
7955   Elf_Internal_Dyn * entry;
7956
7957   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7958                                           dynamic_size, _("dynamic section"));
7959   if (!edyn)
7960     return 0;
7961
7962 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7963    might not have the luxury of section headers.  Look for the DT_NULL
7964    terminator to determine the number of entries.  */
7965   for (ext = edyn, dynamic_nent = 0;
7966        (char *) ext < (char *) edyn + dynamic_size;
7967        ext++)
7968     {
7969       dynamic_nent++;
7970       if (BYTE_GET (ext->d_tag) == DT_NULL)
7971         break;
7972     }
7973
7974   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7975                                                   sizeof (* entry));
7976   if (dynamic_section == NULL)
7977     {
7978       error (_("Out of memory\n"));
7979       free (edyn);
7980       return 0;
7981     }
7982
7983   for (ext = edyn, entry = dynamic_section;
7984        entry < dynamic_section + dynamic_nent;
7985        ext++, entry++)
7986     {
7987       entry->d_tag      = BYTE_GET (ext->d_tag);
7988       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7989     }
7990
7991   free (edyn);
7992
7993   return 1;
7994 }
7995
7996 static int
7997 get_64bit_dynamic_section (FILE * file)
7998 {
7999   Elf64_External_Dyn * edyn;
8000   Elf64_External_Dyn * ext;
8001   Elf_Internal_Dyn * entry;
8002
8003   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8004                                           dynamic_size, _("dynamic section"));
8005   if (!edyn)
8006     return 0;
8007
8008 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8009    might not have the luxury of section headers.  Look for the DT_NULL
8010    terminator to determine the number of entries.  */
8011   for (ext = edyn, dynamic_nent = 0;
8012        (char *) ext < (char *) edyn + dynamic_size;
8013        ext++)
8014     {
8015       dynamic_nent++;
8016       if (BYTE_GET (ext->d_tag) == DT_NULL)
8017         break;
8018     }
8019
8020   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8021                                                   sizeof (* entry));
8022   if (dynamic_section == NULL)
8023     {
8024       error (_("Out of memory\n"));
8025       free (edyn);
8026       return 0;
8027     }
8028
8029   for (ext = edyn, entry = dynamic_section;
8030        entry < dynamic_section + dynamic_nent;
8031        ext++, entry++)
8032     {
8033       entry->d_tag      = BYTE_GET (ext->d_tag);
8034       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8035     }
8036
8037   free (edyn);
8038
8039   return 1;
8040 }
8041
8042 static void
8043 print_dynamic_flags (bfd_vma flags)
8044 {
8045   int first = 1;
8046
8047   while (flags)
8048     {
8049       bfd_vma flag;
8050
8051       flag = flags & - flags;
8052       flags &= ~ flag;
8053
8054       if (first)
8055         first = 0;
8056       else
8057         putc (' ', stdout);
8058
8059       switch (flag)
8060         {
8061         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
8062         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
8063         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
8064         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
8065         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
8066         default:                fputs (_("unknown"), stdout); break;
8067         }
8068     }
8069   puts ("");
8070 }
8071
8072 /* Parse and display the contents of the dynamic section.  */
8073
8074 static int
8075 process_dynamic_section (FILE * file)
8076 {
8077   Elf_Internal_Dyn * entry;
8078
8079   if (dynamic_size == 0)
8080     {
8081       if (do_dynamic)
8082         printf (_("\nThere is no dynamic section in this file.\n"));
8083
8084       return 1;
8085     }
8086
8087   if (is_32bit_elf)
8088     {
8089       if (! get_32bit_dynamic_section (file))
8090         return 0;
8091     }
8092   else if (! get_64bit_dynamic_section (file))
8093     return 0;
8094
8095   /* Find the appropriate symbol table.  */
8096   if (dynamic_symbols == NULL)
8097     {
8098       for (entry = dynamic_section;
8099            entry < dynamic_section + dynamic_nent;
8100            ++entry)
8101         {
8102           Elf_Internal_Shdr section;
8103
8104           if (entry->d_tag != DT_SYMTAB)
8105             continue;
8106
8107           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8108
8109           /* Since we do not know how big the symbol table is,
8110              we default to reading in the entire file (!) and
8111              processing that.  This is overkill, I know, but it
8112              should work.  */
8113           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8114
8115           if (archive_file_offset != 0)
8116             section.sh_size = archive_file_size - section.sh_offset;
8117           else
8118             {
8119               if (fseek (file, 0, SEEK_END))
8120                 error (_("Unable to seek to end of file!\n"));
8121
8122               section.sh_size = ftell (file) - section.sh_offset;
8123             }
8124
8125           if (is_32bit_elf)
8126             section.sh_entsize = sizeof (Elf32_External_Sym);
8127           else
8128             section.sh_entsize = sizeof (Elf64_External_Sym);
8129
8130           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
8131           if (num_dynamic_syms < 1)
8132             {
8133               error (_("Unable to determine the number of symbols to load\n"));
8134               continue;
8135             }
8136         }
8137     }
8138
8139   /* Similarly find a string table.  */
8140   if (dynamic_strings == NULL)
8141     {
8142       for (entry = dynamic_section;
8143            entry < dynamic_section + dynamic_nent;
8144            ++entry)
8145         {
8146           unsigned long offset;
8147           long str_tab_len;
8148
8149           if (entry->d_tag != DT_STRTAB)
8150             continue;
8151
8152           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8153
8154           /* Since we do not know how big the string table is,
8155              we default to reading in the entire file (!) and
8156              processing that.  This is overkill, I know, but it
8157              should work.  */
8158
8159           offset = offset_from_vma (file, entry->d_un.d_val, 0);
8160
8161           if (archive_file_offset != 0)
8162             str_tab_len = archive_file_size - offset;
8163           else
8164             {
8165               if (fseek (file, 0, SEEK_END))
8166                 error (_("Unable to seek to end of file\n"));
8167               str_tab_len = ftell (file) - offset;
8168             }
8169
8170           if (str_tab_len < 1)
8171             {
8172               error
8173                 (_("Unable to determine the length of the dynamic string table\n"));
8174               continue;
8175             }
8176
8177           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8178                                                str_tab_len,
8179                                                _("dynamic string table"));
8180           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
8181           break;
8182         }
8183     }
8184
8185   /* And find the syminfo section if available.  */
8186   if (dynamic_syminfo == NULL)
8187     {
8188       unsigned long syminsz = 0;
8189
8190       for (entry = dynamic_section;
8191            entry < dynamic_section + dynamic_nent;
8192            ++entry)
8193         {
8194           if (entry->d_tag == DT_SYMINENT)
8195             {
8196               /* Note: these braces are necessary to avoid a syntax
8197                  error from the SunOS4 C compiler.  */
8198               assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
8199             }
8200           else if (entry->d_tag == DT_SYMINSZ)
8201             syminsz = entry->d_un.d_val;
8202           else if (entry->d_tag == DT_SYMINFO)
8203             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8204                                                       syminsz);
8205         }
8206
8207       if (dynamic_syminfo_offset != 0 && syminsz != 0)
8208         {
8209           Elf_External_Syminfo * extsyminfo;
8210           Elf_External_Syminfo * extsym;
8211           Elf_Internal_Syminfo * syminfo;
8212
8213           /* There is a syminfo section.  Read the data.  */
8214           extsyminfo = (Elf_External_Syminfo *)
8215               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8216                         _("symbol information"));
8217           if (!extsyminfo)
8218             return 0;
8219
8220           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
8221           if (dynamic_syminfo == NULL)
8222             {
8223               error (_("Out of memory\n"));
8224               return 0;
8225             }
8226
8227           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
8228           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8229                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8230                ++syminfo, ++extsym)
8231             {
8232               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8233               syminfo->si_flags = BYTE_GET (extsym->si_flags);
8234             }
8235
8236           free (extsyminfo);
8237         }
8238     }
8239
8240   if (do_dynamic && dynamic_addr)
8241     printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
8242             dynamic_addr, dynamic_nent);
8243   if (do_dynamic)
8244     printf (_("  Tag        Type                         Name/Value\n"));
8245
8246   for (entry = dynamic_section;
8247        entry < dynamic_section + dynamic_nent;
8248        entry++)
8249     {
8250       if (do_dynamic)
8251         {
8252           const char * dtype;
8253
8254           putchar (' ');
8255           print_vma (entry->d_tag, FULL_HEX);
8256           dtype = get_dynamic_type (entry->d_tag);
8257           printf (" (%s)%*s", dtype,
8258                   ((is_32bit_elf ? 27 : 19)
8259                    - (int) strlen (dtype)),
8260                   " ");
8261         }
8262
8263       switch (entry->d_tag)
8264         {
8265         case DT_FLAGS:
8266           if (do_dynamic)
8267             print_dynamic_flags (entry->d_un.d_val);
8268           break;
8269
8270         case DT_AUXILIARY:
8271         case DT_FILTER:
8272         case DT_CONFIG:
8273         case DT_DEPAUDIT:
8274         case DT_AUDIT:
8275           if (do_dynamic)
8276             {
8277               switch (entry->d_tag)
8278                 {
8279                 case DT_AUXILIARY:
8280                   printf (_("Auxiliary library"));
8281                   break;
8282
8283                 case DT_FILTER:
8284                   printf (_("Filter library"));
8285                   break;
8286
8287                 case DT_CONFIG:
8288                   printf (_("Configuration file"));
8289                   break;
8290
8291                 case DT_DEPAUDIT:
8292                   printf (_("Dependency audit library"));
8293                   break;
8294
8295                 case DT_AUDIT:
8296                   printf (_("Audit library"));
8297                   break;
8298                 }
8299
8300               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8301                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
8302               else
8303                 {
8304                   printf (": ");
8305                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8306                   putchar ('\n');
8307                 }
8308             }
8309           break;
8310
8311         case DT_FEATURE:
8312           if (do_dynamic)
8313             {
8314               printf (_("Flags:"));
8315
8316               if (entry->d_un.d_val == 0)
8317                 printf (_(" None\n"));
8318               else
8319                 {
8320                   unsigned long int val = entry->d_un.d_val;
8321
8322                   if (val & DTF_1_PARINIT)
8323                     {
8324                       printf (" PARINIT");
8325                       val ^= DTF_1_PARINIT;
8326                     }
8327                   if (val & DTF_1_CONFEXP)
8328                     {
8329                       printf (" CONFEXP");
8330                       val ^= DTF_1_CONFEXP;
8331                     }
8332                   if (val != 0)
8333                     printf (" %lx", val);
8334                   puts ("");
8335                 }
8336             }
8337           break;
8338
8339         case DT_POSFLAG_1:
8340           if (do_dynamic)
8341             {
8342               printf (_("Flags:"));
8343
8344               if (entry->d_un.d_val == 0)
8345                 printf (_(" None\n"));
8346               else
8347                 {
8348                   unsigned long int val = entry->d_un.d_val;
8349
8350                   if (val & DF_P1_LAZYLOAD)
8351                     {
8352                       printf (" LAZYLOAD");
8353                       val ^= DF_P1_LAZYLOAD;
8354                     }
8355                   if (val & DF_P1_GROUPPERM)
8356                     {
8357                       printf (" GROUPPERM");
8358                       val ^= DF_P1_GROUPPERM;
8359                     }
8360                   if (val != 0)
8361                     printf (" %lx", val);
8362                   puts ("");
8363                 }
8364             }
8365           break;
8366
8367         case DT_FLAGS_1:
8368           if (do_dynamic)
8369             {
8370               printf (_("Flags:"));
8371               if (entry->d_un.d_val == 0)
8372                 printf (_(" None\n"));
8373               else
8374                 {
8375                   unsigned long int val = entry->d_un.d_val;
8376
8377                   if (val & DF_1_NOW)
8378                     {
8379                       printf (" NOW");
8380                       val ^= DF_1_NOW;
8381                     }
8382                   if (val & DF_1_GLOBAL)
8383                     {
8384                       printf (" GLOBAL");
8385                       val ^= DF_1_GLOBAL;
8386                     }
8387                   if (val & DF_1_GROUP)
8388                     {
8389                       printf (" GROUP");
8390                       val ^= DF_1_GROUP;
8391                     }
8392                   if (val & DF_1_NODELETE)
8393                     {
8394                       printf (" NODELETE");
8395                       val ^= DF_1_NODELETE;
8396                     }
8397                   if (val & DF_1_LOADFLTR)
8398                     {
8399                       printf (" LOADFLTR");
8400                       val ^= DF_1_LOADFLTR;
8401                     }
8402                   if (val & DF_1_INITFIRST)
8403                     {
8404                       printf (" INITFIRST");
8405                       val ^= DF_1_INITFIRST;
8406                     }
8407                   if (val & DF_1_NOOPEN)
8408                     {
8409                       printf (" NOOPEN");
8410                       val ^= DF_1_NOOPEN;
8411                     }
8412                   if (val & DF_1_ORIGIN)
8413                     {
8414                       printf (" ORIGIN");
8415                       val ^= DF_1_ORIGIN;
8416                     }
8417                   if (val & DF_1_DIRECT)
8418                     {
8419                       printf (" DIRECT");
8420                       val ^= DF_1_DIRECT;
8421                     }
8422                   if (val & DF_1_TRANS)
8423                     {
8424                       printf (" TRANS");
8425                       val ^= DF_1_TRANS;
8426                     }
8427                   if (val & DF_1_INTERPOSE)
8428                     {
8429                       printf (" INTERPOSE");
8430                       val ^= DF_1_INTERPOSE;
8431                     }
8432                   if (val & DF_1_NODEFLIB)
8433                     {
8434                       printf (" NODEFLIB");
8435                       val ^= DF_1_NODEFLIB;
8436                     }
8437                   if (val & DF_1_NODUMP)
8438                     {
8439                       printf (" NODUMP");
8440                       val ^= DF_1_NODUMP;
8441                     }
8442                   if (val & DF_1_CONFALT)
8443                     {
8444                       printf (" CONFALT");
8445                       val ^= DF_1_CONFALT;
8446                     }
8447                   if (val & DF_1_ENDFILTEE)
8448                     {
8449                       printf (" ENDFILTEE");
8450                       val ^= DF_1_ENDFILTEE;
8451                     }
8452                   if (val & DF_1_DISPRELDNE)
8453                     {
8454                       printf (" DISPRELDNE");
8455                       val ^= DF_1_DISPRELDNE;
8456                     }
8457                   if (val & DF_1_DISPRELPND)
8458                     {
8459                       printf (" DISPRELPND");
8460                       val ^= DF_1_DISPRELPND;
8461                     }
8462                   if (val & DF_1_NODIRECT)
8463                     {
8464                       printf (" NODIRECT");
8465                       val ^= DF_1_NODIRECT;
8466                     }
8467                   if (val & DF_1_IGNMULDEF)
8468                     {
8469                       printf (" IGNMULDEF");
8470                       val ^= DF_1_IGNMULDEF;
8471                     }
8472                   if (val & DF_1_NOKSYMS)
8473                     {
8474                       printf (" NOKSYMS");
8475                       val ^= DF_1_NOKSYMS;
8476                     }
8477                   if (val & DF_1_NOHDR)
8478                     {
8479                       printf (" NOHDR");
8480                       val ^= DF_1_NOHDR;
8481                     }
8482                   if (val & DF_1_EDITED)
8483                     {
8484                       printf (" EDITED");
8485                       val ^= DF_1_EDITED;
8486                     }
8487                   if (val & DF_1_NORELOC)
8488                     {
8489                       printf (" NORELOC");
8490                       val ^= DF_1_NORELOC;
8491                     }
8492                   if (val & DF_1_SYMINTPOSE)
8493                     {
8494                       printf (" SYMINTPOSE");
8495                       val ^= DF_1_SYMINTPOSE;
8496                     }
8497                   if (val & DF_1_GLOBAUDIT)
8498                     {
8499                       printf (" GLOBAUDIT");
8500                       val ^= DF_1_GLOBAUDIT;
8501                     }
8502                   if (val & DF_1_SINGLETON)
8503                     {
8504                       printf (" SINGLETON");
8505                       val ^= DF_1_SINGLETON;
8506                     }
8507                   if (val != 0)
8508                     printf (" %lx", val);
8509                   puts ("");
8510                 }
8511             }
8512           break;
8513
8514         case DT_PLTREL:
8515           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8516           if (do_dynamic)
8517             puts (get_dynamic_type (entry->d_un.d_val));
8518           break;
8519
8520         case DT_NULL    :
8521         case DT_NEEDED  :
8522         case DT_PLTGOT  :
8523         case DT_HASH    :
8524         case DT_STRTAB  :
8525         case DT_SYMTAB  :
8526         case DT_RELA    :
8527         case DT_INIT    :
8528         case DT_FINI    :
8529         case DT_SONAME  :
8530         case DT_RPATH   :
8531         case DT_SYMBOLIC:
8532         case DT_REL     :
8533         case DT_DEBUG   :
8534         case DT_TEXTREL :
8535         case DT_JMPREL  :
8536         case DT_RUNPATH :
8537           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8538
8539           if (do_dynamic)
8540             {
8541               char * name;
8542
8543               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8544                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8545               else
8546                 name = NULL;
8547
8548               if (name)
8549                 {
8550                   switch (entry->d_tag)
8551                     {
8552                     case DT_NEEDED:
8553                       printf (_("Shared library: [%s]"), name);
8554
8555                       if (streq (name, program_interpreter))
8556                         printf (_(" program interpreter"));
8557                       break;
8558
8559                     case DT_SONAME:
8560                       printf (_("Library soname: [%s]"), name);
8561                       break;
8562
8563                     case DT_RPATH:
8564                       printf (_("Library rpath: [%s]"), name);
8565                       break;
8566
8567                     case DT_RUNPATH:
8568                       printf (_("Library runpath: [%s]"), name);
8569                       break;
8570
8571                     default:
8572                       print_vma (entry->d_un.d_val, PREFIX_HEX);
8573                       break;
8574                     }
8575                 }
8576               else
8577                 print_vma (entry->d_un.d_val, PREFIX_HEX);
8578
8579               putchar ('\n');
8580             }
8581           break;
8582
8583         case DT_PLTRELSZ:
8584         case DT_RELASZ  :
8585         case DT_STRSZ   :
8586         case DT_RELSZ   :
8587         case DT_RELAENT :
8588         case DT_SYMENT  :
8589         case DT_RELENT  :
8590           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8591         case DT_PLTPADSZ:
8592         case DT_MOVEENT :
8593         case DT_MOVESZ  :
8594         case DT_INIT_ARRAYSZ:
8595         case DT_FINI_ARRAYSZ:
8596         case DT_GNU_CONFLICTSZ:
8597         case DT_GNU_LIBLISTSZ:
8598           if (do_dynamic)
8599             {
8600               print_vma (entry->d_un.d_val, UNSIGNED);
8601               printf (_(" (bytes)\n"));
8602             }
8603           break;
8604
8605         case DT_VERDEFNUM:
8606         case DT_VERNEEDNUM:
8607         case DT_RELACOUNT:
8608         case DT_RELCOUNT:
8609           if (do_dynamic)
8610             {
8611               print_vma (entry->d_un.d_val, UNSIGNED);
8612               putchar ('\n');
8613             }
8614           break;
8615
8616         case DT_SYMINSZ:
8617         case DT_SYMINENT:
8618         case DT_SYMINFO:
8619         case DT_USED:
8620         case DT_INIT_ARRAY:
8621         case DT_FINI_ARRAY:
8622           if (do_dynamic)
8623             {
8624               if (entry->d_tag == DT_USED
8625                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
8626                 {
8627                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8628
8629                   if (*name)
8630                     {
8631                       printf (_("Not needed object: [%s]\n"), name);
8632                       break;
8633                     }
8634                 }
8635
8636               print_vma (entry->d_un.d_val, PREFIX_HEX);
8637               putchar ('\n');
8638             }
8639           break;
8640
8641         case DT_BIND_NOW:
8642           /* The value of this entry is ignored.  */
8643           if (do_dynamic)
8644             putchar ('\n');
8645           break;
8646
8647         case DT_GNU_PRELINKED:
8648           if (do_dynamic)
8649             {
8650               struct tm * tmp;
8651               time_t atime = entry->d_un.d_val;
8652
8653               tmp = gmtime (&atime);
8654               printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8655                       tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8656                       tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8657
8658             }
8659           break;
8660
8661         case DT_GNU_HASH:
8662           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8663           if (do_dynamic)
8664             {
8665               print_vma (entry->d_un.d_val, PREFIX_HEX);
8666               putchar ('\n');
8667             }
8668           break;
8669
8670         default:
8671           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
8672             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
8673               entry->d_un.d_val;
8674
8675           if (do_dynamic)
8676             {
8677               switch (elf_header.e_machine)
8678                 {
8679                 case EM_MIPS:
8680                 case EM_MIPS_RS3_LE:
8681                   dynamic_section_mips_val (entry);
8682                   break;
8683                 case EM_PARISC:
8684                   dynamic_section_parisc_val (entry);
8685                   break;
8686                 case EM_IA_64:
8687                   dynamic_section_ia64_val (entry);
8688                   break;
8689                 default:
8690                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8691                   putchar ('\n');
8692                 }
8693             }
8694           break;
8695         }
8696     }
8697
8698   return 1;
8699 }
8700
8701 static char *
8702 get_ver_flags (unsigned int flags)
8703 {
8704   static char buff[32];
8705
8706   buff[0] = 0;
8707
8708   if (flags == 0)
8709     return _("none");
8710
8711   if (flags & VER_FLG_BASE)
8712     strcat (buff, "BASE ");
8713
8714   if (flags & VER_FLG_WEAK)
8715     {
8716       if (flags & VER_FLG_BASE)
8717         strcat (buff, "| ");
8718
8719       strcat (buff, "WEAK ");
8720     }
8721
8722   if (flags & VER_FLG_INFO)
8723     {
8724       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8725         strcat (buff, "| ");
8726
8727       strcat (buff, "INFO ");
8728     }
8729
8730   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
8731     strcat (buff, _("| <unknown>"));
8732
8733   return buff;
8734 }
8735
8736 /* Display the contents of the version sections.  */
8737
8738 static int
8739 process_version_sections (FILE * file)
8740 {
8741   Elf_Internal_Shdr * section;
8742   unsigned i;
8743   int found = 0;
8744
8745   if (! do_version)
8746     return 1;
8747
8748   for (i = 0, section = section_headers;
8749        i < elf_header.e_shnum;
8750        i++, section++)
8751     {
8752       switch (section->sh_type)
8753         {
8754         case SHT_GNU_verdef:
8755           {
8756             Elf_External_Verdef * edefs;
8757             unsigned int idx;
8758             unsigned int cnt;
8759             char * endbuf;
8760
8761             found = 1;
8762
8763             printf
8764               (_("\nVersion definition section '%s' contains %u entries:\n"),
8765                SECTION_NAME (section), section->sh_info);
8766
8767             printf (_("  Addr: 0x"));
8768             printf_vma (section->sh_addr);
8769             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8770                     (unsigned long) section->sh_offset, section->sh_link,
8771                     section->sh_link < elf_header.e_shnum
8772                     ? SECTION_NAME (section_headers + section->sh_link)
8773                     : _("<corrupt>"));
8774
8775             edefs = (Elf_External_Verdef *)
8776                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8777                           _("version definition section"));
8778             if (!edefs)
8779               break;
8780             endbuf = (char *) edefs + section->sh_size;
8781
8782             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8783               {
8784                 char * vstart;
8785                 Elf_External_Verdef * edef;
8786                 Elf_Internal_Verdef ent;
8787                 Elf_External_Verdaux * eaux;
8788                 Elf_Internal_Verdaux aux;
8789                 int j;
8790                 int isum;
8791
8792                 /* Check for very large indicies.  */
8793                 if (idx > (size_t) (endbuf - (char *) edefs))
8794                   break;
8795
8796                 vstart = ((char *) edefs) + idx;
8797                 if (vstart + sizeof (*edef) > endbuf)
8798                   break;
8799
8800                 edef = (Elf_External_Verdef *) vstart;
8801
8802                 ent.vd_version = BYTE_GET (edef->vd_version);
8803                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
8804                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
8805                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
8806                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
8807                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
8808                 ent.vd_next    = BYTE_GET (edef->vd_next);
8809
8810                 printf (_("  %#06x: Rev: %d  Flags: %s"),
8811                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8812
8813                 printf (_("  Index: %d  Cnt: %d  "),
8814                         ent.vd_ndx, ent.vd_cnt);
8815
8816                 /* Check for overflow.  */
8817                 if (ent.vd_aux > (size_t) (endbuf - vstart))
8818                   break;
8819
8820                 vstart += ent.vd_aux;
8821
8822                 eaux = (Elf_External_Verdaux *) vstart;
8823
8824                 aux.vda_name = BYTE_GET (eaux->vda_name);
8825                 aux.vda_next = BYTE_GET (eaux->vda_next);
8826
8827                 if (VALID_DYNAMIC_NAME (aux.vda_name))
8828                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
8829                 else
8830                   printf (_("Name index: %ld\n"), aux.vda_name);
8831
8832                 isum = idx + ent.vd_aux;
8833
8834                 for (j = 1; j < ent.vd_cnt; j++)
8835                   {
8836                     /* Check for overflow.  */
8837                     if (aux.vda_next > (size_t) (endbuf - vstart))
8838                       break;
8839
8840                     isum   += aux.vda_next;
8841                     vstart += aux.vda_next;
8842
8843                     eaux = (Elf_External_Verdaux *) vstart;
8844                     if (vstart + sizeof (*eaux) > endbuf)
8845                       break;
8846
8847                     aux.vda_name = BYTE_GET (eaux->vda_name);
8848                     aux.vda_next = BYTE_GET (eaux->vda_next);
8849
8850                     if (VALID_DYNAMIC_NAME (aux.vda_name))
8851                       printf (_("  %#06x: Parent %d: %s\n"),
8852                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
8853                     else
8854                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
8855                               isum, j, aux.vda_name);
8856                   }
8857
8858                 if (j < ent.vd_cnt)
8859                   printf (_("  Version def aux past end of section\n"));
8860
8861                 idx += ent.vd_next;
8862               }
8863
8864             if (cnt < section->sh_info)
8865               printf (_("  Version definition past end of section\n"));
8866
8867             free (edefs);
8868           }
8869           break;
8870
8871         case SHT_GNU_verneed:
8872           {
8873             Elf_External_Verneed * eneed;
8874             unsigned int idx;
8875             unsigned int cnt;
8876             char * endbuf;
8877
8878             found = 1;
8879
8880             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8881                     SECTION_NAME (section), section->sh_info);
8882
8883             printf (_(" Addr: 0x"));
8884             printf_vma (section->sh_addr);
8885             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8886                     (unsigned long) section->sh_offset, section->sh_link,
8887                     section->sh_link < elf_header.e_shnum
8888                     ? SECTION_NAME (section_headers + section->sh_link)
8889                     : _("<corrupt>"));
8890
8891             eneed = (Elf_External_Verneed *) get_data (NULL, file,
8892                                                        section->sh_offset, 1,
8893                                                        section->sh_size,
8894                                                        _("Version Needs section"));
8895             if (!eneed)
8896               break;
8897             endbuf = (char *) eneed + section->sh_size;
8898
8899             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8900               {
8901                 Elf_External_Verneed * entry;
8902                 Elf_Internal_Verneed ent;
8903                 int j;
8904                 int isum;
8905                 char * vstart;
8906
8907                 if (idx > (size_t) (endbuf - (char *) eneed))
8908                   break;
8909
8910                 vstart = ((char *) eneed) + idx;
8911                 if (vstart + sizeof (*entry) > endbuf)
8912                   break;
8913
8914                 entry = (Elf_External_Verneed *) vstart;
8915
8916                 ent.vn_version = BYTE_GET (entry->vn_version);
8917                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
8918                 ent.vn_file    = BYTE_GET (entry->vn_file);
8919                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
8920                 ent.vn_next    = BYTE_GET (entry->vn_next);
8921
8922                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
8923
8924                 if (VALID_DYNAMIC_NAME (ent.vn_file))
8925                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
8926                 else
8927                   printf (_("  File: %lx"), ent.vn_file);
8928
8929                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
8930
8931                 /* Check for overflow.  */
8932                 if (ent.vn_aux > (size_t) (endbuf - vstart))
8933                   break;
8934
8935                 vstart += ent.vn_aux;
8936
8937                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8938                   {
8939                     Elf_External_Vernaux * eaux;
8940                     Elf_Internal_Vernaux aux;
8941
8942                     if (vstart + sizeof (*eaux) > endbuf)
8943                       break;
8944                     eaux = (Elf_External_Vernaux *) vstart;
8945
8946                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
8947                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
8948                     aux.vna_other = BYTE_GET (eaux->vna_other);
8949                     aux.vna_name  = BYTE_GET (eaux->vna_name);
8950                     aux.vna_next  = BYTE_GET (eaux->vna_next);
8951
8952                     if (VALID_DYNAMIC_NAME (aux.vna_name))
8953                       printf (_("  %#06x:   Name: %s"),
8954                               isum, GET_DYNAMIC_NAME (aux.vna_name));
8955                     else
8956                       printf (_("  %#06x:   Name index: %lx"),
8957                               isum, aux.vna_name);
8958
8959                     printf (_("  Flags: %s  Version: %d\n"),
8960                             get_ver_flags (aux.vna_flags), aux.vna_other);
8961
8962                     /* Check for overflow.  */
8963                     if (aux.vna_next > (size_t) (endbuf - vstart))
8964                       break;
8965
8966                     isum   += aux.vna_next;
8967                     vstart += aux.vna_next;
8968                   }
8969
8970                 if (j < ent.vn_cnt)
8971                   warn (_("Missing Version Needs auxillary information\n"));
8972
8973                 idx += ent.vn_next;
8974               }
8975
8976             if (cnt < section->sh_info)
8977               warn (_("Missing Version Needs information\n"));
8978
8979             free (eneed);
8980           }
8981           break;
8982
8983         case SHT_GNU_versym:
8984           {
8985             Elf_Internal_Shdr * link_section;
8986             int total;
8987             int cnt;
8988             unsigned char * edata;
8989             unsigned short * data;
8990             char * strtab;
8991             Elf_Internal_Sym * symbols;
8992             Elf_Internal_Shdr * string_sec;
8993             unsigned long num_syms;
8994             long off;
8995
8996             if (section->sh_link >= elf_header.e_shnum)
8997               break;
8998
8999             link_section = section_headers + section->sh_link;
9000             total = section->sh_size / sizeof (Elf_External_Versym);
9001
9002             if (link_section->sh_link >= elf_header.e_shnum)
9003               break;
9004
9005             found = 1;
9006
9007             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9008             if (symbols == NULL)
9009               break;
9010
9011             string_sec = section_headers + link_section->sh_link;
9012
9013             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9014                                         string_sec->sh_size,
9015                                         _("version string table"));
9016             if (!strtab)
9017               {
9018                 free (symbols);
9019                 break;
9020               }
9021
9022             printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
9023                     SECTION_NAME (section), total);
9024
9025             printf (_(" Addr: "));
9026             printf_vma (section->sh_addr);
9027             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
9028                     (unsigned long) section->sh_offset, section->sh_link,
9029                     SECTION_NAME (link_section));
9030
9031             off = offset_from_vma (file,
9032                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9033                                    total * sizeof (short));
9034             edata = (unsigned char *) get_data (NULL, file, off, total,
9035                                                 sizeof (short),
9036                                                 _("version symbol data"));
9037             if (!edata)
9038               {
9039                 free (strtab);
9040                 free (symbols);
9041                 break;
9042               }
9043
9044             data = (short unsigned int *) cmalloc (total, sizeof (short));
9045
9046             for (cnt = total; cnt --;)
9047               data[cnt] = byte_get (edata + cnt * sizeof (short),
9048                                     sizeof (short));
9049
9050             free (edata);
9051
9052             for (cnt = 0; cnt < total; cnt += 4)
9053               {
9054                 int j, nn;
9055                 int check_def, check_need;
9056                 char * name;
9057
9058                 printf ("  %03x:", cnt);
9059
9060                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
9061                   switch (data[cnt + j])
9062                     {
9063                     case 0:
9064                       fputs (_("   0 (*local*)    "), stdout);
9065                       break;
9066
9067                     case 1:
9068                       fputs (_("   1 (*global*)   "), stdout);
9069                       break;
9070
9071                     default:
9072                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9073                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
9074
9075                       /* If this index value is greater than the size of the symbols
9076                          array, break to avoid an out-of-bounds read.  */
9077                       if ((unsigned long)(cnt + j) >= num_syms)
9078                         {
9079                           warn (_("invalid index into symbol array\n"));
9080                           break;
9081                         }
9082
9083                       check_def = 1;
9084                       check_need = 1;
9085                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9086                           || section_headers[symbols[cnt + j].st_shndx].sh_type
9087                              != SHT_NOBITS)
9088                         {
9089                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
9090                             check_def = 0;
9091                           else
9092                             check_need = 0;
9093                         }
9094
9095                       if (check_need
9096                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
9097                         {
9098                           Elf_Internal_Verneed ivn;
9099                           unsigned long offset;
9100
9101                           offset = offset_from_vma
9102                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9103                              sizeof (Elf_External_Verneed));
9104
9105                           do
9106                             {
9107                               Elf_Internal_Vernaux ivna;
9108                               Elf_External_Verneed evn;
9109                               Elf_External_Vernaux evna;
9110                               unsigned long a_off;
9111
9112                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9113                                             _("version need")) == NULL)
9114                                 break;
9115
9116                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9117                               ivn.vn_next = BYTE_GET (evn.vn_next);
9118
9119                               a_off = offset + ivn.vn_aux;
9120
9121                               do
9122                                 {
9123                                   if (get_data (&evna, file, a_off, sizeof (evna),
9124                                                 1, _("version need aux (2)")) == NULL)
9125                                     {
9126                                       ivna.vna_next  = 0;
9127                                       ivna.vna_other = 0;
9128                                     }
9129                                   else
9130                                     {
9131                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
9132                                       ivna.vna_other = BYTE_GET (evna.vna_other);
9133                                     }
9134
9135                                   a_off += ivna.vna_next;
9136                                 }
9137                               while (ivna.vna_other != data[cnt + j]
9138                                      && ivna.vna_next != 0);
9139
9140                               if (ivna.vna_other == data[cnt + j])
9141                                 {
9142                                   ivna.vna_name = BYTE_GET (evna.vna_name);
9143
9144                                   if (ivna.vna_name >= string_sec->sh_size)
9145                                     name = _("*invalid*");
9146                                   else
9147                                     name = strtab + ivna.vna_name;
9148                                   nn += printf ("(%s%-*s",
9149                                                 name,
9150                                                 12 - (int) strlen (name),
9151                                                 ")");
9152                                   check_def = 0;
9153                                   break;
9154                                 }
9155
9156                               offset += ivn.vn_next;
9157                             }
9158                           while (ivn.vn_next);
9159                         }
9160
9161                       if (check_def && data[cnt + j] != 0x8001
9162                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9163                         {
9164                           Elf_Internal_Verdef ivd;
9165                           Elf_External_Verdef evd;
9166                           unsigned long offset;
9167
9168                           offset = offset_from_vma
9169                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9170                              sizeof evd);
9171
9172                           do
9173                             {
9174                               if (get_data (&evd, file, offset, sizeof (evd), 1,
9175                                             _("version def")) == NULL)
9176                                 {
9177                                   ivd.vd_next = 0;
9178                                   ivd.vd_ndx  = 0;
9179                                 }
9180                               else
9181                                 {
9182                                   ivd.vd_next = BYTE_GET (evd.vd_next);
9183                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
9184                                 }
9185
9186                               offset += ivd.vd_next;
9187                             }
9188                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
9189                                  && ivd.vd_next != 0);
9190
9191                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
9192                             {
9193                               Elf_External_Verdaux evda;
9194                               Elf_Internal_Verdaux ivda;
9195
9196                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
9197
9198                               if (get_data (&evda, file,
9199                                             offset - ivd.vd_next + ivd.vd_aux,
9200                                             sizeof (evda), 1,
9201                                             _("version def aux")) == NULL)
9202                                 break;
9203
9204                               ivda.vda_name = BYTE_GET (evda.vda_name);
9205
9206                               if (ivda.vda_name >= string_sec->sh_size)
9207                                 name = _("*invalid*");
9208                               else
9209                                 name = strtab + ivda.vda_name;
9210                               nn += printf ("(%s%-*s",
9211                                             name,
9212                                             12 - (int) strlen (name),
9213                                             ")");
9214                             }
9215                         }
9216
9217                       if (nn < 18)
9218                         printf ("%*c", 18 - nn, ' ');
9219                     }
9220
9221                 putchar ('\n');
9222               }
9223
9224             free (data);
9225             free (strtab);
9226             free (symbols);
9227           }
9228           break;
9229
9230         default:
9231           break;
9232         }
9233     }
9234
9235   if (! found)
9236     printf (_("\nNo version information found in this file.\n"));
9237
9238   return 1;
9239 }
9240
9241 static const char *
9242 get_symbol_binding (unsigned int binding)
9243 {
9244   static char buff[32];
9245
9246   switch (binding)
9247     {
9248     case STB_LOCAL:     return "LOCAL";
9249     case STB_GLOBAL:    return "GLOBAL";
9250     case STB_WEAK:      return "WEAK";
9251     default:
9252       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
9253         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9254                   binding);
9255       else if (binding >= STB_LOOS && binding <= STB_HIOS)
9256         {
9257           if (binding == STB_GNU_UNIQUE
9258               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9259                   /* GNU is still using the default value 0.  */
9260                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9261             return "UNIQUE";
9262           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9263         }
9264       else
9265         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
9266       return buff;
9267     }
9268 }
9269
9270 static const char *
9271 get_symbol_type (unsigned int type)
9272 {
9273   static char buff[32];
9274
9275   switch (type)
9276     {
9277     case STT_NOTYPE:    return "NOTYPE";
9278     case STT_OBJECT:    return "OBJECT";
9279     case STT_FUNC:      return "FUNC";
9280     case STT_SECTION:   return "SECTION";
9281     case STT_FILE:      return "FILE";
9282     case STT_COMMON:    return "COMMON";
9283     case STT_TLS:       return "TLS";
9284     case STT_RELC:      return "RELC";
9285     case STT_SRELC:     return "SRELC";
9286     default:
9287       if (type >= STT_LOPROC && type <= STT_HIPROC)
9288         {
9289           if (elf_header.e_machine == EM_ARM)
9290             {
9291               if (type == STT_ARM_TFUNC)
9292                 return "THUMB_FUNC";
9293               if (type == STT_ARM_16BIT)
9294                 return "THUMB_LABEL";
9295             }
9296
9297           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
9298             return "REGISTER";
9299
9300           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9301             return "PARISC_MILLI";
9302
9303           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
9304         }
9305       else if (type >= STT_LOOS && type <= STT_HIOS)
9306         {
9307           if (elf_header.e_machine == EM_PARISC)
9308             {
9309               if (type == STT_HP_OPAQUE)
9310                 return "HP_OPAQUE";
9311               if (type == STT_HP_STUB)
9312                 return "HP_STUB";
9313             }
9314
9315           if (type == STT_GNU_IFUNC
9316               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9317                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9318                   /* GNU is still using the default value 0.  */
9319                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9320             return "IFUNC";
9321
9322           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
9323         }
9324       else
9325         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
9326       return buff;
9327     }
9328 }
9329
9330 static const char *
9331 get_symbol_visibility (unsigned int visibility)
9332 {
9333   switch (visibility)
9334     {
9335     case STV_DEFAULT:   return "DEFAULT";
9336     case STV_INTERNAL:  return "INTERNAL";
9337     case STV_HIDDEN:    return "HIDDEN";
9338     case STV_PROTECTED: return "PROTECTED";
9339     default: abort ();
9340     }
9341 }
9342
9343 static const char *
9344 get_mips_symbol_other (unsigned int other)
9345 {
9346   switch (other)
9347     {
9348     case STO_OPTIONAL:
9349       return "OPTIONAL";
9350     case STO_MIPS_PLT:
9351       return "MIPS PLT";
9352     case STO_MIPS_PIC:
9353       return "MIPS PIC";
9354     case STO_MICROMIPS:
9355       return "MICROMIPS";
9356     case STO_MICROMIPS | STO_MIPS_PIC:
9357       return "MICROMIPS, MIPS PIC";
9358     case STO_MIPS16:
9359       return "MIPS16";
9360     default:
9361       return NULL;
9362     }
9363 }
9364
9365 static const char *
9366 get_ia64_symbol_other (unsigned int other)
9367 {
9368   if (is_ia64_vms ())
9369     {
9370       static char res[32];
9371
9372       res[0] = 0;
9373
9374       /* Function types is for images and .STB files only.  */
9375       switch (elf_header.e_type)
9376         {
9377         case ET_DYN:
9378         case ET_EXEC:
9379           switch (VMS_ST_FUNC_TYPE (other))
9380             {
9381             case VMS_SFT_CODE_ADDR:
9382               strcat (res, " CA");
9383               break;
9384             case VMS_SFT_SYMV_IDX:
9385               strcat (res, " VEC");
9386               break;
9387             case VMS_SFT_FD:
9388               strcat (res, " FD");
9389               break;
9390             case VMS_SFT_RESERVE:
9391               strcat (res, " RSV");
9392               break;
9393             default:
9394               abort ();
9395             }
9396           break;
9397         default:
9398           break;
9399         }
9400       switch (VMS_ST_LINKAGE (other))
9401         {
9402         case VMS_STL_IGNORE:
9403           strcat (res, " IGN");
9404           break;
9405         case VMS_STL_RESERVE:
9406           strcat (res, " RSV");
9407           break;
9408         case VMS_STL_STD:
9409           strcat (res, " STD");
9410           break;
9411         case VMS_STL_LNK:
9412           strcat (res, " LNK");
9413           break;
9414         default:
9415           abort ();
9416         }
9417
9418       if (res[0] != 0)
9419         return res + 1;
9420       else
9421         return res;
9422     }
9423   return NULL;
9424 }
9425
9426 static const char *
9427 get_ppc64_symbol_other (unsigned int other)
9428 {
9429   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
9430     {
9431       static char buf[32];
9432       snprintf (buf, sizeof buf, _("<localentry>: %d"),
9433                 PPC64_LOCAL_ENTRY_OFFSET (other));
9434       return buf;
9435     }
9436   return NULL;
9437 }
9438
9439 static const char *
9440 get_symbol_other (unsigned int other)
9441 {
9442   const char * result = NULL;
9443   static char buff [32];
9444
9445   if (other == 0)
9446     return "";
9447
9448   switch (elf_header.e_machine)
9449     {
9450     case EM_MIPS:
9451       result = get_mips_symbol_other (other);
9452       break;
9453     case EM_IA_64:
9454       result = get_ia64_symbol_other (other);
9455       break;
9456     case EM_PPC64:
9457       result = get_ppc64_symbol_other (other);
9458       break;
9459     default:
9460       break;
9461     }
9462
9463   if (result)
9464     return result;
9465
9466   snprintf (buff, sizeof buff, _("<other>: %x"), other);
9467   return buff;
9468 }
9469
9470 static const char *
9471 get_symbol_index_type (unsigned int type)
9472 {
9473   static char buff[32];
9474
9475   switch (type)
9476     {
9477     case SHN_UNDEF:     return "UND";
9478     case SHN_ABS:       return "ABS";
9479     case SHN_COMMON:    return "COM";
9480     default:
9481       if (type == SHN_IA_64_ANSI_COMMON
9482           && elf_header.e_machine == EM_IA_64
9483           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9484         return "ANSI_COM";
9485       else if ((elf_header.e_machine == EM_X86_64
9486                 || elf_header.e_machine == EM_L1OM
9487                 || elf_header.e_machine == EM_K1OM)
9488                && type == SHN_X86_64_LCOMMON)
9489         return "LARGE_COM";
9490       else if ((type == SHN_MIPS_SCOMMON
9491                 && elf_header.e_machine == EM_MIPS)
9492                || (type == SHN_TIC6X_SCOMMON
9493                    && elf_header.e_machine == EM_TI_C6000))
9494         return "SCOM";
9495       else if (type == SHN_MIPS_SUNDEFINED
9496                && elf_header.e_machine == EM_MIPS)
9497         return "SUND";
9498       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
9499         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
9500       else if (type >= SHN_LOOS && type <= SHN_HIOS)
9501         sprintf (buff, "OS [0x%04x]", type & 0xffff);
9502       else if (type >= SHN_LORESERVE)
9503         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
9504       else if (type >= elf_header.e_shnum)
9505         sprintf (buff, "bad section index[%3d]", type);
9506       else
9507         sprintf (buff, "%3d", type);
9508       break;
9509     }
9510
9511   return buff;
9512 }
9513
9514 static bfd_vma *
9515 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
9516 {
9517   unsigned char * e_data;
9518   bfd_vma * i_data;
9519
9520   e_data = (unsigned char *) cmalloc (number, ent_size);
9521
9522   if (e_data == NULL)
9523     {
9524       error (_("Out of memory\n"));
9525       return NULL;
9526     }
9527
9528   if (fread (e_data, ent_size, number, file) != number)
9529     {
9530       error (_("Unable to read in dynamic data\n"));
9531       return NULL;
9532     }
9533
9534   i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
9535
9536   if (i_data == NULL)
9537     {
9538       error (_("Out of memory\n"));
9539       free (e_data);
9540       return NULL;
9541     }
9542
9543   while (number--)
9544     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
9545
9546   free (e_data);
9547
9548   return i_data;
9549 }
9550
9551 static void
9552 print_dynamic_symbol (bfd_vma si, unsigned long hn)
9553 {
9554   Elf_Internal_Sym * psym;
9555   int n;
9556
9557   psym = dynamic_symbols + si;
9558
9559   n = print_vma (si, DEC_5);
9560   if (n < 5)
9561     fputs (&"     "[n], stdout);
9562   printf (" %3lu: ", hn);
9563   print_vma (psym->st_value, LONG_HEX);
9564   putchar (' ');
9565   print_vma (psym->st_size, DEC_5);
9566
9567   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9568   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9569   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9570   /* Check to see if any other bits in the st_other field are set.
9571      Note - displaying this information disrupts the layout of the
9572      table being generated, but for the moment this case is very
9573      rare.  */
9574   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9575     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9576   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9577   if (VALID_DYNAMIC_NAME (psym->st_name))
9578     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9579   else
9580     printf (_(" <corrupt: %14ld>"), psym->st_name);
9581   putchar ('\n');
9582 }
9583
9584 /* Dump the symbol table.  */
9585 static int
9586 process_symbol_table (FILE * file)
9587 {
9588   Elf_Internal_Shdr * section;
9589   bfd_vma nbuckets = 0;
9590   bfd_vma nchains = 0;
9591   bfd_vma * buckets = NULL;
9592   bfd_vma * chains = NULL;
9593   bfd_vma ngnubuckets = 0;
9594   bfd_vma * gnubuckets = NULL;
9595   bfd_vma * gnuchains = NULL;
9596   bfd_vma gnusymidx = 0;
9597
9598   if (!do_syms && !do_dyn_syms && !do_histogram)
9599     return 1;
9600
9601   if (dynamic_info[DT_HASH]
9602       && (do_histogram
9603           || (do_using_dynamic
9604               && !do_dyn_syms
9605               && dynamic_strings != NULL)))
9606     {
9607       unsigned char nb[8];
9608       unsigned char nc[8];
9609       int hash_ent_size = 4;
9610
9611       if ((elf_header.e_machine == EM_ALPHA
9612            || elf_header.e_machine == EM_S390
9613            || elf_header.e_machine == EM_S390_OLD)
9614           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9615         hash_ent_size = 8;
9616
9617       if (fseek (file,
9618                  (archive_file_offset
9619                   + offset_from_vma (file, dynamic_info[DT_HASH],
9620                                      sizeof nb + sizeof nc)),
9621                  SEEK_SET))
9622         {
9623           error (_("Unable to seek to start of dynamic information\n"));
9624           goto no_hash;
9625         }
9626
9627       if (fread (nb, hash_ent_size, 1, file) != 1)
9628         {
9629           error (_("Failed to read in number of buckets\n"));
9630           goto no_hash;
9631         }
9632
9633       if (fread (nc, hash_ent_size, 1, file) != 1)
9634         {
9635           error (_("Failed to read in number of chains\n"));
9636           goto no_hash;
9637         }
9638
9639       nbuckets = byte_get (nb, hash_ent_size);
9640       nchains  = byte_get (nc, hash_ent_size);
9641
9642       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9643       chains  = get_dynamic_data (file, nchains, hash_ent_size);
9644
9645     no_hash:
9646       if (buckets == NULL || chains == NULL)
9647         {
9648           if (do_using_dynamic)
9649             return 0;
9650           free (buckets);
9651           free (chains);
9652           buckets = NULL;
9653           chains = NULL;
9654           nbuckets = 0;
9655           nchains = 0;
9656         }
9657     }
9658
9659   if (dynamic_info_DT_GNU_HASH
9660       && (do_histogram
9661           || (do_using_dynamic
9662               && !do_dyn_syms
9663               && dynamic_strings != NULL)))
9664     {
9665       unsigned char nb[16];
9666       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9667       bfd_vma buckets_vma;
9668
9669       if (fseek (file,
9670                  (archive_file_offset
9671                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9672                                      sizeof nb)),
9673                  SEEK_SET))
9674         {
9675           error (_("Unable to seek to start of dynamic information\n"));
9676           goto no_gnu_hash;
9677         }
9678
9679       if (fread (nb, 16, 1, file) != 1)
9680         {
9681           error (_("Failed to read in number of buckets\n"));
9682           goto no_gnu_hash;
9683         }
9684
9685       ngnubuckets = byte_get (nb, 4);
9686       gnusymidx = byte_get (nb + 4, 4);
9687       bitmaskwords = byte_get (nb + 8, 4);
9688       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
9689       if (is_32bit_elf)
9690         buckets_vma += bitmaskwords * 4;
9691       else
9692         buckets_vma += bitmaskwords * 8;
9693
9694       if (fseek (file,
9695                  (archive_file_offset
9696                   + offset_from_vma (file, buckets_vma, 4)),
9697                  SEEK_SET))
9698         {
9699           error (_("Unable to seek to start of dynamic information\n"));
9700           goto no_gnu_hash;
9701         }
9702
9703       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
9704
9705       if (gnubuckets == NULL)
9706         goto no_gnu_hash;
9707
9708       for (i = 0; i < ngnubuckets; i++)
9709         if (gnubuckets[i] != 0)
9710           {
9711             if (gnubuckets[i] < gnusymidx)
9712               return 0;
9713
9714             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9715               maxchain = gnubuckets[i];
9716           }
9717
9718       if (maxchain == 0xffffffff)
9719         goto no_gnu_hash;
9720
9721       maxchain -= gnusymidx;
9722
9723       if (fseek (file,
9724                  (archive_file_offset
9725                   + offset_from_vma (file, buckets_vma
9726                                            + 4 * (ngnubuckets + maxchain), 4)),
9727                  SEEK_SET))
9728         {
9729           error (_("Unable to seek to start of dynamic information\n"));
9730           goto no_gnu_hash;
9731         }
9732
9733       do
9734         {
9735           if (fread (nb, 4, 1, file) != 1)
9736             {
9737               error (_("Failed to determine last chain length\n"));
9738               goto no_gnu_hash;
9739             }
9740
9741           if (maxchain + 1 == 0)
9742             goto no_gnu_hash;
9743
9744           ++maxchain;
9745         }
9746       while ((byte_get (nb, 4) & 1) == 0);
9747
9748       if (fseek (file,
9749                  (archive_file_offset
9750                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9751                  SEEK_SET))
9752         {
9753           error (_("Unable to seek to start of dynamic information\n"));
9754           goto no_gnu_hash;
9755         }
9756
9757       gnuchains = get_dynamic_data (file, maxchain, 4);
9758
9759     no_gnu_hash:
9760       if (gnuchains == NULL)
9761         {
9762           free (gnubuckets);
9763           gnubuckets = NULL;
9764           ngnubuckets = 0;
9765           if (do_using_dynamic)
9766             return 0;
9767         }
9768     }
9769
9770   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9771       && do_syms
9772       && do_using_dynamic
9773       && dynamic_strings != NULL)
9774     {
9775       unsigned long hn;
9776
9777       if (dynamic_info[DT_HASH])
9778         {
9779           bfd_vma si;
9780
9781           printf (_("\nSymbol table for image:\n"));
9782           if (is_32bit_elf)
9783             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9784           else
9785             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9786
9787           for (hn = 0; hn < nbuckets; hn++)
9788             {
9789               if (! buckets[hn])
9790                 continue;
9791
9792               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9793                 print_dynamic_symbol (si, hn);
9794             }
9795         }
9796
9797       if (dynamic_info_DT_GNU_HASH)
9798         {
9799           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9800           if (is_32bit_elf)
9801             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9802           else
9803             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9804
9805           for (hn = 0; hn < ngnubuckets; ++hn)
9806             if (gnubuckets[hn] != 0)
9807               {
9808                 bfd_vma si = gnubuckets[hn];
9809                 bfd_vma off = si - gnusymidx;
9810
9811                 do
9812                   {
9813                     print_dynamic_symbol (si, hn);
9814                     si++;
9815                   }
9816                 while ((gnuchains[off++] & 1) == 0);
9817               }
9818         }
9819     }
9820   else if (do_dyn_syms || (do_syms && !do_using_dynamic))
9821     {
9822       unsigned int i;
9823
9824       for (i = 0, section = section_headers;
9825            i < elf_header.e_shnum;
9826            i++, section++)
9827         {
9828           unsigned int si;
9829           char * strtab = NULL;
9830           unsigned long int strtab_size = 0;
9831           Elf_Internal_Sym * symtab;
9832           Elf_Internal_Sym * psym;
9833           unsigned long num_syms;
9834
9835           if ((section->sh_type != SHT_SYMTAB
9836                && section->sh_type != SHT_DYNSYM)
9837               || (!do_syms
9838                   && section->sh_type == SHT_SYMTAB))
9839             continue;
9840
9841           if (section->sh_entsize == 0)
9842             {
9843               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9844                       SECTION_NAME (section));
9845               continue;
9846             }
9847
9848           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9849                   SECTION_NAME (section),
9850                   (unsigned long) (section->sh_size / section->sh_entsize));
9851
9852           if (is_32bit_elf)
9853             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
9854           else
9855             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
9856
9857           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
9858           if (symtab == NULL)
9859             continue;
9860
9861           if (section->sh_link == elf_header.e_shstrndx)
9862             {
9863               strtab = string_table;
9864               strtab_size = string_table_length;
9865             }
9866           else if (section->sh_link < elf_header.e_shnum)
9867             {
9868               Elf_Internal_Shdr * string_sec;
9869
9870               string_sec = section_headers + section->sh_link;
9871
9872               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9873                                           1, string_sec->sh_size,
9874                                           _("string table"));
9875               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
9876             }
9877
9878           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
9879             {
9880               printf ("%6d: ", si);
9881               print_vma (psym->st_value, LONG_HEX);
9882               putchar (' ');
9883               print_vma (psym->st_size, DEC_5);
9884               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9885               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9886               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9887               /* Check to see if any other bits in the st_other field are set.
9888                  Note - displaying this information disrupts the layout of the
9889                  table being generated, but for the moment this case is very rare.  */
9890               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9891                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9892               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
9893               print_symbol (25, psym->st_name < strtab_size
9894                             ? strtab + psym->st_name : _("<corrupt>"));
9895
9896               if (section->sh_type == SHT_DYNSYM
9897                   && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9898                 {
9899                   unsigned char data[2];
9900                   unsigned short vers_data;
9901                   unsigned long offset;
9902                   int is_nobits;
9903                   int check_def;
9904
9905                   offset = offset_from_vma
9906                     (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9907                      sizeof data + si * sizeof (vers_data));
9908
9909                   if (get_data (&data, file, offset + si * sizeof (vers_data),
9910                                 sizeof (data), 1, _("version data")) == NULL)
9911                     break;
9912
9913                   vers_data = byte_get (data, 2);
9914
9915                   is_nobits = (psym->st_shndx < elf_header.e_shnum
9916                                && section_headers[psym->st_shndx].sh_type
9917                                   == SHT_NOBITS);
9918
9919                   check_def = (psym->st_shndx != SHN_UNDEF);
9920
9921                   if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
9922                     {
9923                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
9924                           && (is_nobits || ! check_def))
9925                         {
9926                           Elf_External_Verneed evn;
9927                           Elf_Internal_Verneed ivn;
9928                           Elf_Internal_Vernaux ivna;
9929
9930                           /* We must test both.  */
9931                           offset = offset_from_vma
9932                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9933                              sizeof evn);
9934
9935                           do
9936                             {
9937                               unsigned long vna_off;
9938
9939                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9940                                             _("version need")) == NULL)
9941                                 {
9942                                   ivna.vna_next = 0;
9943                                   ivna.vna_other = 0;
9944                                   ivna.vna_name = 0;
9945                                   break;
9946                                 }
9947
9948                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9949                               ivn.vn_next = BYTE_GET (evn.vn_next);
9950
9951                               vna_off = offset + ivn.vn_aux;
9952
9953                               do
9954                                 {
9955                                   Elf_External_Vernaux evna;
9956
9957                                   if (get_data (&evna, file, vna_off,
9958                                                 sizeof (evna), 1,
9959                                                 _("version need aux (3)")) == NULL)
9960                                     {
9961                                       ivna.vna_next = 0;
9962                                       ivna.vna_other = 0;
9963                                       ivna.vna_name = 0;
9964                                     }
9965                                   else
9966                                     {
9967                                       ivna.vna_other = BYTE_GET (evna.vna_other);
9968                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
9969                                       ivna.vna_name  = BYTE_GET (evna.vna_name);
9970                                     }
9971
9972                                   vna_off += ivna.vna_next;
9973                                 }
9974                               while (ivna.vna_other != vers_data
9975                                      && ivna.vna_next != 0);
9976
9977                               if (ivna.vna_other == vers_data)
9978                                 break;
9979
9980                               offset += ivn.vn_next;
9981                             }
9982                           while (ivn.vn_next != 0);
9983
9984                           if (ivna.vna_other == vers_data)
9985                             {
9986                               printf ("@%s (%d)",
9987                                       ivna.vna_name < strtab_size
9988                                       ? strtab + ivna.vna_name : _("<corrupt>"),
9989                                       ivna.vna_other);
9990                               check_def = 0;
9991                             }
9992                           else if (! is_nobits)
9993                             error (_("bad dynamic symbol\n"));
9994                           else
9995                             check_def = 1;
9996                         }
9997
9998                       if (check_def)
9999                         {
10000                           if (vers_data != 0x8001
10001                               && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10002                             {
10003                               Elf_Internal_Verdef ivd;
10004                               Elf_Internal_Verdaux ivda;
10005                               Elf_External_Verdaux evda;
10006                               unsigned long off;
10007
10008                               off = offset_from_vma
10009                                 (file,
10010                                  version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10011                                  sizeof (Elf_External_Verdef));
10012
10013                               do
10014                                 {
10015                                   Elf_External_Verdef evd;
10016
10017                                   if (get_data (&evd, file, off, sizeof (evd),
10018                                                 1, _("version def")) == NULL)
10019                                     {
10020                                       ivd.vd_ndx = 0;
10021                                       ivd.vd_aux = 0;
10022                                       ivd.vd_next = 0;
10023                                     }
10024                                   else
10025                                     {
10026                                       ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10027                                       ivd.vd_aux = BYTE_GET (evd.vd_aux);
10028                                       ivd.vd_next = BYTE_GET (evd.vd_next);
10029                                     }
10030
10031                                   off += ivd.vd_next;
10032                                 }
10033                               while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10034                                      && ivd.vd_next != 0);
10035
10036                               off -= ivd.vd_next;
10037                               off += ivd.vd_aux;
10038
10039                               if (get_data (&evda, file, off, sizeof (evda),
10040                                             1, _("version def aux")) == NULL)
10041                                 break;
10042
10043                               ivda.vda_name = BYTE_GET (evda.vda_name);
10044
10045                               if (psym->st_name != ivda.vda_name)
10046                                 printf ((vers_data & VERSYM_HIDDEN)
10047                                         ? "@%s" : "@@%s",
10048                                         ivda.vda_name < strtab_size
10049                                         ? strtab + ivda.vda_name : _("<corrupt>"));
10050                             }
10051                         }
10052                     }
10053                 }
10054
10055               putchar ('\n');
10056             }
10057
10058           free (symtab);
10059           if (strtab != string_table)
10060             free (strtab);
10061         }
10062     }
10063   else if (do_syms)
10064     printf
10065       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10066
10067   if (do_histogram && buckets != NULL)
10068     {
10069       unsigned long * lengths;
10070       unsigned long * counts;
10071       unsigned long hn;
10072       bfd_vma si;
10073       unsigned long maxlength = 0;
10074       unsigned long nzero_counts = 0;
10075       unsigned long nsyms = 0;
10076
10077       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10078               (unsigned long) nbuckets);
10079       printf (_(" Length  Number     %% of total  Coverage\n"));
10080
10081       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
10082       if (lengths == NULL)
10083         {
10084           error (_("Out of memory\n"));
10085           return 0;
10086         }
10087       for (hn = 0; hn < nbuckets; ++hn)
10088         {
10089           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
10090             {
10091               ++nsyms;
10092               if (maxlength < ++lengths[hn])
10093                 ++maxlength;
10094             }
10095         }
10096
10097       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10098       if (counts == NULL)
10099         {
10100           free (lengths);
10101           error (_("Out of memory\n"));
10102           return 0;
10103         }
10104
10105       for (hn = 0; hn < nbuckets; ++hn)
10106         ++counts[lengths[hn]];
10107
10108       if (nbuckets > 0)
10109         {
10110           unsigned long i;
10111           printf ("      0  %-10lu (%5.1f%%)\n",
10112                   counts[0], (counts[0] * 100.0) / nbuckets);
10113           for (i = 1; i <= maxlength; ++i)
10114             {
10115               nzero_counts += counts[i] * i;
10116               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
10117                       i, counts[i], (counts[i] * 100.0) / nbuckets,
10118                       (nzero_counts * 100.0) / nsyms);
10119             }
10120         }
10121
10122       free (counts);
10123       free (lengths);
10124     }
10125
10126   if (buckets != NULL)
10127     {
10128       free (buckets);
10129       free (chains);
10130     }
10131
10132   if (do_histogram && gnubuckets != NULL)
10133     {
10134       unsigned long * lengths;
10135       unsigned long * counts;
10136       unsigned long hn;
10137       unsigned long maxlength = 0;
10138       unsigned long nzero_counts = 0;
10139       unsigned long nsyms = 0;
10140
10141       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
10142       if (lengths == NULL)
10143         {
10144           error (_("Out of memory\n"));
10145           return 0;
10146         }
10147
10148       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10149               (unsigned long) ngnubuckets);
10150       printf (_(" Length  Number     %% of total  Coverage\n"));
10151
10152       for (hn = 0; hn < ngnubuckets; ++hn)
10153         if (gnubuckets[hn] != 0)
10154           {
10155             bfd_vma off, length = 1;
10156
10157             for (off = gnubuckets[hn] - gnusymidx;
10158                  (gnuchains[off] & 1) == 0; ++off)
10159               ++length;
10160             lengths[hn] = length;
10161             if (length > maxlength)
10162               maxlength = length;
10163             nsyms += length;
10164           }
10165
10166       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10167       if (counts == NULL)
10168         {
10169           free (lengths);
10170           error (_("Out of memory\n"));
10171           return 0;
10172         }
10173
10174       for (hn = 0; hn < ngnubuckets; ++hn)
10175         ++counts[lengths[hn]];
10176
10177       if (ngnubuckets > 0)
10178         {
10179           unsigned long j;
10180           printf ("      0  %-10lu (%5.1f%%)\n",
10181                   counts[0], (counts[0] * 100.0) / ngnubuckets);
10182           for (j = 1; j <= maxlength; ++j)
10183             {
10184               nzero_counts += counts[j] * j;
10185               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
10186                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10187                       (nzero_counts * 100.0) / nsyms);
10188             }
10189         }
10190
10191       free (counts);
10192       free (lengths);
10193       free (gnubuckets);
10194       free (gnuchains);
10195     }
10196
10197   return 1;
10198 }
10199
10200 static int
10201 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
10202 {
10203   unsigned int i;
10204
10205   if (dynamic_syminfo == NULL
10206       || !do_dynamic)
10207     /* No syminfo, this is ok.  */
10208     return 1;
10209
10210   /* There better should be a dynamic symbol section.  */
10211   if (dynamic_symbols == NULL || dynamic_strings == NULL)
10212     return 0;
10213
10214   if (dynamic_addr)
10215     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10216             dynamic_syminfo_offset, dynamic_syminfo_nent);
10217
10218   printf (_(" Num: Name                           BoundTo     Flags\n"));
10219   for (i = 0; i < dynamic_syminfo_nent; ++i)
10220     {
10221       unsigned short int flags = dynamic_syminfo[i].si_flags;
10222
10223       printf ("%4d: ", i);
10224       if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
10225         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10226       else
10227         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
10228       putchar (' ');
10229
10230       switch (dynamic_syminfo[i].si_boundto)
10231         {
10232         case SYMINFO_BT_SELF:
10233           fputs ("SELF       ", stdout);
10234           break;
10235         case SYMINFO_BT_PARENT:
10236           fputs ("PARENT     ", stdout);
10237           break;
10238         default:
10239           if (dynamic_syminfo[i].si_boundto > 0
10240               && dynamic_syminfo[i].si_boundto < dynamic_nent
10241               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
10242             {
10243               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
10244               putchar (' ' );
10245             }
10246           else
10247             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10248           break;
10249         }
10250
10251       if (flags & SYMINFO_FLG_DIRECT)
10252         printf (" DIRECT");
10253       if (flags & SYMINFO_FLG_PASSTHRU)
10254         printf (" PASSTHRU");
10255       if (flags & SYMINFO_FLG_COPY)
10256         printf (" COPY");
10257       if (flags & SYMINFO_FLG_LAZYLOAD)
10258         printf (" LAZYLOAD");
10259
10260       puts ("");
10261     }
10262
10263   return 1;
10264 }
10265
10266 /* Check to see if the given reloc needs to be handled in a target specific
10267    manner.  If so then process the reloc and return TRUE otherwise return
10268    FALSE.  */
10269
10270 static bfd_boolean
10271 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10272                                 unsigned char *     start,
10273                                 Elf_Internal_Sym *  symtab)
10274 {
10275   unsigned int reloc_type = get_reloc_type (reloc->r_info);
10276
10277   switch (elf_header.e_machine)
10278     {
10279     case EM_MSP430:
10280     case EM_MSP430_OLD:
10281       {
10282         static Elf_Internal_Sym * saved_sym = NULL;
10283
10284         switch (reloc_type)
10285           {
10286           case 10: /* R_MSP430_SYM_DIFF */
10287             if (uses_msp430x_relocs ())
10288               break;
10289           case 21: /* R_MSP430X_SYM_DIFF */
10290             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10291             return TRUE;
10292
10293           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10294           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10295             goto handle_sym_diff;
10296
10297           case 5: /* R_MSP430_16_BYTE */
10298           case 9: /* R_MSP430_8 */
10299             if (uses_msp430x_relocs ())
10300               break;
10301             goto handle_sym_diff;
10302
10303           case 2: /* R_MSP430_ABS16 */
10304           case 15: /* R_MSP430X_ABS16 */
10305             if (! uses_msp430x_relocs ())
10306               break;
10307             goto handle_sym_diff;
10308
10309           handle_sym_diff:
10310             if (saved_sym != NULL)
10311               {
10312                 bfd_vma value;
10313
10314                 value = reloc->r_addend
10315                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10316                      - saved_sym->st_value);
10317
10318                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10319
10320                 saved_sym = NULL;
10321                 return TRUE;
10322               }
10323             break;
10324
10325           default:
10326             if (saved_sym != NULL)
10327               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc"));
10328             break;
10329           }
10330         break;
10331       }
10332
10333     case EM_MN10300:
10334     case EM_CYGNUS_MN10300:
10335       {
10336         static Elf_Internal_Sym * saved_sym = NULL;
10337
10338         switch (reloc_type)
10339           {
10340           case 34: /* R_MN10300_ALIGN */
10341             return TRUE;
10342           case 33: /* R_MN10300_SYM_DIFF */
10343             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10344             return TRUE;
10345           case 1: /* R_MN10300_32 */
10346           case 2: /* R_MN10300_16 */
10347             if (saved_sym != NULL)
10348               {
10349                 bfd_vma value;
10350
10351                 value = reloc->r_addend
10352                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10353                      - saved_sym->st_value);
10354
10355                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10356
10357                 saved_sym = NULL;
10358                 return TRUE;
10359               }
10360             break;
10361           default:
10362             if (saved_sym != NULL)
10363               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10364             break;
10365           }
10366         break;
10367       }
10368     }
10369
10370   return FALSE;
10371 }
10372
10373 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10374    DWARF debug sections.  This is a target specific test.  Note - we do not
10375    go through the whole including-target-headers-multiple-times route, (as
10376    we have already done with <elf/h8.h>) because this would become very
10377    messy and even then this function would have to contain target specific
10378    information (the names of the relocs instead of their numeric values).
10379    FIXME: This is not the correct way to solve this problem.  The proper way
10380    is to have target specific reloc sizing and typing functions created by
10381    the reloc-macros.h header, in the same way that it already creates the
10382    reloc naming functions.  */
10383
10384 static bfd_boolean
10385 is_32bit_abs_reloc (unsigned int reloc_type)
10386 {
10387   switch (elf_header.e_machine)
10388     {
10389     case EM_386:
10390     case EM_486:
10391       return reloc_type == 1; /* R_386_32.  */
10392     case EM_68K:
10393       return reloc_type == 1; /* R_68K_32.  */
10394     case EM_860:
10395       return reloc_type == 1; /* R_860_32.  */
10396     case EM_960:
10397       return reloc_type == 2; /* R_960_32.  */
10398     case EM_AARCH64:
10399       return reloc_type == 258; /* R_AARCH64_ABS32 */
10400     case EM_ALPHA:
10401       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
10402     case EM_ARC:
10403       return reloc_type == 1; /* R_ARC_32.  */
10404     case EM_ARM:
10405       return reloc_type == 2; /* R_ARM_ABS32 */
10406     case EM_AVR_OLD:
10407     case EM_AVR:
10408       return reloc_type == 1;
10409     case EM_ADAPTEVA_EPIPHANY:
10410       return reloc_type == 3;
10411     case EM_BLACKFIN:
10412       return reloc_type == 0x12; /* R_byte4_data.  */
10413     case EM_CRIS:
10414       return reloc_type == 3; /* R_CRIS_32.  */
10415     case EM_CR16:
10416       return reloc_type == 3; /* R_CR16_NUM32.  */
10417     case EM_CRX:
10418       return reloc_type == 15; /* R_CRX_NUM32.  */
10419     case EM_CYGNUS_FRV:
10420       return reloc_type == 1;
10421     case EM_CYGNUS_D10V:
10422     case EM_D10V:
10423       return reloc_type == 6; /* R_D10V_32.  */
10424     case EM_CYGNUS_D30V:
10425     case EM_D30V:
10426       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
10427     case EM_DLX:
10428       return reloc_type == 3; /* R_DLX_RELOC_32.  */
10429     case EM_CYGNUS_FR30:
10430     case EM_FR30:
10431       return reloc_type == 3; /* R_FR30_32.  */
10432     case EM_H8S:
10433     case EM_H8_300:
10434     case EM_H8_300H:
10435       return reloc_type == 1; /* R_H8_DIR32.  */
10436     case EM_IA_64:
10437       return reloc_type == 0x65; /* R_IA64_SECREL32LSB.  */
10438     case EM_IP2K_OLD:
10439     case EM_IP2K:
10440       return reloc_type == 2; /* R_IP2K_32.  */
10441     case EM_IQ2000:
10442       return reloc_type == 2; /* R_IQ2000_32.  */
10443     case EM_LATTICEMICO32:
10444       return reloc_type == 3; /* R_LM32_32.  */
10445     case EM_M32C_OLD:
10446     case EM_M32C:
10447       return reloc_type == 3; /* R_M32C_32.  */
10448     case EM_M32R:
10449       return reloc_type == 34; /* R_M32R_32_RELA.  */
10450     case EM_MCORE:
10451       return reloc_type == 1; /* R_MCORE_ADDR32.  */
10452     case EM_CYGNUS_MEP:
10453       return reloc_type == 4; /* R_MEP_32.  */
10454     case EM_METAG:
10455       return reloc_type == 2; /* R_METAG_ADDR32.  */
10456     case EM_MICROBLAZE:
10457       return reloc_type == 1; /* R_MICROBLAZE_32.  */
10458     case EM_MIPS:
10459       return reloc_type == 2; /* R_MIPS_32.  */
10460     case EM_MMIX:
10461       return reloc_type == 4; /* R_MMIX_32.  */
10462     case EM_CYGNUS_MN10200:
10463     case EM_MN10200:
10464       return reloc_type == 1; /* R_MN10200_32.  */
10465     case EM_CYGNUS_MN10300:
10466     case EM_MN10300:
10467       return reloc_type == 1; /* R_MN10300_32.  */
10468     case EM_MOXIE:
10469       return reloc_type == 1; /* R_MOXIE_32.  */
10470     case EM_MSP430_OLD:
10471     case EM_MSP430:
10472       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
10473     case EM_MT:
10474       return reloc_type == 2; /* R_MT_32.  */
10475     case EM_NDS32:
10476       return reloc_type == 20; /* R_NDS32_RELA.  */
10477     case EM_ALTERA_NIOS2:
10478       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
10479     case EM_NIOS32:
10480       return reloc_type == 1; /* R_NIOS_32.  */
10481     case EM_OPENRISC:
10482     case EM_OR32:
10483       return reloc_type == 1; /* R_OR32_32.  */
10484     case EM_PARISC:
10485       return (reloc_type == 1 /* R_PARISC_DIR32.  */
10486               || reloc_type == 41); /* R_PARISC_SECREL32.  */
10487     case EM_PJ:
10488     case EM_PJ_OLD:
10489       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
10490     case EM_PPC64:
10491       return reloc_type == 1; /* R_PPC64_ADDR32.  */
10492     case EM_PPC:
10493       return reloc_type == 1; /* R_PPC_ADDR32.  */
10494     case EM_RL78:
10495       return reloc_type == 1; /* R_RL78_DIR32.  */
10496     case EM_RX:
10497       return reloc_type == 1; /* R_RX_DIR32.  */
10498     case EM_S370:
10499       return reloc_type == 1; /* R_I370_ADDR31.  */
10500     case EM_S390_OLD:
10501     case EM_S390:
10502       return reloc_type == 4; /* R_S390_32.  */
10503     case EM_SCORE:
10504       return reloc_type == 8; /* R_SCORE_ABS32.  */
10505     case EM_SH:
10506       return reloc_type == 1; /* R_SH_DIR32.  */
10507     case EM_SPARC32PLUS:
10508     case EM_SPARCV9:
10509     case EM_SPARC:
10510       return reloc_type == 3 /* R_SPARC_32.  */
10511         || reloc_type == 23; /* R_SPARC_UA32.  */
10512     case EM_SPU:
10513       return reloc_type == 6; /* R_SPU_ADDR32 */
10514     case EM_TI_C6000:
10515       return reloc_type == 1; /* R_C6000_ABS32.  */
10516     case EM_TILEGX:
10517       return reloc_type == 2; /* R_TILEGX_32.  */
10518     case EM_TILEPRO:
10519       return reloc_type == 1; /* R_TILEPRO_32.  */
10520     case EM_CYGNUS_V850:
10521     case EM_V850:
10522       return reloc_type == 6; /* R_V850_ABS32.  */
10523     case EM_V800:
10524       return reloc_type == 0x33; /* R_V810_WORD.  */
10525     case EM_VAX:
10526       return reloc_type == 1; /* R_VAX_32.  */
10527     case EM_X86_64:
10528     case EM_L1OM:
10529     case EM_K1OM:
10530       return reloc_type == 10; /* R_X86_64_32.  */
10531     case EM_XC16X:
10532     case EM_C166:
10533       return reloc_type == 3; /* R_XC16C_ABS_32.  */
10534     case EM_XGATE:
10535       return reloc_type == 4; /* R_XGATE_32.  */
10536     case EM_XSTORMY16:
10537       return reloc_type == 1; /* R_XSTROMY16_32.  */
10538     case EM_XTENSA_OLD:
10539     case EM_XTENSA:
10540       return reloc_type == 1; /* R_XTENSA_32.  */
10541     default:
10542       error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10543              elf_header.e_machine);
10544       abort ();
10545     }
10546 }
10547
10548 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10549    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
10550
10551 static bfd_boolean
10552 is_32bit_pcrel_reloc (unsigned int reloc_type)
10553 {
10554   switch (elf_header.e_machine)
10555     {
10556     case EM_386:
10557     case EM_486:
10558       return reloc_type == 2;  /* R_386_PC32.  */
10559     case EM_68K:
10560       return reloc_type == 4;  /* R_68K_PC32.  */
10561     case EM_AARCH64:
10562       return reloc_type == 261; /* R_AARCH64_PREL32 */
10563     case EM_ADAPTEVA_EPIPHANY:
10564       return reloc_type == 6;
10565     case EM_ALPHA:
10566       return reloc_type == 10; /* R_ALPHA_SREL32.  */
10567     case EM_ARM:
10568       return reloc_type == 3;  /* R_ARM_REL32 */
10569     case EM_MICROBLAZE:
10570       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
10571     case EM_PARISC:
10572       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
10573     case EM_PPC:
10574       return reloc_type == 26; /* R_PPC_REL32.  */
10575     case EM_PPC64:
10576       return reloc_type == 26; /* R_PPC64_REL32.  */
10577     case EM_S390_OLD:
10578     case EM_S390:
10579       return reloc_type == 5;  /* R_390_PC32.  */
10580     case EM_SH:
10581       return reloc_type == 2;  /* R_SH_REL32.  */
10582     case EM_SPARC32PLUS:
10583     case EM_SPARCV9:
10584     case EM_SPARC:
10585       return reloc_type == 6;  /* R_SPARC_DISP32.  */
10586     case EM_SPU:
10587       return reloc_type == 13; /* R_SPU_REL32.  */
10588     case EM_TILEGX:
10589       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
10590     case EM_TILEPRO:
10591       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
10592     case EM_X86_64:
10593     case EM_L1OM:
10594     case EM_K1OM:
10595       return reloc_type == 2;  /* R_X86_64_PC32.  */
10596     case EM_XTENSA_OLD:
10597     case EM_XTENSA:
10598       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
10599     default:
10600       /* Do not abort or issue an error message here.  Not all targets use
10601          pc-relative 32-bit relocs in their DWARF debug information and we
10602          have already tested for target coverage in is_32bit_abs_reloc.  A
10603          more helpful warning message will be generated by apply_relocations
10604          anyway, so just return.  */
10605       return FALSE;
10606     }
10607 }
10608
10609 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10610    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
10611
10612 static bfd_boolean
10613 is_64bit_abs_reloc (unsigned int reloc_type)
10614 {
10615   switch (elf_header.e_machine)
10616     {
10617     case EM_AARCH64:
10618       return reloc_type == 257; /* R_AARCH64_ABS64.  */
10619     case EM_ALPHA:
10620       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
10621     case EM_IA_64:
10622       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
10623     case EM_PARISC:
10624       return reloc_type == 80; /* R_PARISC_DIR64.  */
10625     case EM_PPC64:
10626       return reloc_type == 38; /* R_PPC64_ADDR64.  */
10627     case EM_SPARC32PLUS:
10628     case EM_SPARCV9:
10629     case EM_SPARC:
10630       return reloc_type == 54; /* R_SPARC_UA64.  */
10631     case EM_X86_64:
10632     case EM_L1OM:
10633     case EM_K1OM:
10634       return reloc_type == 1; /* R_X86_64_64.  */
10635     case EM_S390_OLD:
10636     case EM_S390:
10637       return reloc_type == 22;  /* R_S390_64.  */
10638     case EM_TILEGX:
10639       return reloc_type == 1; /* R_TILEGX_64.  */
10640     case EM_MIPS:
10641       return reloc_type == 18;  /* R_MIPS_64.  */
10642     default:
10643       return FALSE;
10644     }
10645 }
10646
10647 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10648    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
10649
10650 static bfd_boolean
10651 is_64bit_pcrel_reloc (unsigned int reloc_type)
10652 {
10653   switch (elf_header.e_machine)
10654     {
10655     case EM_AARCH64:
10656       return reloc_type == 260; /* R_AARCH64_PREL64.  */
10657     case EM_ALPHA:
10658       return reloc_type == 11; /* R_ALPHA_SREL64.  */
10659     case EM_IA_64:
10660       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
10661     case EM_PARISC:
10662       return reloc_type == 72; /* R_PARISC_PCREL64.  */
10663     case EM_PPC64:
10664       return reloc_type == 44; /* R_PPC64_REL64.  */
10665     case EM_SPARC32PLUS:
10666     case EM_SPARCV9:
10667     case EM_SPARC:
10668       return reloc_type == 46; /* R_SPARC_DISP64.  */
10669     case EM_X86_64:
10670     case EM_L1OM:
10671     case EM_K1OM:
10672       return reloc_type == 24; /* R_X86_64_PC64.  */
10673     case EM_S390_OLD:
10674     case EM_S390:
10675       return reloc_type == 23;  /* R_S390_PC64.  */
10676     case EM_TILEGX:
10677       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
10678     default:
10679       return FALSE;
10680     }
10681 }
10682
10683 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10684    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
10685
10686 static bfd_boolean
10687 is_24bit_abs_reloc (unsigned int reloc_type)
10688 {
10689   switch (elf_header.e_machine)
10690     {
10691     case EM_CYGNUS_MN10200:
10692     case EM_MN10200:
10693       return reloc_type == 4; /* R_MN10200_24.  */
10694     default:
10695       return FALSE;
10696     }
10697 }
10698
10699 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10700    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
10701
10702 static bfd_boolean
10703 is_16bit_abs_reloc (unsigned int reloc_type)
10704 {
10705   switch (elf_header.e_machine)
10706     {
10707     case EM_AVR_OLD:
10708     case EM_AVR:
10709       return reloc_type == 4; /* R_AVR_16.  */
10710     case EM_ADAPTEVA_EPIPHANY:
10711       return reloc_type == 5;
10712     case EM_CYGNUS_D10V:
10713     case EM_D10V:
10714       return reloc_type == 3; /* R_D10V_16.  */
10715     case EM_H8S:
10716     case EM_H8_300:
10717     case EM_H8_300H:
10718       return reloc_type == R_H8_DIR16;
10719     case EM_IP2K_OLD:
10720     case EM_IP2K:
10721       return reloc_type == 1; /* R_IP2K_16.  */
10722     case EM_M32C_OLD:
10723     case EM_M32C:
10724       return reloc_type == 1; /* R_M32C_16 */
10725     case EM_MSP430:
10726       if (uses_msp430x_relocs ())
10727         return reloc_type == 2; /* R_MSP430_ABS16.  */
10728     case EM_MSP430_OLD:
10729       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
10730     case EM_NDS32:
10731       return reloc_type == 19; /* R_NDS32_RELA.  */
10732     case EM_ALTERA_NIOS2:
10733       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
10734     case EM_NIOS32:
10735       return reloc_type == 9; /* R_NIOS_16.  */
10736     case EM_TI_C6000:
10737       return reloc_type == 2; /* R_C6000_ABS16.  */
10738     case EM_XC16X:
10739     case EM_C166:
10740       return reloc_type == 2; /* R_XC16C_ABS_16.  */
10741     case EM_CYGNUS_MN10200:
10742     case EM_MN10200:
10743       return reloc_type == 2; /* R_MN10200_16.  */
10744     case EM_CYGNUS_MN10300:
10745     case EM_MN10300:
10746       return reloc_type == 2; /* R_MN10300_16.  */
10747     case EM_XGATE:
10748       return reloc_type == 3; /* R_XGATE_16.  */
10749     default:
10750       return FALSE;
10751     }
10752 }
10753
10754 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10755    relocation entries (possibly formerly used for SHT_GROUP sections).  */
10756
10757 static bfd_boolean
10758 is_none_reloc (unsigned int reloc_type)
10759 {
10760   switch (elf_header.e_machine)
10761     {
10762     case EM_68K:     /* R_68K_NONE.  */
10763     case EM_386:     /* R_386_NONE.  */
10764     case EM_SPARC32PLUS:
10765     case EM_SPARCV9:
10766     case EM_SPARC:   /* R_SPARC_NONE.  */
10767     case EM_MIPS:    /* R_MIPS_NONE.  */
10768     case EM_PARISC:  /* R_PARISC_NONE.  */
10769     case EM_ALPHA:   /* R_ALPHA_NONE.  */
10770     case EM_ADAPTEVA_EPIPHANY:
10771     case EM_PPC:     /* R_PPC_NONE.  */
10772     case EM_PPC64:   /* R_PPC64_NONE.  */
10773     case EM_ARM:     /* R_ARM_NONE.  */
10774     case EM_IA_64:   /* R_IA64_NONE.  */
10775     case EM_SH:      /* R_SH_NONE.  */
10776     case EM_S390_OLD:
10777     case EM_S390:    /* R_390_NONE.  */
10778     case EM_CRIS:    /* R_CRIS_NONE.  */
10779     case EM_X86_64:  /* R_X86_64_NONE.  */
10780     case EM_L1OM:    /* R_X86_64_NONE.  */
10781     case EM_K1OM:    /* R_X86_64_NONE.  */
10782     case EM_MN10300: /* R_MN10300_NONE.  */
10783     case EM_MOXIE:   /* R_MOXIE_NONE.  */
10784     case EM_M32R:    /* R_M32R_NONE.  */
10785     case EM_TI_C6000:/* R_C6000_NONE.  */
10786     case EM_TILEGX:  /* R_TILEGX_NONE.  */
10787     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
10788     case EM_XC16X:
10789     case EM_C166:    /* R_XC16X_NONE.  */
10790     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
10791     case EM_NIOS32:  /* R_NIOS_NONE.  */
10792       return reloc_type == 0;
10793     case EM_AARCH64:
10794       return reloc_type == 0 || reloc_type == 256;
10795     case EM_NDS32:
10796       return (reloc_type == 0       /* R_XTENSA_NONE.  */
10797               || reloc_type == 204  /* R_NDS32_DIFF8.  */
10798               || reloc_type == 205  /* R_NDS32_DIFF16.  */
10799               || reloc_type == 206  /* R_NDS32_DIFF32.  */
10800               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
10801     case EM_XTENSA_OLD:
10802     case EM_XTENSA:
10803       return (reloc_type == 0      /* R_XTENSA_NONE.  */
10804               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
10805               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
10806               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
10807     case EM_METAG:
10808       return reloc_type == 3; /* R_METAG_NONE.  */
10809     }
10810   return FALSE;
10811 }
10812
10813 /* Apply relocations to a section.
10814    Note: So far support has been added only for those relocations
10815    which can be found in debug sections.
10816    FIXME: Add support for more relocations ?  */
10817
10818 static void
10819 apply_relocations (void * file,
10820                    Elf_Internal_Shdr * section,
10821                    unsigned char * start)
10822 {
10823   Elf_Internal_Shdr * relsec;
10824   unsigned char * end = start + section->sh_size;
10825
10826   if (elf_header.e_type != ET_REL)
10827     return;
10828
10829   /* Find the reloc section associated with the section.  */
10830   for (relsec = section_headers;
10831        relsec < section_headers + elf_header.e_shnum;
10832        ++relsec)
10833     {
10834       bfd_boolean is_rela;
10835       unsigned long num_relocs;
10836       Elf_Internal_Rela * relocs;
10837       Elf_Internal_Rela * rp;
10838       Elf_Internal_Shdr * symsec;
10839       Elf_Internal_Sym * symtab;
10840       unsigned long num_syms;
10841       Elf_Internal_Sym * sym;
10842
10843       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10844           || relsec->sh_info >= elf_header.e_shnum
10845           || section_headers + relsec->sh_info != section
10846           || relsec->sh_size == 0
10847           || relsec->sh_link >= elf_header.e_shnum)
10848         continue;
10849
10850       is_rela = relsec->sh_type == SHT_RELA;
10851
10852       if (is_rela)
10853         {
10854           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10855                                   relsec->sh_size, & relocs, & num_relocs))
10856             return;
10857         }
10858       else
10859         {
10860           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10861                                  relsec->sh_size, & relocs, & num_relocs))
10862             return;
10863         }
10864
10865       /* SH uses RELA but uses in place value instead of the addend field.  */
10866       if (elf_header.e_machine == EM_SH)
10867         is_rela = FALSE;
10868
10869       symsec = section_headers + relsec->sh_link;
10870       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
10871
10872       for (rp = relocs; rp < relocs + num_relocs; ++rp)
10873         {
10874           bfd_vma         addend;
10875           unsigned int    reloc_type;
10876           unsigned int    reloc_size;
10877           unsigned char * rloc;
10878           unsigned long   sym_index;
10879
10880           reloc_type = get_reloc_type (rp->r_info);
10881
10882           if (target_specific_reloc_handling (rp, start, symtab))
10883             continue;
10884           else if (is_none_reloc (reloc_type))
10885             continue;
10886           else if (is_32bit_abs_reloc (reloc_type)
10887                    || is_32bit_pcrel_reloc (reloc_type))
10888             reloc_size = 4;
10889           else if (is_64bit_abs_reloc (reloc_type)
10890                    || is_64bit_pcrel_reloc (reloc_type))
10891             reloc_size = 8;
10892           else if (is_24bit_abs_reloc (reloc_type))
10893             reloc_size = 3;
10894           else if (is_16bit_abs_reloc (reloc_type))
10895             reloc_size = 2;
10896           else
10897             {
10898               warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10899                     reloc_type, SECTION_NAME (section));
10900               continue;
10901             }
10902
10903           rloc = start + rp->r_offset;
10904           if ((rloc + reloc_size) > end || (rloc < start))
10905             {
10906               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10907                     (unsigned long) rp->r_offset,
10908                     SECTION_NAME (section));
10909               continue;
10910             }
10911
10912           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10913           if (sym_index >= num_syms)
10914             {
10915               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10916                     sym_index, SECTION_NAME (section));
10917               continue;
10918             }
10919           sym = symtab + sym_index;
10920
10921           /* If the reloc has a symbol associated with it,
10922              make sure that it is of an appropriate type.
10923
10924              Relocations against symbols without type can happen.
10925              Gcc -feliminate-dwarf2-dups may generate symbols
10926              without type for debug info.
10927
10928              Icc generates relocations against function symbols
10929              instead of local labels.
10930
10931              Relocations against object symbols can happen, eg when
10932              referencing a global array.  For an example of this see
10933              the _clz.o binary in libgcc.a.  */
10934           if (sym != symtab
10935               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
10936             {
10937               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10938                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
10939                     (long int)(rp - relocs),
10940                     SECTION_NAME (relsec));
10941               continue;
10942             }
10943
10944           addend = 0;
10945           if (is_rela)
10946             addend += rp->r_addend;
10947           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10948              partial_inplace.  */
10949           if (!is_rela
10950               || (elf_header.e_machine == EM_XTENSA
10951                   && reloc_type == 1)
10952               || ((elf_header.e_machine == EM_PJ
10953                    || elf_header.e_machine == EM_PJ_OLD)
10954                   && reloc_type == 1)
10955               || ((elf_header.e_machine == EM_D30V
10956                    || elf_header.e_machine == EM_CYGNUS_D30V)
10957                   && reloc_type == 12))
10958             addend += byte_get (rloc, reloc_size);
10959
10960           if (is_32bit_pcrel_reloc (reloc_type)
10961               || is_64bit_pcrel_reloc (reloc_type))
10962             {
10963               /* On HPPA, all pc-relative relocations are biased by 8.  */
10964               if (elf_header.e_machine == EM_PARISC)
10965                 addend -= 8;
10966               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
10967                         reloc_size);
10968             }
10969           else
10970             byte_put (rloc, addend + sym->st_value, reloc_size);
10971         }
10972
10973       free (symtab);
10974       free (relocs);
10975       break;
10976     }
10977 }
10978
10979 #ifdef SUPPORT_DISASSEMBLY
10980 static int
10981 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10982 {
10983   printf (_("\nAssembly dump of section %s\n"),
10984           SECTION_NAME (section));
10985
10986   /* XXX -- to be done --- XXX */
10987
10988   return 1;
10989 }
10990 #endif
10991
10992 /* Reads in the contents of SECTION from FILE, returning a pointer
10993    to a malloc'ed buffer or NULL if something went wrong.  */
10994
10995 static char *
10996 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10997 {
10998   bfd_size_type num_bytes;
10999
11000   num_bytes = section->sh_size;
11001
11002   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11003     {
11004       printf (_("\nSection '%s' has no data to dump.\n"),
11005               SECTION_NAME (section));
11006       return NULL;
11007     }
11008
11009   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11010                              _("section contents"));
11011 }
11012
11013
11014 static void
11015 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11016 {
11017   Elf_Internal_Shdr * relsec;
11018   bfd_size_type num_bytes;
11019   char * data;
11020   char * end;
11021   char * start;
11022   char * name = SECTION_NAME (section);
11023   bfd_boolean some_strings_shown;
11024
11025   start = get_section_contents (section, file);
11026   if (start == NULL)
11027     return;
11028
11029   printf (_("\nString dump of section '%s':\n"), name);
11030
11031   /* If the section being dumped has relocations against it the user might
11032      be expecting these relocations to have been applied.  Check for this
11033      case and issue a warning message in order to avoid confusion.
11034      FIXME: Maybe we ought to have an option that dumps a section with
11035      relocs applied ?  */
11036   for (relsec = section_headers;
11037        relsec < section_headers + elf_header.e_shnum;
11038        ++relsec)
11039     {
11040       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11041           || relsec->sh_info >= elf_header.e_shnum
11042           || section_headers + relsec->sh_info != section
11043           || relsec->sh_size == 0
11044           || relsec->sh_link >= elf_header.e_shnum)
11045         continue;
11046
11047       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11048       break;
11049     }
11050
11051   num_bytes = section->sh_size;
11052   data = start;
11053   end  = start + num_bytes;
11054   some_strings_shown = FALSE;
11055
11056   while (data < end)
11057     {
11058       while (!ISPRINT (* data))
11059         if (++ data >= end)
11060           break;
11061
11062       if (data < end)
11063         {
11064 #ifndef __MSVCRT__
11065           /* PR 11128: Use two separate invocations in order to work
11066              around bugs in the Solaris 8 implementation of printf.  */
11067           printf ("  [%6tx]  ", data - start);
11068           printf ("%s\n", data);
11069 #else
11070           printf ("  [%6Ix]  %s\n", (size_t) (data - start), data);
11071 #endif
11072           data += strlen (data);
11073           some_strings_shown = TRUE;
11074         }
11075     }
11076
11077   if (! some_strings_shown)
11078     printf (_("  No strings found in this section."));
11079
11080   free (start);
11081
11082   putchar ('\n');
11083 }
11084
11085 static void
11086 dump_section_as_bytes (Elf_Internal_Shdr * section,
11087                        FILE * file,
11088                        bfd_boolean relocate)
11089 {
11090   Elf_Internal_Shdr * relsec;
11091   bfd_size_type bytes;
11092   bfd_vma addr;
11093   unsigned char * data;
11094   unsigned char * start;
11095
11096   start = (unsigned char *) get_section_contents (section, file);
11097   if (start == NULL)
11098     return;
11099
11100   printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
11101
11102   if (relocate)
11103     {
11104       apply_relocations (file, section, start);
11105     }
11106   else
11107     {
11108       /* If the section being dumped has relocations against it the user might
11109          be expecting these relocations to have been applied.  Check for this
11110          case and issue a warning message in order to avoid confusion.
11111          FIXME: Maybe we ought to have an option that dumps a section with
11112          relocs applied ?  */
11113       for (relsec = section_headers;
11114            relsec < section_headers + elf_header.e_shnum;
11115            ++relsec)
11116         {
11117           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11118               || relsec->sh_info >= elf_header.e_shnum
11119               || section_headers + relsec->sh_info != section
11120               || relsec->sh_size == 0
11121               || relsec->sh_link >= elf_header.e_shnum)
11122             continue;
11123
11124           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11125           break;
11126         }
11127     }
11128
11129   addr = section->sh_addr;
11130   bytes = section->sh_size;
11131   data = start;
11132
11133   while (bytes)
11134     {
11135       int j;
11136       int k;
11137       int lbytes;
11138
11139       lbytes = (bytes > 16 ? 16 : bytes);
11140
11141       printf ("  0x%8.8lx ", (unsigned long) addr);
11142
11143       for (j = 0; j < 16; j++)
11144         {
11145           if (j < lbytes)
11146             printf ("%2.2x", data[j]);
11147           else
11148             printf ("  ");
11149
11150           if ((j & 3) == 3)
11151             printf (" ");
11152         }
11153
11154       for (j = 0; j < lbytes; j++)
11155         {
11156           k = data[j];
11157           if (k >= ' ' && k < 0x7f)
11158             printf ("%c", k);
11159           else
11160             printf (".");
11161         }
11162
11163       putchar ('\n');
11164
11165       data  += lbytes;
11166       addr  += lbytes;
11167       bytes -= lbytes;
11168     }
11169
11170   free (start);
11171
11172   putchar ('\n');
11173 }
11174
11175 /* Uncompresses a section that was compressed using zlib, in place.  */
11176
11177 static int
11178 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11179                              dwarf_size_type *size ATTRIBUTE_UNUSED)
11180 {
11181 #ifndef HAVE_ZLIB_H
11182   return FALSE;
11183 #else
11184   dwarf_size_type compressed_size = *size;
11185   unsigned char * compressed_buffer = *buffer;
11186   dwarf_size_type uncompressed_size;
11187   unsigned char * uncompressed_buffer;
11188   z_stream strm;
11189   int rc;
11190   dwarf_size_type header_size = 12;
11191
11192   /* Read the zlib header.  In this case, it should be "ZLIB" followed
11193      by the uncompressed section size, 8 bytes in big-endian order.  */
11194   if (compressed_size < header_size
11195       || ! streq ((char *) compressed_buffer, "ZLIB"))
11196     return 0;
11197
11198   uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11199   uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11200   uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11201   uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11202   uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11203   uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11204   uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11205   uncompressed_size += compressed_buffer[11];
11206
11207   /* It is possible the section consists of several compressed
11208      buffers concatenated together, so we uncompress in a loop.  */
11209   strm.zalloc = NULL;
11210   strm.zfree = NULL;
11211   strm.opaque = NULL;
11212   strm.avail_in = compressed_size - header_size;
11213   strm.next_in = (Bytef *) compressed_buffer + header_size;
11214   strm.avail_out = uncompressed_size;
11215   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
11216
11217   rc = inflateInit (& strm);
11218   while (strm.avail_in > 0)
11219     {
11220       if (rc != Z_OK)
11221         goto fail;
11222       strm.next_out = ((Bytef *) uncompressed_buffer
11223                        + (uncompressed_size - strm.avail_out));
11224       rc = inflate (&strm, Z_FINISH);
11225       if (rc != Z_STREAM_END)
11226         goto fail;
11227       rc = inflateReset (& strm);
11228     }
11229   rc = inflateEnd (& strm);
11230   if (rc != Z_OK
11231       || strm.avail_out != 0)
11232     goto fail;
11233
11234   free (compressed_buffer);
11235   *buffer = uncompressed_buffer;
11236   *size = uncompressed_size;
11237   return 1;
11238
11239  fail:
11240   free (uncompressed_buffer);
11241   /* Indicate decompression failure.  */
11242   *buffer = NULL;
11243   return 0;
11244 #endif  /* HAVE_ZLIB_H */
11245 }
11246
11247 static int
11248 load_specific_debug_section (enum dwarf_section_display_enum debug,
11249                              Elf_Internal_Shdr * sec, void * file)
11250 {
11251   struct dwarf_section * section = &debug_displays [debug].section;
11252   char buf [64];
11253
11254   /* If it is already loaded, do nothing.  */
11255   if (section->start != NULL)
11256     return 1;
11257
11258   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11259   section->address = sec->sh_addr;
11260   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11261                                                sec->sh_offset, 1,
11262                                                sec->sh_size, buf);
11263   if (section->start == NULL)
11264     section->size = 0;
11265   else
11266     {
11267       section->size = sec->sh_size;
11268       if (uncompress_section_contents (&section->start, &section->size))
11269         sec->sh_size = section->size;
11270     }
11271
11272   if (section->start == NULL)
11273     return 0;
11274
11275   if (debug_displays [debug].relocate)
11276     apply_relocations ((FILE *) file, sec, section->start);
11277
11278   return 1;
11279 }
11280
11281 /* If this is not NULL, load_debug_section will only look for sections
11282    within the list of sections given here.  */
11283 unsigned int *section_subset = NULL;
11284
11285 int
11286 load_debug_section (enum dwarf_section_display_enum debug, void * file)
11287 {
11288   struct dwarf_section * section = &debug_displays [debug].section;
11289   Elf_Internal_Shdr * sec;
11290
11291   /* Locate the debug section.  */
11292   sec = find_section_in_set (section->uncompressed_name, section_subset);
11293   if (sec != NULL)
11294     section->name = section->uncompressed_name;
11295   else
11296     {
11297       sec = find_section_in_set (section->compressed_name, section_subset);
11298       if (sec != NULL)
11299         section->name = section->compressed_name;
11300     }
11301   if (sec == NULL)
11302     return 0;
11303
11304   /* If we're loading from a subset of sections, and we've loaded
11305      a section matching this name before, it's likely that it's a
11306      different one.  */
11307   if (section_subset != NULL)
11308     free_debug_section (debug);
11309
11310   return load_specific_debug_section (debug, sec, (FILE *) file);
11311 }
11312
11313 void
11314 free_debug_section (enum dwarf_section_display_enum debug)
11315 {
11316   struct dwarf_section * section = &debug_displays [debug].section;
11317
11318   if (section->start == NULL)
11319     return;
11320
11321   free ((char *) section->start);
11322   section->start = NULL;
11323   section->address = 0;
11324   section->size = 0;
11325 }
11326
11327 static int
11328 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
11329 {
11330   char * name = SECTION_NAME (section);
11331   bfd_size_type length;
11332   int result = 1;
11333   int i;
11334
11335   length = section->sh_size;
11336   if (length == 0)
11337     {
11338       printf (_("\nSection '%s' has no debugging data.\n"), name);
11339       return 0;
11340     }
11341   if (section->sh_type == SHT_NOBITS)
11342     {
11343       /* There is no point in dumping the contents of a debugging section
11344          which has the NOBITS type - the bits in the file will be random.
11345          This can happen when a file containing a .eh_frame section is
11346          stripped with the --only-keep-debug command line option.  */
11347       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
11348       return 0;
11349     }
11350
11351   if (const_strneq (name, ".gnu.linkonce.wi."))
11352     name = ".debug_info";
11353
11354   /* See if we know how to display the contents of this section.  */
11355   for (i = 0; i < max; i++)
11356     if (streq (debug_displays[i].section.uncompressed_name, name)
11357         || (i == line && const_strneq (name, ".debug_line."))
11358         || streq (debug_displays[i].section.compressed_name, name))
11359       {
11360         struct dwarf_section * sec = &debug_displays [i].section;
11361         int secondary = (section != find_section (name));
11362
11363         if (secondary)
11364           free_debug_section ((enum dwarf_section_display_enum) i);
11365
11366         if (i == line && const_strneq (name, ".debug_line."))
11367           sec->name = name;
11368         else if (streq (sec->uncompressed_name, name))
11369           sec->name = sec->uncompressed_name;
11370         else
11371           sec->name = sec->compressed_name;
11372         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
11373                                          section, file))
11374           {
11375             /* If this debug section is part of a CU/TU set in a .dwp file,
11376                restrict load_debug_section to the sections in that set.  */
11377             section_subset = find_cu_tu_set (file, shndx);
11378
11379             result &= debug_displays[i].display (sec, file);
11380
11381             section_subset = NULL;
11382
11383             if (secondary || (i != info && i != abbrev))
11384               free_debug_section ((enum dwarf_section_display_enum) i);
11385           }
11386
11387         break;
11388       }
11389
11390   if (i == max)
11391     {
11392       printf (_("Unrecognized debug section: %s\n"), name);
11393       result = 0;
11394     }
11395
11396   return result;
11397 }
11398
11399 /* Set DUMP_SECTS for all sections where dumps were requested
11400    based on section name.  */
11401
11402 static void
11403 initialise_dumps_byname (void)
11404 {
11405   struct dump_list_entry * cur;
11406
11407   for (cur = dump_sects_byname; cur; cur = cur->next)
11408     {
11409       unsigned int i;
11410       int any;
11411
11412       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11413         if (streq (SECTION_NAME (section_headers + i), cur->name))
11414           {
11415             request_dump_bynumber (i, cur->type);
11416             any = 1;
11417           }
11418
11419       if (!any)
11420         warn (_("Section '%s' was not dumped because it does not exist!\n"),
11421               cur->name);
11422     }
11423 }
11424
11425 static void
11426 process_section_contents (FILE * file)
11427 {
11428   Elf_Internal_Shdr * section;
11429   unsigned int i;
11430
11431   if (! do_dump)
11432     return;
11433
11434   initialise_dumps_byname ();
11435
11436   for (i = 0, section = section_headers;
11437        i < elf_header.e_shnum && i < num_dump_sects;
11438        i++, section++)
11439     {
11440 #ifdef SUPPORT_DISASSEMBLY
11441       if (dump_sects[i] & DISASS_DUMP)
11442         disassemble_section (section, file);
11443 #endif
11444       if (dump_sects[i] & HEX_DUMP)
11445         dump_section_as_bytes (section, file, FALSE);
11446
11447       if (dump_sects[i] & RELOC_DUMP)
11448         dump_section_as_bytes (section, file, TRUE);
11449
11450       if (dump_sects[i] & STRING_DUMP)
11451         dump_section_as_strings (section, file);
11452
11453       if (dump_sects[i] & DEBUG_DUMP)
11454         display_debug_section (i, section, file);
11455     }
11456
11457   /* Check to see if the user requested a
11458      dump of a section that does not exist.  */
11459   while (i++ < num_dump_sects)
11460     if (dump_sects[i])
11461       warn (_("Section %d was not dumped because it does not exist!\n"), i);
11462 }
11463
11464 static void
11465 process_mips_fpe_exception (int mask)
11466 {
11467   if (mask)
11468     {
11469       int first = 1;
11470       if (mask & OEX_FPU_INEX)
11471         fputs ("INEX", stdout), first = 0;
11472       if (mask & OEX_FPU_UFLO)
11473         printf ("%sUFLO", first ? "" : "|"), first = 0;
11474       if (mask & OEX_FPU_OFLO)
11475         printf ("%sOFLO", first ? "" : "|"), first = 0;
11476       if (mask & OEX_FPU_DIV0)
11477         printf ("%sDIV0", first ? "" : "|"), first = 0;
11478       if (mask & OEX_FPU_INVAL)
11479         printf ("%sINVAL", first ? "" : "|");
11480     }
11481   else
11482     fputs ("0", stdout);
11483 }
11484
11485 /* Display's the value of TAG at location P.  If TAG is
11486    greater than 0 it is assumed to be an unknown tag, and
11487    a message is printed to this effect.  Otherwise it is
11488    assumed that a message has already been printed.
11489
11490    If the bottom bit of TAG is set it assumed to have a
11491    string value, otherwise it is assumed to have an integer
11492    value.
11493
11494    Returns an updated P pointing to the first unread byte
11495    beyond the end of TAG's value.
11496
11497    Reads at or beyond END will not be made.  */
11498
11499 static unsigned char *
11500 display_tag_value (int tag,
11501                    unsigned char * p,
11502                    const unsigned char * const end)
11503 {
11504   unsigned long val;
11505
11506   if (tag > 0)
11507     printf ("  Tag_unknown_%d: ", tag);
11508
11509   if (p >= end)
11510     {
11511       warn (_("corrupt tag\n"));
11512     }
11513   else if (tag & 1)
11514     {
11515       /* FIXME: we could read beyond END here.  */
11516       printf ("\"%s\"\n", p);
11517       p += strlen ((char *) p) + 1;
11518     }
11519   else
11520     {
11521       unsigned int len;
11522
11523       val = read_uleb128 (p, &len, end);
11524       p += len;
11525       printf ("%ld (0x%lx)\n", val, val);
11526     }
11527
11528   return p;
11529 }
11530
11531 /* ARM EABI attributes section.  */
11532 typedef struct
11533 {
11534   int tag;
11535   const char * name;
11536   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
11537   int type;
11538   const char ** table;
11539 } arm_attr_public_tag;
11540
11541 static const char * arm_attr_tag_CPU_arch[] =
11542   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11543    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11544 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11545 static const char * arm_attr_tag_THUMB_ISA_use[] =
11546   {"No", "Thumb-1", "Thumb-2"};
11547 static const char * arm_attr_tag_FP_arch[] =
11548   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11549    "FP for ARMv8"};
11550 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
11551 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
11552   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11553 static const char * arm_attr_tag_PCS_config[] =
11554   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11555    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11556 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11557   {"V6", "SB", "TLS", "Unused"};
11558 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11559   {"Absolute", "PC-relative", "SB-relative", "None"};
11560 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11561   {"Absolute", "PC-relative", "None"};
11562 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11563   {"None", "direct", "GOT-indirect"};
11564 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11565   {"None", "??? 1", "2", "??? 3", "4"};
11566 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11567 static const char * arm_attr_tag_ABI_FP_denormal[] =
11568   {"Unused", "Needed", "Sign only"};
11569 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11570 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11571 static const char * arm_attr_tag_ABI_FP_number_model[] =
11572   {"Unused", "Finite", "RTABI", "IEEE 754"};
11573 static const char * arm_attr_tag_ABI_enum_size[] =
11574   {"Unused", "small", "int", "forced to int"};
11575 static const char * arm_attr_tag_ABI_HardFP_use[] =
11576   {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11577 static const char * arm_attr_tag_ABI_VFP_args[] =
11578   {"AAPCS", "VFP registers", "custom"};
11579 static const char * arm_attr_tag_ABI_WMMX_args[] =
11580   {"AAPCS", "WMMX registers", "custom"};
11581 static const char * arm_attr_tag_ABI_optimization_goals[] =
11582   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11583     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11584 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11585   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11586     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11587 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
11588 static const char * arm_attr_tag_FP_HP_extension[] =
11589   {"Not Allowed", "Allowed"};
11590 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
11591   {"None", "IEEE 754", "Alternative Format"};
11592 static const char * arm_attr_tag_MPextension_use[] =
11593   {"Not Allowed", "Allowed"};
11594 static const char * arm_attr_tag_DIV_use[] =
11595   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11596     "Allowed in v7-A with integer division extension"};
11597 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11598 static const char * arm_attr_tag_Virtualization_use[] =
11599   {"Not Allowed", "TrustZone", "Virtualization Extensions",
11600     "TrustZone and Virtualization Extensions"};
11601 static const char * arm_attr_tag_MPextension_use_legacy[] =
11602   {"Not Allowed", "Allowed"};
11603
11604 #define LOOKUP(id, name) \
11605   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11606 static arm_attr_public_tag arm_attr_public_tags[] =
11607 {
11608   {4, "CPU_raw_name", 1, NULL},
11609   {5, "CPU_name", 1, NULL},
11610   LOOKUP(6, CPU_arch),
11611   {7, "CPU_arch_profile", 0, NULL},
11612   LOOKUP(8, ARM_ISA_use),
11613   LOOKUP(9, THUMB_ISA_use),
11614   LOOKUP(10, FP_arch),
11615   LOOKUP(11, WMMX_arch),
11616   LOOKUP(12, Advanced_SIMD_arch),
11617   LOOKUP(13, PCS_config),
11618   LOOKUP(14, ABI_PCS_R9_use),
11619   LOOKUP(15, ABI_PCS_RW_data),
11620   LOOKUP(16, ABI_PCS_RO_data),
11621   LOOKUP(17, ABI_PCS_GOT_use),
11622   LOOKUP(18, ABI_PCS_wchar_t),
11623   LOOKUP(19, ABI_FP_rounding),
11624   LOOKUP(20, ABI_FP_denormal),
11625   LOOKUP(21, ABI_FP_exceptions),
11626   LOOKUP(22, ABI_FP_user_exceptions),
11627   LOOKUP(23, ABI_FP_number_model),
11628   {24, "ABI_align_needed", 0, NULL},
11629   {25, "ABI_align_preserved", 0, NULL},
11630   LOOKUP(26, ABI_enum_size),
11631   LOOKUP(27, ABI_HardFP_use),
11632   LOOKUP(28, ABI_VFP_args),
11633   LOOKUP(29, ABI_WMMX_args),
11634   LOOKUP(30, ABI_optimization_goals),
11635   LOOKUP(31, ABI_FP_optimization_goals),
11636   {32, "compatibility", 0, NULL},
11637   LOOKUP(34, CPU_unaligned_access),
11638   LOOKUP(36, FP_HP_extension),
11639   LOOKUP(38, ABI_FP_16bit_format),
11640   LOOKUP(42, MPextension_use),
11641   LOOKUP(44, DIV_use),
11642   {64, "nodefaults", 0, NULL},
11643   {65, "also_compatible_with", 0, NULL},
11644   LOOKUP(66, T2EE_use),
11645   {67, "conformance", 1, NULL},
11646   LOOKUP(68, Virtualization_use),
11647   LOOKUP(70, MPextension_use_legacy)
11648 };
11649 #undef LOOKUP
11650
11651 static unsigned char *
11652 display_arm_attribute (unsigned char * p,
11653                        const unsigned char * const end)
11654 {
11655   int tag;
11656   unsigned int len;
11657   int val;
11658   arm_attr_public_tag * attr;
11659   unsigned i;
11660   int type;
11661
11662   tag = read_uleb128 (p, &len, end);
11663   p += len;
11664   attr = NULL;
11665   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11666     {
11667       if (arm_attr_public_tags[i].tag == tag)
11668         {
11669           attr = &arm_attr_public_tags[i];
11670           break;
11671         }
11672     }
11673
11674   if (attr)
11675     {
11676       printf ("  Tag_%s: ", attr->name);
11677       switch (attr->type)
11678         {
11679         case 0:
11680           switch (tag)
11681             {
11682             case 7: /* Tag_CPU_arch_profile.  */
11683               val = read_uleb128 (p, &len, end);
11684               p += len;
11685               switch (val)
11686                 {
11687                 case 0: printf (_("None\n")); break;
11688                 case 'A': printf (_("Application\n")); break;
11689                 case 'R': printf (_("Realtime\n")); break;
11690                 case 'M': printf (_("Microcontroller\n")); break;
11691                 case 'S': printf (_("Application or Realtime\n")); break;
11692                 default: printf ("??? (%d)\n", val); break;
11693                 }
11694               break;
11695
11696             case 24: /* Tag_align_needed.  */
11697               val = read_uleb128 (p, &len, end);
11698               p += len;
11699               switch (val)
11700                 {
11701                 case 0: printf (_("None\n")); break;
11702                 case 1: printf (_("8-byte\n")); break;
11703                 case 2: printf (_("4-byte\n")); break;
11704                 case 3: printf ("??? 3\n"); break;
11705                 default:
11706                   if (val <= 12)
11707                     printf (_("8-byte and up to %d-byte extended\n"),
11708                             1 << val);
11709                   else
11710                     printf ("??? (%d)\n", val);
11711                   break;
11712                 }
11713               break;
11714
11715             case 25: /* Tag_align_preserved.  */
11716               val = read_uleb128 (p, &len, end);
11717               p += len;
11718               switch (val)
11719                 {
11720                 case 0: printf (_("None\n")); break;
11721                 case 1: printf (_("8-byte, except leaf SP\n")); break;
11722                 case 2: printf (_("8-byte\n")); break;
11723                 case 3: printf ("??? 3\n"); break;
11724                 default:
11725                   if (val <= 12)
11726                     printf (_("8-byte and up to %d-byte extended\n"),
11727                             1 << val);
11728                   else
11729                     printf ("??? (%d)\n", val);
11730                   break;
11731                 }
11732               break;
11733
11734             case 32: /* Tag_compatibility.  */
11735               val = read_uleb128 (p, &len, end);
11736               p += len;
11737               printf (_("flag = %d, vendor = %s\n"), val, p);
11738               p += strlen ((char *) p) + 1;
11739               break;
11740
11741             case 64: /* Tag_nodefaults.  */
11742               p++;
11743               printf (_("True\n"));
11744               break;
11745
11746             case 65: /* Tag_also_compatible_with.  */
11747               val = read_uleb128 (p, &len, end);
11748               p += len;
11749               if (val == 6 /* Tag_CPU_arch.  */)
11750                 {
11751                   val = read_uleb128 (p, &len, end);
11752                   p += len;
11753                   if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
11754                     printf ("??? (%d)\n", val);
11755                   else
11756                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11757                 }
11758               else
11759                 printf ("???\n");
11760               while (*(p++) != '\0' /* NUL terminator.  */);
11761               break;
11762
11763             default:
11764               abort ();
11765             }
11766           return p;
11767
11768         case 1:
11769           return display_tag_value (-1, p, end);
11770         case 2:
11771           return display_tag_value (0, p, end);
11772
11773         default:
11774           assert (attr->type & 0x80);
11775           val = read_uleb128 (p, &len, end);
11776           p += len;
11777           type = attr->type & 0x7f;
11778           if (val >= type)
11779             printf ("??? (%d)\n", val);
11780           else
11781             printf ("%s\n", attr->table[val]);
11782           return p;
11783         }
11784     }
11785
11786   return display_tag_value (tag, p, end);
11787 }
11788
11789 static unsigned char *
11790 display_gnu_attribute (unsigned char * p,
11791                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
11792                        const unsigned char * const end)
11793 {
11794   int tag;
11795   unsigned int len;
11796   int val;
11797
11798   tag = read_uleb128 (p, &len, end);
11799   p += len;
11800
11801   /* Tag_compatibility is the only generic GNU attribute defined at
11802      present.  */
11803   if (tag == 32)
11804     {
11805       val = read_uleb128 (p, &len, end);
11806       p += len;
11807       if (p == end)
11808         {
11809           printf (_("flag = %d, vendor = <corrupt>\n"), val);
11810           warn (_("corrupt vendor attribute\n"));
11811         }
11812       else
11813         {
11814           printf (_("flag = %d, vendor = %s\n"), val, p);
11815           p += strlen ((char *) p) + 1;
11816         }
11817       return p;
11818     }
11819
11820   if ((tag & 2) == 0 && display_proc_gnu_attribute)
11821     return display_proc_gnu_attribute (p, tag, end);
11822
11823   return display_tag_value (tag, p, end);
11824 }
11825
11826 static unsigned char *
11827 display_power_gnu_attribute (unsigned char * p,
11828                              int tag,
11829                              const unsigned char * const end)
11830 {
11831   unsigned int len;
11832   int val;
11833
11834   if (tag == Tag_GNU_Power_ABI_FP)
11835     {
11836       val = read_uleb128 (p, &len, end);
11837       p += len;
11838       printf ("  Tag_GNU_Power_ABI_FP: ");
11839
11840       switch (val)
11841         {
11842         case 0:
11843           printf (_("Hard or soft float\n"));
11844           break;
11845         case 1:
11846           printf (_("Hard float\n"));
11847           break;
11848         case 2:
11849           printf (_("Soft float\n"));
11850           break;
11851         case 3:
11852           printf (_("Single-precision hard float\n"));
11853           break;
11854         default:
11855           printf ("??? (%d)\n", val);
11856           break;
11857         }
11858       return p;
11859    }
11860
11861   if (tag == Tag_GNU_Power_ABI_Vector)
11862     {
11863       val = read_uleb128 (p, &len, end);
11864       p += len;
11865       printf ("  Tag_GNU_Power_ABI_Vector: ");
11866       switch (val)
11867         {
11868         case 0:
11869           printf (_("Any\n"));
11870           break;
11871         case 1:
11872           printf (_("Generic\n"));
11873           break;
11874         case 2:
11875           printf ("AltiVec\n");
11876           break;
11877         case 3:
11878           printf ("SPE\n");
11879           break;
11880         default:
11881           printf ("??? (%d)\n", val);
11882           break;
11883         }
11884       return p;
11885    }
11886
11887   if (tag == Tag_GNU_Power_ABI_Struct_Return)
11888     {
11889       if (p == end)
11890         {
11891           warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
11892           return p;
11893         }
11894
11895       val = read_uleb128 (p, &len, end);
11896       p += len;
11897       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
11898       switch (val)
11899        {
11900        case 0:
11901          printf (_("Any\n"));
11902          break;
11903        case 1:
11904          printf ("r3/r4\n");
11905          break;
11906        case 2:
11907          printf (_("Memory\n"));
11908          break;
11909        default:
11910          printf ("??? (%d)\n", val);
11911          break;
11912        }
11913       return p;
11914     }
11915
11916   return display_tag_value (tag & 1, p, end);
11917 }
11918
11919 static void
11920 display_sparc_hwcaps (int mask)
11921 {
11922   if (mask)
11923     {
11924       int first = 1;
11925       if (mask & ELF_SPARC_HWCAP_MUL32)
11926         fputs ("mul32", stdout), first = 0;
11927       if (mask & ELF_SPARC_HWCAP_DIV32)
11928         printf ("%sdiv32", first ? "" : "|"), first = 0;
11929       if (mask & ELF_SPARC_HWCAP_FSMULD)
11930         printf ("%sfsmuld", first ? "" : "|"), first = 0;
11931       if (mask & ELF_SPARC_HWCAP_V8PLUS)
11932         printf ("%sv8plus", first ? "" : "|"), first = 0;
11933       if (mask & ELF_SPARC_HWCAP_POPC)
11934         printf ("%spopc", first ? "" : "|"), first = 0;
11935       if (mask & ELF_SPARC_HWCAP_VIS)
11936         printf ("%svis", first ? "" : "|"), first = 0;
11937       if (mask & ELF_SPARC_HWCAP_VIS2)
11938         printf ("%svis2", first ? "" : "|"), first = 0;
11939       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11940         printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11941       if (mask & ELF_SPARC_HWCAP_FMAF)
11942         printf ("%sfmaf", first ? "" : "|"), first = 0;
11943       if (mask & ELF_SPARC_HWCAP_VIS3)
11944         printf ("%svis3", first ? "" : "|"), first = 0;
11945       if (mask & ELF_SPARC_HWCAP_HPC)
11946         printf ("%shpc", first ? "" : "|"), first = 0;
11947       if (mask & ELF_SPARC_HWCAP_RANDOM)
11948         printf ("%srandom", first ? "" : "|"), first = 0;
11949       if (mask & ELF_SPARC_HWCAP_TRANS)
11950         printf ("%strans", first ? "" : "|"), first = 0;
11951       if (mask & ELF_SPARC_HWCAP_FJFMAU)
11952         printf ("%sfjfmau", first ? "" : "|"), first = 0;
11953       if (mask & ELF_SPARC_HWCAP_IMA)
11954         printf ("%sima", first ? "" : "|"), first = 0;
11955       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11956         printf ("%scspare", first ? "" : "|"), first = 0;
11957     }
11958   else
11959     fputc('0', stdout);
11960   fputc('\n', stdout);
11961 }
11962
11963 static unsigned char *
11964 display_sparc_gnu_attribute (unsigned char * p,
11965                              int tag,
11966                              const unsigned char * const end)
11967 {
11968   if (tag == Tag_GNU_Sparc_HWCAPS)
11969     {
11970       unsigned int len;
11971       int val;
11972
11973       val = read_uleb128 (p, &len, end);
11974       p += len;
11975       printf ("  Tag_GNU_Sparc_HWCAPS: ");
11976       display_sparc_hwcaps (val);
11977       return p;
11978    }
11979
11980   return display_tag_value (tag, p, end);
11981 }
11982
11983 static unsigned char *
11984 display_mips_gnu_attribute (unsigned char * p,
11985                             int tag,
11986                             const unsigned char * const end)
11987 {
11988   if (tag == Tag_GNU_MIPS_ABI_FP)
11989     {
11990       unsigned int len;
11991       int val;
11992
11993       val = read_uleb128 (p, &len, end);
11994       p += len;
11995       printf ("  Tag_GNU_MIPS_ABI_FP: ");
11996
11997       switch (val)
11998         {
11999         case Val_GNU_MIPS_ABI_FP_ANY:
12000           printf (_("Hard or soft float\n"));
12001           break;
12002         case Val_GNU_MIPS_ABI_FP_DOUBLE:
12003           printf (_("Hard float (double precision)\n"));
12004           break;
12005         case Val_GNU_MIPS_ABI_FP_SINGLE:
12006           printf (_("Hard float (single precision)\n"));
12007           break;
12008         case Val_GNU_MIPS_ABI_FP_SOFT:
12009           printf (_("Soft float\n"));
12010           break;
12011         case Val_GNU_MIPS_ABI_FP_64:
12012           printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
12013           break;
12014         default:
12015           printf ("??? (%d)\n", val);
12016           break;
12017         }
12018       return p;
12019    }
12020
12021   if (tag == Tag_GNU_MIPS_ABI_MSA)
12022     {
12023       unsigned int len;
12024       int val;
12025
12026       val = read_uleb128 (p, &len, end);
12027       p += len;
12028       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
12029
12030       switch (val)
12031         {
12032         case Val_GNU_MIPS_ABI_MSA_ANY:
12033           printf (_("Any MSA or not\n"));
12034           break;
12035         case Val_GNU_MIPS_ABI_MSA_128:
12036           printf (_("128-bit MSA\n"));
12037           break;
12038         default:
12039           printf ("??? (%d)\n", val);
12040           break;
12041         }
12042       return p;
12043     }
12044
12045   return display_tag_value (tag & 1, p, end);
12046 }
12047
12048 static unsigned char *
12049 display_tic6x_attribute (unsigned char * p,
12050                          const unsigned char * const end)
12051 {
12052   int tag;
12053   unsigned int len;
12054   int val;
12055
12056   tag = read_uleb128 (p, &len, end);
12057   p += len;
12058
12059   switch (tag)
12060     {
12061     case Tag_ISA:
12062       val = read_uleb128 (p, &len, end);
12063       p += len;
12064       printf ("  Tag_ISA: ");
12065
12066       switch (val)
12067         {
12068         case C6XABI_Tag_ISA_none:
12069           printf (_("None\n"));
12070           break;
12071         case C6XABI_Tag_ISA_C62X:
12072           printf ("C62x\n");
12073           break;
12074         case C6XABI_Tag_ISA_C67X:
12075           printf ("C67x\n");
12076           break;
12077         case C6XABI_Tag_ISA_C67XP:
12078           printf ("C67x+\n");
12079           break;
12080         case C6XABI_Tag_ISA_C64X:
12081           printf ("C64x\n");
12082           break;
12083         case C6XABI_Tag_ISA_C64XP:
12084           printf ("C64x+\n");
12085           break;
12086         case C6XABI_Tag_ISA_C674X:
12087           printf ("C674x\n");
12088           break;
12089         default:
12090           printf ("??? (%d)\n", val);
12091           break;
12092         }
12093       return p;
12094
12095     case Tag_ABI_wchar_t:
12096       val = read_uleb128 (p, &len, end);
12097       p += len;
12098       printf ("  Tag_ABI_wchar_t: ");
12099       switch (val)
12100         {
12101         case 0:
12102           printf (_("Not used\n"));
12103           break;
12104         case 1:
12105           printf (_("2 bytes\n"));
12106           break;
12107         case 2:
12108           printf (_("4 bytes\n"));
12109           break;
12110         default:
12111           printf ("??? (%d)\n", val);
12112           break;
12113         }
12114       return p;
12115
12116     case Tag_ABI_stack_align_needed:
12117       val = read_uleb128 (p, &len, end);
12118       p += len;
12119       printf ("  Tag_ABI_stack_align_needed: ");
12120       switch (val)
12121         {
12122         case 0:
12123           printf (_("8-byte\n"));
12124           break;
12125         case 1:
12126           printf (_("16-byte\n"));
12127           break;
12128         default:
12129           printf ("??? (%d)\n", val);
12130           break;
12131         }
12132       return p;
12133
12134     case Tag_ABI_stack_align_preserved:
12135       val = read_uleb128 (p, &len, end);
12136       p += len;
12137       printf ("  Tag_ABI_stack_align_preserved: ");
12138       switch (val)
12139         {
12140         case 0:
12141           printf (_("8-byte\n"));
12142           break;
12143         case 1:
12144           printf (_("16-byte\n"));
12145           break;
12146         default:
12147           printf ("??? (%d)\n", val);
12148           break;
12149         }
12150       return p;
12151
12152     case Tag_ABI_DSBT:
12153       val = read_uleb128 (p, &len, end);
12154       p += len;
12155       printf ("  Tag_ABI_DSBT: ");
12156       switch (val)
12157         {
12158         case 0:
12159           printf (_("DSBT addressing not used\n"));
12160           break;
12161         case 1:
12162           printf (_("DSBT addressing used\n"));
12163           break;
12164         default:
12165           printf ("??? (%d)\n", val);
12166           break;
12167         }
12168       return p;
12169
12170     case Tag_ABI_PID:
12171       val = read_uleb128 (p, &len, end);
12172       p += len;
12173       printf ("  Tag_ABI_PID: ");
12174       switch (val)
12175         {
12176         case 0:
12177           printf (_("Data addressing position-dependent\n"));
12178           break;
12179         case 1:
12180           printf (_("Data addressing position-independent, GOT near DP\n"));
12181           break;
12182         case 2:
12183           printf (_("Data addressing position-independent, GOT far from DP\n"));
12184           break;
12185         default:
12186           printf ("??? (%d)\n", val);
12187           break;
12188         }
12189       return p;
12190
12191     case Tag_ABI_PIC:
12192       val = read_uleb128 (p, &len, end);
12193       p += len;
12194       printf ("  Tag_ABI_PIC: ");
12195       switch (val)
12196         {
12197         case 0:
12198           printf (_("Code addressing position-dependent\n"));
12199           break;
12200         case 1:
12201           printf (_("Code addressing position-independent\n"));
12202           break;
12203         default:
12204           printf ("??? (%d)\n", val);
12205           break;
12206         }
12207       return p;
12208
12209     case Tag_ABI_array_object_alignment:
12210       val = read_uleb128 (p, &len, end);
12211       p += len;
12212       printf ("  Tag_ABI_array_object_alignment: ");
12213       switch (val)
12214         {
12215         case 0:
12216           printf (_("8-byte\n"));
12217           break;
12218         case 1:
12219           printf (_("4-byte\n"));
12220           break;
12221         case 2:
12222           printf (_("16-byte\n"));
12223           break;
12224         default:
12225           printf ("??? (%d)\n", val);
12226           break;
12227         }
12228       return p;
12229
12230     case Tag_ABI_array_object_align_expected:
12231       val = read_uleb128 (p, &len, end);
12232       p += len;
12233       printf ("  Tag_ABI_array_object_align_expected: ");
12234       switch (val)
12235         {
12236         case 0:
12237           printf (_("8-byte\n"));
12238           break;
12239         case 1:
12240           printf (_("4-byte\n"));
12241           break;
12242         case 2:
12243           printf (_("16-byte\n"));
12244           break;
12245         default:
12246           printf ("??? (%d)\n", val);
12247           break;
12248         }
12249       return p;
12250
12251     case Tag_ABI_compatibility:
12252       val = read_uleb128 (p, &len, end);
12253       p += len;
12254       printf ("  Tag_ABI_compatibility: ");
12255       printf (_("flag = %d, vendor = %s\n"), val, p);
12256       p += strlen ((char *) p) + 1;
12257       return p;
12258
12259     case Tag_ABI_conformance:
12260       printf ("  Tag_ABI_conformance: ");
12261       printf ("\"%s\"\n", p);
12262       p += strlen ((char *) p) + 1;
12263       return p;
12264     }
12265
12266   return display_tag_value (tag, p, end);
12267 }
12268
12269 static void
12270 display_raw_attribute (unsigned char * p, unsigned char * end)
12271 {
12272   unsigned long addr = 0;
12273   size_t bytes = end - p;
12274
12275   while (bytes)
12276     {
12277       int j;
12278       int k;
12279       int lbytes = (bytes > 16 ? 16 : bytes);
12280
12281       printf ("  0x%8.8lx ", addr);
12282
12283       for (j = 0; j < 16; j++)
12284         {
12285           if (j < lbytes)
12286             printf ("%2.2x", p[j]);
12287           else
12288             printf ("  ");
12289
12290           if ((j & 3) == 3)
12291             printf (" ");
12292         }
12293
12294       for (j = 0; j < lbytes; j++)
12295         {
12296           k = p[j];
12297           if (k >= ' ' && k < 0x7f)
12298             printf ("%c", k);
12299           else
12300             printf (".");
12301         }
12302
12303       putchar ('\n');
12304
12305       p  += lbytes;
12306       bytes -= lbytes;
12307       addr += lbytes;
12308     }
12309
12310   putchar ('\n');
12311 }
12312
12313 static unsigned char *
12314 display_msp430x_attribute (unsigned char * p,
12315                            const unsigned char * const end)
12316 {
12317   unsigned int len;
12318   int val;
12319   int tag;
12320
12321   tag = read_uleb128 (p, & len, end);
12322   p += len;
12323
12324   switch (tag)
12325     {
12326     case OFBA_MSPABI_Tag_ISA:
12327       val = read_uleb128 (p, &len, end);
12328       p += len;
12329       printf ("  Tag_ISA: ");
12330       switch (val)
12331         {
12332         case 0: printf (_("None\n")); break;
12333         case 1: printf (_("MSP430\n")); break;
12334         case 2: printf (_("MSP430X\n")); break;
12335         default: printf ("??? (%d)\n", val); break;
12336         }
12337       break;
12338
12339     case OFBA_MSPABI_Tag_Code_Model:
12340       val = read_uleb128 (p, &len, end);
12341       p += len;
12342       printf ("  Tag_Code_Model: ");
12343       switch (val)
12344         {
12345         case 0: printf (_("None\n")); break;
12346         case 1: printf (_("Small\n")); break;
12347         case 2: printf (_("Large\n")); break;
12348         default: printf ("??? (%d)\n", val); break;
12349         }
12350       break;
12351
12352     case OFBA_MSPABI_Tag_Data_Model:
12353       val = read_uleb128 (p, &len, end);
12354       p += len;
12355       printf ("  Tag_Data_Model: ");
12356       switch (val)
12357         {
12358         case 0: printf (_("None\n")); break;
12359         case 1: printf (_("Small\n")); break;
12360         case 2: printf (_("Large\n")); break;
12361         case 3: printf (_("Restricted Large\n")); break;
12362         default: printf ("??? (%d)\n", val); break;
12363         }
12364       break;
12365
12366     default:
12367       printf (_("  <unknown tag %d>: "), tag);
12368
12369       if (tag & 1)
12370         {
12371           printf ("\"%s\"\n", p);
12372           p += strlen ((char *) p) + 1;
12373         }
12374       else
12375         {
12376           val = read_uleb128 (p, &len, end);
12377           p += len;
12378           printf ("%d (0x%x)\n", val, val);
12379         }
12380       break;
12381    }
12382
12383   return p;
12384 }
12385
12386 static int
12387 process_attributes (FILE * file,
12388                     const char * public_name,
12389                     unsigned int proc_type,
12390                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
12391                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
12392 {
12393   Elf_Internal_Shdr * sect;
12394   unsigned char * contents;
12395   unsigned char * p;
12396   unsigned char * end;
12397   bfd_vma section_len;
12398   bfd_vma len;
12399   unsigned i;
12400
12401   /* Find the section header so that we get the size.  */
12402   for (i = 0, sect = section_headers;
12403        i < elf_header.e_shnum;
12404        i++, sect++)
12405     {
12406       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
12407         continue;
12408
12409       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
12410                                              sect->sh_size, _("attributes"));
12411       if (contents == NULL)
12412         continue;
12413
12414       p = contents;
12415       if (*p == 'A')
12416         {
12417           len = sect->sh_size - 1;
12418           p++;
12419
12420           while (len > 0)
12421             {
12422               int namelen;
12423               bfd_boolean public_section;
12424               bfd_boolean gnu_section;
12425
12426               section_len = byte_get (p, 4);
12427               p += 4;
12428
12429               if (section_len > len)
12430                 {
12431                   printf (_("ERROR: Bad section length (%d > %d)\n"),
12432                           (int) section_len, (int) len);
12433                   section_len = len;
12434                 }
12435
12436               len -= section_len;
12437               printf (_("Attribute Section: %s\n"), p);
12438
12439               if (public_name && streq ((char *) p, public_name))
12440                 public_section = TRUE;
12441               else
12442                 public_section = FALSE;
12443
12444               if (streq ((char *) p, "gnu"))
12445                 gnu_section = TRUE;
12446               else
12447                 gnu_section = FALSE;
12448
12449               namelen = strlen ((char *) p) + 1;
12450               p += namelen;
12451               section_len -= namelen + 4;
12452
12453               while (section_len > 0)
12454                 {
12455                   int tag = *(p++);
12456                   int val;
12457                   bfd_vma size;
12458
12459                   size = byte_get (p, 4);
12460                   if (size > section_len)
12461                     {
12462                       printf (_("ERROR: Bad subsection length (%d > %d)\n"),
12463                               (int) size, (int) section_len);
12464                       size = section_len;
12465                     }
12466
12467                   section_len -= size;
12468                   end = p + size - 1;
12469                   p += 4;
12470
12471                   switch (tag)
12472                     {
12473                     case 1:
12474                       printf (_("File Attributes\n"));
12475                       break;
12476                     case 2:
12477                       printf (_("Section Attributes:"));
12478                       goto do_numlist;
12479                     case 3:
12480                       printf (_("Symbol Attributes:"));
12481                     do_numlist:
12482                       for (;;)
12483                         {
12484                           unsigned int j;
12485
12486                           val = read_uleb128 (p, &j, end);
12487                           p += j;
12488                           if (val == 0)
12489                             break;
12490                           printf (" %d", val);
12491                         }
12492                       printf ("\n");
12493                       break;
12494                     default:
12495                       printf (_("Unknown tag: %d\n"), tag);
12496                       public_section = FALSE;
12497                       break;
12498                     }
12499
12500                   if (public_section)
12501                     {
12502                       while (p < end)
12503                         p = display_pub_attribute (p, end);
12504                     }
12505                   else if (gnu_section)
12506                     {
12507                       while (p < end)
12508                         p = display_gnu_attribute (p,
12509                                                    display_proc_gnu_attribute,
12510                                                    end);
12511                     }
12512                   else
12513                     {
12514                       printf (_("  Unknown section contexts\n"));
12515                       display_raw_attribute (p, end);
12516                       p = end;
12517                     }
12518                 }
12519             }
12520         }
12521       else
12522         printf (_("Unknown format '%c'\n"), *p);
12523
12524       free (contents);
12525     }
12526   return 1;
12527 }
12528
12529 static int
12530 process_arm_specific (FILE * file)
12531 {
12532   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
12533                              display_arm_attribute, NULL);
12534 }
12535
12536 static int
12537 process_power_specific (FILE * file)
12538 {
12539   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12540                              display_power_gnu_attribute);
12541 }
12542
12543 static int
12544 process_sparc_specific (FILE * file)
12545 {
12546   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12547                              display_sparc_gnu_attribute);
12548 }
12549
12550 static int
12551 process_tic6x_specific (FILE * file)
12552 {
12553   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
12554                              display_tic6x_attribute, NULL);
12555 }
12556
12557 static int
12558 process_msp430x_specific (FILE * file)
12559 {
12560   return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
12561                              display_msp430x_attribute, NULL);
12562 }
12563
12564 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12565    Print the Address, Access and Initial fields of an entry at VMA ADDR
12566    and return the VMA of the next entry.  */
12567
12568 static bfd_vma
12569 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12570 {
12571   printf ("  ");
12572   print_vma (addr, LONG_HEX);
12573   printf (" ");
12574   if (addr < pltgot + 0xfff0)
12575     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
12576   else
12577     printf ("%10s", "");
12578   printf (" ");
12579   if (data == NULL)
12580     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12581   else
12582     {
12583       bfd_vma entry;
12584
12585       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12586       print_vma (entry, LONG_HEX);
12587     }
12588   return addr + (is_32bit_elf ? 4 : 8);
12589 }
12590
12591 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12592    PLTGOT.  Print the Address and Initial fields of an entry at VMA
12593    ADDR and return the VMA of the next entry.  */
12594
12595 static bfd_vma
12596 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12597 {
12598   printf ("  ");
12599   print_vma (addr, LONG_HEX);
12600   printf (" ");
12601   if (data == NULL)
12602     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12603   else
12604     {
12605       bfd_vma entry;
12606
12607       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12608       print_vma (entry, LONG_HEX);
12609     }
12610   return addr + (is_32bit_elf ? 4 : 8);
12611 }
12612
12613 static int
12614 process_mips_specific (FILE * file)
12615 {
12616   Elf_Internal_Dyn * entry;
12617   size_t liblist_offset = 0;
12618   size_t liblistno = 0;
12619   size_t conflictsno = 0;
12620   size_t options_offset = 0;
12621   size_t conflicts_offset = 0;
12622   size_t pltrelsz = 0;
12623   size_t pltrel = 0;
12624   bfd_vma pltgot = 0;
12625   bfd_vma mips_pltgot = 0;
12626   bfd_vma jmprel = 0;
12627   bfd_vma local_gotno = 0;
12628   bfd_vma gotsym = 0;
12629   bfd_vma symtabno = 0;
12630
12631   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12632                       display_mips_gnu_attribute);
12633
12634   /* We have a lot of special sections.  Thanks SGI!  */
12635   if (dynamic_section == NULL)
12636     /* No information available.  */
12637     return 0;
12638
12639   for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
12640     switch (entry->d_tag)
12641       {
12642       case DT_MIPS_LIBLIST:
12643         liblist_offset
12644           = offset_from_vma (file, entry->d_un.d_val,
12645                              liblistno * sizeof (Elf32_External_Lib));
12646         break;
12647       case DT_MIPS_LIBLISTNO:
12648         liblistno = entry->d_un.d_val;
12649         break;
12650       case DT_MIPS_OPTIONS:
12651         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
12652         break;
12653       case DT_MIPS_CONFLICT:
12654         conflicts_offset
12655           = offset_from_vma (file, entry->d_un.d_val,
12656                              conflictsno * sizeof (Elf32_External_Conflict));
12657         break;
12658       case DT_MIPS_CONFLICTNO:
12659         conflictsno = entry->d_un.d_val;
12660         break;
12661       case DT_PLTGOT:
12662         pltgot = entry->d_un.d_ptr;
12663         break;
12664       case DT_MIPS_LOCAL_GOTNO:
12665         local_gotno = entry->d_un.d_val;
12666         break;
12667       case DT_MIPS_GOTSYM:
12668         gotsym = entry->d_un.d_val;
12669         break;
12670       case DT_MIPS_SYMTABNO:
12671         symtabno = entry->d_un.d_val;
12672         break;
12673       case DT_MIPS_PLTGOT:
12674         mips_pltgot = entry->d_un.d_ptr;
12675         break;
12676       case DT_PLTREL:
12677         pltrel = entry->d_un.d_val;
12678         break;
12679       case DT_PLTRELSZ:
12680         pltrelsz = entry->d_un.d_val;
12681         break;
12682       case DT_JMPREL:
12683         jmprel = entry->d_un.d_ptr;
12684         break;
12685       default:
12686         break;
12687       }
12688
12689   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
12690     {
12691       Elf32_External_Lib * elib;
12692       size_t cnt;
12693
12694       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
12695                                               liblistno,
12696                                               sizeof (Elf32_External_Lib),
12697                                               _("liblist section data"));
12698       if (elib)
12699         {
12700           printf (_("\nSection '.liblist' contains %lu entries:\n"),
12701                   (unsigned long) liblistno);
12702           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
12703                  stdout);
12704
12705           for (cnt = 0; cnt < liblistno; ++cnt)
12706             {
12707               Elf32_Lib liblist;
12708               time_t atime;
12709               char timebuf[20];
12710               struct tm * tmp;
12711
12712               liblist.l_name = BYTE_GET (elib[cnt].l_name);
12713               atime = BYTE_GET (elib[cnt].l_time_stamp);
12714               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12715               liblist.l_version = BYTE_GET (elib[cnt].l_version);
12716               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12717
12718               tmp = gmtime (&atime);
12719               snprintf (timebuf, sizeof (timebuf),
12720                         "%04u-%02u-%02uT%02u:%02u:%02u",
12721                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12722                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12723
12724               printf ("%3lu: ", (unsigned long) cnt);
12725               if (VALID_DYNAMIC_NAME (liblist.l_name))
12726                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
12727               else
12728                 printf (_("<corrupt: %9ld>"), liblist.l_name);
12729               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
12730                       liblist.l_version);
12731
12732               if (liblist.l_flags == 0)
12733                 puts (_(" NONE"));
12734               else
12735                 {
12736                   static const struct
12737                   {
12738                     const char * name;
12739                     int bit;
12740                   }
12741                   l_flags_vals[] =
12742                   {
12743                     { " EXACT_MATCH", LL_EXACT_MATCH },
12744                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
12745                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
12746                     { " EXPORTS", LL_EXPORTS },
12747                     { " DELAY_LOAD", LL_DELAY_LOAD },
12748                     { " DELTA", LL_DELTA }
12749                   };
12750                   int flags = liblist.l_flags;
12751                   size_t fcnt;
12752
12753                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
12754                     if ((flags & l_flags_vals[fcnt].bit) != 0)
12755                       {
12756                         fputs (l_flags_vals[fcnt].name, stdout);
12757                         flags ^= l_flags_vals[fcnt].bit;
12758                       }
12759                   if (flags != 0)
12760                     printf (" %#x", (unsigned int) flags);
12761
12762                   puts ("");
12763                 }
12764             }
12765
12766           free (elib);
12767         }
12768     }
12769
12770   if (options_offset != 0)
12771     {
12772       Elf_External_Options * eopt;
12773       Elf_Internal_Shdr * sect = section_headers;
12774       Elf_Internal_Options * iopt;
12775       Elf_Internal_Options * option;
12776       size_t offset;
12777       int cnt;
12778
12779       /* Find the section header so that we get the size.  */
12780       while (sect->sh_type != SHT_MIPS_OPTIONS)
12781         ++sect;
12782
12783       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
12784                                                 sect->sh_size, _("options"));
12785       if (eopt)
12786         {
12787           iopt = (Elf_Internal_Options *)
12788               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
12789           if (iopt == NULL)
12790             {
12791               error (_("Out of memory\n"));
12792               return 0;
12793             }
12794
12795           offset = cnt = 0;
12796           option = iopt;
12797
12798           while (offset < sect->sh_size)
12799             {
12800               Elf_External_Options * eoption;
12801
12802               eoption = (Elf_External_Options *) ((char *) eopt + offset);
12803
12804               option->kind = BYTE_GET (eoption->kind);
12805               option->size = BYTE_GET (eoption->size);
12806               option->section = BYTE_GET (eoption->section);
12807               option->info = BYTE_GET (eoption->info);
12808
12809               offset += option->size;
12810
12811               ++option;
12812               ++cnt;
12813             }
12814
12815           printf (_("\nSection '%s' contains %d entries:\n"),
12816                   SECTION_NAME (sect), cnt);
12817
12818           option = iopt;
12819
12820           while (cnt-- > 0)
12821             {
12822               size_t len;
12823
12824               switch (option->kind)
12825                 {
12826                 case ODK_NULL:
12827                   /* This shouldn't happen.  */
12828                   printf (" NULL       %d %lx", option->section, option->info);
12829                   break;
12830                 case ODK_REGINFO:
12831                   printf (" REGINFO    ");
12832                   if (elf_header.e_machine == EM_MIPS)
12833                     {
12834                       /* 32bit form.  */
12835                       Elf32_External_RegInfo * ereg;
12836                       Elf32_RegInfo reginfo;
12837
12838                       ereg = (Elf32_External_RegInfo *) (option + 1);
12839                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12840                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12841                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12842                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12843                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12844                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12845
12846                       printf ("GPR %08lx  GP 0x%lx\n",
12847                               reginfo.ri_gprmask,
12848                               (unsigned long) reginfo.ri_gp_value);
12849                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
12850                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12851                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12852                     }
12853                   else
12854                     {
12855                       /* 64 bit form.  */
12856                       Elf64_External_RegInfo * ereg;
12857                       Elf64_Internal_RegInfo reginfo;
12858
12859                       ereg = (Elf64_External_RegInfo *) (option + 1);
12860                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
12861                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12862                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12863                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12864                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12865                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
12866
12867                       printf ("GPR %08lx  GP 0x",
12868                               reginfo.ri_gprmask);
12869                       printf_vma (reginfo.ri_gp_value);
12870                       printf ("\n");
12871
12872                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
12873                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12874                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12875                     }
12876                   ++option;
12877                   continue;
12878                 case ODK_EXCEPTIONS:
12879                   fputs (" EXCEPTIONS fpe_min(", stdout);
12880                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12881                   fputs (") fpe_max(", stdout);
12882                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12883                   fputs (")", stdout);
12884
12885                   if (option->info & OEX_PAGE0)
12886                     fputs (" PAGE0", stdout);
12887                   if (option->info & OEX_SMM)
12888                     fputs (" SMM", stdout);
12889                   if (option->info & OEX_FPDBUG)
12890                     fputs (" FPDBUG", stdout);
12891                   if (option->info & OEX_DISMISS)
12892                     fputs (" DISMISS", stdout);
12893                   break;
12894                 case ODK_PAD:
12895                   fputs (" PAD       ", stdout);
12896                   if (option->info & OPAD_PREFIX)
12897                     fputs (" PREFIX", stdout);
12898                   if (option->info & OPAD_POSTFIX)
12899                     fputs (" POSTFIX", stdout);
12900                   if (option->info & OPAD_SYMBOL)
12901                     fputs (" SYMBOL", stdout);
12902                   break;
12903                 case ODK_HWPATCH:
12904                   fputs (" HWPATCH   ", stdout);
12905                   if (option->info & OHW_R4KEOP)
12906                     fputs (" R4KEOP", stdout);
12907                   if (option->info & OHW_R8KPFETCH)
12908                     fputs (" R8KPFETCH", stdout);
12909                   if (option->info & OHW_R5KEOP)
12910                     fputs (" R5KEOP", stdout);
12911                   if (option->info & OHW_R5KCVTL)
12912                     fputs (" R5KCVTL", stdout);
12913                   break;
12914                 case ODK_FILL:
12915                   fputs (" FILL       ", stdout);
12916                   /* XXX Print content of info word?  */
12917                   break;
12918                 case ODK_TAGS:
12919                   fputs (" TAGS       ", stdout);
12920                   /* XXX Print content of info word?  */
12921                   break;
12922                 case ODK_HWAND:
12923                   fputs (" HWAND     ", stdout);
12924                   if (option->info & OHWA0_R4KEOP_CHECKED)
12925                     fputs (" R4KEOP_CHECKED", stdout);
12926                   if (option->info & OHWA0_R4KEOP_CLEAN)
12927                     fputs (" R4KEOP_CLEAN", stdout);
12928                   break;
12929                 case ODK_HWOR:
12930                   fputs (" HWOR      ", stdout);
12931                   if (option->info & OHWA0_R4KEOP_CHECKED)
12932                     fputs (" R4KEOP_CHECKED", stdout);
12933                   if (option->info & OHWA0_R4KEOP_CLEAN)
12934                     fputs (" R4KEOP_CLEAN", stdout);
12935                   break;
12936                 case ODK_GP_GROUP:
12937                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
12938                           option->info & OGP_GROUP,
12939                           (option->info & OGP_SELF) >> 16);
12940                   break;
12941                 case ODK_IDENT:
12942                   printf (" IDENT     %#06lx  self-contained %#06lx",
12943                           option->info & OGP_GROUP,
12944                           (option->info & OGP_SELF) >> 16);
12945                   break;
12946                 default:
12947                   /* This shouldn't happen.  */
12948                   printf (" %3d ???     %d %lx",
12949                           option->kind, option->section, option->info);
12950                   break;
12951                 }
12952
12953               len = sizeof (* eopt);
12954               while (len < option->size)
12955                 if (((char *) option)[len] >= ' '
12956                     && ((char *) option)[len] < 0x7f)
12957                   printf ("%c", ((char *) option)[len++]);
12958                 else
12959                   printf ("\\%03o", ((char *) option)[len++]);
12960
12961               fputs ("\n", stdout);
12962               ++option;
12963             }
12964
12965           free (eopt);
12966         }
12967     }
12968
12969   if (conflicts_offset != 0 && conflictsno != 0)
12970     {
12971       Elf32_Conflict * iconf;
12972       size_t cnt;
12973
12974       if (dynamic_symbols == NULL)
12975         {
12976           error (_("conflict list found without a dynamic symbol table\n"));
12977           return 0;
12978         }
12979
12980       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
12981       if (iconf == NULL)
12982         {
12983           error (_("Out of memory\n"));
12984           return 0;
12985         }
12986
12987       if (is_32bit_elf)
12988         {
12989           Elf32_External_Conflict * econf32;
12990
12991           econf32 = (Elf32_External_Conflict *)
12992               get_data (NULL, file, conflicts_offset, conflictsno,
12993                         sizeof (* econf32), _("conflict"));
12994           if (!econf32)
12995             return 0;
12996
12997           for (cnt = 0; cnt < conflictsno; ++cnt)
12998             iconf[cnt] = BYTE_GET (econf32[cnt]);
12999
13000           free (econf32);
13001         }
13002       else
13003         {
13004           Elf64_External_Conflict * econf64;
13005
13006           econf64 = (Elf64_External_Conflict *)
13007               get_data (NULL, file, conflicts_offset, conflictsno,
13008                         sizeof (* econf64), _("conflict"));
13009           if (!econf64)
13010             return 0;
13011
13012           for (cnt = 0; cnt < conflictsno; ++cnt)
13013             iconf[cnt] = BYTE_GET (econf64[cnt]);
13014
13015           free (econf64);
13016         }
13017
13018       printf (_("\nSection '.conflict' contains %lu entries:\n"),
13019               (unsigned long) conflictsno);
13020       puts (_("  Num:    Index       Value  Name"));
13021
13022       for (cnt = 0; cnt < conflictsno; ++cnt)
13023         {
13024           Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
13025
13026           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
13027           print_vma (psym->st_value, FULL_HEX);
13028           putchar (' ');
13029           if (VALID_DYNAMIC_NAME (psym->st_name))
13030             print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
13031           else
13032             printf (_("<corrupt: %14ld>"), psym->st_name);
13033           putchar ('\n');
13034         }
13035
13036       free (iconf);
13037     }
13038
13039   if (pltgot != 0 && local_gotno != 0)
13040     {
13041       bfd_vma ent, local_end, global_end;
13042       size_t i, offset;
13043       unsigned char * data;
13044       int addr_size;
13045
13046       ent = pltgot;
13047       addr_size = (is_32bit_elf ? 4 : 8);
13048       local_end = pltgot + local_gotno * addr_size;
13049       global_end = local_end + (symtabno - gotsym) * addr_size;
13050
13051       offset = offset_from_vma (file, pltgot, global_end - pltgot);
13052       data = (unsigned char *) get_data (NULL, file, offset,
13053                                          global_end - pltgot, 1,
13054                                          _("Global Offset Table data"));
13055       if (data == NULL)
13056         return 0;
13057
13058       printf (_("\nPrimary GOT:\n"));
13059       printf (_(" Canonical gp value: "));
13060       print_vma (pltgot + 0x7ff0, LONG_HEX);
13061       printf ("\n\n");
13062
13063       printf (_(" Reserved entries:\n"));
13064       printf (_("  %*s %10s %*s Purpose\n"),
13065               addr_size * 2, _("Address"), _("Access"),
13066               addr_size * 2, _("Initial"));
13067       ent = print_mips_got_entry (data, pltgot, ent);
13068       printf (_(" Lazy resolver\n"));
13069       if (data
13070           && (byte_get (data + ent - pltgot, addr_size)
13071               >> (addr_size * 8 - 1)) != 0)
13072         {
13073           ent = print_mips_got_entry (data, pltgot, ent);
13074           printf (_(" Module pointer (GNU extension)\n"));
13075         }
13076       printf ("\n");
13077
13078       if (ent < local_end)
13079         {
13080           printf (_(" Local entries:\n"));
13081           printf ("  %*s %10s %*s\n",
13082                   addr_size * 2, _("Address"), _("Access"),
13083                   addr_size * 2, _("Initial"));
13084           while (ent < local_end)
13085             {
13086               ent = print_mips_got_entry (data, pltgot, ent);
13087               printf ("\n");
13088             }
13089           printf ("\n");
13090         }
13091
13092       if (gotsym < symtabno)
13093         {
13094           int sym_width;
13095
13096           printf (_(" Global entries:\n"));
13097           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
13098                   addr_size * 2, _("Address"),
13099                   _("Access"),
13100                   addr_size * 2, _("Initial"),
13101                   addr_size * 2, _("Sym.Val."),
13102                   _("Type"),
13103                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
13104                   _("Ndx"), _("Name"));
13105
13106           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
13107           for (i = gotsym; i < symtabno; i++)
13108             {
13109               Elf_Internal_Sym * psym;
13110
13111               psym = dynamic_symbols + i;
13112               ent = print_mips_got_entry (data, pltgot, ent);
13113               printf (" ");
13114               print_vma (psym->st_value, LONG_HEX);
13115               printf (" %-7s %3s ",
13116                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13117                       get_symbol_index_type (psym->st_shndx));
13118               if (VALID_DYNAMIC_NAME (psym->st_name))
13119                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13120               else
13121                 printf (_("<corrupt: %14ld>"), psym->st_name);
13122               printf ("\n");
13123             }
13124           printf ("\n");
13125         }
13126
13127       if (data)
13128         free (data);
13129     }
13130
13131   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
13132     {
13133       bfd_vma ent, end;
13134       size_t offset, rel_offset;
13135       unsigned long count, i;
13136       unsigned char * data;
13137       int addr_size, sym_width;
13138       Elf_Internal_Rela * rels;
13139
13140       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
13141       if (pltrel == DT_RELA)
13142         {
13143           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
13144             return 0;
13145         }
13146       else
13147         {
13148           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
13149             return 0;
13150         }
13151
13152       ent = mips_pltgot;
13153       addr_size = (is_32bit_elf ? 4 : 8);
13154       end = mips_pltgot + (2 + count) * addr_size;
13155
13156       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
13157       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
13158                                          1, _("Procedure Linkage Table data"));
13159       if (data == NULL)
13160         return 0;
13161
13162       printf ("\nPLT GOT:\n\n");
13163       printf (_(" Reserved entries:\n"));
13164       printf (_("  %*s %*s Purpose\n"),
13165               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
13166       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
13167       printf (_(" PLT lazy resolver\n"));
13168       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
13169       printf (_(" Module pointer\n"));
13170       printf ("\n");
13171
13172       printf (_(" Entries:\n"));
13173       printf ("  %*s %*s %*s %-7s %3s %s\n",
13174               addr_size * 2, _("Address"),
13175               addr_size * 2, _("Initial"),
13176               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
13177       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
13178       for (i = 0; i < count; i++)
13179         {
13180           Elf_Internal_Sym * psym;
13181
13182           psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
13183           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
13184           printf (" ");
13185           print_vma (psym->st_value, LONG_HEX);
13186           printf (" %-7s %3s ",
13187                   get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13188                   get_symbol_index_type (psym->st_shndx));
13189           if (VALID_DYNAMIC_NAME (psym->st_name))
13190             print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13191           else
13192             printf (_("<corrupt: %14ld>"), psym->st_name);
13193           printf ("\n");
13194         }
13195       printf ("\n");
13196
13197       if (data)
13198         free (data);
13199       free (rels);
13200     }
13201
13202   return 1;
13203 }
13204
13205 static int
13206 process_nds32_specific (FILE * file)
13207 {
13208   Elf_Internal_Shdr *sect = NULL;
13209
13210   sect = find_section (".nds32_e_flags");
13211   if (sect != NULL)
13212     {
13213       unsigned int *flag;
13214
13215       printf ("\nNDS32 elf flags section:\n");
13216       flag = get_data (NULL, file, sect->sh_offset, 1,
13217                        sect->sh_size, _("NDS32 elf flags section"));
13218
13219       switch ((*flag) & 0x3)
13220         {
13221         case 0:
13222           printf ("(VEC_SIZE):\tNo entry.\n");
13223           break;
13224         case 1:
13225           printf ("(VEC_SIZE):\t4 bytes\n");
13226           break;
13227         case 2:
13228           printf ("(VEC_SIZE):\t16 bytes\n");
13229           break;
13230         case 3:
13231           printf ("(VEC_SIZE):\treserved\n");
13232           break;
13233         }
13234     }
13235
13236   return TRUE;
13237 }
13238
13239 static int
13240 process_gnu_liblist (FILE * file)
13241 {
13242   Elf_Internal_Shdr * section;
13243   Elf_Internal_Shdr * string_sec;
13244   Elf32_External_Lib * elib;
13245   char * strtab;
13246   size_t strtab_size;
13247   size_t cnt;
13248   unsigned i;
13249
13250   if (! do_arch)
13251     return 0;
13252
13253   for (i = 0, section = section_headers;
13254        i < elf_header.e_shnum;
13255        i++, section++)
13256     {
13257       switch (section->sh_type)
13258         {
13259         case SHT_GNU_LIBLIST:
13260           if (section->sh_link >= elf_header.e_shnum)
13261             break;
13262
13263           elib = (Elf32_External_Lib *)
13264               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
13265                         _("liblist section data"));
13266
13267           if (elib == NULL)
13268             break;
13269           string_sec = section_headers + section->sh_link;
13270
13271           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
13272                                       string_sec->sh_size,
13273                                       _("liblist string table"));
13274           if (strtab == NULL
13275               || section->sh_entsize != sizeof (Elf32_External_Lib))
13276             {
13277               free (elib);
13278               free (strtab);
13279               break;
13280             }
13281           strtab_size = string_sec->sh_size;
13282
13283           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
13284                   SECTION_NAME (section),
13285                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
13286
13287           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
13288
13289           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
13290                ++cnt)
13291             {
13292               Elf32_Lib liblist;
13293               time_t atime;
13294               char timebuf[20];
13295               struct tm * tmp;
13296
13297               liblist.l_name = BYTE_GET (elib[cnt].l_name);
13298               atime = BYTE_GET (elib[cnt].l_time_stamp);
13299               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13300               liblist.l_version = BYTE_GET (elib[cnt].l_version);
13301               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13302
13303               tmp = gmtime (&atime);
13304               snprintf (timebuf, sizeof (timebuf),
13305                         "%04u-%02u-%02uT%02u:%02u:%02u",
13306                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13307                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
13308
13309               printf ("%3lu: ", (unsigned long) cnt);
13310               if (do_wide)
13311                 printf ("%-20s", liblist.l_name < strtab_size
13312                         ? strtab + liblist.l_name : _("<corrupt>"));
13313               else
13314                 printf ("%-20.20s", liblist.l_name < strtab_size
13315                         ? strtab + liblist.l_name : _("<corrupt>"));
13316               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
13317                       liblist.l_version, liblist.l_flags);
13318             }
13319
13320           free (elib);
13321           free (strtab);
13322         }
13323     }
13324
13325   return 1;
13326 }
13327
13328 static const char *
13329 get_note_type (unsigned e_type)
13330 {
13331   static char buff[64];
13332
13333   if (elf_header.e_type == ET_CORE)
13334     switch (e_type)
13335       {
13336       case NT_AUXV:
13337         return _("NT_AUXV (auxiliary vector)");
13338       case NT_PRSTATUS:
13339         return _("NT_PRSTATUS (prstatus structure)");
13340       case NT_FPREGSET:
13341         return _("NT_FPREGSET (floating point registers)");
13342       case NT_PRPSINFO:
13343         return _("NT_PRPSINFO (prpsinfo structure)");
13344       case NT_TASKSTRUCT:
13345         return _("NT_TASKSTRUCT (task structure)");
13346       case NT_PRXFPREG:
13347         return _("NT_PRXFPREG (user_xfpregs structure)");
13348       case NT_PPC_VMX:
13349         return _("NT_PPC_VMX (ppc Altivec registers)");
13350       case NT_PPC_VSX:
13351         return _("NT_PPC_VSX (ppc VSX registers)");
13352       case NT_386_TLS:
13353         return _("NT_386_TLS (x86 TLS information)");
13354       case NT_386_IOPERM:
13355         return _("NT_386_IOPERM (x86 I/O permissions)");
13356       case NT_X86_XSTATE:
13357         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
13358       case NT_S390_HIGH_GPRS:
13359         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
13360       case NT_S390_TIMER:
13361         return _("NT_S390_TIMER (s390 timer register)");
13362       case NT_S390_TODCMP:
13363         return _("NT_S390_TODCMP (s390 TOD comparator register)");
13364       case NT_S390_TODPREG:
13365         return _("NT_S390_TODPREG (s390 TOD programmable register)");
13366       case NT_S390_CTRS:
13367         return _("NT_S390_CTRS (s390 control registers)");
13368       case NT_S390_PREFIX:
13369         return _("NT_S390_PREFIX (s390 prefix register)");
13370       case NT_S390_LAST_BREAK:
13371         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
13372       case NT_S390_SYSTEM_CALL:
13373         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
13374       case NT_S390_TDB:
13375         return _("NT_S390_TDB (s390 transaction diagnostic block)");
13376       case NT_ARM_VFP:
13377         return _("NT_ARM_VFP (arm VFP registers)");
13378       case NT_ARM_TLS:
13379         return _("NT_ARM_TLS (AArch TLS registers)");
13380       case NT_ARM_HW_BREAK:
13381         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
13382       case NT_ARM_HW_WATCH:
13383         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
13384       case NT_PSTATUS:
13385         return _("NT_PSTATUS (pstatus structure)");
13386       case NT_FPREGS:
13387         return _("NT_FPREGS (floating point registers)");
13388       case NT_PSINFO:
13389         return _("NT_PSINFO (psinfo structure)");
13390       case NT_LWPSTATUS:
13391         return _("NT_LWPSTATUS (lwpstatus_t structure)");
13392       case NT_LWPSINFO:
13393         return _("NT_LWPSINFO (lwpsinfo_t structure)");
13394       case NT_WIN32PSTATUS:
13395         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
13396       case NT_SIGINFO:
13397         return _("NT_SIGINFO (siginfo_t data)");
13398       case NT_FILE:
13399         return _("NT_FILE (mapped files)");
13400       default:
13401         break;
13402       }
13403   else
13404     switch (e_type)
13405       {
13406       case NT_VERSION:
13407         return _("NT_VERSION (version)");
13408       case NT_ARCH:
13409         return _("NT_ARCH (architecture)");
13410       default:
13411         break;
13412       }
13413
13414   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13415   return buff;
13416 }
13417
13418 static int
13419 print_core_note (Elf_Internal_Note *pnote)
13420 {
13421   unsigned int addr_size = is_32bit_elf ? 4 : 8;
13422   bfd_vma count, page_size;
13423   unsigned char *descdata, *filenames, *descend;
13424
13425   if (pnote->type != NT_FILE)
13426     return 1;
13427
13428 #ifndef BFD64
13429   if (!is_32bit_elf)
13430     {
13431       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
13432       /* Still "successful".  */
13433       return 1;
13434     }
13435 #endif
13436
13437   if (pnote->descsz < 2 * addr_size)
13438     {
13439       printf (_("    Malformed note - too short for header\n"));
13440       return 0;
13441     }
13442
13443   descdata = (unsigned char *) pnote->descdata;
13444   descend = descdata + pnote->descsz;
13445
13446   if (descdata[pnote->descsz - 1] != '\0')
13447     {
13448       printf (_("    Malformed note - does not end with \\0\n"));
13449       return 0;
13450     }
13451
13452   count = byte_get (descdata, addr_size);
13453   descdata += addr_size;
13454
13455   page_size = byte_get (descdata, addr_size);
13456   descdata += addr_size;
13457
13458   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
13459     {
13460       printf (_("    Malformed note - too short for supplied file count\n"));
13461       return 0;
13462     }
13463
13464   printf (_("    Page size: "));
13465   print_vma (page_size, DEC);
13466   printf ("\n");
13467
13468   printf (_("    %*s%*s%*s\n"),
13469           (int) (2 + 2 * addr_size), _("Start"),
13470           (int) (4 + 2 * addr_size), _("End"),
13471           (int) (4 + 2 * addr_size), _("Page Offset"));
13472   filenames = descdata + count * 3 * addr_size;
13473   while (--count > 0)
13474     {
13475       bfd_vma start, end, file_ofs;
13476
13477       if (filenames == descend)
13478         {
13479           printf (_("    Malformed note - filenames end too early\n"));
13480           return 0;
13481         }
13482
13483       start = byte_get (descdata, addr_size);
13484       descdata += addr_size;
13485       end = byte_get (descdata, addr_size);
13486       descdata += addr_size;
13487       file_ofs = byte_get (descdata, addr_size);
13488       descdata += addr_size;
13489
13490       printf ("    ");
13491       print_vma (start, FULL_HEX);
13492       printf ("  ");
13493       print_vma (end, FULL_HEX);
13494       printf ("  ");
13495       print_vma (file_ofs, FULL_HEX);
13496       printf ("\n        %s\n", filenames);
13497
13498       filenames += 1 + strlen ((char *) filenames);
13499     }
13500
13501   return 1;
13502 }
13503
13504 static const char *
13505 get_gnu_elf_note_type (unsigned e_type)
13506 {
13507   static char buff[64];
13508
13509   switch (e_type)
13510     {
13511     case NT_GNU_ABI_TAG:
13512       return _("NT_GNU_ABI_TAG (ABI version tag)");
13513     case NT_GNU_HWCAP:
13514       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
13515     case NT_GNU_BUILD_ID:
13516       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
13517     case NT_GNU_GOLD_VERSION:
13518       return _("NT_GNU_GOLD_VERSION (gold version)");
13519     default:
13520       break;
13521     }
13522
13523   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13524   return buff;
13525 }
13526
13527 static int
13528 print_gnu_note (Elf_Internal_Note *pnote)
13529 {
13530   switch (pnote->type)
13531     {
13532     case NT_GNU_BUILD_ID:
13533       {
13534         unsigned long i;
13535
13536         printf (_("    Build ID: "));
13537         for (i = 0; i < pnote->descsz; ++i)
13538           printf ("%02x", pnote->descdata[i] & 0xff);
13539         printf ("\n");
13540       }
13541       break;
13542
13543     case NT_GNU_ABI_TAG:
13544       {
13545         unsigned long os, major, minor, subminor;
13546         const char *osname;
13547
13548         os = byte_get ((unsigned char *) pnote->descdata, 4);
13549         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
13550         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
13551         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
13552
13553         switch (os)
13554           {
13555           case GNU_ABI_TAG_LINUX:
13556             osname = "Linux";
13557             break;
13558           case GNU_ABI_TAG_HURD:
13559             osname = "Hurd";
13560             break;
13561           case GNU_ABI_TAG_SOLARIS:
13562             osname = "Solaris";
13563             break;
13564           case GNU_ABI_TAG_FREEBSD:
13565             osname = "FreeBSD";
13566             break;
13567           case GNU_ABI_TAG_NETBSD:
13568             osname = "NetBSD";
13569             break;
13570           default:
13571             osname = "Unknown";
13572             break;
13573           }
13574
13575         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
13576                 major, minor, subminor);
13577       }
13578       break;
13579     }
13580
13581   return 1;
13582 }
13583
13584 static const char *
13585 get_netbsd_elfcore_note_type (unsigned e_type)
13586 {
13587   static char buff[64];
13588
13589   if (e_type == NT_NETBSDCORE_PROCINFO)
13590     {
13591       /* NetBSD core "procinfo" structure.  */
13592       return _("NetBSD procinfo structure");
13593     }
13594
13595   /* As of Jan 2002 there are no other machine-independent notes
13596      defined for NetBSD core files.  If the note type is less
13597      than the start of the machine-dependent note types, we don't
13598      understand it.  */
13599
13600   if (e_type < NT_NETBSDCORE_FIRSTMACH)
13601     {
13602       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13603       return buff;
13604     }
13605
13606   switch (elf_header.e_machine)
13607     {
13608     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13609        and PT_GETFPREGS == mach+2.  */
13610
13611     case EM_OLD_ALPHA:
13612     case EM_ALPHA:
13613     case EM_SPARC:
13614     case EM_SPARC32PLUS:
13615     case EM_SPARCV9:
13616       switch (e_type)
13617         {
13618         case NT_NETBSDCORE_FIRSTMACH + 0:
13619           return _("PT_GETREGS (reg structure)");
13620         case NT_NETBSDCORE_FIRSTMACH + 2:
13621           return _("PT_GETFPREGS (fpreg structure)");
13622         default:
13623           break;
13624         }
13625       break;
13626
13627     /* On all other arch's, PT_GETREGS == mach+1 and
13628        PT_GETFPREGS == mach+3.  */
13629     default:
13630       switch (e_type)
13631         {
13632         case NT_NETBSDCORE_FIRSTMACH + 1:
13633           return _("PT_GETREGS (reg structure)");
13634         case NT_NETBSDCORE_FIRSTMACH + 3:
13635           return _("PT_GETFPREGS (fpreg structure)");
13636         default:
13637           break;
13638         }
13639     }
13640
13641   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
13642             e_type - NT_NETBSDCORE_FIRSTMACH);
13643   return buff;
13644 }
13645
13646 static const char *
13647 get_stapsdt_note_type (unsigned e_type)
13648 {
13649   static char buff[64];
13650
13651   switch (e_type)
13652     {
13653     case NT_STAPSDT:
13654       return _("NT_STAPSDT (SystemTap probe descriptors)");
13655
13656     default:
13657       break;
13658     }
13659
13660   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13661   return buff;
13662 }
13663
13664 static int
13665 print_stapsdt_note (Elf_Internal_Note *pnote)
13666 {
13667   int addr_size = is_32bit_elf ? 4 : 8;
13668   char *data = pnote->descdata;
13669   char *data_end = pnote->descdata + pnote->descsz;
13670   bfd_vma pc, base_addr, semaphore;
13671   char *provider, *probe, *arg_fmt;
13672
13673   pc = byte_get ((unsigned char *) data, addr_size);
13674   data += addr_size;
13675   base_addr = byte_get ((unsigned char *) data, addr_size);
13676   data += addr_size;
13677   semaphore = byte_get ((unsigned char *) data, addr_size);
13678   data += addr_size;
13679
13680   provider = data;
13681   data += strlen (data) + 1;
13682   probe = data;
13683   data += strlen (data) + 1;
13684   arg_fmt = data;
13685   data += strlen (data) + 1;
13686
13687   printf (_("    Provider: %s\n"), provider);
13688   printf (_("    Name: %s\n"), probe);
13689   printf (_("    Location: "));
13690   print_vma (pc, FULL_HEX);
13691   printf (_(", Base: "));
13692   print_vma (base_addr, FULL_HEX);
13693   printf (_(", Semaphore: "));
13694   print_vma (semaphore, FULL_HEX);
13695   printf ("\n");
13696   printf (_("    Arguments: %s\n"), arg_fmt);
13697
13698   return data == data_end;
13699 }
13700
13701 static const char *
13702 get_ia64_vms_note_type (unsigned e_type)
13703 {
13704   static char buff[64];
13705
13706   switch (e_type)
13707     {
13708     case NT_VMS_MHD:
13709       return _("NT_VMS_MHD (module header)");
13710     case NT_VMS_LNM:
13711       return _("NT_VMS_LNM (language name)");
13712     case NT_VMS_SRC:
13713       return _("NT_VMS_SRC (source files)");
13714     case NT_VMS_TITLE:
13715       return "NT_VMS_TITLE";
13716     case NT_VMS_EIDC:
13717       return _("NT_VMS_EIDC (consistency check)");
13718     case NT_VMS_FPMODE:
13719       return _("NT_VMS_FPMODE (FP mode)");
13720     case NT_VMS_LINKTIME:
13721       return "NT_VMS_LINKTIME";
13722     case NT_VMS_IMGNAM:
13723       return _("NT_VMS_IMGNAM (image name)");
13724     case NT_VMS_IMGID:
13725       return _("NT_VMS_IMGID (image id)");
13726     case NT_VMS_LINKID:
13727       return _("NT_VMS_LINKID (link id)");
13728     case NT_VMS_IMGBID:
13729       return _("NT_VMS_IMGBID (build id)");
13730     case NT_VMS_GSTNAM:
13731       return _("NT_VMS_GSTNAM (sym table name)");
13732     case NT_VMS_ORIG_DYN:
13733       return "NT_VMS_ORIG_DYN";
13734     case NT_VMS_PATCHTIME:
13735       return "NT_VMS_PATCHTIME";
13736     default:
13737       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13738       return buff;
13739     }
13740 }
13741
13742 static int
13743 print_ia64_vms_note (Elf_Internal_Note * pnote)
13744 {
13745   switch (pnote->type)
13746     {
13747     case NT_VMS_MHD:
13748       if (pnote->descsz > 36)
13749         {
13750           size_t l = strlen (pnote->descdata + 34);
13751           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
13752           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
13753           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
13754           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
13755         }
13756       else
13757         printf (_("    Invalid size\n"));
13758       break;
13759     case NT_VMS_LNM:
13760       printf (_("   Language: %s\n"), pnote->descdata);
13761       break;
13762 #ifdef BFD64
13763     case NT_VMS_FPMODE:
13764       printf (_("   Floating Point mode: "));
13765       printf ("0x%016" BFD_VMA_FMT "x\n",
13766               (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
13767       break;
13768     case NT_VMS_LINKTIME:
13769       printf (_("   Link time: "));
13770       print_vms_time
13771         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13772       printf ("\n");
13773       break;
13774     case NT_VMS_PATCHTIME:
13775       printf (_("   Patch time: "));
13776       print_vms_time
13777         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13778       printf ("\n");
13779       break;
13780     case NT_VMS_ORIG_DYN:
13781       printf (_("   Major id: %u,  minor id: %u\n"),
13782               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
13783               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
13784       printf (_("   Last modified  : "));
13785       print_vms_time
13786         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
13787       printf (_("\n   Link flags  : "));
13788       printf ("0x%016" BFD_VMA_FMT "x\n",
13789               (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
13790       printf (_("   Header flags: 0x%08x\n"),
13791               (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
13792       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
13793       break;
13794 #endif
13795     case NT_VMS_IMGNAM:
13796       printf (_("    Image name: %s\n"), pnote->descdata);
13797       break;
13798     case NT_VMS_GSTNAM:
13799       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
13800       break;
13801     case NT_VMS_IMGID:
13802       printf (_("    Image id: %s\n"), pnote->descdata);
13803       break;
13804     case NT_VMS_LINKID:
13805       printf (_("    Linker id: %s\n"), pnote->descdata);
13806       break;
13807     default:
13808       break;
13809     }
13810   return 1;
13811 }
13812
13813 /* Note that by the ELF standard, the name field is already null byte
13814    terminated, and namesz includes the terminating null byte.
13815    I.E. the value of namesz for the name "FSF" is 4.
13816
13817    If the value of namesz is zero, there is no name present.  */
13818 static int
13819 process_note (Elf_Internal_Note * pnote)
13820 {
13821   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
13822   const char * nt;
13823
13824   if (pnote->namesz == 0)
13825     /* If there is no note name, then use the default set of
13826        note type strings.  */
13827     nt = get_note_type (pnote->type);
13828
13829   else if (const_strneq (pnote->namedata, "GNU"))
13830     /* GNU-specific object file notes.  */
13831     nt = get_gnu_elf_note_type (pnote->type);
13832
13833   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
13834     /* NetBSD-specific core file notes.  */
13835     nt = get_netbsd_elfcore_note_type (pnote->type);
13836
13837   else if (strneq (pnote->namedata, "SPU/", 4))
13838     {
13839       /* SPU-specific core file notes.  */
13840       nt = pnote->namedata + 4;
13841       name = "SPU";
13842     }
13843
13844   else if (const_strneq (pnote->namedata, "IPF/VMS"))
13845     /* VMS/ia64-specific file notes.  */
13846     nt = get_ia64_vms_note_type (pnote->type);
13847
13848   else if (const_strneq (pnote->namedata, "stapsdt"))
13849     nt = get_stapsdt_note_type (pnote->type);
13850
13851   else
13852     /* Don't recognize this note name; just use the default set of
13853        note type strings.  */
13854     nt = get_note_type (pnote->type);
13855
13856   printf ("  %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
13857
13858   if (const_strneq (pnote->namedata, "IPF/VMS"))
13859     return print_ia64_vms_note (pnote);
13860   else if (const_strneq (pnote->namedata, "GNU"))
13861     return print_gnu_note (pnote);
13862   else if (const_strneq (pnote->namedata, "stapsdt"))
13863     return print_stapsdt_note (pnote);
13864   else if (const_strneq (pnote->namedata, "CORE"))
13865     return print_core_note (pnote);
13866   else
13867     return 1;
13868 }
13869
13870
13871 static int
13872 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
13873 {
13874   Elf_External_Note * pnotes;
13875   Elf_External_Note * external;
13876   int res = 1;
13877
13878   if (length <= 0)
13879     return 0;
13880
13881   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
13882                                            _("notes"));
13883   if (pnotes == NULL)
13884     return 0;
13885
13886   external = pnotes;
13887
13888   printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
13889           (unsigned long) offset, (unsigned long) length);
13890   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
13891
13892   while ((char *) external < (char *) pnotes + length)
13893     {
13894       Elf_Internal_Note inote;
13895       size_t min_notesz;
13896       char *next;
13897       char * temp = NULL;
13898       size_t data_remaining = ((char *) pnotes + length) - (char *) external;
13899
13900       if (!is_ia64_vms ())
13901         {
13902           /* PR binutils/15191
13903              Make sure that there is enough data to read.  */
13904           min_notesz = offsetof (Elf_External_Note, name);
13905           if (data_remaining < min_notesz)
13906             {
13907               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13908                     (int) data_remaining);
13909               break;
13910             }
13911           inote.type     = BYTE_GET (external->type);
13912           inote.namesz   = BYTE_GET (external->namesz);
13913           inote.namedata = external->name;
13914           inote.descsz   = BYTE_GET (external->descsz);
13915           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
13916           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
13917           next = inote.descdata + align_power (inote.descsz, 2);
13918         }
13919       else
13920         {
13921           Elf64_External_VMS_Note *vms_external;
13922
13923           /* PR binutils/15191
13924              Make sure that there is enough data to read.  */
13925           min_notesz = offsetof (Elf64_External_VMS_Note, name);
13926           if (data_remaining < min_notesz)
13927             {
13928               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13929                     (int) data_remaining);
13930               break;
13931             }
13932
13933           vms_external = (Elf64_External_VMS_Note *) external;
13934           inote.type     = BYTE_GET (vms_external->type);
13935           inote.namesz   = BYTE_GET (vms_external->namesz);
13936           inote.namedata = vms_external->name;
13937           inote.descsz   = BYTE_GET (vms_external->descsz);
13938           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
13939           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
13940           next = inote.descdata + align_power (inote.descsz, 3);
13941         }
13942
13943       if (inote.descdata < (char *) external + min_notesz
13944           || next < (char *) external + min_notesz
13945           || data_remaining < (size_t)(next - (char *) external))
13946         {
13947           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
13948                 (unsigned long) ((char *) external - (char *) pnotes));
13949           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
13950                 inote.type, inote.namesz, inote.descsz);
13951           break;
13952         }
13953
13954       external = (Elf_External_Note *) next;
13955
13956       /* Verify that name is null terminated.  It appears that at least
13957          one version of Linux (RedHat 6.0) generates corefiles that don't
13958          comply with the ELF spec by failing to include the null byte in
13959          namesz.  */
13960       if (inote.namedata[inote.namesz - 1] != '\0')
13961         {
13962           temp = (char *) malloc (inote.namesz + 1);
13963
13964           if (temp == NULL)
13965             {
13966               error (_("Out of memory\n"));
13967               res = 0;
13968               break;
13969             }
13970
13971           strncpy (temp, inote.namedata, inote.namesz);
13972           temp[inote.namesz] = 0;
13973
13974           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
13975           inote.namedata = temp;
13976         }
13977
13978       res &= process_note (& inote);
13979
13980       if (temp != NULL)
13981         {
13982           free (temp);
13983           temp = NULL;
13984         }
13985     }
13986
13987   free (pnotes);
13988
13989   return res;
13990 }
13991
13992 static int
13993 process_corefile_note_segments (FILE * file)
13994 {
13995   Elf_Internal_Phdr * segment;
13996   unsigned int i;
13997   int res = 1;
13998
13999   if (! get_program_headers (file))
14000       return 0;
14001
14002   for (i = 0, segment = program_headers;
14003        i < elf_header.e_phnum;
14004        i++, segment++)
14005     {
14006       if (segment->p_type == PT_NOTE)
14007         res &= process_corefile_note_segment (file,
14008                                               (bfd_vma) segment->p_offset,
14009                                               (bfd_vma) segment->p_filesz);
14010     }
14011
14012   return res;
14013 }
14014
14015 static int
14016 process_note_sections (FILE * file)
14017 {
14018   Elf_Internal_Shdr * section;
14019   unsigned long i;
14020   int res = 1;
14021
14022   for (i = 0, section = section_headers;
14023        i < elf_header.e_shnum && section != NULL;
14024        i++, section++)
14025     if (section->sh_type == SHT_NOTE)
14026       res &= process_corefile_note_segment (file,
14027                                             (bfd_vma) section->sh_offset,
14028                                             (bfd_vma) section->sh_size);
14029
14030   return res;
14031 }
14032
14033 static int
14034 process_notes (FILE * file)
14035 {
14036   /* If we have not been asked to display the notes then do nothing.  */
14037   if (! do_notes)
14038     return 1;
14039
14040   if (elf_header.e_type != ET_CORE)
14041     return process_note_sections (file);
14042
14043   /* No program headers means no NOTE segment.  */
14044   if (elf_header.e_phnum > 0)
14045     return process_corefile_note_segments (file);
14046
14047   printf (_("No note segments present in the core file.\n"));
14048   return 1;
14049 }
14050
14051 static int
14052 process_arch_specific (FILE * file)
14053 {
14054   if (! do_arch)
14055     return 1;
14056
14057   switch (elf_header.e_machine)
14058     {
14059     case EM_ARM:
14060       return process_arm_specific (file);
14061     case EM_MIPS:
14062     case EM_MIPS_RS3_LE:
14063       return process_mips_specific (file);
14064       break;
14065     case EM_NDS32:
14066       return process_nds32_specific (file);
14067       break;
14068     case EM_PPC:
14069       return process_power_specific (file);
14070       break;
14071     case EM_SPARC:
14072     case EM_SPARC32PLUS:
14073     case EM_SPARCV9:
14074       return process_sparc_specific (file);
14075       break;
14076     case EM_TI_C6000:
14077       return process_tic6x_specific (file);
14078       break;
14079     case EM_MSP430:
14080       return process_msp430x_specific (file);
14081     default:
14082       break;
14083     }
14084   return 1;
14085 }
14086
14087 static int
14088 get_file_header (FILE * file)
14089 {
14090   /* Read in the identity array.  */
14091   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
14092     return 0;
14093
14094   /* Determine how to read the rest of the header.  */
14095   switch (elf_header.e_ident[EI_DATA])
14096     {
14097     default: /* fall through */
14098     case ELFDATANONE: /* fall through */
14099     case ELFDATA2LSB:
14100       byte_get = byte_get_little_endian;
14101       byte_put = byte_put_little_endian;
14102       break;
14103     case ELFDATA2MSB:
14104       byte_get = byte_get_big_endian;
14105       byte_put = byte_put_big_endian;
14106       break;
14107     }
14108
14109   /* For now we only support 32 bit and 64 bit ELF files.  */
14110   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
14111
14112   /* Read in the rest of the header.  */
14113   if (is_32bit_elf)
14114     {
14115       Elf32_External_Ehdr ehdr32;
14116
14117       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
14118         return 0;
14119
14120       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
14121       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
14122       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
14123       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
14124       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
14125       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
14126       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
14127       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
14128       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
14129       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
14130       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
14131       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
14132       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
14133     }
14134   else
14135     {
14136       Elf64_External_Ehdr ehdr64;
14137
14138       /* If we have been compiled with sizeof (bfd_vma) == 4, then
14139          we will not be able to cope with the 64bit data found in
14140          64 ELF files.  Detect this now and abort before we start
14141          overwriting things.  */
14142       if (sizeof (bfd_vma) < 8)
14143         {
14144           error (_("This instance of readelf has been built without support for a\n\
14145 64 bit data type and so it cannot read 64 bit ELF files.\n"));
14146           return 0;
14147         }
14148
14149       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
14150         return 0;
14151
14152       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
14153       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
14154       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
14155       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
14156       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
14157       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
14158       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
14159       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
14160       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
14161       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
14162       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
14163       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
14164       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
14165     }
14166
14167   if (elf_header.e_shoff)
14168     {
14169       /* There may be some extensions in the first section header.  Don't
14170          bomb if we can't read it.  */
14171       if (is_32bit_elf)
14172         get_32bit_section_headers (file, 1);
14173       else
14174         get_64bit_section_headers (file, 1);
14175     }
14176
14177   return 1;
14178 }
14179
14180 /* Process one ELF object file according to the command line options.
14181    This file may actually be stored in an archive.  The file is
14182    positioned at the start of the ELF object.  */
14183
14184 static int
14185 process_object (char * file_name, FILE * file)
14186 {
14187   unsigned int i;
14188
14189   if (! get_file_header (file))
14190     {
14191       error (_("%s: Failed to read file header\n"), file_name);
14192       return 1;
14193     }
14194
14195   /* Initialise per file variables.  */
14196   for (i = ARRAY_SIZE (version_info); i--;)
14197     version_info[i] = 0;
14198
14199   for (i = ARRAY_SIZE (dynamic_info); i--;)
14200     dynamic_info[i] = 0;
14201   dynamic_info_DT_GNU_HASH = 0;
14202
14203   /* Process the file.  */
14204   if (show_name)
14205     printf (_("\nFile: %s\n"), file_name);
14206
14207   /* Initialise the dump_sects array from the cmdline_dump_sects array.
14208      Note we do this even if cmdline_dump_sects is empty because we
14209      must make sure that the dump_sets array is zeroed out before each
14210      object file is processed.  */
14211   if (num_dump_sects > num_cmdline_dump_sects)
14212     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
14213
14214   if (num_cmdline_dump_sects > 0)
14215     {
14216       if (num_dump_sects == 0)
14217         /* A sneaky way of allocating the dump_sects array.  */
14218         request_dump_bynumber (num_cmdline_dump_sects, 0);
14219
14220       assert (num_dump_sects >= num_cmdline_dump_sects);
14221       memcpy (dump_sects, cmdline_dump_sects,
14222               num_cmdline_dump_sects * sizeof (* dump_sects));
14223     }
14224
14225   if (! process_file_header ())
14226     return 1;
14227
14228   if (! process_section_headers (file))
14229     {
14230       /* Without loaded section headers we cannot process lots of
14231          things.  */
14232       do_unwind = do_version = do_dump = do_arch = 0;
14233
14234       if (! do_using_dynamic)
14235         do_syms = do_dyn_syms = do_reloc = 0;
14236     }
14237
14238   if (! process_section_groups (file))
14239     {
14240       /* Without loaded section groups we cannot process unwind.  */
14241       do_unwind = 0;
14242     }
14243
14244   if (process_program_headers (file))
14245     process_dynamic_section (file);
14246
14247   process_relocs (file);
14248
14249   process_unwind (file);
14250
14251   process_symbol_table (file);
14252
14253   process_syminfo (file);
14254
14255   process_version_sections (file);
14256
14257   process_section_contents (file);
14258
14259   process_notes (file);
14260
14261   process_gnu_liblist (file);
14262
14263   process_arch_specific (file);
14264
14265   if (program_headers)
14266     {
14267       free (program_headers);
14268       program_headers = NULL;
14269     }
14270
14271   if (section_headers)
14272     {
14273       free (section_headers);
14274       section_headers = NULL;
14275     }
14276
14277   if (string_table)
14278     {
14279       free (string_table);
14280       string_table = NULL;
14281       string_table_length = 0;
14282     }
14283
14284   if (dynamic_strings)
14285     {
14286       free (dynamic_strings);
14287       dynamic_strings = NULL;
14288       dynamic_strings_length = 0;
14289     }
14290
14291   if (dynamic_symbols)
14292     {
14293       free (dynamic_symbols);
14294       dynamic_symbols = NULL;
14295       num_dynamic_syms = 0;
14296     }
14297
14298   if (dynamic_syminfo)
14299     {
14300       free (dynamic_syminfo);
14301       dynamic_syminfo = NULL;
14302     }
14303
14304   if (dynamic_section)
14305     {
14306       free (dynamic_section);
14307       dynamic_section = NULL;
14308     }
14309
14310   if (section_headers_groups)
14311     {
14312       free (section_headers_groups);
14313       section_headers_groups = NULL;
14314     }
14315
14316   if (section_groups)
14317     {
14318       struct group_list * g;
14319       struct group_list * next;
14320
14321       for (i = 0; i < group_count; i++)
14322         {
14323           for (g = section_groups [i].root; g != NULL; g = next)
14324             {
14325               next = g->next;
14326               free (g);
14327             }
14328         }
14329
14330       free (section_groups);
14331       section_groups = NULL;
14332     }
14333
14334   free_debug_memory ();
14335
14336   return 0;
14337 }
14338
14339 /* Process an ELF archive.
14340    On entry the file is positioned just after the ARMAG string.  */
14341
14342 static int
14343 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
14344 {
14345   struct archive_info arch;
14346   struct archive_info nested_arch;
14347   size_t got;
14348   int ret;
14349
14350   show_name = 1;
14351
14352   /* The ARCH structure is used to hold information about this archive.  */
14353   arch.file_name = NULL;
14354   arch.file = NULL;
14355   arch.index_array = NULL;
14356   arch.sym_table = NULL;
14357   arch.longnames = NULL;
14358
14359   /* The NESTED_ARCH structure is used as a single-item cache of information
14360      about a nested archive (when members of a thin archive reside within
14361      another regular archive file).  */
14362   nested_arch.file_name = NULL;
14363   nested_arch.file = NULL;
14364   nested_arch.index_array = NULL;
14365   nested_arch.sym_table = NULL;
14366   nested_arch.longnames = NULL;
14367
14368   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
14369     {
14370       ret = 1;
14371       goto out;
14372     }
14373
14374   if (do_archive_index)
14375     {
14376       if (arch.sym_table == NULL)
14377         error (_("%s: unable to dump the index as none was found\n"), file_name);
14378       else
14379         {
14380           unsigned int i, l;
14381           unsigned long current_pos;
14382
14383           printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
14384                   file_name, (long) arch.index_num, arch.sym_size);
14385           current_pos = ftell (file);
14386
14387           for (i = l = 0; i < arch.index_num; i++)
14388             {
14389               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
14390                 {
14391                   char * member_name;
14392
14393                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
14394
14395                   if (member_name != NULL)
14396                     {
14397                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
14398
14399                       if (qualified_name != NULL)
14400                         {
14401                           printf (_("Contents of binary %s at offset "), qualified_name);
14402                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
14403                           putchar ('\n');
14404                           free (qualified_name);
14405                         }
14406                     }
14407                 }
14408
14409               if (l >= arch.sym_size)
14410                 {
14411                   error (_("%s: end of the symbol table reached before the end of the index\n"),
14412                          file_name);
14413                   break;
14414                 }
14415               printf ("\t%s\n", arch.sym_table + l);
14416               l += strlen (arch.sym_table + l) + 1;
14417             }
14418
14419           if (arch.uses_64bit_indicies)
14420             l = (l + 7) & ~ 7;
14421           else
14422             l += l & 1;
14423
14424           if (l < arch.sym_size)
14425             error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
14426                    file_name, arch.sym_size - l);
14427
14428           if (fseek (file, current_pos, SEEK_SET) != 0)
14429             {
14430               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
14431               ret = 1;
14432               goto out;
14433             }
14434         }
14435
14436       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
14437           && !do_segments && !do_header && !do_dump && !do_version
14438           && !do_histogram && !do_debugging && !do_arch && !do_notes
14439           && !do_section_groups && !do_dyn_syms)
14440         {
14441           ret = 0; /* Archive index only.  */
14442           goto out;
14443         }
14444     }
14445
14446   ret = 0;
14447
14448   while (1)
14449     {
14450       char * name;
14451       size_t namelen;
14452       char * qualified_name;
14453
14454       /* Read the next archive header.  */
14455       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
14456         {
14457           error (_("%s: failed to seek to next archive header\n"), file_name);
14458           return 1;
14459         }
14460       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
14461       if (got != sizeof arch.arhdr)
14462         {
14463           if (got == 0)
14464             break;
14465           error (_("%s: failed to read archive header\n"), file_name);
14466           ret = 1;
14467           break;
14468         }
14469       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
14470         {
14471           error (_("%s: did not find a valid archive header\n"), arch.file_name);
14472           ret = 1;
14473           break;
14474         }
14475
14476       arch.next_arhdr_offset += sizeof arch.arhdr;
14477
14478       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
14479       if (archive_file_size & 01)
14480         ++archive_file_size;
14481
14482       name = get_archive_member_name (&arch, &nested_arch);
14483       if (name == NULL)
14484         {
14485           error (_("%s: bad archive file name\n"), file_name);
14486           ret = 1;
14487           break;
14488         }
14489       namelen = strlen (name);
14490
14491       qualified_name = make_qualified_name (&arch, &nested_arch, name);
14492       if (qualified_name == NULL)
14493         {
14494           error (_("%s: bad archive file name\n"), file_name);
14495           ret = 1;
14496           break;
14497         }
14498
14499       if (is_thin_archive && arch.nested_member_origin == 0)
14500         {
14501           /* This is a proxy for an external member of a thin archive.  */
14502           FILE * member_file;
14503           char * member_file_name = adjust_relative_path (file_name, name, namelen);
14504           if (member_file_name == NULL)
14505             {
14506               ret = 1;
14507               break;
14508             }
14509
14510           member_file = fopen (member_file_name, "rb");
14511           if (member_file == NULL)
14512             {
14513               error (_("Input file '%s' is not readable.\n"), member_file_name);
14514               free (member_file_name);
14515               ret = 1;
14516               break;
14517             }
14518
14519           archive_file_offset = arch.nested_member_origin;
14520
14521           ret |= process_object (qualified_name, member_file);
14522
14523           fclose (member_file);
14524           free (member_file_name);
14525         }
14526       else if (is_thin_archive)
14527         {
14528           /* PR 15140: Allow for corrupt thin archives.  */
14529           if (nested_arch.file == NULL)
14530             {
14531               error (_("%s: contains corrupt thin archive: %s\n"),
14532                      file_name, name);
14533               ret = 1;
14534               break;
14535             }
14536
14537           /* This is a proxy for a member of a nested archive.  */
14538           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
14539
14540           /* The nested archive file will have been opened and setup by
14541              get_archive_member_name.  */
14542           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
14543             {
14544               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
14545               ret = 1;
14546               break;
14547             }
14548
14549           ret |= process_object (qualified_name, nested_arch.file);
14550         }
14551       else
14552         {
14553           archive_file_offset = arch.next_arhdr_offset;
14554           arch.next_arhdr_offset += archive_file_size;
14555
14556           ret |= process_object (qualified_name, file);
14557         }
14558
14559       if (dump_sects != NULL)
14560         {
14561           free (dump_sects);
14562           dump_sects = NULL;
14563           num_dump_sects = 0;
14564         }
14565
14566       free (qualified_name);
14567     }
14568
14569  out:
14570   if (nested_arch.file != NULL)
14571     fclose (nested_arch.file);
14572   release_archive (&nested_arch);
14573   release_archive (&arch);
14574
14575   return ret;
14576 }
14577
14578 static int
14579 process_file (char * file_name)
14580 {
14581   FILE * file;
14582   struct stat statbuf;
14583   char armag[SARMAG];
14584   int ret;
14585
14586   if (stat (file_name, &statbuf) < 0)
14587     {
14588       if (errno == ENOENT)
14589         error (_("'%s': No such file\n"), file_name);
14590       else
14591         error (_("Could not locate '%s'.  System error message: %s\n"),
14592                file_name, strerror (errno));
14593       return 1;
14594     }
14595
14596   if (! S_ISREG (statbuf.st_mode))
14597     {
14598       error (_("'%s' is not an ordinary file\n"), file_name);
14599       return 1;
14600     }
14601
14602   file = fopen (file_name, "rb");
14603   if (file == NULL)
14604     {
14605       error (_("Input file '%s' is not readable.\n"), file_name);
14606       return 1;
14607     }
14608
14609   if (fread (armag, SARMAG, 1, file) != 1)
14610     {
14611       error (_("%s: Failed to read file's magic number\n"), file_name);
14612       fclose (file);
14613       return 1;
14614     }
14615
14616   if (memcmp (armag, ARMAG, SARMAG) == 0)
14617     ret = process_archive (file_name, file, FALSE);
14618   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
14619     ret = process_archive (file_name, file, TRUE);
14620   else
14621     {
14622       if (do_archive_index)
14623         error (_("File %s is not an archive so its index cannot be displayed.\n"),
14624                file_name);
14625
14626       rewind (file);
14627       archive_file_size = archive_file_offset = 0;
14628       ret = process_object (file_name, file);
14629     }
14630
14631   fclose (file);
14632
14633   return ret;
14634 }
14635
14636 #ifdef SUPPORT_DISASSEMBLY
14637 /* Needed by the i386 disassembler.  For extra credit, someone could
14638    fix this so that we insert symbolic addresses here, esp for GOT/PLT
14639    symbols.  */
14640
14641 void
14642 print_address (unsigned int addr, FILE * outfile)
14643 {
14644   fprintf (outfile,"0x%8.8x", addr);
14645 }
14646
14647 /* Needed by the i386 disassembler.  */
14648 void
14649 db_task_printsym (unsigned int addr)
14650 {
14651   print_address (addr, stderr);
14652 }
14653 #endif
14654
14655 int
14656 main (int argc, char ** argv)
14657 {
14658   int err;
14659
14660 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14661   setlocale (LC_MESSAGES, "");
14662 #endif
14663 #if defined (HAVE_SETLOCALE)
14664   setlocale (LC_CTYPE, "");
14665 #endif
14666   bindtextdomain (PACKAGE, LOCALEDIR);
14667   textdomain (PACKAGE);
14668
14669   expandargv (&argc, &argv);
14670
14671   parse_args (argc, argv);
14672
14673   if (num_dump_sects > 0)
14674     {
14675       /* Make a copy of the dump_sects array.  */
14676       cmdline_dump_sects = (dump_type *)
14677           malloc (num_dump_sects * sizeof (* dump_sects));
14678       if (cmdline_dump_sects == NULL)
14679         error (_("Out of memory allocating dump request table.\n"));
14680       else
14681         {
14682           memcpy (cmdline_dump_sects, dump_sects,
14683                   num_dump_sects * sizeof (* dump_sects));
14684           num_cmdline_dump_sects = num_dump_sects;
14685         }
14686     }
14687
14688   if (optind < (argc - 1))
14689     show_name = 1;
14690
14691   err = 0;
14692   while (optind < argc)
14693     err |= process_file (argv[optind++]);
14694
14695   if (dump_sects != NULL)
14696     free (dump_sects);
14697   if (cmdline_dump_sects != NULL)
14698     free (cmdline_dump_sects);
14699
14700   return err;
14701 }