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/nios2.h"
 135 #include "elf/or32.h"
 136 #include "elf/pj.h"
 137 #include "elf/ppc.h"
 138 #include "elf/ppc64.h"
 139 #include "elf/rl78.h"
 140 #include "elf/rx.h"
 141 #include "elf/s390.h"
 142 #include "elf/score.h"
 143 #include "elf/sh.h"
 144 #include "elf/sparc.h"
 145 #include "elf/spu.h"
 146 #include "elf/tic6x.h"
 147 #include "elf/tilegx.h"
 148 #include "elf/tilepro.h"
 149 #include "elf/v850.h"
 150 #include "elf/vax.h"
 151 #include "elf/x86-64.h"
 152 #include "elf/xc16x.h"
 153 #include "elf/xgate.h"
 154 #include "elf/xstormy16.h"
 155 #include "elf/xtensa.h"
 156
 157 #include "getopt.h"
 158 #include "libiberty.h"
 159 #include "safe-ctype.h"
 160 #include "filenames.h"
 161
 162 #ifndef offsetof
 163 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 164 #endif
 165
 166 char * program_name = "readelf";
 167 static long archive_file_offset;
 168 static unsigned long archive_file_size;
 169 static unsigned long dynamic_addr;
 170 static bfd_size_type dynamic_size;
 171 static unsigned int dynamic_nent;
 172 static char * dynamic_strings;
 173 static unsigned long dynamic_strings_length;
 174 static char * string_table;
 175 static unsigned long string_table_length;
 176 static unsigned long num_dynamic_syms;
 177 static Elf_Internal_Sym * dynamic_symbols;
 178 static Elf_Internal_Syminfo * dynamic_syminfo;
 179 static unsigned long dynamic_syminfo_offset;
 180 static unsigned int dynamic_syminfo_nent;
 181 static char program_interpreter[PATH_MAX];
 182 static bfd_vma dynamic_info[DT_ENCODING];
 183 static bfd_vma dynamic_info_DT_GNU_HASH;
 184 static bfd_vma version_info[16];
 185 static Elf_Internal_Ehdr elf_header;
 186 static Elf_Internal_Shdr * section_headers;
 187 static Elf_Internal_Phdr * program_headers;
 188 static Elf_Internal_Dyn *  dynamic_section;
 189 static Elf_Internal_Shdr * symtab_shndx_hdr;
 190 static int show_name;
 191 static int do_dynamic;
 192 static int do_syms;
 193 static int do_dyn_syms;
 194 static int do_reloc;
 195 static int do_sections;
 196 static int do_section_groups;
 197 static int do_section_details;
 198 static int do_segments;
 199 static int do_unwind;
 200 static int do_using_dynamic;
 201 static int do_header;
 202 static int do_dump;
 203 static int do_version;
 204 static int do_histogram;
 205 static int do_debugging;
 206 static int do_arch;
 207 static int do_notes;
 208 static int do_archive_index;
 209 static int is_32bit_elf;
 210
 211 struct group_list
 212 {
 213   struct group_list * next;
 214   unsigned int section_index;
 215 };
 216
 217 struct group
 218 {
 219   struct group_list * root;
 220   unsigned int group_index;
 221 };
 222
 223 static size_t group_count;
 224 static struct group * section_groups;
 225 static struct group ** section_headers_groups;
 226
 227
 228 /* Flag bits indicating particular types of dump.  */
 229 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 230 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 231 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 232 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 233 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 234
 235 typedef unsigned char dump_type;
 236
 237 /* A linked list of the section names for which dumps were requested.  */
 238 struct dump_list_entry
 239 {
 240   char * name;
 241   dump_type type;
 242   struct dump_list_entry * next;
 243 };
 244 static struct dump_list_entry * dump_sects_byname;
 245
 246 /* A dynamic array of flags indicating for which sections a dump
 247    has been requested via command line switches.  */
 248 static dump_type *   cmdline_dump_sects = NULL;
 249 static unsigned int  num_cmdline_dump_sects = 0;
 250
 251 /* A dynamic array of flags indicating for which sections a dump of
 252    some kind has been requested.  It is reset on a per-object file
 253    basis and then initialised from the cmdline_dump_sects array,
 254    the results of interpreting the -w switch, and the
 255    dump_sects_byname list.  */
 256 static dump_type *   dump_sects = NULL;
 257 static unsigned int  num_dump_sects = 0;
 258
 259
 260 /* How to print a vma value.  */
 261 typedef enum print_mode
 262 {
 263   HEX,
 264   DEC,
 265   DEC_5,
 266   UNSIGNED,
 267   PREFIX_HEX,
 268   FULL_HEX,
 269   LONG_HEX
 270 }
 271 print_mode;
 272
 273 #define UNKNOWN -1
 274
 275 #define SECTION_NAME(X)                                         \
 276   ((X) == NULL ? _("<none>")                                    \
 277    : string_table == NULL ? _("<no-name>")                      \
 278    : ((X)->sh_name >= string_table_length ? _("<corrupt>")      \
 279   : string_table + (X)->sh_name))
 280
 281 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 282
 283 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 284   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 285    : get_64bit_elf_symbols (file, section, sym_count))
 286
 287 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 288 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 289    already been called and verified that the string exists.  */
 290 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 291
 292 #define REMOVE_ARCH_BITS(ADDR)                  \
 293   do                                            \
 294     {                                           \
 295       if (elf_header.e_machine == EM_ARM)       \
 296         (ADDR) &= ~1;                           \
 297     }                                           \
 298   while (0)
 299 \f
 300 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
 301    Put the retrieved data into VAR, if it is not NULL.  Otherwise allocate a buffer
 302    using malloc and fill that.  In either case return the pointer to the start of
 303    the retrieved data or NULL if something went wrong.  If something does go wrong
 304    emit an error message using REASON as part of the context.  */
 305
 306 static void *
 307 get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
 308           const char * reason)
 309 {
 310   void * mvar;
 311
 312   if (size == 0 || nmemb == 0)
 313     return NULL;
 314
 315   if (fseek (file, archive_file_offset + offset, SEEK_SET))
 316     {
 317       error (_("Unable to seek to 0x%lx for %s\n"),
 318              (unsigned long) archive_file_offset + offset, reason);
 319       return NULL;
 320     }
 321
 322   mvar = var;
 323   if (mvar == NULL)
 324     {
 325       /* Check for overflow.  */
 326       if (nmemb < (~(size_t) 0 - 1) / size)
 327         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 328         mvar = malloc (size * nmemb + 1);
 329
 330       if (mvar == NULL)
 331         {
 332           error (_("Out of memory allocating 0x%lx bytes for %s\n"),
 333                  (unsigned long)(size * nmemb), reason);
 334           return NULL;
 335         }
 336
 337       ((char *) mvar)[size * nmemb] = '\0';
 338     }
 339
 340   if (fread (mvar, size, nmemb, file) != nmemb)
 341     {
 342       error (_("Unable to read in 0x%lx bytes of %s\n"),
 343              (unsigned long)(size * nmemb), reason);
 344       if (mvar != var)
 345         free (mvar);
 346       return NULL;
 347     }
 348
 349   return mvar;
 350 }
 351
 352 /* Print a VMA value.  */
 353
 354 static int
 355 print_vma (bfd_vma vma, print_mode mode)
 356 {
 357   int nc = 0;
 358
 359   switch (mode)
 360     {
 361     case FULL_HEX:
 362       nc = printf ("0x");
 363       /* Drop through.  */
 364
 365     case LONG_HEX:
 366 #ifdef BFD64
 367       if (is_32bit_elf)
 368         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 369 #endif
 370       printf_vma (vma);
 371       return nc + 16;
 372
 373     case DEC_5:
 374       if (vma <= 99999)
 375         return printf ("%5" BFD_VMA_FMT "d", vma);
 376       /* Drop through.  */
 377
 378     case PREFIX_HEX:
 379       nc = printf ("0x");
 380       /* Drop through.  */
 381
 382     case HEX:
 383       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 384
 385     case DEC:
 386       return printf ("%" BFD_VMA_FMT "d", vma);
 387
 388     case UNSIGNED:
 389       return printf ("%" BFD_VMA_FMT "u", vma);
 390     }
 391   return 0;
 392 }
 393
 394 /* Display a symbol on stdout.  Handles the display of control characters and
 395    multibye characters (assuming the host environment supports them).
 396
 397    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 398
 399    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 400    padding as necessary.
 401
 402    Returns the number of emitted characters.  */
 403
 404 static unsigned int
 405 print_symbol (int width, const char *symbol)
 406 {
 407   bfd_boolean extra_padding = FALSE;
 408   int num_printed = 0;
 409 #ifdef HAVE_MBSTATE_T
 410   mbstate_t state;
 411 #endif
 412   int width_remaining;
 413
 414   if (width < 0)
 415     {
 416       /* Keep the width positive.  This also helps.  */
 417       width = - width;
 418       extra_padding = TRUE;
 419     }
 420
 421   if (do_wide)
 422     /* Set the remaining width to a very large value.
 423        This simplifies the code below.  */
 424     width_remaining = INT_MAX;
 425   else
 426     width_remaining = width;
 427
 428 #ifdef HAVE_MBSTATE_T
 429   /* Initialise the multibyte conversion state.  */
 430   memset (& state, 0, sizeof (state));
 431 #endif
 432
 433   while (width_remaining)
 434     {
 435       size_t  n;
 436       const char c = *symbol++;
 437
 438       if (c == 0)
 439         break;
 440
 441       /* Do not print control characters directly as they can affect terminal
 442          settings.  Such characters usually appear in the names generated
 443          by the assembler for local labels.  */
 444       if (ISCNTRL (c))
 445         {
 446           if (width_remaining < 2)
 447             break;
 448
 449           printf ("^%c", c + 0x40);
 450           width_remaining -= 2;
 451           num_printed += 2;
 452         }
 453       else if (ISPRINT (c))
 454         {
 455           putchar (c);
 456           width_remaining --;
 457           num_printed ++;
 458         }
 459       else
 460         {
 461 #ifdef HAVE_MBSTATE_T
 462           wchar_t w;
 463 #endif
 464           /* Let printf do the hard work of displaying multibyte characters.  */
 465           printf ("%.1s", symbol - 1);
 466           width_remaining --;
 467           num_printed ++;
 468
 469 #ifdef HAVE_MBSTATE_T
 470           /* Try to find out how many bytes made up the character that was
 471              just printed.  Advance the symbol pointer past the bytes that
 472              were displayed.  */
 473           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 474 #else
 475           n = 1;
 476 #endif
 477           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 478             symbol += (n - 1);
 479         }
 480     }
 481
 482   if (extra_padding && num_printed < width)
 483     {
 484       /* Fill in the remaining spaces.  */
 485       printf ("%-*s", width - num_printed, " ");
 486       num_printed = width;
 487     }
 488
 489   return num_printed;
 490 }
 491
 492 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 493
 494 static Elf_Internal_Shdr *
 495 find_section (const char * name)
 496 {
 497   unsigned int i;
 498
 499   for (i = 0; i < elf_header.e_shnum; i++)
 500     if (streq (SECTION_NAME (section_headers + i), name))
 501       return section_headers + i;
 502
 503   return NULL;
 504 }
 505
 506 /* Return a pointer to a section containing ADDR, or NULL if no such
 507    section exists.  */
 508
 509 static Elf_Internal_Shdr *
 510 find_section_by_address (bfd_vma addr)
 511 {
 512   unsigned int i;
 513
 514   for (i = 0; i < elf_header.e_shnum; i++)
 515     {
 516       Elf_Internal_Shdr *sec = section_headers + i;
 517       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 518         return sec;
 519     }
 520
 521   return NULL;
 522 }
 523
 524 /* Return a pointer to section NAME, or NULL if no such section exists,
 525    restricted to the list of sections given in SET.  */
 526
 527 static Elf_Internal_Shdr *
 528 find_section_in_set (const char * name, unsigned int * set)
 529 {
 530   unsigned int i;
 531
 532   if (set != NULL)
 533     {
 534       while ((i = *set++) > 0)
 535         if (streq (SECTION_NAME (section_headers + i), name))
 536           return section_headers + i;
 537     }
 538
 539   return find_section (name);
 540 }
 541
 542 /* Read an unsigned LEB128 encoded value from p.  Set *PLEN to the number of
 543    bytes read.  */
 544
 545 static inline unsigned long
 546 read_uleb128 (unsigned char *data,
 547               unsigned int *length_return,
 548               const unsigned char * const end)
 549 {
 550   return read_leb128 (data, length_return, FALSE, end);
 551 }
 552
 553 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
 554    This OS has so many departures from the ELF standard that we test it at
 555    many places.  */
 556
 557 static inline int
 558 is_ia64_vms (void)
 559 {
 560   return elf_header.e_machine == EM_IA_64
 561     && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 562 }
 563
 564 /* Guess the relocation size commonly used by the specific machines.  */
 565
 566 static int
 567 guess_is_rela (unsigned int e_machine)
 568 {
 569   switch (e_machine)
 570     {
 571       /* Targets that use REL relocations.  */
 572     case EM_386:
 573     case EM_486:
 574     case EM_960:
 575     case EM_ARM:
 576     case EM_D10V:
 577     case EM_CYGNUS_D10V:
 578     case EM_DLX:
 579     case EM_MIPS:
 580     case EM_MIPS_RS3_LE:
 581     case EM_CYGNUS_M32R:
 582     case EM_OPENRISC:
 583     case EM_OR32:
 584     case EM_SCORE:
 585     case EM_XGATE:
 586       return FALSE;
 587
 588       /* Targets that use RELA relocations.  */
 589     case EM_68K:
 590     case EM_860:
 591     case EM_AARCH64:
 592     case EM_ADAPTEVA_EPIPHANY:
 593     case EM_ALPHA:
 594     case EM_ALTERA_NIOS2:
 595     case EM_AVR:
 596     case EM_AVR_OLD:
 597     case EM_BLACKFIN:
 598     case EM_CR16:
 599     case EM_CRIS:
 600     case EM_CRX:
 601     case EM_D30V:
 602     case EM_CYGNUS_D30V:
 603     case EM_FR30:
 604     case EM_CYGNUS_FR30:
 605     case EM_CYGNUS_FRV:
 606     case EM_H8S:
 607     case EM_H8_300:
 608     case EM_H8_300H:
 609     case EM_IA_64:
 610     case EM_IP2K:
 611     case EM_IP2K_OLD:
 612     case EM_IQ2000:
 613     case EM_LATTICEMICO32:
 614     case EM_M32C_OLD:
 615     case EM_M32C:
 616     case EM_M32R:
 617     case EM_MCORE:
 618     case EM_CYGNUS_MEP:
 619     case EM_METAG:
 620     case EM_MMIX:
 621     case EM_MN10200:
 622     case EM_CYGNUS_MN10200:
 623     case EM_MN10300:
 624     case EM_CYGNUS_MN10300:
 625     case EM_MOXIE:
 626     case EM_MSP430:
 627     case EM_MSP430_OLD:
 628     case EM_MT:
 629     case EM_NIOS32:
 630     case EM_PPC64:
 631     case EM_PPC:
 632     case EM_RL78:
 633     case EM_RX:
 634     case EM_S390:
 635     case EM_S390_OLD:
 636     case EM_SH:
 637     case EM_SPARC:
 638     case EM_SPARC32PLUS:
 639     case EM_SPARCV9:
 640     case EM_SPU:
 641     case EM_TI_C6000:
 642     case EM_TILEGX:
 643     case EM_TILEPRO:
 644     case EM_V800:
 645     case EM_V850:
 646     case EM_CYGNUS_V850:
 647     case EM_VAX:
 648     case EM_X86_64:
 649     case EM_L1OM:
 650     case EM_K1OM:
 651     case EM_XSTORMY16:
 652     case EM_XTENSA:
 653     case EM_XTENSA_OLD:
 654     case EM_MICROBLAZE:
 655     case EM_MICROBLAZE_OLD:
 656       return TRUE;
 657
 658     case EM_68HC05:
 659     case EM_68HC08:
 660     case EM_68HC11:
 661     case EM_68HC16:
 662     case EM_FX66:
 663     case EM_ME16:
 664     case EM_MMA:
 665     case EM_NCPU:
 666     case EM_NDR1:
 667     case EM_PCP:
 668     case EM_ST100:
 669     case EM_ST19:
 670     case EM_ST7:
 671     case EM_ST9PLUS:
 672     case EM_STARCORE:
 673     case EM_SVX:
 674     case EM_TINYJ:
 675     default:
 676       warn (_("Don't know about relocations on this machine architecture\n"));
 677       return FALSE;
 678     }
 679 }
 680
 681 static int
 682 slurp_rela_relocs (FILE * file,
 683                    unsigned long rel_offset,
 684                    unsigned long rel_size,
 685                    Elf_Internal_Rela ** relasp,
 686                    unsigned long * nrelasp)
 687 {
 688   Elf_Internal_Rela * relas;
 689   unsigned long nrelas;
 690   unsigned int i;
 691
 692   if (is_32bit_elf)
 693     {
 694       Elf32_External_Rela * erelas;
 695
 696       erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
 697                                                  rel_size, _("32-bit relocation data"));
 698       if (!erelas)
 699         return 0;
 700
 701       nrelas = rel_size / sizeof (Elf32_External_Rela);
 702
 703       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 704                                              sizeof (Elf_Internal_Rela));
 705
 706       if (relas == NULL)
 707         {
 708           free (erelas);
 709           error (_("out of memory parsing relocs\n"));
 710           return 0;
 711         }
 712
 713       for (i = 0; i < nrelas; i++)
 714         {
 715           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 716           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 717           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 718         }
 719
 720       free (erelas);
 721     }
 722   else
 723     {
 724       Elf64_External_Rela * erelas;
 725
 726       erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
 727                                                  rel_size, _("64-bit relocation data"));
 728       if (!erelas)
 729         return 0;
 730
 731       nrelas = rel_size / sizeof (Elf64_External_Rela);
 732
 733       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 734                                              sizeof (Elf_Internal_Rela));
 735
 736       if (relas == NULL)
 737         {
 738           free (erelas);
 739           error (_("out of memory parsing relocs\n"));
 740           return 0;
 741         }
 742
 743       for (i = 0; i < nrelas; i++)
 744         {
 745           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 746           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 747           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 748
 749           /* The #ifdef BFD64 below is to prevent a compile time
 750              warning.  We know that if we do not have a 64 bit data
 751              type that we will never execute this code anyway.  */
 752 #ifdef BFD64
 753           if (elf_header.e_machine == EM_MIPS
 754               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 755             {
 756               /* In little-endian objects, r_info isn't really a
 757                  64-bit little-endian value: it has a 32-bit
 758                  little-endian symbol index followed by four
 759                  individual byte fields.  Reorder INFO
 760                  accordingly.  */
 761               bfd_vma inf = relas[i].r_info;
 762               inf = (((inf & 0xffffffff) << 32)
 763                       | ((inf >> 56) & 0xff)
 764                       | ((inf >> 40) & 0xff00)
 765                       | ((inf >> 24) & 0xff0000)
 766                       | ((inf >> 8) & 0xff000000));
 767               relas[i].r_info = inf;
 768             }
 769 #endif /* BFD64 */
 770         }
 771
 772       free (erelas);
 773     }
 774   *relasp = relas;
 775   *nrelasp = nrelas;
 776   return 1;
 777 }
 778
 779 static int
 780 slurp_rel_relocs (FILE * file,
 781                   unsigned long rel_offset,
 782                   unsigned long rel_size,
 783                   Elf_Internal_Rela ** relsp,
 784                   unsigned long * nrelsp)
 785 {
 786   Elf_Internal_Rela * rels;
 787   unsigned long nrels;
 788   unsigned int i;
 789
 790   if (is_32bit_elf)
 791     {
 792       Elf32_External_Rel * erels;
 793
 794       erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
 795                                                rel_size, _("32-bit relocation data"));
 796       if (!erels)
 797         return 0;
 798
 799       nrels = rel_size / sizeof (Elf32_External_Rel);
 800
 801       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 802
 803       if (rels == NULL)
 804         {
 805           free (erels);
 806           error (_("out of memory parsing relocs\n"));
 807           return 0;
 808         }
 809
 810       for (i = 0; i < nrels; i++)
 811         {
 812           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 813           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 814           rels[i].r_addend = 0;
 815         }
 816
 817       free (erels);
 818     }
 819   else
 820     {
 821       Elf64_External_Rel * erels;
 822
 823       erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
 824                                                rel_size, _("64-bit relocation data"));
 825       if (!erels)
 826         return 0;
 827
 828       nrels = rel_size / sizeof (Elf64_External_Rel);
 829
 830       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 831
 832       if (rels == NULL)
 833         {
 834           free (erels);
 835           error (_("out of memory parsing relocs\n"));
 836           return 0;
 837         }
 838
 839       for (i = 0; i < nrels; i++)
 840         {
 841           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 842           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 843           rels[i].r_addend = 0;
 844
 845           /* The #ifdef BFD64 below is to prevent a compile time
 846              warning.  We know that if we do not have a 64 bit data
 847              type that we will never execute this code anyway.  */
 848 #ifdef BFD64
 849           if (elf_header.e_machine == EM_MIPS
 850               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 851             {
 852               /* In little-endian objects, r_info isn't really a
 853                  64-bit little-endian value: it has a 32-bit
 854                  little-endian symbol index followed by four
 855                  individual byte fields.  Reorder INFO
 856                  accordingly.  */
 857               bfd_vma inf = rels[i].r_info;
 858               inf = (((inf & 0xffffffff) << 32)
 859                      | ((inf >> 56) & 0xff)
 860                      | ((inf >> 40) & 0xff00)
 861                      | ((inf >> 24) & 0xff0000)
 862                      | ((inf >> 8) & 0xff000000));
 863               rels[i].r_info = inf;
 864             }
 865 #endif /* BFD64 */
 866         }
 867
 868       free (erels);
 869     }
 870   *relsp = rels;
 871   *nrelsp = nrels;
 872   return 1;
 873 }
 874
 875 /* Returns the reloc type extracted from the reloc info field.  */
 876
 877 static unsigned int
 878 get_reloc_type (bfd_vma reloc_info)
 879 {
 880   if (is_32bit_elf)
 881     return ELF32_R_TYPE (reloc_info);
 882
 883   switch (elf_header.e_machine)
 884     {
 885     case EM_MIPS:
 886       /* Note: We assume that reloc_info has already been adjusted for us.  */
 887       return ELF64_MIPS_R_TYPE (reloc_info);
 888
 889     case EM_SPARCV9:
 890       return ELF64_R_TYPE_ID (reloc_info);
 891
 892     default:
 893       return ELF64_R_TYPE (reloc_info);
 894     }
 895 }
 896
 897 /* Return the symbol index extracted from the reloc info field.  */
 898
 899 static bfd_vma
 900 get_reloc_symindex (bfd_vma reloc_info)
 901 {
 902   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
 903 }
 904
 905 static inline bfd_boolean
 906 uses_msp430x_relocs (void)
 907 {
 908   return
 909     elf_header.e_machine == EM_MSP430 /* Paranoia.  */
 910     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
 911     && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
 912         /* TI compiler uses ELFOSABI_NONE.  */
 913         || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
 914 }
 915
 916 /* Display the contents of the relocation data found at the specified
 917    offset.  */
 918
 919 static void
 920 dump_relocations (FILE * file,
 921                   unsigned long rel_offset,
 922                   unsigned long rel_size,
 923                   Elf_Internal_Sym * symtab,
 924                   unsigned long nsyms,
 925                   char * strtab,
 926                   unsigned long strtablen,
 927                   int is_rela)
 928 {
 929   unsigned int i;
 930   Elf_Internal_Rela * rels;
 931
 932   if (is_rela == UNKNOWN)
 933     is_rela = guess_is_rela (elf_header.e_machine);
 934
 935   if (is_rela)
 936     {
 937       if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
 938         return;
 939     }
 940   else
 941     {
 942       if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
 943         return;
 944     }
 945
 946   if (is_32bit_elf)
 947     {
 948       if (is_rela)
 949         {
 950           if (do_wide)
 951             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
 952           else
 953             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
 954         }
 955       else
 956         {
 957           if (do_wide)
 958             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
 959           else
 960             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
 961         }
 962     }
 963   else
 964     {
 965       if (is_rela)
 966         {
 967           if (do_wide)
 968             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
 969           else
 970             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
 971         }
 972       else
 973         {
 974           if (do_wide)
 975             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
 976           else
 977             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
 978         }
 979     }
 980
 981   for (i = 0; i < rel_size; i++)
 982     {
 983       const char * rtype;
 984       bfd_vma offset;
 985       bfd_vma inf;
 986       bfd_vma symtab_index;
 987       bfd_vma type;
 988
 989       offset = rels[i].r_offset;
 990       inf    = rels[i].r_info;
 991
 992       type = get_reloc_type (inf);
 993       symtab_index = get_reloc_symindex  (inf);
 994
 995       if (is_32bit_elf)
 996         {
 997           printf ("%8.8lx  %8.8lx ",
 998                   (unsigned long) offset & 0xffffffff,
 999                   (unsigned long) inf & 0xffffffff);
1000         }
1001       else
1002         {
1003 #if BFD_HOST_64BIT_LONG
1004           printf (do_wide
1005                   ? "%16.16lx  %16.16lx "
1006                   : "%12.12lx  %12.12lx ",
1007                   offset, inf);
1008 #elif BFD_HOST_64BIT_LONG_LONG
1009 #ifndef __MSVCRT__
1010           printf (do_wide
1011                   ? "%16.16llx  %16.16llx "
1012                   : "%12.12llx  %12.12llx ",
1013                   offset, inf);
1014 #else
1015           printf (do_wide
1016                   ? "%16.16I64x  %16.16I64x "
1017                   : "%12.12I64x  %12.12I64x ",
1018                   offset, inf);
1019 #endif
1020 #else
1021           printf (do_wide
1022                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1023                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1024                   _bfd_int64_high (offset),
1025                   _bfd_int64_low (offset),
1026                   _bfd_int64_high (inf),
1027                   _bfd_int64_low (inf));
1028 #endif
1029         }
1030
1031       switch (elf_header.e_machine)
1032         {
1033         default:
1034           rtype = NULL;
1035           break;
1036
1037         case EM_AARCH64:
1038           rtype = elf_aarch64_reloc_type (type);
1039           break;
1040
1041         case EM_M32R:
1042         case EM_CYGNUS_M32R:
1043           rtype = elf_m32r_reloc_type (type);
1044           break;
1045
1046         case EM_386:
1047         case EM_486:
1048           rtype = elf_i386_reloc_type (type);
1049           break;
1050
1051         case EM_68HC11:
1052         case EM_68HC12:
1053           rtype = elf_m68hc11_reloc_type (type);
1054           break;
1055
1056         case EM_68K:
1057           rtype = elf_m68k_reloc_type (type);
1058           break;
1059
1060         case EM_960:
1061           rtype = elf_i960_reloc_type (type);
1062           break;
1063
1064         case EM_AVR:
1065         case EM_AVR_OLD:
1066           rtype = elf_avr_reloc_type (type);
1067           break;
1068
1069         case EM_OLD_SPARCV9:
1070         case EM_SPARC32PLUS:
1071         case EM_SPARCV9:
1072         case EM_SPARC:
1073           rtype = elf_sparc_reloc_type (type);
1074           break;
1075
1076         case EM_SPU:
1077           rtype = elf_spu_reloc_type (type);
1078           break;
1079
1080         case EM_V800:
1081           rtype = v800_reloc_type (type);
1082           break;
1083         case EM_V850:
1084         case EM_CYGNUS_V850:
1085           rtype = v850_reloc_type (type);
1086           break;
1087
1088         case EM_D10V:
1089         case EM_CYGNUS_D10V:
1090           rtype = elf_d10v_reloc_type (type);
1091           break;
1092
1093         case EM_D30V:
1094         case EM_CYGNUS_D30V:
1095           rtype = elf_d30v_reloc_type (type);
1096           break;
1097
1098         case EM_DLX:
1099           rtype = elf_dlx_reloc_type (type);
1100           break;
1101
1102         case EM_SH:
1103           rtype = elf_sh_reloc_type (type);
1104           break;
1105
1106         case EM_MN10300:
1107         case EM_CYGNUS_MN10300:
1108           rtype = elf_mn10300_reloc_type (type);
1109           break;
1110
1111         case EM_MN10200:
1112         case EM_CYGNUS_MN10200:
1113           rtype = elf_mn10200_reloc_type (type);
1114           break;
1115
1116         case EM_FR30:
1117         case EM_CYGNUS_FR30:
1118           rtype = elf_fr30_reloc_type (type);
1119           break;
1120
1121         case EM_CYGNUS_FRV:
1122           rtype = elf_frv_reloc_type (type);
1123           break;
1124
1125         case EM_MCORE:
1126           rtype = elf_mcore_reloc_type (type);
1127           break;
1128
1129         case EM_MMIX:
1130           rtype = elf_mmix_reloc_type (type);
1131           break;
1132
1133         case EM_MOXIE:
1134           rtype = elf_moxie_reloc_type (type);
1135           break;
1136
1137         case EM_MSP430:
1138           if (uses_msp430x_relocs ())
1139             {
1140               rtype = elf_msp430x_reloc_type (type);
1141               break;
1142             }
1143         case EM_MSP430_OLD:
1144           rtype = elf_msp430_reloc_type (type);
1145           break;
1146
1147         case EM_PPC:
1148           rtype = elf_ppc_reloc_type (type);
1149           break;
1150
1151         case EM_PPC64:
1152           rtype = elf_ppc64_reloc_type (type);
1153           break;
1154
1155         case EM_MIPS:
1156         case EM_MIPS_RS3_LE:
1157           rtype = elf_mips_reloc_type (type);
1158           break;
1159
1160         case EM_ALPHA:
1161           rtype = elf_alpha_reloc_type (type);
1162           break;
1163
1164         case EM_ARM:
1165           rtype = elf_arm_reloc_type (type);
1166           break;
1167
1168         case EM_ARC:
1169           rtype = elf_arc_reloc_type (type);
1170           break;
1171
1172         case EM_PARISC:
1173           rtype = elf_hppa_reloc_type (type);
1174           break;
1175
1176         case EM_H8_300:
1177         case EM_H8_300H:
1178         case EM_H8S:
1179           rtype = elf_h8_reloc_type (type);
1180           break;
1181
1182         case EM_OPENRISC:
1183         case EM_OR32:
1184           rtype = elf_or32_reloc_type (type);
1185           break;
1186
1187         case EM_PJ:
1188         case EM_PJ_OLD:
1189           rtype = elf_pj_reloc_type (type);
1190           break;
1191         case EM_IA_64:
1192           rtype = elf_ia64_reloc_type (type);
1193           break;
1194
1195         case EM_CRIS:
1196           rtype = elf_cris_reloc_type (type);
1197           break;
1198
1199         case EM_860:
1200           rtype = elf_i860_reloc_type (type);
1201           break;
1202
1203         case EM_X86_64:
1204         case EM_L1OM:
1205         case EM_K1OM:
1206           rtype = elf_x86_64_reloc_type (type);
1207           break;
1208
1209         case EM_S370:
1210           rtype = i370_reloc_type (type);
1211           break;
1212
1213         case EM_S390_OLD:
1214         case EM_S390:
1215           rtype = elf_s390_reloc_type (type);
1216           break;
1217
1218         case EM_SCORE:
1219           rtype = elf_score_reloc_type (type);
1220           break;
1221
1222         case EM_XSTORMY16:
1223           rtype = elf_xstormy16_reloc_type (type);
1224           break;
1225
1226         case EM_CRX:
1227           rtype = elf_crx_reloc_type (type);
1228           break;
1229
1230         case EM_VAX:
1231           rtype = elf_vax_reloc_type (type);
1232           break;
1233
1234         case EM_ADAPTEVA_EPIPHANY:
1235           rtype = elf_epiphany_reloc_type (type);
1236           break;
1237
1238         case EM_IP2K:
1239         case EM_IP2K_OLD:
1240           rtype = elf_ip2k_reloc_type (type);
1241           break;
1242
1243         case EM_IQ2000:
1244           rtype = elf_iq2000_reloc_type (type);
1245           break;
1246
1247         case EM_XTENSA_OLD:
1248         case EM_XTENSA:
1249           rtype = elf_xtensa_reloc_type (type);
1250           break;
1251
1252         case EM_LATTICEMICO32:
1253           rtype = elf_lm32_reloc_type (type);
1254           break;
1255
1256         case EM_M32C_OLD:
1257         case EM_M32C:
1258           rtype = elf_m32c_reloc_type (type);
1259           break;
1260
1261         case EM_MT:
1262           rtype = elf_mt_reloc_type (type);
1263           break;
1264
1265         case EM_BLACKFIN:
1266           rtype = elf_bfin_reloc_type (type);
1267           break;
1268
1269         case EM_CYGNUS_MEP:
1270           rtype = elf_mep_reloc_type (type);
1271           break;
1272
1273         case EM_CR16:
1274           rtype = elf_cr16_reloc_type (type);
1275           break;
1276
1277         case EM_MICROBLAZE:
1278         case EM_MICROBLAZE_OLD:
1279           rtype = elf_microblaze_reloc_type (type);
1280           break;
1281
1282         case EM_RL78:
1283           rtype = elf_rl78_reloc_type (type);
1284           break;
1285
1286         case EM_RX:
1287           rtype = elf_rx_reloc_type (type);
1288           break;
1289
1290         case EM_METAG:
1291           rtype = elf_metag_reloc_type (type);
1292           break;
1293
1294         case EM_XC16X:
1295         case EM_C166:
1296           rtype = elf_xc16x_reloc_type (type);
1297           break;
1298
1299         case EM_TI_C6000:
1300           rtype = elf_tic6x_reloc_type (type);
1301           break;
1302
1303         case EM_TILEGX:
1304           rtype = elf_tilegx_reloc_type (type);
1305           break;
1306
1307         case EM_TILEPRO:
1308           rtype = elf_tilepro_reloc_type (type);
1309           break;
1310
1311         case EM_XGATE:
1312           rtype = elf_xgate_reloc_type (type);
1313           break;
1314
1315         case EM_ALTERA_NIOS2:
1316           rtype = elf_nios2_reloc_type (type);
1317           break;
1318         }
1319
1320       if (rtype == NULL)
1321         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1322       else
1323         printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1324
1325       if (elf_header.e_machine == EM_ALPHA
1326           && rtype != NULL
1327           && streq (rtype, "R_ALPHA_LITUSE")
1328           && is_rela)
1329         {
1330           switch (rels[i].r_addend)
1331             {
1332             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1333             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1334             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1335             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1336             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1337             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1338             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1339             default: rtype = NULL;
1340             }
1341           if (rtype)
1342             printf (" (%s)", rtype);
1343           else
1344             {
1345               putchar (' ');
1346               printf (_("<unknown addend: %lx>"),
1347                       (unsigned long) rels[i].r_addend);
1348             }
1349         }
1350       else if (symtab_index)
1351         {
1352           if (symtab == NULL || symtab_index >= nsyms)
1353             printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1354           else
1355             {
1356               Elf_Internal_Sym * psym;
1357
1358               psym = symtab + symtab_index;
1359
1360               printf (" ");
1361
1362               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1363                 {
1364                   const char * name;
1365                   unsigned int len;
1366                   unsigned int width = is_32bit_elf ? 8 : 14;
1367
1368                   /* Relocations against GNU_IFUNC symbols do not use the value
1369                      of the symbol as the address to relocate against.  Instead
1370                      they invoke the function named by the symbol and use its
1371                      result as the address for relocation.
1372
1373                      To indicate this to the user, do not display the value of
1374                      the symbol in the "Symbols's Value" field.  Instead show
1375                      its name followed by () as a hint that the symbol is
1376                      invoked.  */
1377
1378                   if (strtab == NULL
1379                       || psym->st_name == 0
1380                       || psym->st_name >= strtablen)
1381                     name = "??";
1382                   else
1383                     name = strtab + psym->st_name;
1384
1385                   len = print_symbol (width, name);
1386                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1387                 }
1388               else
1389                 {
1390                   print_vma (psym->st_value, LONG_HEX);
1391
1392                   printf (is_32bit_elf ? "   " : " ");
1393                 }
1394
1395               if (psym->st_name == 0)
1396                 {
1397                   const char * sec_name = "<null>";
1398                   char name_buf[40];
1399
1400                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1401                     {
1402                       if (psym->st_shndx < elf_header.e_shnum)
1403                         sec_name
1404                           = SECTION_NAME (section_headers + psym->st_shndx);
1405                       else if (psym->st_shndx == SHN_ABS)
1406                         sec_name = "ABS";
1407                       else if (psym->st_shndx == SHN_COMMON)
1408                         sec_name = "COMMON";
1409                       else if ((elf_header.e_machine == EM_MIPS
1410                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1411                                || (elf_header.e_machine == EM_TI_C6000
1412                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1413                         sec_name = "SCOMMON";
1414                       else if (elf_header.e_machine == EM_MIPS
1415                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1416                         sec_name = "SUNDEF";
1417                       else if ((elf_header.e_machine == EM_X86_64
1418                                 || elf_header.e_machine == EM_L1OM
1419                                 || elf_header.e_machine == EM_K1OM)
1420                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1421                         sec_name = "LARGE_COMMON";
1422                       else if (elf_header.e_machine == EM_IA_64
1423                                && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1424                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1425                         sec_name = "ANSI_COM";
1426                       else if (is_ia64_vms ()
1427                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1428                         sec_name = "VMS_SYMVEC";
1429                       else
1430                         {
1431                           sprintf (name_buf, "<section 0x%x>",
1432                                    (unsigned int) psym->st_shndx);
1433                           sec_name = name_buf;
1434                         }
1435                     }
1436                   print_symbol (22, sec_name);
1437                 }
1438               else if (strtab == NULL)
1439                 printf (_("<string table index: %3ld>"), psym->st_name);
1440               else if (psym->st_name >= strtablen)
1441                 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1442               else
1443                 print_symbol (22, strtab + psym->st_name);
1444
1445               if (is_rela)
1446                 {
1447                   bfd_signed_vma off = rels[i].r_addend;
1448
1449                   if (off < 0)
1450                     printf (" - %" BFD_VMA_FMT "x", - off);
1451                   else
1452                     printf (" + %" BFD_VMA_FMT "x", off);
1453                 }
1454             }
1455         }
1456       else if (is_rela)
1457         {
1458           bfd_signed_vma off = rels[i].r_addend;
1459
1460           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1461           if (off < 0)
1462             printf ("-%" BFD_VMA_FMT "x", - off);
1463           else
1464             printf ("%" BFD_VMA_FMT "x", off);
1465         }
1466
1467       if (elf_header.e_machine == EM_SPARCV9
1468           && rtype != NULL
1469           && streq (rtype, "R_SPARC_OLO10"))
1470         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1471
1472       putchar ('\n');
1473
1474 #ifdef BFD64
1475       if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1476         {
1477           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1478           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1479           const char * rtype2 = elf_mips_reloc_type (type2);
1480           const char * rtype3 = elf_mips_reloc_type (type3);
1481
1482           printf ("                    Type2: ");
1483
1484           if (rtype2 == NULL)
1485             printf (_("unrecognized: %-7lx"),
1486                     (unsigned long) type2 & 0xffffffff);
1487           else
1488             printf ("%-17.17s", rtype2);
1489
1490           printf ("\n                    Type3: ");
1491
1492           if (rtype3 == NULL)
1493             printf (_("unrecognized: %-7lx"),
1494                     (unsigned long) type3 & 0xffffffff);
1495           else
1496             printf ("%-17.17s", rtype3);
1497
1498           putchar ('\n');
1499         }
1500 #endif /* BFD64 */
1501     }
1502
1503   free (rels);
1504 }
1505
1506 static const char *
1507 get_mips_dynamic_type (unsigned long type)
1508 {
1509   switch (type)
1510     {
1511     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1512     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1513     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1514     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1515     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1516     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1517     case DT_MIPS_MSYM: return "MIPS_MSYM";
1518     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1519     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1520     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1521     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1522     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1523     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1524     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1525     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1526     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1527     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1528     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1529     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1530     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1531     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1532     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1533     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1534     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1535     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1536     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1537     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1538     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1539     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1540     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1541     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1542     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1543     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1544     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1545     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1546     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1547     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1548     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1549     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1550     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1551     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1552     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1553     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1554     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1555     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1556     default:
1557       return NULL;
1558     }
1559 }
1560
1561 static const char *
1562 get_sparc64_dynamic_type (unsigned long type)
1563 {
1564   switch (type)
1565     {
1566     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1567     default:
1568       return NULL;
1569     }
1570 }
1571
1572 static const char *
1573 get_ppc_dynamic_type (unsigned long type)
1574 {
1575   switch (type)
1576     {
1577     case DT_PPC_GOT:    return "PPC_GOT";
1578     case DT_PPC_OPT:    return "PPC_OPT";
1579     default:
1580       return NULL;
1581     }
1582 }
1583
1584 static const char *
1585 get_ppc64_dynamic_type (unsigned long type)
1586 {
1587   switch (type)
1588     {
1589     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1590     case DT_PPC64_OPD:    return "PPC64_OPD";
1591     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1592     case DT_PPC64_OPT:    return "PPC64_OPT";
1593     default:
1594       return NULL;
1595     }
1596 }
1597
1598 static const char *
1599 get_parisc_dynamic_type (unsigned long type)
1600 {
1601   switch (type)
1602     {
1603     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1604     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1605     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1606     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1607     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1608     case DT_HP_PREINIT:         return "HP_PREINIT";
1609     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1610     case DT_HP_NEEDED:          return "HP_NEEDED";
1611     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1612     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1613     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1614     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1615     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1616     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1617     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1618     case DT_HP_FILTERED:        return "HP_FILTERED";
1619     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1620     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1621     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1622     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1623     case DT_PLT:                return "PLT";
1624     case DT_PLT_SIZE:           return "PLT_SIZE";
1625     case DT_DLT:                return "DLT";
1626     case DT_DLT_SIZE:           return "DLT_SIZE";
1627     default:
1628       return NULL;
1629     }
1630 }
1631
1632 static const char *
1633 get_ia64_dynamic_type (unsigned long type)
1634 {
1635   switch (type)
1636     {
1637     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1638     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1639     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1640     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1641     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1642     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1643     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1644     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1645     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1646     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1647     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1648     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1649     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1650     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1651     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1652     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1653     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1654     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1655     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1656     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1657     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1658     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1659     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1660     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1661     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1662     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1663     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1664     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1665     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1666     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1667     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1668     default:
1669       return NULL;
1670     }
1671 }
1672
1673 static const char *
1674 get_alpha_dynamic_type (unsigned long type)
1675 {
1676   switch (type)
1677     {
1678     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1679     default:
1680       return NULL;
1681     }
1682 }
1683
1684 static const char *
1685 get_score_dynamic_type (unsigned long type)
1686 {
1687   switch (type)
1688     {
1689     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1690     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1691     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1692     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1693     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1694     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1695     default:
1696       return NULL;
1697     }
1698 }
1699
1700 static const char *
1701 get_tic6x_dynamic_type (unsigned long type)
1702 {
1703   switch (type)
1704     {
1705     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1706     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1707     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
1708     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
1709     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
1710     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
1711     default:
1712       return NULL;
1713     }
1714 }
1715
1716 static const char *
1717 get_nios2_dynamic_type (unsigned long type)
1718 {
1719   switch (type)
1720     {
1721     case DT_NIOS2_GP: return "NIOS2_GP";
1722     default:
1723       return NULL;
1724     }
1725 }
1726
1727 static const char *
1728 get_dynamic_type (unsigned long type)
1729 {
1730   static char buff[64];
1731
1732   switch (type)
1733     {
1734     case DT_NULL:       return "NULL";
1735     case DT_NEEDED:     return "NEEDED";
1736     case DT_PLTRELSZ:   return "PLTRELSZ";
1737     case DT_PLTGOT:     return "PLTGOT";
1738     case DT_HASH:       return "HASH";
1739     case DT_STRTAB:     return "STRTAB";
1740     case DT_SYMTAB:     return "SYMTAB";
1741     case DT_RELA:       return "RELA";
1742     case DT_RELASZ:     return "RELASZ";
1743     case DT_RELAENT:    return "RELAENT";
1744     case DT_STRSZ:      return "STRSZ";
1745     case DT_SYMENT:     return "SYMENT";
1746     case DT_INIT:       return "INIT";
1747     case DT_FINI:       return "FINI";
1748     case DT_SONAME:     return "SONAME";
1749     case DT_RPATH:      return "RPATH";
1750     case DT_SYMBOLIC:   return "SYMBOLIC";
1751     case DT_REL:        return "REL";
1752     case DT_RELSZ:      return "RELSZ";
1753     case DT_RELENT:     return "RELENT";
1754     case DT_PLTREL:     return "PLTREL";
1755     case DT_DEBUG:      return "DEBUG";
1756     case DT_TEXTREL:    return "TEXTREL";
1757     case DT_JMPREL:     return "JMPREL";
1758     case DT_BIND_NOW:   return "BIND_NOW";
1759     case DT_INIT_ARRAY: return "INIT_ARRAY";
1760     case DT_FINI_ARRAY: return "FINI_ARRAY";
1761     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1762     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1763     case DT_RUNPATH:    return "RUNPATH";
1764     case DT_FLAGS:      return "FLAGS";
1765
1766     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1767     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1768
1769     case DT_CHECKSUM:   return "CHECKSUM";
1770     case DT_PLTPADSZ:   return "PLTPADSZ";
1771     case DT_MOVEENT:    return "MOVEENT";
1772     case DT_MOVESZ:     return "MOVESZ";
1773     case DT_FEATURE:    return "FEATURE";
1774     case DT_POSFLAG_1:  return "POSFLAG_1";
1775     case DT_SYMINSZ:    return "SYMINSZ";
1776     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
1777
1778     case DT_ADDRRNGLO:  return "ADDRRNGLO";
1779     case DT_CONFIG:     return "CONFIG";
1780     case DT_DEPAUDIT:   return "DEPAUDIT";
1781     case DT_AUDIT:      return "AUDIT";
1782     case DT_PLTPAD:     return "PLTPAD";
1783     case DT_MOVETAB:    return "MOVETAB";
1784     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
1785
1786     case DT_VERSYM:     return "VERSYM";
1787
1788     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1789     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1790     case DT_RELACOUNT:  return "RELACOUNT";
1791     case DT_RELCOUNT:   return "RELCOUNT";
1792     case DT_FLAGS_1:    return "FLAGS_1";
1793     case DT_VERDEF:     return "VERDEF";
1794     case DT_VERDEFNUM:  return "VERDEFNUM";
1795     case DT_VERNEED:    return "VERNEED";
1796     case DT_VERNEEDNUM: return "VERNEEDNUM";
1797
1798     case DT_AUXILIARY:  return "AUXILIARY";
1799     case DT_USED:       return "USED";
1800     case DT_FILTER:     return "FILTER";
1801
1802     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1803     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1804     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1805     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1806     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1807     case DT_GNU_HASH:   return "GNU_HASH";
1808
1809     default:
1810       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1811         {
1812           const char * result;
1813
1814           switch (elf_header.e_machine)
1815             {
1816             case EM_MIPS:
1817             case EM_MIPS_RS3_LE:
1818               result = get_mips_dynamic_type (type);
1819               break;
1820             case EM_SPARCV9:
1821               result = get_sparc64_dynamic_type (type);
1822               break;
1823             case EM_PPC:
1824               result = get_ppc_dynamic_type (type);
1825               break;
1826             case EM_PPC64:
1827               result = get_ppc64_dynamic_type (type);
1828               break;
1829             case EM_IA_64:
1830               result = get_ia64_dynamic_type (type);
1831               break;
1832             case EM_ALPHA:
1833               result = get_alpha_dynamic_type (type);
1834               break;
1835             case EM_SCORE:
1836               result = get_score_dynamic_type (type);
1837               break;
1838             case EM_TI_C6000:
1839               result = get_tic6x_dynamic_type (type);
1840               break;
1841             case EM_ALTERA_NIOS2:
1842               result = get_nios2_dynamic_type (type);
1843               break;
1844             default:
1845               result = NULL;
1846               break;
1847             }
1848
1849           if (result != NULL)
1850             return result;
1851
1852           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1853         }
1854       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1855                || (elf_header.e_machine == EM_PARISC
1856                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1857         {
1858           const char * result;
1859
1860           switch (elf_header.e_machine)
1861             {
1862             case EM_PARISC:
1863               result = get_parisc_dynamic_type (type);
1864               break;
1865             case EM_IA_64:
1866               result = get_ia64_dynamic_type (type);
1867               break;
1868             default:
1869               result = NULL;
1870               break;
1871             }
1872
1873           if (result != NULL)
1874             return result;
1875
1876           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1877                     type);
1878         }
1879       else
1880         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1881
1882       return buff;
1883     }
1884 }
1885
1886 static char *
1887 get_file_type (unsigned e_type)
1888 {
1889   static char buff[32];
1890
1891   switch (e_type)
1892     {
1893     case ET_NONE:       return _("NONE (None)");
1894     case ET_REL:        return _("REL (Relocatable file)");
1895     case ET_EXEC:       return _("EXEC (Executable file)");
1896     case ET_DYN:        return _("DYN (Shared object file)");
1897     case ET_CORE:       return _("CORE (Core file)");
1898
1899     default:
1900       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1901         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1902       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1903         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1904       else
1905         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1906       return buff;
1907     }
1908 }
1909
1910 static char *
1911 get_machine_name (unsigned e_machine)
1912 {
1913   static char buff[64]; /* XXX */
1914
1915   switch (e_machine)
1916     {
1917     case EM_NONE:               return _("None");
1918     case EM_AARCH64:            return "AArch64";
1919     case EM_M32:                return "WE32100";
1920     case EM_SPARC:              return "Sparc";
1921     case EM_SPU:                return "SPU";
1922     case EM_386:                return "Intel 80386";
1923     case EM_68K:                return "MC68000";
1924     case EM_88K:                return "MC88000";
1925     case EM_486:                return "Intel 80486";
1926     case EM_860:                return "Intel 80860";
1927     case EM_MIPS:               return "MIPS R3000";
1928     case EM_S370:               return "IBM System/370";
1929     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
1930     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
1931     case EM_PARISC:             return "HPPA";
1932     case EM_PPC_OLD:            return "Power PC (old)";
1933     case EM_SPARC32PLUS:        return "Sparc v8+" ;
1934     case EM_960:                return "Intel 90860";
1935     case EM_PPC:                return "PowerPC";
1936     case EM_PPC64:              return "PowerPC64";
1937     case EM_FR20:               return "Fujitsu FR20";
1938     case EM_RH32:               return "TRW RH32";
1939     case EM_MCORE:              return "MCORE";
1940     case EM_ARM:                return "ARM";
1941     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
1942     case EM_SH:                 return "Renesas / SuperH SH";
1943     case EM_SPARCV9:            return "Sparc v9";
1944     case EM_TRICORE:            return "Siemens Tricore";
1945     case EM_ARC:                return "ARC";
1946     case EM_H8_300:             return "Renesas H8/300";
1947     case EM_H8_300H:            return "Renesas H8/300H";
1948     case EM_H8S:                return "Renesas H8S";
1949     case EM_H8_500:             return "Renesas H8/500";
1950     case EM_IA_64:              return "Intel IA-64";
1951     case EM_MIPS_X:             return "Stanford MIPS-X";
1952     case EM_COLDFIRE:           return "Motorola Coldfire";
1953     case EM_ALPHA:              return "Alpha";
1954     case EM_CYGNUS_D10V:
1955     case EM_D10V:               return "d10v";
1956     case EM_CYGNUS_D30V:
1957     case EM_D30V:               return "d30v";
1958     case EM_CYGNUS_M32R:
1959     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
1960     case EM_CYGNUS_V850:
1961     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
1962     case EM_V850:               return "Renesas V850";
1963     case EM_CYGNUS_MN10300:
1964     case EM_MN10300:            return "mn10300";
1965     case EM_CYGNUS_MN10200:
1966     case EM_MN10200:            return "mn10200";
1967     case EM_MOXIE:              return "Moxie";
1968     case EM_CYGNUS_FR30:
1969     case EM_FR30:               return "Fujitsu FR30";
1970     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
1971     case EM_PJ_OLD:
1972     case EM_PJ:                 return "picoJava";
1973     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
1974     case EM_PCP:                return "Siemens PCP";
1975     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
1976     case EM_NDR1:               return "Denso NDR1 microprocesspr";
1977     case EM_STARCORE:           return "Motorola Star*Core processor";
1978     case EM_ME16:               return "Toyota ME16 processor";
1979     case EM_ST100:              return "STMicroelectronics ST100 processor";
1980     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
1981     case EM_PDSP:               return "Sony DSP processor";
1982     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
1983     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
1984     case EM_FX66:               return "Siemens FX66 microcontroller";
1985     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1986     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
1987     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
1988     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
1989     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
1990     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
1991     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
1992     case EM_SVX:                return "Silicon Graphics SVx";
1993     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
1994     case EM_VAX:                return "Digital VAX";
1995     case EM_AVR_OLD:
1996     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
1997     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
1998     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
1999     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2000     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2001     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2002     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2003     case EM_PRISM:              return "Vitesse Prism";
2004     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2005     case EM_L1OM:               return "Intel L1OM";
2006     case EM_K1OM:               return "Intel K1OM";
2007     case EM_S390_OLD:
2008     case EM_S390:               return "IBM S/390";
2009     case EM_SCORE:              return "SUNPLUS S+Core";
2010     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2011     case EM_OPENRISC:
2012     case EM_OR32:               return "OpenRISC";
2013     case EM_ARC_A5:             return "ARC International ARCompact processor";
2014     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2015     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2016     case EM_DLX:                return "OpenDLX";
2017     case EM_IP2K_OLD:
2018     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2019     case EM_IQ2000:             return "Vitesse IQ2000";
2020     case EM_XTENSA_OLD:
2021     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2022     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2023     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2024     case EM_NS32K:              return "National Semiconductor 32000 series";
2025     case EM_TPC:                return "Tenor Network TPC processor";
2026     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2027     case EM_MAX:                return "MAX Processor";
2028     case EM_CR:                 return "National Semiconductor CompactRISC";
2029     case EM_F2MC16:             return "Fujitsu F2MC16";
2030     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2031     case EM_LATTICEMICO32:      return "Lattice Mico32";
2032     case EM_M32C_OLD:
2033     case EM_M32C:               return "Renesas M32c";
2034     case EM_MT:                 return "Morpho Techologies MT processor";
2035     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2036     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2037     case EM_SEP:                return "Sharp embedded microprocessor";
2038     case EM_ARCA:               return "Arca RISC microprocessor";
2039     case EM_UNICORE:            return "Unicore";
2040     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2041     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2042     case EM_NIOS32:             return "Altera Nios";
2043     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2044     case EM_C166:
2045     case EM_XC16X:              return "Infineon Technologies xc16x";
2046     case EM_M16C:               return "Renesas M16C series microprocessors";
2047     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2048     case EM_CE:                 return "Freescale Communication Engine RISC core";
2049     case EM_TSK3000:            return "Altium TSK3000 core";
2050     case EM_RS08:               return "Freescale RS08 embedded processor";
2051     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2052     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2053     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2054     case EM_SE_C17:             return "Seiko Epson C17 family";
2055     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2056     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2057     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2058     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2059     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2060     case EM_R32C:               return "Renesas R32C series microprocessors";
2061     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2062     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2063     case EM_8051:               return "Intel 8051 and variants";
2064     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2065     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2066     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2067     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2068     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2069     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2070     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2071     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2072     case EM_CR16:
2073     case EM_MICROBLAZE:
2074     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2075     case EM_RL78:               return "Renesas RL78";
2076     case EM_RX:                 return "Renesas RX";
2077     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2078     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2079     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2080     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2081     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2082     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor family";
2083     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2084     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2085     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2086     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2087     case EM_CUDA:               return "NVIDIA CUDA architecture";
2088     case EM_XGATE:              return "Motorola XGATE embedded processor";
2089     default:
2090       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2091       return buff;
2092     }
2093 }
2094
2095 static void
2096 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2097 {
2098   unsigned eabi;
2099   int unknown = 0;
2100
2101   eabi = EF_ARM_EABI_VERSION (e_flags);
2102   e_flags &= ~ EF_ARM_EABIMASK;
2103
2104   /* Handle "generic" ARM flags.  */
2105   if (e_flags & EF_ARM_RELEXEC)
2106     {
2107       strcat (buf, ", relocatable executable");
2108       e_flags &= ~ EF_ARM_RELEXEC;
2109     }
2110
2111   if (e_flags & EF_ARM_HASENTRY)
2112     {
2113       strcat (buf, ", has entry point");
2114       e_flags &= ~ EF_ARM_HASENTRY;
2115     }
2116
2117   /* Now handle EABI specific flags.  */
2118   switch (eabi)
2119     {
2120     default:
2121       strcat (buf, ", <unrecognized EABI>");
2122       if (e_flags)
2123         unknown = 1;
2124       break;
2125
2126     case EF_ARM_EABI_VER1:
2127       strcat (buf, ", Version1 EABI");
2128       while (e_flags)
2129         {
2130           unsigned flag;
2131
2132           /* Process flags one bit at a time.  */
2133           flag = e_flags & - e_flags;
2134           e_flags &= ~ flag;
2135
2136           switch (flag)
2137             {
2138             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2139               strcat (buf, ", sorted symbol tables");
2140               break;
2141
2142             default:
2143               unknown = 1;
2144               break;
2145             }
2146         }
2147       break;
2148
2149     case EF_ARM_EABI_VER2:
2150       strcat (buf, ", Version2 EABI");
2151       while (e_flags)
2152         {
2153           unsigned flag;
2154
2155           /* Process flags one bit at a time.  */
2156           flag = e_flags & - e_flags;
2157           e_flags &= ~ flag;
2158
2159           switch (flag)
2160             {
2161             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2162               strcat (buf, ", sorted symbol tables");
2163               break;
2164
2165             case EF_ARM_DYNSYMSUSESEGIDX:
2166               strcat (buf, ", dynamic symbols use segment index");
2167               break;
2168
2169             case EF_ARM_MAPSYMSFIRST:
2170               strcat (buf, ", mapping symbols precede others");
2171               break;
2172
2173             default:
2174               unknown = 1;
2175               break;
2176             }
2177         }
2178       break;
2179
2180     case EF_ARM_EABI_VER3:
2181       strcat (buf, ", Version3 EABI");
2182       break;
2183
2184     case EF_ARM_EABI_VER4:
2185       strcat (buf, ", Version4 EABI");
2186       while (e_flags)
2187         {
2188           unsigned flag;
2189
2190           /* Process flags one bit at a time.  */
2191           flag = e_flags & - e_flags;
2192           e_flags &= ~ flag;
2193
2194           switch (flag)
2195             {
2196             case EF_ARM_BE8:
2197               strcat (buf, ", BE8");
2198               break;
2199
2200             case EF_ARM_LE8:
2201               strcat (buf, ", LE8");
2202               break;
2203
2204             default:
2205               unknown = 1;
2206               break;
2207             }
2208       break;
2209         }
2210       break;
2211
2212     case EF_ARM_EABI_VER5:
2213       strcat (buf, ", Version5 EABI");
2214       while (e_flags)
2215         {
2216           unsigned flag;
2217
2218           /* Process flags one bit at a time.  */
2219           flag = e_flags & - e_flags;
2220           e_flags &= ~ flag;
2221
2222           switch (flag)
2223             {
2224             case EF_ARM_BE8:
2225               strcat (buf, ", BE8");
2226               break;
2227
2228             case EF_ARM_LE8:
2229               strcat (buf, ", LE8");
2230               break;
2231
2232             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2233               strcat (buf, ", soft-float ABI");
2234               break;
2235
2236             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2237               strcat (buf, ", hard-float ABI");
2238               break;
2239
2240             default:
2241               unknown = 1;
2242               break;
2243             }
2244         }
2245       break;
2246
2247     case EF_ARM_EABI_UNKNOWN:
2248       strcat (buf, ", GNU EABI");
2249       while (e_flags)
2250         {
2251           unsigned flag;
2252
2253           /* Process flags one bit at a time.  */
2254           flag = e_flags & - e_flags;
2255           e_flags &= ~ flag;
2256
2257           switch (flag)
2258             {
2259             case EF_ARM_INTERWORK:
2260               strcat (buf, ", interworking enabled");
2261               break;
2262
2263             case EF_ARM_APCS_26:
2264               strcat (buf, ", uses APCS/26");
2265               break;
2266
2267             case EF_ARM_APCS_FLOAT:
2268               strcat (buf, ", uses APCS/float");
2269               break;
2270
2271             case EF_ARM_PIC:
2272               strcat (buf, ", position independent");
2273               break;
2274
2275             case EF_ARM_ALIGN8:
2276               strcat (buf, ", 8 bit structure alignment");
2277               break;
2278
2279             case EF_ARM_NEW_ABI:
2280               strcat (buf, ", uses new ABI");
2281               break;
2282
2283             case EF_ARM_OLD_ABI:
2284               strcat (buf, ", uses old ABI");
2285               break;
2286
2287             case EF_ARM_SOFT_FLOAT:
2288               strcat (buf, ", software FP");
2289               break;
2290
2291             case EF_ARM_VFP_FLOAT:
2292               strcat (buf, ", VFP");
2293               break;
2294
2295             case EF_ARM_MAVERICK_FLOAT:
2296               strcat (buf, ", Maverick FP");
2297               break;
2298
2299             default:
2300               unknown = 1;
2301               break;
2302             }
2303         }
2304     }
2305
2306   if (unknown)
2307     strcat (buf,_(", <unknown>"));
2308 }
2309
2310 static char *
2311 get_machine_flags (unsigned e_flags, unsigned e_machine)
2312 {
2313   static char buf[1024];
2314
2315   buf[0] = '\0';
2316
2317   if (e_flags)
2318     {
2319       switch (e_machine)
2320         {
2321         default:
2322           break;
2323
2324         case EM_ARM:
2325           decode_ARM_machine_flags (e_flags, buf);
2326           break;
2327
2328         case EM_BLACKFIN:
2329           if (e_flags & EF_BFIN_PIC)
2330             strcat (buf, ", PIC");
2331
2332           if (e_flags & EF_BFIN_FDPIC)
2333             strcat (buf, ", FDPIC");
2334
2335           if (e_flags & EF_BFIN_CODE_IN_L1)
2336             strcat (buf, ", code in L1");
2337
2338           if (e_flags & EF_BFIN_DATA_IN_L1)
2339             strcat (buf, ", data in L1");
2340
2341           break;
2342
2343         case EM_CYGNUS_FRV:
2344           switch (e_flags & EF_FRV_CPU_MASK)
2345             {
2346             case EF_FRV_CPU_GENERIC:
2347               break;
2348
2349             default:
2350               strcat (buf, ", fr???");
2351               break;
2352
2353             case EF_FRV_CPU_FR300:
2354               strcat (buf, ", fr300");
2355               break;
2356
2357             case EF_FRV_CPU_FR400:
2358               strcat (buf, ", fr400");
2359               break;
2360             case EF_FRV_CPU_FR405:
2361               strcat (buf, ", fr405");
2362               break;
2363
2364             case EF_FRV_CPU_FR450:
2365               strcat (buf, ", fr450");
2366               break;
2367
2368             case EF_FRV_CPU_FR500:
2369               strcat (buf, ", fr500");
2370               break;
2371             case EF_FRV_CPU_FR550:
2372               strcat (buf, ", fr550");
2373               break;
2374
2375             case EF_FRV_CPU_SIMPLE:
2376               strcat (buf, ", simple");
2377               break;
2378             case EF_FRV_CPU_TOMCAT:
2379               strcat (buf, ", tomcat");
2380               break;
2381             }
2382           break;
2383
2384         case EM_68K:
2385           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2386             strcat (buf, ", m68000");
2387           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2388             strcat (buf, ", cpu32");
2389           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2390             strcat (buf, ", fido_a");
2391           else
2392             {
2393               char const * isa = _("unknown");
2394               char const * mac = _("unknown mac");
2395               char const * additional = NULL;
2396
2397               switch (e_flags & EF_M68K_CF_ISA_MASK)
2398                 {
2399                 case EF_M68K_CF_ISA_A_NODIV:
2400                   isa = "A";
2401                   additional = ", nodiv";
2402                   break;
2403                 case EF_M68K_CF_ISA_A:
2404                   isa = "A";
2405                   break;
2406                 case EF_M68K_CF_ISA_A_PLUS:
2407                   isa = "A+";
2408                   break;
2409                 case EF_M68K_CF_ISA_B_NOUSP:
2410                   isa = "B";
2411                   additional = ", nousp";
2412                   break;
2413                 case EF_M68K_CF_ISA_B:
2414                   isa = "B";
2415                   break;
2416                 case EF_M68K_CF_ISA_C:
2417                   isa = "C";
2418                   break;
2419                 case EF_M68K_CF_ISA_C_NODIV:
2420                   isa = "C";
2421                   additional = ", nodiv";
2422                   break;
2423                 }
2424               strcat (buf, ", cf, isa ");
2425               strcat (buf, isa);
2426               if (additional)
2427                 strcat (buf, additional);
2428               if (e_flags & EF_M68K_CF_FLOAT)
2429                 strcat (buf, ", float");
2430               switch (e_flags & EF_M68K_CF_MAC_MASK)
2431                 {
2432                 case 0:
2433                   mac = NULL;
2434                   break;
2435                 case EF_M68K_CF_MAC:
2436                   mac = "mac";
2437                   break;
2438                 case EF_M68K_CF_EMAC:
2439                   mac = "emac";
2440                   break;
2441                 case EF_M68K_CF_EMAC_B:
2442                   mac = "emac_b";
2443                   break;
2444                 }
2445               if (mac)
2446                 {
2447                   strcat (buf, ", ");
2448                   strcat (buf, mac);
2449                 }
2450             }
2451           break;
2452
2453         case EM_PPC:
2454           if (e_flags & EF_PPC_EMB)
2455             strcat (buf, ", emb");
2456
2457           if (e_flags & EF_PPC_RELOCATABLE)
2458             strcat (buf, _(", relocatable"));
2459
2460           if (e_flags & EF_PPC_RELOCATABLE_LIB)
2461             strcat (buf, _(", relocatable-lib"));
2462           break;
2463
2464         case EM_PPC64:
2465           if (e_flags & EF_PPC64_ABI)
2466             {
2467               char abi[] = ", abiv0";
2468
2469               abi[6] += e_flags & EF_PPC64_ABI;
2470               strcat (buf, abi);
2471             }
2472           break;
2473
2474         case EM_V800:
2475           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2476             strcat (buf, ", RH850 ABI");
2477
2478           if (e_flags & EF_V800_850E3)
2479             strcat (buf, ", V3 architecture");
2480
2481           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2482             strcat (buf, ", FPU not used");
2483
2484           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2485             strcat (buf, ", regmode: COMMON");
2486
2487           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2488             strcat (buf, ", r4 not used");
2489
2490           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2491             strcat (buf, ", r30 not used");
2492
2493           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2494             strcat (buf, ", r5 not used");
2495
2496           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2497             strcat (buf, ", r2 not used");
2498
2499           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2500             {
2501               switch (e_flags & - e_flags)
2502                 {
2503                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2504                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2505                 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2506                 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2507                 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2508                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2509                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2510                 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2511                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2512                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2513                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2514                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2515                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2516                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2517                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2518                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2519                 default: break;
2520                 }
2521             }
2522           break;
2523
2524         case EM_V850:
2525         case EM_CYGNUS_V850:
2526           switch (e_flags & EF_V850_ARCH)
2527             {
2528             case E_V850E3V5_ARCH:
2529               strcat (buf, ", v850e3v5");
2530               break;
2531             case E_V850E2V3_ARCH:
2532               strcat (buf, ", v850e2v3");
2533               break;
2534             case E_V850E2_ARCH:
2535               strcat (buf, ", v850e2");
2536               break;
2537             case E_V850E1_ARCH:
2538               strcat (buf, ", v850e1");
2539               break;
2540             case E_V850E_ARCH:
2541               strcat (buf, ", v850e");
2542               break;
2543             case E_V850_ARCH:
2544               strcat (buf, ", v850");
2545               break;
2546             default:
2547               strcat (buf, _(", unknown v850 architecture variant"));
2548               break;
2549             }
2550           break;
2551
2552         case EM_M32R:
2553         case EM_CYGNUS_M32R:
2554           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2555             strcat (buf, ", m32r");
2556           break;
2557
2558         case EM_MIPS:
2559         case EM_MIPS_RS3_LE:
2560           if (e_flags & EF_MIPS_NOREORDER)
2561             strcat (buf, ", noreorder");
2562
2563           if (e_flags & EF_MIPS_PIC)
2564             strcat (buf, ", pic");
2565
2566           if (e_flags & EF_MIPS_CPIC)
2567             strcat (buf, ", cpic");
2568
2569           if (e_flags & EF_MIPS_UCODE)
2570             strcat (buf, ", ugen_reserved");
2571
2572           if (e_flags & EF_MIPS_ABI2)
2573             strcat (buf, ", abi2");
2574
2575           if (e_flags & EF_MIPS_OPTIONS_FIRST)
2576             strcat (buf, ", odk first");
2577
2578           if (e_flags & EF_MIPS_32BITMODE)
2579             strcat (buf, ", 32bitmode");
2580
2581           if (e_flags & EF_MIPS_NAN2008)
2582             strcat (buf, ", nan2008");
2583
2584           if (e_flags & EF_MIPS_FP64)
2585             strcat (buf, ", fp64");
2586
2587           switch ((e_flags & EF_MIPS_MACH))
2588             {
2589             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2590             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2591             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2592             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2593             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2594             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2595             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2596             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2597             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
2598             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2599             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2600             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2601             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
2602             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2603             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2604             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
2605             case 0:
2606             /* We simply ignore the field in this case to avoid confusion:
2607                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2608                extension.  */
2609               break;
2610             default: strcat (buf, _(", unknown CPU")); break;
2611             }
2612
2613           switch ((e_flags & EF_MIPS_ABI))
2614             {
2615             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2616             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2617             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2618             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2619             case 0:
2620             /* We simply ignore the field in this case to avoid confusion:
2621                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2622                This means it is likely to be an o32 file, but not for
2623                sure.  */
2624               break;
2625             default: strcat (buf, _(", unknown ABI")); break;
2626             }
2627
2628           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2629             strcat (buf, ", mdmx");
2630
2631           if (e_flags & EF_MIPS_ARCH_ASE_M16)
2632             strcat (buf, ", mips16");
2633
2634           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2635             strcat (buf, ", micromips");
2636
2637           switch ((e_flags & EF_MIPS_ARCH))
2638             {
2639             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2640             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2641             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2642             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2643             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2644             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2645             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2646             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2647             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2648             default: strcat (buf, _(", unknown ISA")); break;
2649             }
2650           break;
2651
2652         case EM_SH:
2653           switch ((e_flags & EF_SH_MACH_MASK))
2654             {
2655             case EF_SH1: strcat (buf, ", sh1"); break;
2656             case EF_SH2: strcat (buf, ", sh2"); break;
2657             case EF_SH3: strcat (buf, ", sh3"); break;
2658             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2659             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2660             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2661             case EF_SH3E: strcat (buf, ", sh3e"); break;
2662             case EF_SH4: strcat (buf, ", sh4"); break;
2663             case EF_SH5: strcat (buf, ", sh5"); break;
2664             case EF_SH2E: strcat (buf, ", sh2e"); break;
2665             case EF_SH4A: strcat (buf, ", sh4a"); break;
2666             case EF_SH2A: strcat (buf, ", sh2a"); break;
2667             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2668             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2669             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2670             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2671             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2672             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2673             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2674             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2675             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2676             default: strcat (buf, _(", unknown ISA")); break;
2677             }
2678
2679           if (e_flags & EF_SH_PIC)
2680             strcat (buf, ", pic");
2681
2682           if (e_flags & EF_SH_FDPIC)
2683             strcat (buf, ", fdpic");
2684           break;
2685
2686         case EM_SPARCV9:
2687           if (e_flags & EF_SPARC_32PLUS)
2688             strcat (buf, ", v8+");
2689
2690           if (e_flags & EF_SPARC_SUN_US1)
2691             strcat (buf, ", ultrasparcI");
2692
2693           if (e_flags & EF_SPARC_SUN_US3)
2694             strcat (buf, ", ultrasparcIII");
2695
2696           if (e_flags & EF_SPARC_HAL_R1)
2697             strcat (buf, ", halr1");
2698
2699           if (e_flags & EF_SPARC_LEDATA)
2700             strcat (buf, ", ledata");
2701
2702           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2703             strcat (buf, ", tso");
2704
2705           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2706             strcat (buf, ", pso");
2707
2708           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2709             strcat (buf, ", rmo");
2710           break;
2711
2712         case EM_PARISC:
2713           switch (e_flags & EF_PARISC_ARCH)
2714             {
2715             case EFA_PARISC_1_0:
2716               strcpy (buf, ", PA-RISC 1.0");
2717               break;
2718             case EFA_PARISC_1_1:
2719               strcpy (buf, ", PA-RISC 1.1");
2720               break;
2721             case EFA_PARISC_2_0:
2722               strcpy (buf, ", PA-RISC 2.0");
2723               break;
2724             default:
2725               break;
2726             }
2727           if (e_flags & EF_PARISC_TRAPNIL)
2728             strcat (buf, ", trapnil");
2729           if (e_flags & EF_PARISC_EXT)
2730             strcat (buf, ", ext");
2731           if (e_flags & EF_PARISC_LSB)
2732             strcat (buf, ", lsb");
2733           if (e_flags & EF_PARISC_WIDE)
2734             strcat (buf, ", wide");
2735           if (e_flags & EF_PARISC_NO_KABP)
2736             strcat (buf, ", no kabp");
2737           if (e_flags & EF_PARISC_LAZYSWAP)
2738             strcat (buf, ", lazyswap");
2739           break;
2740
2741         case EM_PJ:
2742         case EM_PJ_OLD:
2743           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2744             strcat (buf, ", new calling convention");
2745
2746           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2747             strcat (buf, ", gnu calling convention");
2748           break;
2749
2750         case EM_IA_64:
2751           if ((e_flags & EF_IA_64_ABI64))
2752             strcat (buf, ", 64-bit");
2753           else
2754             strcat (buf, ", 32-bit");
2755           if ((e_flags & EF_IA_64_REDUCEDFP))
2756             strcat (buf, ", reduced fp model");
2757           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2758             strcat (buf, ", no function descriptors, constant gp");
2759           else if ((e_flags & EF_IA_64_CONS_GP))
2760             strcat (buf, ", constant gp");
2761           if ((e_flags & EF_IA_64_ABSOLUTE))
2762             strcat (buf, ", absolute");
2763           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2764             {
2765               if ((e_flags & EF_IA_64_VMS_LINKAGES))
2766                 strcat (buf, ", vms_linkages");
2767               switch ((e_flags & EF_IA_64_VMS_COMCOD))
2768                 {
2769                 case EF_IA_64_VMS_COMCOD_SUCCESS:
2770                   break;
2771                 case EF_IA_64_VMS_COMCOD_WARNING:
2772                   strcat (buf, ", warning");
2773                   break;
2774                 case EF_IA_64_VMS_COMCOD_ERROR:
2775                   strcat (buf, ", error");
2776                   break;
2777                 case EF_IA_64_VMS_COMCOD_ABORT:
2778                   strcat (buf, ", abort");
2779                   break;
2780                 default:
2781                   abort ();
2782                 }
2783             }
2784           break;
2785
2786         case EM_VAX:
2787           if ((e_flags & EF_VAX_NONPIC))
2788             strcat (buf, ", non-PIC");
2789           if ((e_flags & EF_VAX_DFLOAT))
2790             strcat (buf, ", D-Float");
2791           if ((e_flags & EF_VAX_GFLOAT))
2792             strcat (buf, ", G-Float");
2793           break;
2794
2795         case EM_RL78:
2796           if (e_flags & E_FLAG_RL78_G10)
2797             strcat (buf, ", G10");
2798           break;
2799
2800         case EM_RX:
2801           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2802             strcat (buf, ", 64-bit doubles");
2803           if (e_flags & E_FLAG_RX_DSP)
2804             strcat (buf, ", dsp");
2805           if (e_flags & E_FLAG_RX_PID)
2806             strcat (buf, ", pid");
2807           if (e_flags & E_FLAG_RX_ABI)
2808             strcat (buf, ", RX ABI");
2809           break;
2810
2811         case EM_S390:
2812           if (e_flags & EF_S390_HIGH_GPRS)
2813             strcat (buf, ", highgprs");
2814           break;
2815
2816         case EM_TI_C6000:
2817           if ((e_flags & EF_C6000_REL))
2818             strcat (buf, ", relocatable module");
2819           break;
2820
2821         case EM_MSP430:
2822           strcat (buf, _(": architecture variant: "));
2823           switch (e_flags & EF_MSP430_MACH)
2824             {
2825             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
2826             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
2827             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
2828             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
2829             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
2830             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
2831             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
2832             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
2833             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
2834             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
2835             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
2836             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
2837             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
2838             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
2839             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
2840             default:
2841               strcat (buf, _(": unknown")); break;
2842             }
2843
2844           if (e_flags & ~ EF_MSP430_MACH)
2845             strcat (buf, _(": unknown extra flag bits also present"));
2846         }
2847     }
2848
2849   return buf;
2850 }
2851
2852 static const char *
2853 get_osabi_name (unsigned int osabi)
2854 {
2855   static char buff[32];
2856
2857   switch (osabi)
2858     {
2859     case ELFOSABI_NONE:         return "UNIX - System V";
2860     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
2861     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
2862     case ELFOSABI_GNU:          return "UNIX - GNU";
2863     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
2864     case ELFOSABI_AIX:          return "UNIX - AIX";
2865     case ELFOSABI_IRIX:         return "UNIX - IRIX";
2866     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
2867     case ELFOSABI_TRU64:        return "UNIX - TRU64";
2868     case ELFOSABI_MODESTO:      return "Novell - Modesto";
2869     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
2870     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
2871     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
2872     case ELFOSABI_AROS:         return "AROS";
2873     case ELFOSABI_FENIXOS:      return "FenixOS";
2874     default:
2875       if (osabi >= 64)
2876         switch (elf_header.e_machine)
2877           {
2878           case EM_ARM:
2879             switch (osabi)
2880               {
2881               case ELFOSABI_ARM:        return "ARM";
2882               default:
2883                 break;
2884               }
2885             break;
2886
2887           case EM_MSP430:
2888           case EM_MSP430_OLD:
2889             switch (osabi)
2890               {
2891               case ELFOSABI_STANDALONE: return _("Standalone App");
2892               default:
2893                 break;
2894               }
2895             break;
2896
2897           case EM_TI_C6000:
2898             switch (osabi)
2899               {
2900               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
2901               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
2902               default:
2903                 break;
2904               }
2905             break;
2906
2907           default:
2908             break;
2909           }
2910       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2911       return buff;
2912     }
2913 }
2914
2915 static const char *
2916 get_aarch64_segment_type (unsigned long type)
2917 {
2918   switch (type)
2919     {
2920     case PT_AARCH64_ARCHEXT:
2921       return "AARCH64_ARCHEXT";
2922     default:
2923       break;
2924     }
2925
2926   return NULL;
2927 }
2928
2929 static const char *
2930 get_arm_segment_type (unsigned long type)
2931 {
2932   switch (type)
2933     {
2934     case PT_ARM_EXIDX:
2935       return "EXIDX";
2936     default:
2937       break;
2938     }
2939
2940   return NULL;
2941 }
2942
2943 static const char *
2944 get_mips_segment_type (unsigned long type)
2945 {
2946   switch (type)
2947     {
2948     case PT_MIPS_REGINFO:
2949       return "REGINFO";
2950     case PT_MIPS_RTPROC:
2951       return "RTPROC";
2952     case PT_MIPS_OPTIONS:
2953       return "OPTIONS";
2954     default:
2955       break;
2956     }
2957
2958   return NULL;
2959 }
2960
2961 static const char *
2962 get_parisc_segment_type (unsigned long type)
2963 {
2964   switch (type)
2965     {
2966     case PT_HP_TLS:             return "HP_TLS";
2967     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
2968     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
2969     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
2970     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
2971     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
2972     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
2973     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
2974     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
2975     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
2976     case PT_HP_PARALLEL:        return "HP_PARALLEL";
2977     case PT_HP_FASTBIND:        return "HP_FASTBIND";
2978     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
2979     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
2980     case PT_HP_STACK:           return "HP_STACK";
2981     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
2982     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
2983     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
2984     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
2985     default:
2986       break;
2987     }
2988
2989   return NULL;
2990 }
2991
2992 static const char *
2993 get_ia64_segment_type (unsigned long type)
2994 {
2995   switch (type)
2996     {
2997     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
2998     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
2999     case PT_HP_TLS:             return "HP_TLS";
3000     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3001     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3002     case PT_IA_64_HP_STACK:     return "HP_STACK";
3003     default:
3004       break;
3005     }
3006
3007   return NULL;
3008 }
3009
3010 static const char *
3011 get_tic6x_segment_type (unsigned long type)
3012 {
3013   switch (type)
3014     {
3015     case PT_C6000_PHATTR:       return "C6000_PHATTR";
3016     default:
3017       break;
3018     }
3019
3020   return NULL;
3021 }
3022
3023 static const char *
3024 get_segment_type (unsigned long p_type)
3025 {
3026   static char buff[32];
3027
3028   switch (p_type)
3029     {
3030     case PT_NULL:       return "NULL";
3031     case PT_LOAD:       return "LOAD";
3032     case PT_DYNAMIC:    return "DYNAMIC";
3033     case PT_INTERP:     return "INTERP";
3034     case PT_NOTE:       return "NOTE";
3035     case PT_SHLIB:      return "SHLIB";
3036     case PT_PHDR:       return "PHDR";
3037     case PT_TLS:        return "TLS";
3038
3039     case PT_GNU_EH_FRAME:
3040                         return "GNU_EH_FRAME";
3041     case PT_GNU_STACK:  return "GNU_STACK";
3042     case PT_GNU_RELRO:  return "GNU_RELRO";
3043
3044     default:
3045       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3046         {
3047           const char * result;
3048
3049           switch (elf_header.e_machine)
3050             {
3051             case EM_AARCH64:
3052               result = get_aarch64_segment_type (p_type);
3053               break;
3054             case EM_ARM:
3055               result = get_arm_segment_type (p_type);
3056               break;
3057             case EM_MIPS:
3058             case EM_MIPS_RS3_LE:
3059               result = get_mips_segment_type (p_type);
3060               break;
3061             case EM_PARISC:
3062               result = get_parisc_segment_type (p_type);
3063               break;
3064             case EM_IA_64:
3065               result = get_ia64_segment_type (p_type);
3066               break;
3067             case EM_TI_C6000:
3068               result = get_tic6x_segment_type (p_type);
3069               break;
3070             default:
3071               result = NULL;
3072               break;
3073             }
3074
3075           if (result != NULL)
3076             return result;
3077
3078           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3079         }
3080       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3081         {
3082           const char * result;
3083
3084           switch (elf_header.e_machine)
3085             {
3086             case EM_PARISC:
3087               result = get_parisc_segment_type (p_type);
3088               break;
3089             case EM_IA_64:
3090               result = get_ia64_segment_type (p_type);
3091               break;
3092             default:
3093               result = NULL;
3094               break;
3095             }
3096
3097           if (result != NULL)
3098             return result;
3099
3100           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3101         }
3102       else
3103         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3104
3105       return buff;
3106     }
3107 }
3108
3109 static const char *
3110 get_mips_section_type_name (unsigned int sh_type)
3111 {
3112   switch (sh_type)
3113     {
3114     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3115     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3116     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3117     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3118     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3119     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3120     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3121     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3122     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3123     case SHT_MIPS_RELD:          return "MIPS_RELD";
3124     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3125     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3126     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3127     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3128     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3129     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3130     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3131     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3132     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3133     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3134     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3135     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3136     case SHT_MIPS_LINE:          return "MIPS_LINE";
3137     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3138     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3139     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3140     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3141     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3142     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3143     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3144     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3145     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3146     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3147     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3148     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3149     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3150     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3151     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3152     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3153     default:
3154       break;
3155     }
3156   return NULL;
3157 }
3158
3159 static const char *
3160 get_parisc_section_type_name (unsigned int sh_type)
3161 {
3162   switch (sh_type)
3163     {
3164     case SHT_PARISC_EXT:        return "PARISC_EXT";
3165     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
3166     case SHT_PARISC_DOC:        return "PARISC_DOC";
3167     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
3168     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
3169     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
3170     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
3171     default:
3172       break;
3173     }
3174   return NULL;
3175 }
3176
3177 static const char *
3178 get_ia64_section_type_name (unsigned int sh_type)
3179 {
3180   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
3181   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3182     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3183
3184   switch (sh_type)
3185     {
3186     case SHT_IA_64_EXT:                return "IA_64_EXT";
3187     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
3188     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
3189     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
3190     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3191     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
3192     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
3193     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
3194     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
3195     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
3196     default:
3197       break;
3198     }
3199   return NULL;
3200 }
3201
3202 static const char *
3203 get_x86_64_section_type_name (unsigned int sh_type)
3204 {
3205   switch (sh_type)
3206     {
3207     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
3208     default:
3209       break;
3210     }
3211   return NULL;
3212 }
3213
3214 static const char *
3215 get_aarch64_section_type_name (unsigned int sh_type)
3216 {
3217   switch (sh_type)
3218     {
3219     case SHT_AARCH64_ATTRIBUTES:
3220       return "AARCH64_ATTRIBUTES";
3221     default:
3222       break;
3223     }
3224   return NULL;
3225 }
3226
3227 static const char *
3228 get_arm_section_type_name (unsigned int sh_type)
3229 {
3230   switch (sh_type)
3231     {
3232     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
3233     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
3234     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
3235     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
3236     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
3237     default:
3238       break;
3239     }
3240   return NULL;
3241 }
3242
3243 static const char *
3244 get_tic6x_section_type_name (unsigned int sh_type)
3245 {
3246   switch (sh_type)
3247     {
3248     case SHT_C6000_UNWIND:
3249       return "C6000_UNWIND";
3250     case SHT_C6000_PREEMPTMAP:
3251       return "C6000_PREEMPTMAP";
3252     case SHT_C6000_ATTRIBUTES:
3253       return "C6000_ATTRIBUTES";
3254     case SHT_TI_ICODE:
3255       return "TI_ICODE";
3256     case SHT_TI_XREF:
3257       return "TI_XREF";
3258     case SHT_TI_HANDLER:
3259       return "TI_HANDLER";
3260     case SHT_TI_INITINFO:
3261       return "TI_INITINFO";
3262     case SHT_TI_PHATTRS:
3263       return "TI_PHATTRS";
3264     default:
3265       break;
3266     }
3267   return NULL;
3268 }
3269
3270 static const char *
3271 get_msp430x_section_type_name (unsigned int sh_type)
3272 {
3273   switch (sh_type)
3274     {
3275     case SHT_MSP430_SEC_FLAGS:   return "MSP430_SEC_FLAGS";
3276     case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3277     case SHT_MSP430_ATTRIBUTES:  return "MSP430_ATTRIBUTES";
3278     default: return NULL;
3279     }
3280 }
3281
3282 static const char *
3283 get_section_type_name (unsigned int sh_type)
3284 {
3285   static char buff[32];
3286
3287   switch (sh_type)
3288     {
3289     case SHT_NULL:              return "NULL";
3290     case SHT_PROGBITS:          return "PROGBITS";
3291     case SHT_SYMTAB:            return "SYMTAB";
3292     case SHT_STRTAB:            return "STRTAB";
3293     case SHT_RELA:              return "RELA";
3294     case SHT_HASH:              return "HASH";
3295     case SHT_DYNAMIC:           return "DYNAMIC";
3296     case SHT_NOTE:              return "NOTE";
3297     case SHT_NOBITS:            return "NOBITS";
3298     case SHT_REL:               return "REL";
3299     case SHT_SHLIB:             return "SHLIB";
3300     case SHT_DYNSYM:            return "DYNSYM";
3301     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
3302     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
3303     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
3304     case SHT_GNU_HASH:          return "GNU_HASH";
3305     case SHT_GROUP:             return "GROUP";
3306     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
3307     case SHT_GNU_verdef:        return "VERDEF";
3308     case SHT_GNU_verneed:       return "VERNEED";
3309     case SHT_GNU_versym:        return "VERSYM";
3310     case 0x6ffffff0:            return "VERSYM";
3311     case 0x6ffffffc:            return "VERDEF";
3312     case 0x7ffffffd:            return "AUXILIARY";
3313     case 0x7fffffff:            return "FILTER";
3314     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
3315
3316     default:
3317       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3318         {
3319           const char * result;
3320
3321           switch (elf_header.e_machine)
3322             {
3323             case EM_MIPS:
3324             case EM_MIPS_RS3_LE:
3325               result = get_mips_section_type_name (sh_type);
3326               break;
3327             case EM_PARISC:
3328               result = get_parisc_section_type_name (sh_type);
3329               break;
3330             case EM_IA_64:
3331               result = get_ia64_section_type_name (sh_type);
3332               break;
3333             case EM_X86_64:
3334             case EM_L1OM:
3335             case EM_K1OM:
3336               result = get_x86_64_section_type_name (sh_type);
3337               break;
3338             case EM_AARCH64:
3339               result = get_aarch64_section_type_name (sh_type);
3340               break;
3341             case EM_ARM:
3342               result = get_arm_section_type_name (sh_type);
3343               break;
3344             case EM_TI_C6000:
3345               result = get_tic6x_section_type_name (sh_type);
3346               break;
3347             case EM_MSP430:
3348               result = get_msp430x_section_type_name (sh_type);
3349               break;
3350             default:
3351               result = NULL;
3352               break;
3353             }
3354
3355           if (result != NULL)
3356             return result;
3357
3358           sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3359         }
3360       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3361         {
3362           const char * result;
3363
3364           switch (elf_header.e_machine)
3365             {
3366             case EM_IA_64:
3367               result = get_ia64_section_type_name (sh_type);
3368               break;
3369             default:
3370               result = NULL;
3371               break;
3372             }
3373
3374           if (result != NULL)
3375             return result;
3376
3377           sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3378         }
3379       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3380         sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3381       else
3382         /* This message is probably going to be displayed in a 15
3383            character wide field, so put the hex value first.  */
3384         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3385
3386       return buff;
3387     }
3388 }
3389
3390 #define OPTION_DEBUG_DUMP       512
3391 #define OPTION_DYN_SYMS         513
3392 #define OPTION_DWARF_DEPTH      514
3393 #define OPTION_DWARF_START      515
3394 #define OPTION_DWARF_CHECK      516
3395
3396 static struct option options[] =
3397 {
3398   {"all",              no_argument, 0, 'a'},
3399   {"file-header",      no_argument, 0, 'h'},
3400   {"program-headers",  no_argument, 0, 'l'},
3401   {"headers",          no_argument, 0, 'e'},
3402   {"histogram",        no_argument, 0, 'I'},
3403   {"segments",         no_argument, 0, 'l'},
3404   {"sections",         no_argument, 0, 'S'},
3405   {"section-headers",  no_argument, 0, 'S'},
3406   {"section-groups",   no_argument, 0, 'g'},
3407   {"section-details",  no_argument, 0, 't'},
3408   {"full-section-name",no_argument, 0, 'N'},
3409   {"symbols",          no_argument, 0, 's'},
3410   {"syms",             no_argument, 0, 's'},
3411   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
3412   {"relocs",           no_argument, 0, 'r'},
3413   {"notes",            no_argument, 0, 'n'},
3414   {"dynamic",          no_argument, 0, 'd'},
3415   {"arch-specific",    no_argument, 0, 'A'},
3416   {"version-info",     no_argument, 0, 'V'},
3417   {"use-dynamic",      no_argument, 0, 'D'},
3418   {"unwind",           no_argument, 0, 'u'},
3419   {"archive-index",    no_argument, 0, 'c'},
3420   {"hex-dump",         required_argument, 0, 'x'},
3421   {"relocated-dump",   required_argument, 0, 'R'},
3422   {"string-dump",      required_argument, 0, 'p'},
3423 #ifdef SUPPORT_DISASSEMBLY
3424   {"instruction-dump", required_argument, 0, 'i'},
3425 #endif
3426   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
3427
3428   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
3429   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
3430   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
3431
3432   {"version",          no_argument, 0, 'v'},
3433   {"wide",             no_argument, 0, 'W'},
3434   {"help",             no_argument, 0, 'H'},
3435   {0,                  no_argument, 0, 0}
3436 };
3437
3438 static void
3439 usage (FILE * stream)
3440 {
3441   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3442   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3443   fprintf (stream, _(" Options are:\n\
3444   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3445   -h --file-header       Display the ELF file header\n\
3446   -l --program-headers   Display the program headers\n\
3447      --segments          An alias for --program-headers\n\
3448   -S --section-headers   Display the sections' header\n\
3449      --sections          An alias for --section-headers\n\
3450   -g --section-groups    Display the section groups\n\
3451   -t --section-details   Display the section details\n\
3452   -e --headers           Equivalent to: -h -l -S\n\
3453   -s --syms              Display the symbol table\n\
3454      --symbols           An alias for --syms\n\
3455   --dyn-syms             Display the dynamic symbol table\n\
3456   -n --notes             Display the core notes (if present)\n\
3457   -r --relocs            Display the relocations (if present)\n\
3458   -u --unwind            Display the unwind info (if present)\n\
3459   -d --dynamic           Display the dynamic section (if present)\n\
3460   -V --version-info      Display the version sections (if present)\n\
3461   -A --arch-specific     Display architecture specific information (if any)\n\
3462   -c --archive-index     Display the symbol/file index in an archive\n\
3463   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
3464   -x --hex-dump=<number|name>\n\
3465                          Dump the contents of section <number|name> as bytes\n\
3466   -p --string-dump=<number|name>\n\
3467                          Dump the contents of section <number|name> as strings\n\
3468   -R --relocated-dump=<number|name>\n\
3469                          Dump the contents of section <number|name> as relocated bytes\n\
3470   -w[lLiaprmfFsoRt] or\n\
3471   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3472                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3473                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3474                =addr,=cu_index]\n\
3475                          Display the contents of DWARF2 debug sections\n"));
3476   fprintf (stream, _("\
3477   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
3478   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
3479                          or deeper\n"));
3480 #ifdef SUPPORT_DISASSEMBLY
3481   fprintf (stream, _("\
3482   -i --instruction-dump=<number|name>\n\
3483                          Disassemble the contents of section <number|name>\n"));
3484 #endif
3485   fprintf (stream, _("\
3486   -I --histogram         Display histogram of bucket list lengths\n\
3487   -W --wide              Allow output width to exceed 80 characters\n\
3488   @<file>                Read options from <file>\n\
3489   -H --help              Display this information\n\
3490   -v --version           Display the version number of readelf\n"));
3491
3492   if (REPORT_BUGS_TO[0] && stream == stdout)
3493     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3494
3495   exit (stream == stdout ? 0 : 1);
3496 }
3497
3498 /* Record the fact that the user wants the contents of section number
3499    SECTION to be displayed using the method(s) encoded as flags bits
3500    in TYPE.  Note, TYPE can be zero if we are creating the array for
3501    the first time.  */
3502
3503 static void
3504 request_dump_bynumber (unsigned int section, dump_type type)
3505 {
3506   if (section >= num_dump_sects)
3507     {
3508       dump_type * new_dump_sects;
3509
3510       new_dump_sects = (dump_type *) calloc (section + 1,
3511                                              sizeof (* dump_sects));
3512
3513       if (new_dump_sects == NULL)
3514         error (_("Out of memory allocating dump request table.\n"));
3515       else
3516         {
3517           /* Copy current flag settings.  */
3518           memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3519
3520           free (dump_sects);
3521
3522           dump_sects = new_dump_sects;
3523           num_dump_sects = section + 1;
3524         }
3525     }
3526
3527   if (dump_sects)
3528     dump_sects[section] |= type;
3529
3530   return;
3531 }
3532
3533 /* Request a dump by section name.  */
3534
3535 static void
3536 request_dump_byname (const char * section, dump_type type)
3537 {
3538   struct dump_list_entry * new_request;
3539
3540   new_request = (struct dump_list_entry *)
3541       malloc (sizeof (struct dump_list_entry));
3542   if (!new_request)
3543     error (_("Out of memory allocating dump request table.\n"));
3544
3545   new_request->name = strdup (section);
3546   if (!new_request->name)
3547     error (_("Out of memory allocating dump request table.\n"));
3548
3549   new_request->type = type;
3550
3551   new_request->next = dump_sects_byname;
3552   dump_sects_byname = new_request;
3553 }
3554
3555 static inline void
3556 request_dump (dump_type type)
3557 {
3558   int section;
3559   char * cp;
3560
3561   do_dump++;
3562   section = strtoul (optarg, & cp, 0);
3563
3564   if (! *cp && section >= 0)
3565     request_dump_bynumber (section, type);
3566   else
3567     request_dump_byname (optarg, type);
3568 }
3569
3570
3571 static void
3572 parse_args (int argc, char ** argv)
3573 {
3574   int c;
3575
3576   if (argc < 2)
3577     usage (stderr);
3578
3579   while ((c = getopt_long
3580           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3581     {
3582       switch (c)
3583         {
3584         case 0:
3585           /* Long options.  */
3586           break;
3587         case 'H':
3588           usage (stdout);
3589           break;
3590
3591         case 'a':
3592           do_syms++;
3593           do_reloc++;
3594           do_unwind++;
3595           do_dynamic++;
3596           do_header++;
3597           do_sections++;
3598           do_section_groups++;
3599           do_segments++;
3600           do_version++;
3601           do_histogram++;
3602           do_arch++;
3603           do_notes++;
3604           break;
3605         case 'g':
3606           do_section_groups++;
3607           break;
3608         case 't':
3609         case 'N':
3610           do_sections++;
3611           do_section_details++;
3612           break;
3613         case 'e':
3614           do_header++;
3615           do_sections++;
3616           do_segments++;
3617           break;
3618         case 'A':
3619           do_arch++;
3620           break;
3621         case 'D':
3622           do_using_dynamic++;
3623           break;
3624         case 'r':
3625           do_reloc++;
3626           break;
3627         case 'u':
3628           do_unwind++;
3629           break;
3630         case 'h':
3631           do_header++;
3632           break;
3633         case 'l':
3634           do_segments++;
3635           break;
3636         case 's':
3637           do_syms++;
3638           break;
3639         case 'S':
3640           do_sections++;
3641           break;
3642         case 'd':
3643           do_dynamic++;
3644           break;
3645         case 'I':
3646           do_histogram++;
3647           break;
3648         case 'n':
3649           do_notes++;
3650           break;
3651         case 'c':
3652           do_archive_index++;
3653           break;
3654         case 'x':
3655           request_dump (HEX_DUMP);
3656           break;
3657         case 'p':
3658           request_dump (STRING_DUMP);
3659           break;
3660         case 'R':
3661           request_dump (RELOC_DUMP);
3662           break;
3663         case 'w':
3664           do_dump++;
3665           if (optarg == 0)
3666             {
3667               do_debugging = 1;
3668               dwarf_select_sections_all ();
3669             }
3670           else
3671             {
3672               do_debugging = 0;
3673               dwarf_select_sections_by_letters (optarg);
3674             }
3675           break;
3676         case OPTION_DEBUG_DUMP:
3677           do_dump++;
3678           if (optarg == 0)
3679             do_debugging = 1;
3680           else
3681             {
3682               do_debugging = 0;
3683               dwarf_select_sections_by_names (optarg);
3684             }
3685           break;
3686         case OPTION_DWARF_DEPTH:
3687           {
3688             char *cp;
3689
3690             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3691           }
3692           break;
3693         case OPTION_DWARF_START:
3694           {
3695             char *cp;
3696
3697             dwarf_start_die = strtoul (optarg, & cp, 0);
3698           }
3699           break;
3700         case OPTION_DWARF_CHECK:
3701           dwarf_check = 1;
3702           break;
3703         case OPTION_DYN_SYMS:
3704           do_dyn_syms++;
3705           break;
3706 #ifdef SUPPORT_DISASSEMBLY
3707         case 'i':
3708           request_dump (DISASS_DUMP);
3709           break;
3710 #endif
3711         case 'v':
3712           print_version (program_name);
3713           break;
3714         case 'V':
3715           do_version++;
3716           break;
3717         case 'W':
3718           do_wide++;
3719           break;
3720         default:
3721           /* xgettext:c-format */
3722           error (_("Invalid option '-%c'\n"), c);
3723           /* Drop through.  */
3724         case '?':
3725           usage (stderr);
3726         }
3727     }
3728
3729   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3730       && !do_segments && !do_header && !do_dump && !do_version
3731       && !do_histogram && !do_debugging && !do_arch && !do_notes
3732       && !do_section_groups && !do_archive_index
3733       && !do_dyn_syms)
3734     usage (stderr);
3735   else if (argc < 3)
3736     {
3737       warn (_("Nothing to do.\n"));
3738       usage (stderr);
3739     }
3740 }
3741
3742 static const char *
3743 get_elf_class (unsigned int elf_class)
3744 {
3745   static char buff[32];
3746
3747   switch (elf_class)
3748     {
3749     case ELFCLASSNONE: return _("none");
3750     case ELFCLASS32:   return "ELF32";
3751     case ELFCLASS64:   return "ELF64";
3752     default:
3753       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3754       return buff;
3755     }
3756 }
3757
3758 static const char *
3759 get_data_encoding (unsigned int encoding)
3760 {
3761   static char buff[32];
3762
3763   switch (encoding)
3764     {
3765     case ELFDATANONE: return _("none");
3766     case ELFDATA2LSB: return _("2's complement, little endian");
3767     case ELFDATA2MSB: return _("2's complement, big endian");
3768     default:
3769       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3770       return buff;
3771     }
3772 }
3773
3774 /* Decode the data held in 'elf_header'.  */
3775
3776 static int
3777 process_file_header (void)
3778 {
3779   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
3780       || elf_header.e_ident[EI_MAG1] != ELFMAG1
3781       || elf_header.e_ident[EI_MAG2] != ELFMAG2
3782       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3783     {
3784       error
3785         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3786       return 0;
3787     }
3788
3789   init_dwarf_regnames (elf_header.e_machine);
3790
3791   if (do_header)
3792     {
3793       int i;
3794
3795       printf (_("ELF Header:\n"));
3796       printf (_("  Magic:   "));
3797       for (i = 0; i < EI_NIDENT; i++)
3798         printf ("%2.2x ", elf_header.e_ident[i]);
3799       printf ("\n");
3800       printf (_("  Class:                             %s\n"),
3801               get_elf_class (elf_header.e_ident[EI_CLASS]));
3802       printf (_("  Data:                              %s\n"),
3803               get_data_encoding (elf_header.e_ident[EI_DATA]));
3804       printf (_("  Version:                           %d %s\n"),
3805               elf_header.e_ident[EI_VERSION],
3806               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3807                ? "(current)"
3808                : (elf_header.e_ident[EI_VERSION] != EV_NONE
3809                   ? _("<unknown: %lx>")
3810                   : "")));
3811       printf (_("  OS/ABI:                            %s\n"),
3812               get_osabi_name (elf_header.e_ident[EI_OSABI]));
3813       printf (_("  ABI Version:                       %d\n"),
3814               elf_header.e_ident[EI_ABIVERSION]);
3815       printf (_("  Type:                              %s\n"),
3816               get_file_type (elf_header.e_type));
3817       printf (_("  Machine:                           %s\n"),
3818               get_machine_name (elf_header.e_machine));
3819       printf (_("  Version:                           0x%lx\n"),
3820               (unsigned long) elf_header.e_version);
3821
3822       printf (_("  Entry point address:               "));
3823       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3824       printf (_("\n  Start of program headers:          "));
3825       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3826       printf (_(" (bytes into file)\n  Start of section headers:          "));
3827       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3828       printf (_(" (bytes into file)\n"));
3829
3830       printf (_("  Flags:                             0x%lx%s\n"),
3831               (unsigned long) elf_header.e_flags,
3832               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3833       printf (_("  Size of this header:               %ld (bytes)\n"),
3834               (long) elf_header.e_ehsize);
3835       printf (_("  Size of program headers:           %ld (bytes)\n"),
3836               (long) elf_header.e_phentsize);
3837       printf (_("  Number of program headers:         %ld"),
3838               (long) elf_header.e_phnum);
3839       if (section_headers != NULL
3840           && elf_header.e_phnum == PN_XNUM
3841           && section_headers[0].sh_info != 0)
3842         printf (" (%ld)", (long) section_headers[0].sh_info);
3843       putc ('\n', stdout);
3844       printf (_("  Size of section headers:           %ld (bytes)\n"),
3845               (long) elf_header.e_shentsize);
3846       printf (_("  Number of section headers:         %ld"),
3847               (long) elf_header.e_shnum);
3848       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
3849         printf (" (%ld)", (long) section_headers[0].sh_size);
3850       putc ('\n', stdout);
3851       printf (_("  Section header string table index: %ld"),
3852               (long) elf_header.e_shstrndx);
3853       if (section_headers != NULL
3854           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3855         printf (" (%u)", section_headers[0].sh_link);
3856       else if (elf_header.e_shstrndx != SHN_UNDEF
3857                && elf_header.e_shstrndx >= elf_header.e_shnum)
3858         printf (_(" <corrupt: out of range>"));
3859       putc ('\n', stdout);
3860     }
3861
3862   if (section_headers != NULL)
3863     {
3864       if (elf_header.e_phnum == PN_XNUM
3865           && section_headers[0].sh_info != 0)
3866         elf_header.e_phnum = section_headers[0].sh_info;
3867       if (elf_header.e_shnum == SHN_UNDEF)
3868         elf_header.e_shnum = section_headers[0].sh_size;
3869       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3870         elf_header.e_shstrndx = section_headers[0].sh_link;
3871       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3872         elf_header.e_shstrndx = SHN_UNDEF;
3873       free (section_headers);
3874       section_headers = NULL;
3875     }
3876
3877   return 1;
3878 }
3879
3880
3881 static int
3882 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3883 {
3884   Elf32_External_Phdr * phdrs;
3885   Elf32_External_Phdr * external;
3886   Elf_Internal_Phdr *   internal;
3887   unsigned int i;
3888
3889   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3890                                             elf_header.e_phentsize,
3891                                             elf_header.e_phnum,
3892                                             _("program headers"));
3893   if (!phdrs)
3894     return 0;
3895
3896   for (i = 0, internal = pheaders, external = phdrs;
3897        i < elf_header.e_phnum;
3898        i++, internal++, external++)
3899     {
3900       internal->p_type   = BYTE_GET (external->p_type);
3901       internal->p_offset = BYTE_GET (external->p_offset);
3902       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
3903       internal->p_paddr  = BYTE_GET (external->p_paddr);
3904       internal->p_filesz = BYTE_GET (external->p_filesz);
3905       internal->p_memsz  = BYTE_GET (external->p_memsz);
3906       internal->p_flags  = BYTE_GET (external->p_flags);
3907       internal->p_align  = BYTE_GET (external->p_align);
3908     }
3909
3910   free (phdrs);
3911
3912   return 1;
3913 }
3914
3915 static int
3916 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3917 {
3918   Elf64_External_Phdr * phdrs;
3919   Elf64_External_Phdr * external;
3920   Elf_Internal_Phdr *   internal;
3921   unsigned int i;
3922
3923   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3924                                             elf_header.e_phentsize,
3925                                             elf_header.e_phnum,
3926                                             _("program headers"));
3927   if (!phdrs)
3928     return 0;
3929
3930   for (i = 0, internal = pheaders, external = phdrs;
3931        i < elf_header.e_phnum;
3932        i++, internal++, external++)
3933     {
3934       internal->p_type   = BYTE_GET (external->p_type);
3935       internal->p_flags  = BYTE_GET (external->p_flags);
3936       internal->p_offset = BYTE_GET (external->p_offset);
3937       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
3938       internal->p_paddr  = BYTE_GET (external->p_paddr);
3939       internal->p_filesz = BYTE_GET (external->p_filesz);
3940       internal->p_memsz  = BYTE_GET (external->p_memsz);
3941       internal->p_align  = BYTE_GET (external->p_align);
3942     }
3943
3944   free (phdrs);
3945
3946   return 1;
3947 }
3948
3949 /* Returns 1 if the program headers were read into `program_headers'.  */
3950
3951 static int
3952 get_program_headers (FILE * file)
3953 {
3954   Elf_Internal_Phdr * phdrs;
3955
3956   /* Check cache of prior read.  */
3957   if (program_headers != NULL)
3958     return 1;
3959
3960   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3961                                          sizeof (Elf_Internal_Phdr));
3962
3963   if (phdrs == NULL)
3964     {
3965       error (_("Out of memory\n"));
3966       return 0;
3967     }
3968
3969   if (is_32bit_elf
3970       ? get_32bit_program_headers (file, phdrs)
3971       : get_64bit_program_headers (file, phdrs))
3972     {
3973       program_headers = phdrs;
3974       return 1;
3975     }
3976
3977   free (phdrs);
3978   return 0;
3979 }
3980
3981 /* Returns 1 if the program headers were loaded.  */
3982
3983 static int
3984 process_program_headers (FILE * file)
3985 {
3986   Elf_Internal_Phdr * segment;
3987   unsigned int i;
3988
3989   if (elf_header.e_phnum == 0)
3990     {
3991       /* PR binutils/12467.  */
3992       if (elf_header.e_phoff != 0)
3993         warn (_("possibly corrupt ELF header - it has a non-zero program"
3994                 " header offset, but no program headers"));
3995       else if (do_segments)
3996         printf (_("\nThere are no program headers in this file.\n"));
3997       return 0;
3998     }
3999
4000   if (do_segments && !do_header)
4001     {
4002       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4003       printf (_("Entry point "));
4004       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4005       printf (_("\nThere are %d program headers, starting at offset "),
4006               elf_header.e_phnum);
4007       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4008       printf ("\n");
4009     }
4010
4011   if (! get_program_headers (file))
4012       return 0;
4013
4014   if (do_segments)
4015     {
4016       if (elf_header.e_phnum > 1)
4017         printf (_("\nProgram Headers:\n"));
4018       else
4019         printf (_("\nProgram Headers:\n"));
4020
4021       if (is_32bit_elf)
4022         printf
4023           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4024       else if (do_wide)
4025         printf
4026           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4027       else
4028         {
4029           printf
4030             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4031           printf
4032             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4033         }
4034     }
4035
4036   dynamic_addr = 0;
4037   dynamic_size = 0;
4038
4039   for (i = 0, segment = program_headers;
4040        i < elf_header.e_phnum;
4041        i++, segment++)
4042     {
4043       if (do_segments)
4044         {
4045           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4046
4047           if (is_32bit_elf)
4048             {
4049               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4050               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4051               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4052               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4053               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4054               printf ("%c%c%c ",
4055                       (segment->p_flags & PF_R ? 'R' : ' '),
4056                       (segment->p_flags & PF_W ? 'W' : ' '),
4057                       (segment->p_flags & PF_X ? 'E' : ' '));
4058               printf ("%#lx", (unsigned long) segment->p_align);
4059             }
4060           else if (do_wide)
4061             {
4062               if ((unsigned long) segment->p_offset == segment->p_offset)
4063                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4064               else
4065                 {
4066                   print_vma (segment->p_offset, FULL_HEX);
4067                   putchar (' ');
4068                 }
4069
4070               print_vma (segment->p_vaddr, FULL_HEX);
4071               putchar (' ');
4072               print_vma (segment->p_paddr, FULL_HEX);
4073               putchar (' ');
4074
4075               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4076                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4077               else
4078                 {
4079                   print_vma (segment->p_filesz, FULL_HEX);
4080                   putchar (' ');
4081                 }
4082
4083               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4084                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4085               else
4086                 {
4087                   print_vma (segment->p_memsz, FULL_HEX);
4088                 }
4089
4090               printf (" %c%c%c ",
4091                       (segment->p_flags & PF_R ? 'R' : ' '),
4092                       (segment->p_flags & PF_W ? 'W' : ' '),
4093                       (segment->p_flags & PF_X ? 'E' : ' '));
4094
4095               if ((unsigned long) segment->p_align == segment->p_align)
4096                 printf ("%#lx", (unsigned long) segment->p_align);
4097               else
4098                 {
4099                   print_vma (segment->p_align, PREFIX_HEX);
4100                 }
4101             }
4102           else
4103             {
4104               print_vma (segment->p_offset, FULL_HEX);
4105               putchar (' ');
4106               print_vma (segment->p_vaddr, FULL_HEX);
4107               putchar (' ');
4108               print_vma (segment->p_paddr, FULL_HEX);
4109               printf ("\n                 ");
4110               print_vma (segment->p_filesz, FULL_HEX);
4111               putchar (' ');
4112               print_vma (segment->p_memsz, FULL_HEX);
4113               printf ("  %c%c%c    ",
4114                       (segment->p_flags & PF_R ? 'R' : ' '),
4115                       (segment->p_flags & PF_W ? 'W' : ' '),
4116                       (segment->p_flags & PF_X ? 'E' : ' '));
4117               print_vma (segment->p_align, HEX);
4118             }
4119         }
4120
4121       switch (segment->p_type)
4122         {
4123         case PT_DYNAMIC:
4124           if (dynamic_addr)
4125             error (_("more than one dynamic segment\n"));
4126
4127           /* By default, assume that the .dynamic section is the first
4128              section in the DYNAMIC segment.  */
4129           dynamic_addr = segment->p_offset;
4130           dynamic_size = segment->p_filesz;
4131
4132           /* Try to locate the .dynamic section. If there is
4133              a section header table, we can easily locate it.  */
4134           if (section_headers != NULL)
4135             {
4136               Elf_Internal_Shdr * sec;
4137
4138               sec = find_section (".dynamic");
4139               if (sec == NULL || sec->sh_size == 0)
4140                 {
4141                   /* A corresponding .dynamic section is expected, but on
4142                      IA-64/OpenVMS it is OK for it to be missing.  */
4143                   if (!is_ia64_vms ())
4144                     error (_("no .dynamic section in the dynamic segment\n"));
4145                   break;
4146                 }
4147
4148               if (sec->sh_type == SHT_NOBITS)
4149                 {
4150                   dynamic_size = 0;
4151                   break;
4152                 }
4153
4154               dynamic_addr = sec->sh_offset;
4155               dynamic_size = sec->sh_size;
4156
4157               if (dynamic_addr < segment->p_offset
4158                   || dynamic_addr > segment->p_offset + segment->p_filesz)
4159                 warn (_("the .dynamic section is not contained"
4160                         " within the dynamic segment\n"));
4161               else if (dynamic_addr > segment->p_offset)
4162                 warn (_("the .dynamic section is not the first section"
4163                         " in the dynamic segment.\n"));
4164             }
4165           break;
4166
4167         case PT_INTERP:
4168           if (fseek (file, archive_file_offset + (long) segment->p_offset,
4169                      SEEK_SET))
4170             error (_("Unable to find program interpreter name\n"));
4171           else
4172             {
4173               char fmt [32];
4174               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
4175
4176               if (ret >= (int) sizeof (fmt) || ret < 0)
4177                 error (_("Internal error: failed to create format string to display program interpreter\n"));
4178
4179               program_interpreter[0] = 0;
4180               if (fscanf (file, fmt, program_interpreter) <= 0)
4181                 error (_("Unable to read program interpreter name\n"));
4182
4183               if (do_segments)
4184                 printf (_("\n      [Requesting program interpreter: %s]"),
4185                     program_interpreter);
4186             }
4187           break;
4188         }
4189
4190       if (do_segments)
4191         putc ('\n', stdout);
4192     }
4193
4194   if (do_segments && section_headers != NULL && string_table != NULL)
4195     {
4196       printf (_("\n Section to Segment mapping:\n"));
4197       printf (_("  Segment Sections...\n"));
4198
4199       for (i = 0; i < elf_header.e_phnum; i++)
4200         {
4201           unsigned int j;
4202           Elf_Internal_Shdr * section;
4203
4204           segment = program_headers + i;
4205           section = section_headers + 1;
4206
4207           printf ("   %2.2d     ", i);
4208
4209           for (j = 1; j < elf_header.e_shnum; j++, section++)
4210             {
4211               if (!ELF_TBSS_SPECIAL (section, segment)
4212                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4213                 printf ("%s ", SECTION_NAME (section));
4214             }
4215
4216           putc ('\n',stdout);
4217         }
4218     }
4219
4220   return 1;
4221 }
4222
4223
4224 /* Find the file offset corresponding to VMA by using the program headers.  */
4225
4226 static long
4227 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4228 {
4229   Elf_Internal_Phdr * seg;
4230
4231   if (! get_program_headers (file))
4232     {
4233       warn (_("Cannot interpret virtual addresses without program headers.\n"));
4234       return (long) vma;
4235     }
4236
4237   for (seg = program_headers;
4238        seg < program_headers + elf_header.e_phnum;
4239        ++seg)
4240     {
4241       if (seg->p_type != PT_LOAD)
4242         continue;
4243
4244       if (vma >= (seg->p_vaddr & -seg->p_align)
4245           && vma + size <= seg->p_vaddr + seg->p_filesz)
4246         return vma - seg->p_vaddr + seg->p_offset;
4247     }
4248
4249   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4250         (unsigned long) vma);
4251   return (long) vma;
4252 }
4253
4254
4255 static int
4256 get_32bit_section_headers (FILE * file, unsigned int num)
4257 {
4258   Elf32_External_Shdr * shdrs;
4259   Elf_Internal_Shdr *   internal;
4260   unsigned int i;
4261
4262   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4263                                             elf_header.e_shentsize, num,
4264                                             _("section headers"));
4265   if (!shdrs)
4266     return 0;
4267
4268   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4269                                                    sizeof (Elf_Internal_Shdr));
4270
4271   if (section_headers == NULL)
4272     {
4273       error (_("Out of memory\n"));
4274       return 0;
4275     }
4276
4277   for (i = 0, internal = section_headers;
4278        i < num;
4279        i++, internal++)
4280     {
4281       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4282       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4283       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4284       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4285       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4286       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4287       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4288       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4289       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4290       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4291     }
4292
4293   free (shdrs);
4294
4295   return 1;
4296 }
4297
4298 static int
4299 get_64bit_section_headers (FILE * file, unsigned int num)
4300 {
4301   Elf64_External_Shdr * shdrs;
4302   Elf_Internal_Shdr *   internal;
4303   unsigned int i;
4304
4305   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4306                                             elf_header.e_shentsize, num,
4307                                             _("section headers"));
4308   if (!shdrs)
4309     return 0;
4310
4311   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4312                                                    sizeof (Elf_Internal_Shdr));
4313
4314   if (section_headers == NULL)
4315     {
4316       error (_("Out of memory\n"));
4317       return 0;
4318     }
4319
4320   for (i = 0, internal = section_headers;
4321        i < num;
4322        i++, internal++)
4323     {
4324       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4325       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4326       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4327       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4328       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4329       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4330       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4331       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4332       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4333       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4334     }
4335
4336   free (shdrs);
4337
4338   return 1;
4339 }
4340
4341 static Elf_Internal_Sym *
4342 get_32bit_elf_symbols (FILE * file,
4343                        Elf_Internal_Shdr * section,
4344                        unsigned long * num_syms_return)
4345 {
4346   unsigned long number = 0;
4347   Elf32_External_Sym * esyms = NULL;
4348   Elf_External_Sym_Shndx * shndx = NULL;
4349   Elf_Internal_Sym * isyms = NULL;
4350   Elf_Internal_Sym * psym;
4351   unsigned int j;
4352
4353   /* Run some sanity checks first.  */
4354   if (section->sh_entsize == 0)
4355     {
4356       error (_("sh_entsize is zero\n"));
4357       goto exit_point;
4358     }
4359
4360   number = section->sh_size / section->sh_entsize;
4361
4362   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4363     {
4364       error (_("Invalid sh_entsize\n"));
4365       goto exit_point;
4366     }
4367
4368   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4369                                            section->sh_size, _("symbols"));
4370   if (esyms == NULL)
4371     goto exit_point;
4372
4373   shndx = NULL;
4374   if (symtab_shndx_hdr != NULL
4375       && (symtab_shndx_hdr->sh_link
4376           == (unsigned long) (section - section_headers)))
4377     {
4378       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4379                                                    symtab_shndx_hdr->sh_offset,
4380                                                    1, symtab_shndx_hdr->sh_size,
4381                                                    _("symbol table section indicies"));
4382       if (shndx == NULL)
4383         goto exit_point;
4384     }
4385
4386   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4387
4388   if (isyms == NULL)
4389     {
4390       error (_("Out of memory\n"));
4391       goto exit_point;
4392     }
4393
4394   for (j = 0, psym = isyms; j < number; j++, psym++)
4395     {
4396       psym->st_name  = BYTE_GET (esyms[j].st_name);
4397       psym->st_value = BYTE_GET (esyms[j].st_value);
4398       psym->st_size  = BYTE_GET (esyms[j].st_size);
4399       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4400       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4401         psym->st_shndx
4402           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4403       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4404         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4405       psym->st_info  = BYTE_GET (esyms[j].st_info);
4406       psym->st_other = BYTE_GET (esyms[j].st_other);
4407     }
4408
4409  exit_point:
4410   if (shndx != NULL)
4411     free (shndx);
4412   if (esyms != NULL)
4413     free (esyms);
4414
4415   if (num_syms_return != NULL)
4416     * num_syms_return = isyms == NULL ? 0 : number;
4417
4418   return isyms;
4419 }
4420
4421 static Elf_Internal_Sym *
4422 get_64bit_elf_symbols (FILE * file,
4423                        Elf_Internal_Shdr * section,
4424                        unsigned long * num_syms_return)
4425 {
4426   unsigned long number = 0;
4427   Elf64_External_Sym * esyms = NULL;
4428   Elf_External_Sym_Shndx * shndx = NULL;
4429   Elf_Internal_Sym * isyms = NULL;
4430   Elf_Internal_Sym * psym;
4431   unsigned int j;
4432
4433   /* Run some sanity checks first.  */
4434   if (section->sh_entsize == 0)
4435     {
4436       error (_("sh_entsize is zero\n"));
4437       goto exit_point;
4438     }
4439
4440   number = section->sh_size / section->sh_entsize;
4441
4442   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4443     {
4444       error (_("Invalid sh_entsize\n"));
4445       goto exit_point;
4446     }
4447
4448   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4449                                            section->sh_size, _("symbols"));
4450   if (!esyms)
4451     goto exit_point;
4452
4453   if (symtab_shndx_hdr != NULL
4454       && (symtab_shndx_hdr->sh_link
4455           == (unsigned long) (section - section_headers)))
4456     {
4457       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4458                                                    symtab_shndx_hdr->sh_offset,
4459                                                    1, symtab_shndx_hdr->sh_size,
4460                                                    _("symbol table section indicies"));
4461       if (shndx == NULL)
4462         goto exit_point;
4463     }
4464
4465   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4466
4467   if (isyms == NULL)
4468     {
4469       error (_("Out of memory\n"));
4470       goto exit_point;
4471     }
4472
4473   for (j = 0, psym = isyms; j < number; j++, psym++)
4474     {
4475       psym->st_name  = BYTE_GET (esyms[j].st_name);
4476       psym->st_info  = BYTE_GET (esyms[j].st_info);
4477       psym->st_other = BYTE_GET (esyms[j].st_other);
4478       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4479
4480       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4481         psym->st_shndx
4482           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4483       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4484         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4485
4486       psym->st_value = BYTE_GET (esyms[j].st_value);
4487       psym->st_size  = BYTE_GET (esyms[j].st_size);
4488     }
4489
4490  exit_point:
4491   if (shndx != NULL)
4492     free (shndx);
4493   if (esyms != NULL)
4494     free (esyms);
4495
4496   if (num_syms_return != NULL)
4497     * num_syms_return = isyms == NULL ? 0 : number;
4498
4499   return isyms;
4500 }
4501
4502 static const char *
4503 get_elf_section_flags (bfd_vma sh_flags)
4504 {
4505   static char buff[1024];
4506   char * p = buff;
4507   int field_size = is_32bit_elf ? 8 : 16;
4508   int sindex;
4509   int size = sizeof (buff) - (field_size + 4 + 1);
4510   bfd_vma os_flags = 0;
4511   bfd_vma proc_flags = 0;
4512   bfd_vma unknown_flags = 0;
4513   static const struct
4514     {
4515       const char * str;
4516       int len;
4517     }
4518   flags [] =
4519     {
4520       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
4521       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
4522       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
4523       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
4524       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
4525       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
4526       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4527       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4528       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
4529       /*  9 */ { STRING_COMMA_LEN ("TLS") },
4530       /* IA-64 specific.  */
4531       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4532       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4533       /* IA-64 OpenVMS specific.  */
4534       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4535       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4536       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4537       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4538       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4539       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4540       /* Generic.  */
4541       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4542       /* SPARC specific.  */
4543       /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4544     };
4545
4546   if (do_section_details)
4547     {
4548       sprintf (buff, "[%*.*lx]: ",
4549                field_size, field_size, (unsigned long) sh_flags);
4550       p += field_size + 4;
4551     }
4552
4553   while (sh_flags)
4554     {
4555       bfd_vma flag;
4556
4557       flag = sh_flags & - sh_flags;
4558       sh_flags &= ~ flag;
4559
4560       if (do_section_details)
4561         {
4562           switch (flag)
4563             {
4564             case SHF_WRITE:             sindex = 0; break;
4565             case SHF_ALLOC:             sindex = 1; break;
4566             case SHF_EXECINSTR:         sindex = 2; break;
4567             case SHF_MERGE:             sindex = 3; break;
4568             case SHF_STRINGS:           sindex = 4; break;
4569             case SHF_INFO_LINK:         sindex = 5; break;
4570             case SHF_LINK_ORDER:        sindex = 6; break;
4571             case SHF_OS_NONCONFORMING:  sindex = 7; break;
4572             case SHF_GROUP:             sindex = 8; break;
4573             case SHF_TLS:               sindex = 9; break;
4574             case SHF_EXCLUDE:           sindex = 18; break;
4575
4576             default:
4577               sindex = -1;
4578               switch (elf_header.e_machine)
4579                 {
4580                 case EM_IA_64:
4581                   if (flag == SHF_IA_64_SHORT)
4582                     sindex = 10;
4583                   else if (flag == SHF_IA_64_NORECOV)
4584                     sindex = 11;
4585 #ifdef BFD64
4586                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4587                     switch (flag)
4588                       {
4589                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
4590                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
4591                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
4592                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
4593                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4594                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
4595                       default:                        break;
4596                       }
4597 #endif
4598                   break;
4599
4600                 case EM_386:
4601                 case EM_486:
4602                 case EM_X86_64:
4603                 case EM_L1OM:
4604                 case EM_K1OM:
4605                 case EM_OLD_SPARCV9:
4606                 case EM_SPARC32PLUS:
4607                 case EM_SPARCV9:
4608                 case EM_SPARC:
4609                   if (flag == SHF_ORDERED)
4610                     sindex = 19;
4611                   break;
4612                 default:
4613                   break;
4614                 }
4615             }
4616
4617           if (sindex != -1)
4618             {
4619               if (p != buff + field_size + 4)
4620                 {
4621                   if (size < (10 + 2))
4622                     abort ();
4623                   size -= 2;
4624                   *p++ = ',';
4625                   *p++ = ' ';
4626                 }
4627
4628               size -= flags [sindex].len;
4629               p = stpcpy (p, flags [sindex].str);
4630             }
4631           else if (flag & SHF_MASKOS)
4632             os_flags |= flag;
4633           else if (flag & SHF_MASKPROC)
4634             proc_flags |= flag;
4635           else
4636             unknown_flags |= flag;
4637         }
4638       else
4639         {
4640           switch (flag)
4641             {
4642             case SHF_WRITE:             *p = 'W'; break;
4643             case SHF_ALLOC:             *p = 'A'; break;
4644             case SHF_EXECINSTR:         *p = 'X'; break;
4645             case SHF_MERGE:             *p = 'M'; break;
4646             case SHF_STRINGS:           *p = 'S'; break;
4647             case SHF_INFO_LINK:         *p = 'I'; break;
4648             case SHF_LINK_ORDER:        *p = 'L'; break;
4649             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
4650             case SHF_GROUP:             *p = 'G'; break;
4651             case SHF_TLS:               *p = 'T'; break;
4652             case SHF_EXCLUDE:           *p = 'E'; break;
4653
4654             default:
4655               if ((elf_header.e_machine == EM_X86_64
4656                    || elf_header.e_machine == EM_L1OM
4657                    || elf_header.e_machine == EM_K1OM)
4658                   && flag == SHF_X86_64_LARGE)
4659                 *p = 'l';
4660               else if (flag & SHF_MASKOS)
4661                 {
4662                   *p = 'o';
4663                   sh_flags &= ~ SHF_MASKOS;
4664                 }
4665               else if (flag & SHF_MASKPROC)
4666                 {
4667                   *p = 'p';
4668                   sh_flags &= ~ SHF_MASKPROC;
4669                 }
4670               else
4671                 *p = 'x';
4672               break;
4673             }
4674           p++;
4675         }
4676     }
4677
4678   if (do_section_details)
4679     {
4680       if (os_flags)
4681         {
4682           size -= 5 + field_size;
4683           if (p != buff + field_size + 4)
4684             {
4685               if (size < (2 + 1))
4686                 abort ();
4687               size -= 2;
4688               *p++ = ',';
4689               *p++ = ' ';
4690             }
4691           sprintf (p, "OS (%*.*lx)", field_size, field_size,
4692                    (unsigned long) os_flags);
4693           p += 5 + field_size;
4694         }
4695       if (proc_flags)
4696         {
4697           size -= 7 + field_size;
4698           if (p != buff + field_size + 4)
4699             {
4700               if (size < (2 + 1))
4701                 abort ();
4702               size -= 2;
4703               *p++ = ',';
4704               *p++ = ' ';
4705             }
4706           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4707                    (unsigned long) proc_flags);
4708           p += 7 + field_size;
4709         }
4710       if (unknown_flags)
4711         {
4712           size -= 10 + field_size;
4713           if (p != buff + field_size + 4)
4714             {
4715               if (size < (2 + 1))
4716                 abort ();
4717               size -= 2;
4718               *p++ = ',';
4719               *p++ = ' ';
4720             }
4721           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
4722                    (unsigned long) unknown_flags);
4723           p += 10 + field_size;
4724         }
4725     }
4726
4727   *p = '\0';
4728   return buff;
4729 }
4730
4731 static int
4732 process_section_headers (FILE * file)
4733 {
4734   Elf_Internal_Shdr * section;
4735   unsigned int i;
4736
4737   section_headers = NULL;
4738
4739   if (elf_header.e_shnum == 0)
4740     {
4741       /* PR binutils/12467.  */
4742       if (elf_header.e_shoff != 0)
4743         warn (_("possibly corrupt ELF file header - it has a non-zero"
4744                 " section header offset, but no section headers\n"));
4745       else if (do_sections)
4746         printf (_("\nThere are no sections in this file.\n"));
4747
4748       return 1;
4749     }
4750
4751   if (do_sections && !do_header)
4752     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4753             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4754
4755   if (is_32bit_elf)
4756     {
4757       if (! get_32bit_section_headers (file, elf_header.e_shnum))
4758         return 0;
4759     }
4760   else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4761     return 0;
4762
4763   /* Read in the string table, so that we have names to display.  */
4764   if (elf_header.e_shstrndx != SHN_UNDEF
4765        && elf_header.e_shstrndx < elf_header.e_shnum)
4766     {
4767       section = section_headers + elf_header.e_shstrndx;
4768
4769       if (section->sh_size != 0)
4770         {
4771           string_table = (char *) get_data (NULL, file, section->sh_offset,
4772                                             1, section->sh_size,
4773                                             _("string table"));
4774
4775           string_table_length = string_table != NULL ? section->sh_size : 0;
4776         }
4777     }
4778
4779   /* Scan the sections for the dynamic symbol table
4780      and dynamic string table and debug sections.  */
4781   dynamic_symbols = NULL;
4782   dynamic_strings = NULL;
4783   dynamic_syminfo = NULL;
4784   symtab_shndx_hdr = NULL;
4785
4786   eh_addr_size = is_32bit_elf ? 4 : 8;
4787   switch (elf_header.e_machine)
4788     {
4789     case EM_MIPS:
4790     case EM_MIPS_RS3_LE:
4791       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4792          FDE addresses.  However, the ABI also has a semi-official ILP32
4793          variant for which the normal FDE address size rules apply.
4794
4795          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4796          section, where XX is the size of longs in bits.  Unfortunately,
4797          earlier compilers provided no way of distinguishing ILP32 objects
4798          from LP64 objects, so if there's any doubt, we should assume that
4799          the official LP64 form is being used.  */
4800       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4801           && find_section (".gcc_compiled_long32") == NULL)
4802         eh_addr_size = 8;
4803       break;
4804
4805     case EM_H8_300:
4806     case EM_H8_300H:
4807       switch (elf_header.e_flags & EF_H8_MACH)
4808         {
4809         case E_H8_MACH_H8300:
4810         case E_H8_MACH_H8300HN:
4811         case E_H8_MACH_H8300SN:
4812         case E_H8_MACH_H8300SXN:
4813           eh_addr_size = 2;
4814           break;
4815         case E_H8_MACH_H8300H:
4816         case E_H8_MACH_H8300S:
4817         case E_H8_MACH_H8300SX:
4818           eh_addr_size = 4;
4819           break;
4820         }
4821       break;
4822
4823     case EM_M32C_OLD:
4824     case EM_M32C:
4825       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4826         {
4827         case EF_M32C_CPU_M16C:
4828           eh_addr_size = 2;
4829           break;
4830         }
4831       break;
4832     }
4833
4834 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4835   do                                                                        \
4836     {                                                                       \
4837       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;      \
4838       if (section->sh_entsize != expected_entsize)                          \
4839         {                                                               \
4840           error (_("Section %d has invalid sh_entsize of %" BFD_VMA_FMT "x\n"), \
4841                  i, section->sh_entsize);       \
4842           error (_("(Using the expected size of %d for the rest of this dump)\n"), \
4843                    (int) expected_entsize); \
4844           section->sh_entsize = expected_entsize;                       \
4845         } \
4846     }                                                                       \
4847   while (0)
4848
4849 #define CHECK_ENTSIZE(section, i, type)                                 \
4850   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
4851                         sizeof (Elf64_External_##type))
4852
4853   for (i = 0, section = section_headers;
4854        i < elf_header.e_shnum;
4855        i++, section++)
4856     {
4857       char * name = SECTION_NAME (section);
4858
4859       if (section->sh_type == SHT_DYNSYM)
4860         {
4861           if (dynamic_symbols != NULL)
4862             {
4863               error (_("File contains multiple dynamic symbol tables\n"));
4864               continue;
4865             }
4866
4867           CHECK_ENTSIZE (section, i, Sym);
4868           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
4869         }
4870       else if (section->sh_type == SHT_STRTAB
4871                && streq (name, ".dynstr"))
4872         {
4873           if (dynamic_strings != NULL)
4874             {
4875               error (_("File contains multiple dynamic string tables\n"));
4876               continue;
4877             }
4878
4879           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4880                                                1, section->sh_size,
4881                                                _("dynamic strings"));
4882           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
4883         }
4884       else if (section->sh_type == SHT_SYMTAB_SHNDX)
4885         {
4886           if (symtab_shndx_hdr != NULL)
4887             {
4888               error (_("File contains multiple symtab shndx tables\n"));
4889               continue;
4890             }
4891           symtab_shndx_hdr = section;
4892         }
4893       else if (section->sh_type == SHT_SYMTAB)
4894         CHECK_ENTSIZE (section, i, Sym);
4895       else if (section->sh_type == SHT_GROUP)
4896         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4897       else if (section->sh_type == SHT_REL)
4898         CHECK_ENTSIZE (section, i, Rel);
4899       else if (section->sh_type == SHT_RELA)
4900         CHECK_ENTSIZE (section, i, Rela);
4901       else if ((do_debugging || do_debug_info || do_debug_abbrevs
4902                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
4903                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
4904                 || do_debug_str || do_debug_loc || do_debug_ranges
4905                 || do_debug_addr || do_debug_cu_index)
4906                && (const_strneq (name, ".debug_")
4907                    || const_strneq (name, ".zdebug_")))
4908         {
4909           if (name[1] == 'z')
4910             name += sizeof (".zdebug_") - 1;
4911           else
4912             name += sizeof (".debug_") - 1;
4913
4914           if (do_debugging
4915               || (do_debug_info     && const_strneq (name, "info"))
4916               || (do_debug_info     && const_strneq (name, "types"))
4917               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
4918               || (do_debug_lines    && strcmp (name, "line") == 0)
4919               || (do_debug_lines    && const_strneq (name, "line."))
4920               || (do_debug_pubnames && const_strneq (name, "pubnames"))
4921               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
4922               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
4923               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
4924               || (do_debug_aranges  && const_strneq (name, "aranges"))
4925               || (do_debug_ranges   && const_strneq (name, "ranges"))
4926               || (do_debug_frames   && const_strneq (name, "frame"))
4927               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
4928               || (do_debug_macinfo  && const_strneq (name, "macro"))
4929               || (do_debug_str      && const_strneq (name, "str"))
4930               || (do_debug_loc      && const_strneq (name, "loc"))
4931               || (do_debug_addr     && const_strneq (name, "addr"))
4932               || (do_debug_cu_index && const_strneq (name, "cu_index"))
4933               || (do_debug_cu_index && const_strneq (name, "tu_index"))
4934               )
4935             request_dump_bynumber (i, DEBUG_DUMP);
4936         }
4937       /* Linkonce section to be combined with .debug_info at link time.  */
4938       else if ((do_debugging || do_debug_info)
4939                && const_strneq (name, ".gnu.linkonce.wi."))
4940         request_dump_bynumber (i, DEBUG_DUMP);
4941       else if (do_debug_frames && streq (name, ".eh_frame"))
4942         request_dump_bynumber (i, DEBUG_DUMP);
4943       else if (do_gdb_index && streq (name, ".gdb_index"))
4944         request_dump_bynumber (i, DEBUG_DUMP);
4945       /* Trace sections for Itanium VMS.  */
4946       else if ((do_debugging || do_trace_info || do_trace_abbrevs
4947                 || do_trace_aranges)
4948                && const_strneq (name, ".trace_"))
4949         {
4950           name += sizeof (".trace_") - 1;
4951
4952           if (do_debugging
4953               || (do_trace_info     && streq (name, "info"))
4954               || (do_trace_abbrevs  && streq (name, "abbrev"))
4955               || (do_trace_aranges  && streq (name, "aranges"))
4956               )
4957             request_dump_bynumber (i, DEBUG_DUMP);
4958         }
4959
4960     }
4961
4962   if (! do_sections)
4963     return 1;
4964
4965   if (elf_header.e_shnum > 1)
4966     printf (_("\nSection Headers:\n"));
4967   else
4968     printf (_("\nSection Header:\n"));
4969
4970   if (is_32bit_elf)
4971     {
4972       if (do_section_details)
4973         {
4974           printf (_("  [Nr] Name\n"));
4975           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
4976         }
4977       else
4978         printf
4979           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
4980     }
4981   else if (do_wide)
4982     {
4983       if (do_section_details)
4984         {
4985           printf (_("  [Nr] Name\n"));
4986           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
4987         }
4988       else
4989         printf
4990           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
4991     }
4992   else
4993     {
4994       if (do_section_details)
4995         {
4996           printf (_("  [Nr] Name\n"));
4997           printf (_("       Type              Address          Offset            Link\n"));
4998           printf (_("       Size              EntSize          Info              Align\n"));
4999         }
5000       else
5001         {
5002           printf (_("  [Nr] Name              Type             Address           Offset\n"));
5003           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
5004         }
5005     }
5006
5007   if (do_section_details)
5008     printf (_("       Flags\n"));
5009
5010   for (i = 0, section = section_headers;
5011        i < elf_header.e_shnum;
5012        i++, section++)
5013     {
5014       printf ("  [%2u] ", i);
5015       if (do_section_details)
5016         {
5017           print_symbol (INT_MAX, SECTION_NAME (section));
5018           printf ("\n      ");
5019         }
5020       else
5021         {
5022           print_symbol (-17, SECTION_NAME (section));
5023         }
5024
5025       printf (do_wide ? " %-15s " : " %-15.15s ",
5026               get_section_type_name (section->sh_type));
5027
5028       if (is_32bit_elf)
5029         {
5030           const char * link_too_big = NULL;
5031
5032           print_vma (section->sh_addr, LONG_HEX);
5033
5034           printf ( " %6.6lx %6.6lx %2.2lx",
5035                    (unsigned long) section->sh_offset,
5036                    (unsigned long) section->sh_size,
5037                    (unsigned long) section->sh_entsize);
5038
5039           if (do_section_details)
5040             fputs ("  ", stdout);
5041           else
5042             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5043
5044           if (section->sh_link >= elf_header.e_shnum)
5045             {
5046               link_too_big = "";
5047               /* The sh_link value is out of range.  Normally this indicates
5048                  an error but it can have special values in Solaris binaries.  */
5049               switch (elf_header.e_machine)
5050                 {
5051                 case EM_386:
5052                 case EM_486:
5053                 case EM_X86_64:
5054                 case EM_L1OM:
5055                 case EM_K1OM:
5056                 case EM_OLD_SPARCV9:
5057                 case EM_SPARC32PLUS:
5058                 case EM_SPARCV9:
5059                 case EM_SPARC:
5060                   if (section->sh_link == (SHN_BEFORE & 0xffff))
5061                     link_too_big = "BEFORE";
5062                   else if (section->sh_link == (SHN_AFTER & 0xffff))
5063                     link_too_big = "AFTER";
5064                   break;
5065                 default:
5066                   break;
5067                 }
5068             }
5069
5070           if (do_section_details)
5071             {
5072               if (link_too_big != NULL && * link_too_big)
5073                 printf ("<%s> ", link_too_big);
5074               else
5075                 printf ("%2u ", section->sh_link);
5076               printf ("%3u %2lu\n", section->sh_info,
5077                       (unsigned long) section->sh_addralign);
5078             }
5079           else
5080             printf ("%2u %3u %2lu\n",
5081                     section->sh_link,
5082                     section->sh_info,
5083                     (unsigned long) section->sh_addralign);
5084
5085           if (link_too_big && ! * link_too_big)
5086             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5087                   i, section->sh_link);
5088         }
5089       else if (do_wide)
5090         {
5091           print_vma (section->sh_addr, LONG_HEX);
5092
5093           if ((long) section->sh_offset == section->sh_offset)
5094             printf (" %6.6lx", (unsigned long) section->sh_offset);
5095           else
5096             {
5097               putchar (' ');
5098               print_vma (section->sh_offset, LONG_HEX);
5099             }
5100
5101           if ((unsigned long) section->sh_size == section->sh_size)
5102             printf (" %6.6lx", (unsigned long) section->sh_size);
5103           else
5104             {
5105               putchar (' ');
5106               print_vma (section->sh_size, LONG_HEX);
5107             }
5108
5109           if ((unsigned long) section->sh_entsize == section->sh_entsize)
5110             printf (" %2.2lx", (unsigned long) section->sh_entsize);
5111           else
5112             {
5113               putchar (' ');
5114               print_vma (section->sh_entsize, LONG_HEX);
5115             }
5116
5117           if (do_section_details)
5118             fputs ("  ", stdout);
5119           else
5120             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5121
5122           printf ("%2u %3u ", section->sh_link, section->sh_info);
5123
5124           if ((unsigned long) section->sh_addralign == section->sh_addralign)
5125             printf ("%2lu\n", (unsigned long) section->sh_addralign);
5126           else
5127             {
5128               print_vma (section->sh_addralign, DEC);
5129               putchar ('\n');
5130             }
5131         }
5132       else if (do_section_details)
5133         {
5134           printf ("       %-15.15s  ",
5135                   get_section_type_name (section->sh_type));
5136           print_vma (section->sh_addr, LONG_HEX);
5137           if ((long) section->sh_offset == section->sh_offset)
5138             printf ("  %16.16lx", (unsigned long) section->sh_offset);
5139           else
5140             {
5141               printf ("  ");
5142               print_vma (section->sh_offset, LONG_HEX);
5143             }
5144           printf ("  %u\n       ", section->sh_link);
5145           print_vma (section->sh_size, LONG_HEX);
5146           putchar (' ');
5147           print_vma (section->sh_entsize, LONG_HEX);
5148
5149           printf ("  %-16u  %lu\n",
5150                   section->sh_info,
5151                   (unsigned long) section->sh_addralign);
5152         }
5153       else
5154         {
5155           putchar (' ');
5156           print_vma (section->sh_addr, LONG_HEX);
5157           if ((long) section->sh_offset == section->sh_offset)
5158             printf ("  %8.8lx", (unsigned long) section->sh_offset);
5159           else
5160             {
5161               printf ("  ");
5162               print_vma (section->sh_offset, LONG_HEX);
5163             }
5164           printf ("\n       ");
5165           print_vma (section->sh_size, LONG_HEX);
5166           printf ("  ");
5167           print_vma (section->sh_entsize, LONG_HEX);
5168
5169           printf (" %3s ", get_elf_section_flags (section->sh_flags));
5170
5171           printf ("     %2u   %3u     %lu\n",
5172                   section->sh_link,
5173                   section->sh_info,
5174                   (unsigned long) section->sh_addralign);
5175         }
5176
5177       if (do_section_details)
5178         printf ("       %s\n", get_elf_section_flags (section->sh_flags));
5179     }
5180
5181   if (!do_section_details)
5182     {
5183       if (elf_header.e_machine == EM_X86_64
5184           || elf_header.e_machine == EM_L1OM
5185           || elf_header.e_machine == EM_K1OM)
5186         printf (_("Key to Flags:\n\
5187   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5188   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5189   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5190       else
5191         printf (_("Key to Flags:\n\
5192   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5193   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5194   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5195     }
5196
5197   return 1;
5198 }
5199
5200 static const char *
5201 get_group_flags (unsigned int flags)
5202 {
5203   static char buff[32];
5204   switch (flags)
5205     {
5206     case 0:
5207       return "";
5208
5209     case GRP_COMDAT:
5210       return "COMDAT ";
5211
5212    default:
5213       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5214       break;
5215     }
5216   return buff;
5217 }
5218
5219 static int
5220 process_section_groups (FILE * file)
5221 {
5222   Elf_Internal_Shdr * section;
5223   unsigned int i;
5224   struct group * group;
5225   Elf_Internal_Shdr * symtab_sec;
5226   Elf_Internal_Shdr * strtab_sec;
5227   Elf_Internal_Sym * symtab;
5228   unsigned long num_syms;
5229   char * strtab;
5230   size_t strtab_size;
5231
5232   /* Don't process section groups unless needed.  */
5233   if (!do_unwind && !do_section_groups)
5234     return 1;
5235
5236   if (elf_header.e_shnum == 0)
5237     {
5238       if (do_section_groups)
5239         printf (_("\nThere are no sections to group in this file.\n"));
5240
5241       return 1;
5242     }
5243
5244   if (section_headers == NULL)
5245     {
5246       error (_("Section headers are not available!\n"));
5247       /* PR 13622: This can happen with a corrupt ELF header.  */
5248       return 0;
5249     }
5250
5251   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5252                                                      sizeof (struct group *));
5253
5254   if (section_headers_groups == NULL)
5255     {
5256       error (_("Out of memory\n"));
5257       return 0;
5258     }
5259
5260   /* Scan the sections for the group section.  */
5261   group_count = 0;
5262   for (i = 0, section = section_headers;
5263        i < elf_header.e_shnum;
5264        i++, section++)
5265     if (section->sh_type == SHT_GROUP)
5266       group_count++;
5267
5268   if (group_count == 0)
5269     {
5270       if (do_section_groups)
5271         printf (_("\nThere are no section groups in this file.\n"));
5272
5273       return 1;
5274     }
5275
5276   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5277
5278   if (section_groups == NULL)
5279     {
5280       error (_("Out of memory\n"));
5281       return 0;
5282     }
5283
5284   symtab_sec = NULL;
5285   strtab_sec = NULL;
5286   symtab = NULL;
5287   num_syms = 0;
5288   strtab = NULL;
5289   strtab_size = 0;
5290   for (i = 0, section = section_headers, group = section_groups;
5291        i < elf_header.e_shnum;
5292        i++, section++)
5293     {
5294       if (section->sh_type == SHT_GROUP)
5295         {
5296           char * name = SECTION_NAME (section);
5297           char * group_name;
5298           unsigned char * start;
5299           unsigned char * indices;
5300           unsigned int entry, j, size;
5301           Elf_Internal_Shdr * sec;
5302           Elf_Internal_Sym * sym;
5303
5304           /* Get the symbol table.  */
5305           if (section->sh_link >= elf_header.e_shnum
5306               || ((sec = section_headers + section->sh_link)->sh_type
5307                   != SHT_SYMTAB))
5308             {
5309               error (_("Bad sh_link in group section `%s'\n"), name);
5310               continue;
5311             }
5312
5313           if (symtab_sec != sec)
5314             {
5315               symtab_sec = sec;
5316               if (symtab)
5317                 free (symtab);
5318               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5319             }
5320
5321           if (symtab == NULL)
5322             {
5323               error (_("Corrupt header in group section `%s'\n"), name);
5324               continue;
5325             }
5326
5327           if (section->sh_info >= num_syms)
5328             {
5329               error (_("Bad sh_info in group section `%s'\n"), name);
5330               continue;
5331             }
5332
5333           sym = symtab + section->sh_info;
5334
5335           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5336             {
5337               if (sym->st_shndx == 0
5338                   || sym->st_shndx >= elf_header.e_shnum)
5339                 {
5340                   error (_("Bad sh_info in group section `%s'\n"), name);
5341                   continue;
5342                 }
5343
5344               group_name = SECTION_NAME (section_headers + sym->st_shndx);
5345               strtab_sec = NULL;
5346               if (strtab)
5347                 free (strtab);
5348               strtab = NULL;
5349               strtab_size = 0;
5350             }
5351           else
5352             {
5353               /* Get the string table.  */
5354               if (symtab_sec->sh_link >= elf_header.e_shnum)
5355                 {
5356                   strtab_sec = NULL;
5357                   if (strtab)
5358                     free (strtab);
5359                   strtab = NULL;
5360                   strtab_size = 0;
5361                 }
5362               else if (strtab_sec
5363                        != (sec = section_headers + symtab_sec->sh_link))
5364                 {
5365                   strtab_sec = sec;
5366                   if (strtab)
5367                     free (strtab);
5368                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5369                                               1, strtab_sec->sh_size,
5370                                               _("string table"));
5371                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5372                 }
5373               group_name = sym->st_name < strtab_size
5374                 ? strtab + sym->st_name : _("<corrupt>");
5375             }
5376
5377           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5378                                               1, section->sh_size,
5379                                               _("section data"));
5380           if (start == NULL)
5381             continue;
5382
5383           indices = start;
5384           size = (section->sh_size / section->sh_entsize) - 1;
5385           entry = byte_get (indices, 4);
5386           indices += 4;
5387
5388           if (do_section_groups)
5389             {
5390               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5391                       get_group_flags (entry), i, name, group_name, size);
5392
5393               printf (_("   [Index]    Name\n"));
5394             }
5395
5396           group->group_index = i;
5397
5398           for (j = 0; j < size; j++)
5399             {
5400               struct group_list * g;
5401
5402               entry = byte_get (indices, 4);
5403               indices += 4;
5404
5405               if (entry >= elf_header.e_shnum)
5406                 {
5407                   error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5408                          entry, i, elf_header.e_shnum - 1);
5409                   continue;
5410                 }
5411
5412               if (section_headers_groups [entry] != NULL)
5413                 {
5414                   if (entry)
5415                     {
5416                       error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5417                              entry, i,
5418                              section_headers_groups [entry]->group_index);
5419                       continue;
5420                     }
5421                   else
5422                     {
5423                       /* Intel C/C++ compiler may put section 0 in a
5424                          section group. We just warn it the first time
5425                          and ignore it afterwards.  */
5426                       static int warned = 0;
5427                       if (!warned)
5428                         {
5429                           error (_("section 0 in group section [%5u]\n"),
5430                                  section_headers_groups [entry]->group_index);
5431                           warned++;
5432                         }
5433                     }
5434                 }
5435
5436               section_headers_groups [entry] = group;
5437
5438               if (do_section_groups)
5439                 {
5440                   sec = section_headers + entry;
5441                   printf ("   [%5u]   %s\n", entry, SECTION_NAME (sec));
5442                 }
5443
5444               g = (struct group_list *) xmalloc (sizeof (struct group_list));
5445               g->section_index = entry;
5446               g->next = group->root;
5447               group->root = g;
5448             }
5449
5450           if (start)
5451             free (start);
5452
5453           group++;
5454         }
5455     }
5456
5457   if (symtab)
5458     free (symtab);
5459   if (strtab)
5460     free (strtab);
5461   return 1;
5462 }
5463
5464 /* Data used to display dynamic fixups.  */
5465
5466 struct ia64_vms_dynfixup
5467 {
5468   bfd_vma needed_ident;         /* Library ident number.  */
5469   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
5470   bfd_vma fixup_needed;         /* Index of the library.  */
5471   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
5472   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
5473 };
5474
5475 /* Data used to display dynamic relocations.  */
5476
5477 struct ia64_vms_dynimgrela
5478 {
5479   bfd_vma img_rela_cnt;         /* Number of relocations.  */
5480   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
5481 };
5482
5483 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5484    library).  */
5485
5486 static void
5487 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5488                               const char *strtab, unsigned int strtab_sz)
5489 {
5490   Elf64_External_VMS_IMAGE_FIXUP *imfs;
5491   long i;
5492   const char *lib_name;
5493
5494   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5495                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
5496                    _("dynamic section image fixups"));
5497   if (!imfs)
5498     return;
5499
5500   if (fixup->needed < strtab_sz)
5501     lib_name = strtab + fixup->needed;
5502   else
5503     {
5504       warn ("corrupt library name index of 0x%lx found in dynamic entry",
5505             (unsigned long) fixup->needed);
5506       lib_name = "???";
5507     }
5508   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5509           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5510   printf
5511     (_("Seg Offset           Type                             SymVec DataType\n"));
5512
5513   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5514     {
5515       unsigned int type;
5516       const char *rtype;
5517
5518       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5519       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5520       type = BYTE_GET (imfs [i].type);
5521       rtype = elf_ia64_reloc_type (type);
5522       if (rtype == NULL)
5523         printf (" 0x%08x                       ", type);
5524       else
5525         printf (" %-32s ", rtype);
5526       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5527       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5528     }
5529
5530   free (imfs);
5531 }
5532
5533 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
5534
5535 static void
5536 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5537 {
5538   Elf64_External_VMS_IMAGE_RELA *imrs;
5539   long i;
5540
5541   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5542                    1, imgrela->img_rela_cnt * sizeof (*imrs),
5543                    _("dynamic section image relocations"));
5544   if (!imrs)
5545     return;
5546
5547   printf (_("\nImage relocs\n"));
5548   printf
5549     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
5550
5551   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5552     {
5553       unsigned int type;
5554       const char *rtype;
5555
5556       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5557       printf ("%08" BFD_VMA_FMT "x ",
5558               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5559       type = BYTE_GET (imrs [i].type);
5560       rtype = elf_ia64_reloc_type (type);
5561       if (rtype == NULL)
5562         printf ("0x%08x                      ", type);
5563       else
5564         printf ("%-31s ", rtype);
5565       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5566       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5567       printf ("%08" BFD_VMA_FMT "x\n",
5568               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5569     }
5570
5571   free (imrs);
5572 }
5573
5574 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
5575
5576 static int
5577 process_ia64_vms_dynamic_relocs (FILE *file)
5578 {
5579   struct ia64_vms_dynfixup fixup;
5580   struct ia64_vms_dynimgrela imgrela;
5581   Elf_Internal_Dyn *entry;
5582   int res = 0;
5583   bfd_vma strtab_off = 0;
5584   bfd_vma strtab_sz = 0;
5585   char *strtab = NULL;
5586
5587   memset (&fixup, 0, sizeof (fixup));
5588   memset (&imgrela, 0, sizeof (imgrela));
5589
5590   /* Note: the order of the entries is specified by the OpenVMS specs.  */
5591   for (entry = dynamic_section;
5592        entry < dynamic_section + dynamic_nent;
5593        entry++)
5594     {
5595       switch (entry->d_tag)
5596         {
5597         case DT_IA_64_VMS_STRTAB_OFFSET:
5598           strtab_off = entry->d_un.d_val;
5599           break;
5600         case DT_STRSZ:
5601           strtab_sz = entry->d_un.d_val;
5602           if (strtab == NULL)
5603             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5604                                1, strtab_sz, _("dynamic string section"));
5605           break;
5606
5607         case DT_IA_64_VMS_NEEDED_IDENT:
5608           fixup.needed_ident = entry->d_un.d_val;
5609           break;
5610         case DT_NEEDED:
5611           fixup.needed = entry->d_un.d_val;
5612           break;
5613         case DT_IA_64_VMS_FIXUP_NEEDED:
5614           fixup.fixup_needed = entry->d_un.d_val;
5615           break;
5616         case DT_IA_64_VMS_FIXUP_RELA_CNT:
5617           fixup.fixup_rela_cnt = entry->d_un.d_val;
5618           break;
5619         case DT_IA_64_VMS_FIXUP_RELA_OFF:
5620           fixup.fixup_rela_off = entry->d_un.d_val;
5621           res++;
5622           dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5623           break;
5624
5625         case DT_IA_64_VMS_IMG_RELA_CNT:
5626           imgrela.img_rela_cnt = entry->d_un.d_val;
5627           break;
5628         case DT_IA_64_VMS_IMG_RELA_OFF:
5629           imgrela.img_rela_off = entry->d_un.d_val;
5630           res++;
5631           dump_ia64_vms_dynamic_relocs (file, &imgrela);
5632           break;
5633
5634         default:
5635           break;
5636         }
5637     }
5638
5639   if (strtab != NULL)
5640     free (strtab);
5641
5642   return res;
5643 }
5644
5645 static struct
5646 {
5647   const char * name;
5648   int reloc;
5649   int size;
5650   int rela;
5651 } dynamic_relocations [] =
5652 {
5653     { "REL", DT_REL, DT_RELSZ, FALSE },
5654     { "RELA", DT_RELA, DT_RELASZ, TRUE },
5655     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5656 };
5657
5658 /* Process the reloc section.  */
5659
5660 static int
5661 process_relocs (FILE * file)
5662 {
5663   unsigned long rel_size;
5664   unsigned long rel_offset;
5665
5666
5667   if (!do_reloc)
5668     return 1;
5669
5670   if (do_using_dynamic)
5671     {
5672       int is_rela;
5673       const char * name;
5674       int has_dynamic_reloc;
5675       unsigned int i;
5676
5677       has_dynamic_reloc = 0;
5678
5679       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5680         {
5681           is_rela = dynamic_relocations [i].rela;
5682           name = dynamic_relocations [i].name;
5683           rel_size = dynamic_info [dynamic_relocations [i].size];
5684           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5685
5686           has_dynamic_reloc |= rel_size;
5687
5688           if (is_rela == UNKNOWN)
5689             {
5690               if (dynamic_relocations [i].reloc == DT_JMPREL)
5691                 switch (dynamic_info[DT_PLTREL])
5692                   {
5693                   case DT_REL:
5694                     is_rela = FALSE;
5695                     break;
5696                   case DT_RELA:
5697                     is_rela = TRUE;
5698                     break;
5699                   }
5700             }
5701
5702           if (rel_size)
5703             {
5704               printf
5705                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5706                  name, rel_offset, rel_size);
5707
5708               dump_relocations (file,
5709                                 offset_from_vma (file, rel_offset, rel_size),
5710                                 rel_size,
5711                                 dynamic_symbols, num_dynamic_syms,
5712                                 dynamic_strings, dynamic_strings_length, is_rela);
5713             }
5714         }
5715
5716       if (is_ia64_vms ())
5717         has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5718
5719       if (! has_dynamic_reloc)
5720         printf (_("\nThere are no dynamic relocations in this file.\n"));
5721     }
5722   else
5723     {
5724       Elf_Internal_Shdr * section;
5725       unsigned long i;
5726       int found = 0;
5727
5728       for (i = 0, section = section_headers;
5729            i < elf_header.e_shnum;
5730            i++, section++)
5731         {
5732           if (   section->sh_type != SHT_RELA
5733               && section->sh_type != SHT_REL)
5734             continue;
5735
5736           rel_offset = section->sh_offset;
5737           rel_size   = section->sh_size;
5738
5739           if (rel_size)
5740             {
5741               Elf_Internal_Shdr * strsec;
5742               int is_rela;
5743
5744               printf (_("\nRelocation section "));
5745
5746               if (string_table == NULL)
5747                 printf ("%d", section->sh_name);
5748               else
5749                 printf ("'%s'", SECTION_NAME (section));
5750
5751               printf (_(" at offset 0x%lx contains %lu entries:\n"),
5752                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5753
5754               is_rela = section->sh_type == SHT_RELA;
5755
5756               if (section->sh_link != 0
5757                   && section->sh_link < elf_header.e_shnum)
5758                 {
5759                   Elf_Internal_Shdr * symsec;
5760                   Elf_Internal_Sym *  symtab;
5761                   unsigned long nsyms;
5762                   unsigned long strtablen = 0;
5763                   char * strtab = NULL;
5764
5765                   symsec = section_headers + section->sh_link;
5766                   if (symsec->sh_type != SHT_SYMTAB
5767                       && symsec->sh_type != SHT_DYNSYM)
5768                     continue;
5769
5770                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
5771
5772                   if (symtab == NULL)
5773                     continue;
5774
5775                   if (symsec->sh_link != 0
5776                       && symsec->sh_link < elf_header.e_shnum)
5777                     {
5778                       strsec = section_headers + symsec->sh_link;
5779
5780                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5781                                                   1, strsec->sh_size,
5782                                                   _("string table"));
5783                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
5784                     }
5785
5786                   dump_relocations (file, rel_offset, rel_size,
5787                                     symtab, nsyms, strtab, strtablen, is_rela);
5788                   if (strtab)
5789                     free (strtab);
5790                   free (symtab);
5791                 }
5792               else
5793                 dump_relocations (file, rel_offset, rel_size,
5794                                   NULL, 0, NULL, 0, is_rela);
5795
5796               found = 1;
5797             }
5798         }
5799
5800       if (! found)
5801         printf (_("\nThere are no relocations in this file.\n"));
5802     }
5803
5804   return 1;
5805 }
5806
5807 /* Process the unwind section.  */
5808
5809 #include "unwind-ia64.h"
5810
5811 /* An absolute address consists of a section and an offset.  If the
5812    section is NULL, the offset itself is the address, otherwise, the
5813    address equals to LOAD_ADDRESS(section) + offset.  */
5814
5815 struct absaddr
5816   {
5817     unsigned short section;
5818     bfd_vma offset;
5819   };
5820
5821 #define ABSADDR(a) \
5822   ((a).section \
5823    ? section_headers [(a).section].sh_addr + (a).offset \
5824    : (a).offset)
5825
5826 struct ia64_unw_table_entry
5827   {
5828     struct absaddr start;
5829     struct absaddr end;
5830     struct absaddr info;
5831   };
5832
5833 struct ia64_unw_aux_info
5834   {
5835
5836     struct ia64_unw_table_entry *table; /* Unwind table.  */
5837     unsigned long table_len;    /* Length of unwind table.  */
5838     unsigned char * info;       /* Unwind info.  */
5839     unsigned long info_size;    /* Size of unwind info.  */
5840     bfd_vma info_addr;          /* starting address of unwind info.  */
5841     bfd_vma seg_base;           /* Starting address of segment.  */
5842     Elf_Internal_Sym * symtab;  /* The symbol table.  */
5843     unsigned long nsyms;        /* Number of symbols.  */
5844     char * strtab;              /* The string table.  */
5845     unsigned long strtab_size;  /* Size of string table.  */
5846   };
5847
5848 static void
5849 find_symbol_for_address (Elf_Internal_Sym * symtab,
5850                          unsigned long nsyms,
5851                          const char * strtab,
5852                          unsigned long strtab_size,
5853                          struct absaddr addr,
5854                          const char ** symname,
5855                          bfd_vma * offset)
5856 {
5857   bfd_vma dist = 0x100000;
5858   Elf_Internal_Sym * sym;
5859   Elf_Internal_Sym * best = NULL;
5860   unsigned long i;
5861
5862   REMOVE_ARCH_BITS (addr.offset);
5863
5864   for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
5865     {
5866       bfd_vma value = sym->st_value;
5867
5868       REMOVE_ARCH_BITS (value);
5869
5870       if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5871           && sym->st_name != 0
5872           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
5873           && addr.offset >= value
5874           && addr.offset - value < dist)
5875         {
5876           best = sym;
5877           dist = addr.offset - value;
5878           if (!dist)
5879             break;
5880         }
5881     }
5882
5883   if (best)
5884     {
5885       *symname = (best->st_name >= strtab_size
5886                   ? _("<corrupt>") : strtab + best->st_name);
5887       *offset = dist;
5888       return;
5889     }
5890
5891   *symname = NULL;
5892   *offset = addr.offset;
5893 }
5894
5895 static void
5896 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
5897 {
5898   struct ia64_unw_table_entry * tp;
5899   int in_body;
5900
5901   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5902     {
5903       bfd_vma stamp;
5904       bfd_vma offset;
5905       const unsigned char * dp;
5906       const unsigned char * head;
5907       const char * procname;
5908
5909       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5910                                aux->strtab_size, tp->start, &procname, &offset);
5911
5912       fputs ("\n<", stdout);
5913
5914       if (procname)
5915         {
5916           fputs (procname, stdout);
5917
5918           if (offset)
5919             printf ("+%lx", (unsigned long) offset);
5920         }
5921
5922       fputs (">: [", stdout);
5923       print_vma (tp->start.offset, PREFIX_HEX);
5924       fputc ('-', stdout);
5925       print_vma (tp->end.offset, PREFIX_HEX);
5926       printf ("], info at +0x%lx\n",
5927               (unsigned long) (tp->info.offset - aux->seg_base));
5928
5929       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5930       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5931
5932       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5933               (unsigned) UNW_VER (stamp),
5934               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5935               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5936               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5937               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5938
5939       if (UNW_VER (stamp) != 1)
5940         {
5941           printf (_("\tUnknown version.\n"));
5942           continue;
5943         }
5944
5945       in_body = 0;
5946       for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5947         dp = unw_decode (dp, in_body, & in_body);
5948     }
5949 }
5950
5951 static int
5952 slurp_ia64_unwind_table (FILE * file,
5953                          struct ia64_unw_aux_info * aux,
5954                          Elf_Internal_Shdr * sec)
5955 {
5956   unsigned long size, nrelas, i;
5957   Elf_Internal_Phdr * seg;
5958   struct ia64_unw_table_entry * tep;
5959   Elf_Internal_Shdr * relsec;
5960   Elf_Internal_Rela * rela;
5961   Elf_Internal_Rela * rp;
5962   unsigned char * table;
5963   unsigned char * tp;
5964   Elf_Internal_Sym * sym;
5965   const char * relname;
5966
5967   /* First, find the starting address of the segment that includes
5968      this section: */
5969
5970   if (elf_header.e_phnum)
5971     {
5972       if (! get_program_headers (file))
5973           return 0;
5974
5975       for (seg = program_headers;
5976            seg < program_headers + elf_header.e_phnum;
5977            ++seg)
5978         {
5979           if (seg->p_type != PT_LOAD)
5980             continue;
5981
5982           if (sec->sh_addr >= seg->p_vaddr
5983               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5984             {
5985               aux->seg_base = seg->p_vaddr;
5986               break;
5987             }
5988         }
5989     }
5990
5991   /* Second, build the unwind table from the contents of the unwind section:  */
5992   size = sec->sh_size;
5993   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5994                                       _("unwind table"));
5995   if (!table)
5996     return 0;
5997
5998   aux->table = (struct ia64_unw_table_entry *)
5999       xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
6000   tep = aux->table;
6001   for (tp = table; tp < table + size; ++tep)
6002     {
6003       tep->start.section = SHN_UNDEF;
6004       tep->end.section   = SHN_UNDEF;
6005       tep->info.section  = SHN_UNDEF;
6006       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6007       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6008       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6009       tep->start.offset += aux->seg_base;
6010       tep->end.offset   += aux->seg_base;
6011       tep->info.offset  += aux->seg_base;
6012     }
6013   free (table);
6014
6015   /* Third, apply any relocations to the unwind table:  */
6016   for (relsec = section_headers;
6017        relsec < section_headers + elf_header.e_shnum;
6018        ++relsec)
6019     {
6020       if (relsec->sh_type != SHT_RELA
6021           || relsec->sh_info >= elf_header.e_shnum
6022           || section_headers + relsec->sh_info != sec)
6023         continue;
6024
6025       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6026                               & rela, & nrelas))
6027         return 0;
6028
6029       for (rp = rela; rp < rela + nrelas; ++rp)
6030         {
6031           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6032           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6033
6034           if (! const_strneq (relname, "R_IA64_SEGREL"))
6035             {
6036               warn (_("Skipping unexpected relocation type %s\n"), relname);
6037               continue;
6038             }
6039
6040           i = rp->r_offset / (3 * eh_addr_size);
6041
6042           switch (rp->r_offset/eh_addr_size % 3)
6043             {
6044             case 0:
6045               aux->table[i].start.section = sym->st_shndx;
6046               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
6047               break;
6048             case 1:
6049               aux->table[i].end.section   = sym->st_shndx;
6050               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
6051               break;
6052             case 2:
6053               aux->table[i].info.section  = sym->st_shndx;
6054               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
6055               break;
6056             default:
6057               break;
6058             }
6059         }
6060
6061       free (rela);
6062     }
6063
6064   aux->table_len = size / (3 * eh_addr_size);
6065   return 1;
6066 }
6067
6068 static void
6069 ia64_process_unwind (FILE * file)
6070 {
6071   Elf_Internal_Shdr * sec;
6072   Elf_Internal_Shdr * unwsec = NULL;
6073   Elf_Internal_Shdr * strsec;
6074   unsigned long i, unwcount = 0, unwstart = 0;
6075   struct ia64_unw_aux_info aux;
6076
6077   memset (& aux, 0, sizeof (aux));
6078
6079   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6080     {
6081       if (sec->sh_type == SHT_SYMTAB
6082           && sec->sh_link < elf_header.e_shnum)
6083         {
6084           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6085
6086           strsec = section_headers + sec->sh_link;
6087           assert (aux.strtab == NULL);
6088           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6089                                           1, strsec->sh_size,
6090                                           _("string table"));
6091           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6092         }
6093       else if (sec->sh_type == SHT_IA_64_UNWIND)
6094         unwcount++;
6095     }
6096
6097   if (!unwcount)
6098     printf (_("\nThere are no unwind sections in this file.\n"));
6099
6100   while (unwcount-- > 0)
6101     {
6102       char * suffix;
6103       size_t len, len2;
6104
6105       for (i = unwstart, sec = section_headers + unwstart;
6106            i < elf_header.e_shnum; ++i, ++sec)
6107         if (sec->sh_type == SHT_IA_64_UNWIND)
6108           {
6109             unwsec = sec;
6110             break;
6111           }
6112
6113       unwstart = i + 1;
6114       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6115
6116       if ((unwsec->sh_flags & SHF_GROUP) != 0)
6117         {
6118           /* We need to find which section group it is in.  */
6119           struct group_list * g = section_headers_groups [i]->root;
6120
6121           for (; g != NULL; g = g->next)
6122             {
6123               sec = section_headers + g->section_index;
6124
6125               if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6126                 break;
6127             }
6128
6129           if (g == NULL)
6130             i = elf_header.e_shnum;
6131         }
6132       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6133         {
6134           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
6135           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6136           suffix = SECTION_NAME (unwsec) + len;
6137           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6138                ++i, ++sec)
6139             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6140                 && streq (SECTION_NAME (sec) + len2, suffix))
6141               break;
6142         }
6143       else
6144         {
6145           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6146              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
6147           len = sizeof (ELF_STRING_ia64_unwind) - 1;
6148           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6149           suffix = "";
6150           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6151             suffix = SECTION_NAME (unwsec) + len;
6152           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6153                ++i, ++sec)
6154             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6155                 && streq (SECTION_NAME (sec) + len2, suffix))
6156               break;
6157         }
6158
6159       if (i == elf_header.e_shnum)
6160         {
6161           printf (_("\nCould not find unwind info section for "));
6162
6163           if (string_table == NULL)
6164             printf ("%d", unwsec->sh_name);
6165           else
6166             printf (_("'%s'"), SECTION_NAME (unwsec));
6167         }
6168       else
6169         {
6170           aux.info_addr = sec->sh_addr;
6171           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6172                                                  sec->sh_size,
6173                                                  _("unwind info"));
6174           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6175
6176           printf (_("\nUnwind section "));
6177
6178           if (string_table == NULL)
6179             printf ("%d", unwsec->sh_name);
6180           else
6181             printf (_("'%s'"), SECTION_NAME (unwsec));
6182
6183           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6184                   (unsigned long) unwsec->sh_offset,
6185                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6186
6187           (void) slurp_ia64_unwind_table (file, & aux, unwsec);
6188
6189           if (aux.table_len > 0)
6190             dump_ia64_unwind (& aux);
6191
6192           if (aux.table)
6193             free ((char *) aux.table);
6194           if (aux.info)
6195             free ((char *) aux.info);
6196           aux.table = NULL;
6197           aux.info = NULL;
6198         }
6199     }
6200
6201   if (aux.symtab)
6202     free (aux.symtab);
6203   if (aux.strtab)
6204     free ((char *) aux.strtab);
6205 }
6206
6207 struct hppa_unw_table_entry
6208   {
6209     struct absaddr start;
6210     struct absaddr end;
6211     unsigned int Cannot_unwind:1;                       /* 0 */
6212     unsigned int Millicode:1;                   /* 1 */
6213     unsigned int Millicode_save_sr0:1;          /* 2 */
6214     unsigned int Region_description:2;          /* 3..4 */
6215     unsigned int reserved1:1;                   /* 5 */
6216     unsigned int Entry_SR:1;                    /* 6 */
6217     unsigned int Entry_FR:4;     /* number saved */     /* 7..10 */
6218     unsigned int Entry_GR:5;     /* number saved */     /* 11..15 */
6219     unsigned int Args_stored:1;                 /* 16 */
6220     unsigned int Variable_Frame:1;                      /* 17 */
6221     unsigned int Separate_Package_Body:1;               /* 18 */
6222     unsigned int Frame_Extension_Millicode:1;   /* 19 */
6223     unsigned int Stack_Overflow_Check:1;                /* 20 */
6224     unsigned int Two_Instruction_SP_Increment:1;        /* 21 */
6225     unsigned int Ada_Region:1;                  /* 22 */
6226     unsigned int cxx_info:1;                    /* 23 */
6227     unsigned int cxx_try_catch:1;                       /* 24 */
6228     unsigned int sched_entry_seq:1;                     /* 25 */
6229     unsigned int reserved2:1;                   /* 26 */
6230     unsigned int Save_SP:1;                             /* 27 */
6231     unsigned int Save_RP:1;                             /* 28 */
6232     unsigned int Save_MRP_in_frame:1;           /* 29 */
6233     unsigned int extn_ptr_defined:1;            /* 30 */
6234     unsigned int Cleanup_defined:1;                     /* 31 */
6235
6236     unsigned int MPE_XL_interrupt_marker:1;             /* 0 */
6237     unsigned int HP_UX_interrupt_marker:1;              /* 1 */
6238     unsigned int Large_frame:1;                 /* 2 */
6239     unsigned int Pseudo_SP_Set:1;                       /* 3 */
6240     unsigned int reserved4:1;                   /* 4 */
6241     unsigned int Total_frame_size:27;           /* 5..31 */
6242   };
6243
6244 struct hppa_unw_aux_info
6245   {
6246     struct hppa_unw_table_entry *table; /* Unwind table.  */
6247     unsigned long table_len;    /* Length of unwind table.  */
6248     bfd_vma seg_base;           /* Starting address of segment.  */
6249     Elf_Internal_Sym * symtab;  /* The symbol table.  */
6250     unsigned long nsyms;        /* Number of symbols.  */
6251     char * strtab;              /* The string table.  */
6252     unsigned long strtab_size;  /* Size of string table.  */
6253   };
6254
6255 static void
6256 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
6257 {
6258   struct hppa_unw_table_entry * tp;
6259
6260   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6261     {
6262       bfd_vma offset;
6263       const char * procname;
6264
6265       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6266                                aux->strtab_size, tp->start, &procname,
6267                                &offset);
6268
6269       fputs ("\n<", stdout);
6270
6271       if (procname)
6272         {
6273           fputs (procname, stdout);
6274
6275           if (offset)
6276             printf ("+%lx", (unsigned long) offset);
6277         }
6278
6279       fputs (">: [", stdout);
6280       print_vma (tp->start.offset, PREFIX_HEX);
6281       fputc ('-', stdout);
6282       print_vma (tp->end.offset, PREFIX_HEX);
6283       printf ("]\n\t");
6284
6285 #define PF(_m) if (tp->_m) printf (#_m " ");
6286 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6287       PF(Cannot_unwind);
6288       PF(Millicode);
6289       PF(Millicode_save_sr0);
6290       /* PV(Region_description);  */
6291       PF(Entry_SR);
6292       PV(Entry_FR);
6293       PV(Entry_GR);
6294       PF(Args_stored);
6295       PF(Variable_Frame);
6296       PF(Separate_Package_Body);
6297       PF(Frame_Extension_Millicode);
6298       PF(Stack_Overflow_Check);
6299       PF(Two_Instruction_SP_Increment);
6300       PF(Ada_Region);
6301       PF(cxx_info);
6302       PF(cxx_try_catch);
6303       PF(sched_entry_seq);
6304       PF(Save_SP);
6305       PF(Save_RP);
6306       PF(Save_MRP_in_frame);
6307       PF(extn_ptr_defined);
6308       PF(Cleanup_defined);
6309       PF(MPE_XL_interrupt_marker);
6310       PF(HP_UX_interrupt_marker);
6311       PF(Large_frame);
6312       PF(Pseudo_SP_Set);
6313       PV(Total_frame_size);
6314 #undef PF
6315 #undef PV
6316     }
6317
6318   printf ("\n");
6319 }
6320
6321 static int
6322 slurp_hppa_unwind_table (FILE * file,
6323                          struct hppa_unw_aux_info * aux,
6324                          Elf_Internal_Shdr * sec)
6325 {
6326   unsigned long size, unw_ent_size, nentries, nrelas, i;
6327   Elf_Internal_Phdr * seg;
6328   struct hppa_unw_table_entry * tep;
6329   Elf_Internal_Shdr * relsec;
6330   Elf_Internal_Rela * rela;
6331   Elf_Internal_Rela * rp;
6332   unsigned char * table;
6333   unsigned char * tp;
6334   Elf_Internal_Sym * sym;
6335   const char * relname;
6336
6337   /* First, find the starting address of the segment that includes
6338      this section.  */
6339
6340   if (elf_header.e_phnum)
6341     {
6342       if (! get_program_headers (file))
6343         return 0;
6344
6345       for (seg = program_headers;
6346            seg < program_headers + elf_header.e_phnum;
6347            ++seg)
6348         {
6349           if (seg->p_type != PT_LOAD)
6350             continue;
6351
6352           if (sec->sh_addr >= seg->p_vaddr
6353               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6354             {
6355               aux->seg_base = seg->p_vaddr;
6356               break;
6357             }
6358         }
6359     }
6360
6361   /* Second, build the unwind table from the contents of the unwind
6362      section.  */
6363   size = sec->sh_size;
6364   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6365                                       _("unwind table"));
6366   if (!table)
6367     return 0;
6368
6369   unw_ent_size = 16;
6370   nentries = size / unw_ent_size;
6371   size = unw_ent_size * nentries;
6372
6373   tep = aux->table = (struct hppa_unw_table_entry *)
6374       xcmalloc (nentries, sizeof (aux->table[0]));
6375
6376   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6377     {
6378       unsigned int tmp1, tmp2;
6379
6380       tep->start.section = SHN_UNDEF;
6381       tep->end.section   = SHN_UNDEF;
6382
6383       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6384       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6385       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6386       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6387
6388       tep->start.offset += aux->seg_base;
6389       tep->end.offset   += aux->seg_base;
6390
6391       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6392       tep->Millicode = (tmp1 >> 30) & 0x1;
6393       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6394       tep->Region_description = (tmp1 >> 27) & 0x3;
6395       tep->reserved1 = (tmp1 >> 26) & 0x1;
6396       tep->Entry_SR = (tmp1 >> 25) & 0x1;
6397       tep->Entry_FR = (tmp1 >> 21) & 0xf;
6398       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6399       tep->Args_stored = (tmp1 >> 15) & 0x1;
6400       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6401       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6402       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6403       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6404       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6405       tep->Ada_Region = (tmp1 >> 9) & 0x1;
6406       tep->cxx_info = (tmp1 >> 8) & 0x1;
6407       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6408       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6409       tep->reserved2 = (tmp1 >> 5) & 0x1;
6410       tep->Save_SP = (tmp1 >> 4) & 0x1;
6411       tep->Save_RP = (tmp1 >> 3) & 0x1;
6412       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6413       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6414       tep->Cleanup_defined = tmp1 & 0x1;
6415
6416       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6417       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6418       tep->Large_frame = (tmp2 >> 29) & 0x1;
6419       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6420       tep->reserved4 = (tmp2 >> 27) & 0x1;
6421       tep->Total_frame_size = tmp2 & 0x7ffffff;
6422     }
6423   free (table);
6424
6425   /* Third, apply any relocations to the unwind table.  */
6426   for (relsec = section_headers;
6427        relsec < section_headers + elf_header.e_shnum;
6428        ++relsec)
6429     {
6430       if (relsec->sh_type != SHT_RELA
6431           || relsec->sh_info >= elf_header.e_shnum
6432           || section_headers + relsec->sh_info != sec)
6433         continue;
6434
6435       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6436                               & rela, & nrelas))
6437         return 0;
6438
6439       for (rp = rela; rp < rela + nrelas; ++rp)
6440         {
6441           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6442           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6443
6444           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
6445           if (! const_strneq (relname, "R_PARISC_SEGREL"))
6446             {
6447               warn (_("Skipping unexpected relocation type %s\n"), relname);
6448               continue;
6449             }
6450
6451           i = rp->r_offset / unw_ent_size;
6452
6453           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6454             {
6455             case 0:
6456               aux->table[i].start.section = sym->st_shndx;
6457               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
6458               break;
6459             case 1:
6460               aux->table[i].end.section   = sym->st_shndx;
6461               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
6462               break;
6463             default:
6464               break;
6465             }
6466         }
6467
6468       free (rela);
6469     }
6470
6471   aux->table_len = nentries;
6472
6473   return 1;
6474 }
6475
6476 static void
6477 hppa_process_unwind (FILE * file)
6478 {
6479   struct hppa_unw_aux_info aux;
6480   Elf_Internal_Shdr * unwsec = NULL;
6481   Elf_Internal_Shdr * strsec;
6482   Elf_Internal_Shdr * sec;
6483   unsigned long i;
6484
6485   if (string_table == NULL)
6486     return;
6487
6488   memset (& aux, 0, sizeof (aux));
6489
6490   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6491     {
6492       if (sec->sh_type == SHT_SYMTAB
6493           && sec->sh_link < elf_header.e_shnum)
6494         {
6495           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6496
6497           strsec = section_headers + sec->sh_link;
6498           assert (aux.strtab == NULL);
6499           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6500                                           1, strsec->sh_size,
6501                                           _("string table"));
6502           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6503         }
6504       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6505         unwsec = sec;
6506     }
6507
6508   if (!unwsec)
6509     printf (_("\nThere are no unwind sections in this file.\n"));
6510
6511   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6512     {
6513       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6514         {
6515           printf (_("\nUnwind section "));
6516           printf (_("'%s'"), SECTION_NAME (sec));
6517
6518           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6519                   (unsigned long) sec->sh_offset,
6520                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6521
6522           slurp_hppa_unwind_table (file, &aux, sec);
6523           if (aux.table_len > 0)
6524             dump_hppa_unwind (&aux);
6525
6526           if (aux.table)
6527             free ((char *) aux.table);
6528           aux.table = NULL;
6529         }
6530     }
6531
6532   if (aux.symtab)
6533     free (aux.symtab);
6534   if (aux.strtab)
6535     free ((char *) aux.strtab);
6536 }
6537
6538 struct arm_section
6539 {
6540   unsigned char *      data;            /* The unwind data.  */
6541   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
6542   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
6543   unsigned long        nrelas;          /* The number of relocations.  */
6544   unsigned int         rel_type;        /* REL or RELA ?  */
6545   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
6546 };
6547
6548 struct arm_unw_aux_info
6549 {
6550   FILE *              file;             /* The file containing the unwind sections.  */
6551   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
6552   unsigned long       nsyms;            /* Number of symbols.  */
6553   char *              strtab;           /* The file's string table.  */
6554   unsigned long       strtab_size;      /* Size of string table.  */
6555 };
6556
6557 static const char *
6558 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6559                         bfd_vma fn, struct absaddr addr)
6560 {
6561   const char *procname;
6562   bfd_vma sym_offset;
6563
6564   if (addr.section == SHN_UNDEF)
6565     addr.offset = fn;
6566
6567   find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6568                            aux->strtab_size, addr, &procname,
6569                            &sym_offset);
6570
6571   print_vma (fn, PREFIX_HEX);
6572
6573   if (procname)
6574     {
6575       fputs (" <", stdout);
6576       fputs (procname, stdout);
6577
6578       if (sym_offset)
6579         printf ("+0x%lx", (unsigned long) sym_offset);
6580       fputc ('>', stdout);
6581     }
6582
6583   return procname;
6584 }
6585
6586 static void
6587 arm_free_section (struct arm_section *arm_sec)
6588 {
6589   if (arm_sec->data != NULL)
6590     free (arm_sec->data);
6591
6592   if (arm_sec->rela != NULL)
6593     free (arm_sec->rela);
6594 }
6595
6596 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6597       cached section and install SEC instead.
6598    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6599       and return its valued in * WORDP, relocating if necessary.
6600    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6601       relocation's offset in ADDR.
6602    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6603       into the string table of the symbol associated with the reloc.  If no
6604       reloc was applied store -1 there.
6605    5) Return TRUE upon success, FALSE otherwise.  */
6606
6607 static bfd_boolean
6608 get_unwind_section_word (struct arm_unw_aux_info *  aux,
6609                          struct arm_section *       arm_sec,
6610                          Elf_Internal_Shdr *        sec,
6611                          bfd_vma                    word_offset,
6612                          unsigned int *             wordp,
6613                          struct absaddr *           addr,
6614                          bfd_vma *                  sym_name)
6615 {
6616   Elf_Internal_Rela *rp;
6617   Elf_Internal_Sym *sym;
6618   const char * relname;
6619   unsigned int word;
6620   bfd_boolean wrapped;
6621
6622   addr->section = SHN_UNDEF;
6623   addr->offset = 0;
6624
6625   if (sym_name != NULL)
6626     *sym_name = (bfd_vma) -1;
6627
6628   /* If necessary, update the section cache.  */
6629   if (sec != arm_sec->sec)
6630     {
6631       Elf_Internal_Shdr *relsec;
6632
6633       arm_free_section (arm_sec);
6634
6635       arm_sec->sec = sec;
6636       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6637                                 sec->sh_size, _("unwind data"));
6638       arm_sec->rela = NULL;
6639       arm_sec->nrelas = 0;
6640
6641       for (relsec = section_headers;
6642            relsec < section_headers + elf_header.e_shnum;
6643            ++relsec)
6644         {
6645           if (relsec->sh_info >= elf_header.e_shnum
6646               || section_headers + relsec->sh_info != sec
6647               /* PR 15745: Check the section type as well.  */
6648               || (relsec->sh_type != SHT_REL
6649                   && relsec->sh_type != SHT_RELA))
6650             continue;
6651
6652           arm_sec->rel_type = relsec->sh_type;
6653           if (relsec->sh_type == SHT_REL)
6654             {
6655               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6656                                      relsec->sh_size,
6657                                      & arm_sec->rela, & arm_sec->nrelas))
6658                 return FALSE;
6659             }
6660           else /* relsec->sh_type == SHT_RELA */
6661             {
6662               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6663                                       relsec->sh_size,
6664                                       & arm_sec->rela, & arm_sec->nrelas))
6665                 return FALSE;
6666             }
6667           break;
6668         }
6669
6670       arm_sec->next_rela = arm_sec->rela;
6671     }
6672
6673   /* If there is no unwind data we can do nothing.  */
6674   if (arm_sec->data == NULL)
6675     return FALSE;
6676
6677   /* Get the word at the required offset.  */
6678   word = byte_get (arm_sec->data + word_offset, 4);
6679
6680   /* Look through the relocs to find the one that applies to the provided offset.  */
6681   wrapped = FALSE;
6682   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6683     {
6684       bfd_vma prelval, offset;
6685
6686       if (rp->r_offset > word_offset && !wrapped)
6687         {
6688           rp = arm_sec->rela;
6689           wrapped = TRUE;
6690         }
6691       if (rp->r_offset > word_offset)
6692         break;
6693
6694       if (rp->r_offset & 3)
6695         {
6696           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6697                 (unsigned long) rp->r_offset);
6698           continue;
6699         }
6700
6701       if (rp->r_offset < word_offset)
6702         continue;
6703
6704       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6705
6706       if (arm_sec->rel_type == SHT_REL)
6707         {
6708           offset = word & 0x7fffffff;
6709           if (offset & 0x40000000)
6710             offset |= ~ (bfd_vma) 0x7fffffff;
6711         }
6712       else if (arm_sec->rel_type == SHT_RELA)
6713         offset = rp->r_addend;
6714       else
6715         abort ();
6716
6717       offset += sym->st_value;
6718       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6719
6720       /* Check that we are processing the expected reloc type.  */
6721       if (elf_header.e_machine == EM_ARM)
6722         {
6723           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6724
6725           if (streq (relname, "R_ARM_NONE"))
6726               continue;
6727
6728           if (! streq (relname, "R_ARM_PREL31"))
6729             {
6730               warn (_("Skipping unexpected relocation type %s\n"), relname);
6731               continue;
6732             }
6733         }
6734       else if (elf_header.e_machine == EM_TI_C6000)
6735         {
6736           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6737
6738           if (streq (relname, "R_C6000_NONE"))
6739             continue;
6740
6741           if (! streq (relname, "R_C6000_PREL31"))
6742             {
6743               warn (_("Skipping unexpected relocation type %s\n"), relname);
6744               continue;
6745             }
6746
6747           prelval >>= 1;
6748         }
6749       else
6750         /* This function currently only supports ARM and TI unwinders.  */
6751         abort ();
6752
6753       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6754       addr->section = sym->st_shndx;
6755       addr->offset = offset;
6756       if (sym_name)
6757         * sym_name = sym->st_name;
6758       break;
6759     }
6760
6761   *wordp = word;
6762   arm_sec->next_rela = rp;
6763
6764   return TRUE;
6765 }
6766
6767 static const char *tic6x_unwind_regnames[16] =
6768 {
6769   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6770   "A14", "A13", "A12", "A11", "A10",
6771   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6772 };
6773
6774 static void
6775 decode_tic6x_unwind_regmask (unsigned int mask)
6776 {
6777   int i;
6778
6779   for (i = 12; mask; mask >>= 1, i--)
6780     {
6781       if (mask & 1)
6782         {
6783           fputs (tic6x_unwind_regnames[i], stdout);
6784           if (mask > 1)
6785             fputs (", ", stdout);
6786         }
6787     }
6788 }
6789
6790 #define ADVANCE                                                 \
6791   if (remaining == 0 && more_words)                             \
6792     {                                                           \
6793       data_offset += 4;                                         \
6794       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
6795                                      data_offset, & word, & addr, NULL))        \
6796         return;                                                 \
6797       remaining = 4;                                            \
6798       more_words--;                                             \
6799     }                                                           \
6800
6801 #define GET_OP(OP)                      \
6802   ADVANCE;                              \
6803   if (remaining)                        \
6804     {                                   \
6805       remaining--;                      \
6806       (OP) = word >> 24;                \
6807       word <<= 8;                       \
6808     }                                   \
6809   else                                  \
6810     {                                   \
6811       printf (_("[Truncated opcode]\n"));       \
6812       return;                           \
6813     }                                   \
6814   printf ("0x%02x ", OP)
6815
6816 static void
6817 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6818                             unsigned int word, unsigned int remaining,
6819                             unsigned int more_words,
6820                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6821                             struct arm_section *data_arm_sec)
6822 {
6823   struct absaddr addr;
6824
6825   /* Decode the unwinding instructions.  */
6826   while (1)
6827     {
6828       unsigned int op, op2;
6829
6830       ADVANCE;
6831       if (remaining == 0)
6832         break;
6833       remaining--;
6834       op = word >> 24;
6835       word <<= 8;
6836
6837       printf ("  0x%02x ", op);
6838
6839       if ((op & 0xc0) == 0x00)
6840         {
6841           int offset = ((op & 0x3f) << 2) + 4;
6842
6843           printf ("     vsp = vsp + %d", offset);
6844         }
6845       else if ((op & 0xc0) == 0x40)
6846         {
6847           int offset = ((op & 0x3f) << 2) + 4;
6848
6849           printf ("     vsp = vsp - %d", offset);
6850         }
6851       else if ((op & 0xf0) == 0x80)
6852         {
6853           GET_OP (op2);
6854           if (op == 0x80 && op2 == 0)
6855             printf (_("Refuse to unwind"));
6856           else
6857             {
6858               unsigned int mask = ((op & 0x0f) << 8) | op2;
6859               int first = 1;
6860               int i;
6861
6862               printf ("pop {");
6863               for (i = 0; i < 12; i++)
6864                 if (mask & (1 << i))
6865                   {
6866                     if (first)
6867                       first = 0;
6868                     else
6869                       printf (", ");
6870                     printf ("r%d", 4 + i);
6871                   }
6872               printf ("}");
6873             }
6874         }
6875       else if ((op & 0xf0) == 0x90)
6876         {
6877           if (op == 0x9d || op == 0x9f)
6878             printf (_("     [Reserved]"));
6879           else
6880             printf ("     vsp = r%d", op & 0x0f);
6881         }
6882       else if ((op & 0xf0) == 0xa0)
6883         {
6884           int end = 4 + (op & 0x07);
6885           int first = 1;
6886           int i;
6887
6888           printf ("     pop {");
6889           for (i = 4; i <= end; i++)
6890             {
6891               if (first)
6892                 first = 0;
6893               else
6894                 printf (", ");
6895               printf ("r%d", i);
6896             }
6897           if (op & 0x08)
6898             {
6899               if (!first)
6900                 printf (", ");
6901               printf ("r14");
6902             }
6903           printf ("}");
6904         }
6905       else if (op == 0xb0)
6906         printf (_("     finish"));
6907       else if (op == 0xb1)
6908         {
6909           GET_OP (op2);
6910           if (op2 == 0 || (op2 & 0xf0) != 0)
6911             printf (_("[Spare]"));
6912           else
6913             {
6914               unsigned int mask = op2 & 0x0f;
6915               int first = 1;
6916               int i;
6917
6918               printf ("pop {");
6919               for (i = 0; i < 12; i++)
6920                 if (mask & (1 << i))
6921                   {
6922                     if (first)
6923                       first = 0;
6924                     else
6925                       printf (", ");
6926                     printf ("r%d", i);
6927                   }
6928               printf ("}");
6929             }
6930         }
6931       else if (op == 0xb2)
6932         {
6933           unsigned char buf[9];
6934           unsigned int i, len;
6935           unsigned long offset;
6936
6937           for (i = 0; i < sizeof (buf); i++)
6938             {
6939               GET_OP (buf[i]);
6940               if ((buf[i] & 0x80) == 0)
6941                 break;
6942             }
6943           assert (i < sizeof (buf));
6944           offset = read_uleb128 (buf, &len, buf + i + 1);
6945           assert (len == i + 1);
6946           offset = offset * 4 + 0x204;
6947           printf ("vsp = vsp + %ld", offset);
6948         }
6949       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
6950         {
6951           unsigned int first, last;
6952
6953           GET_OP (op2);
6954           first = op2 >> 4;
6955           last = op2 & 0x0f;
6956           if (op == 0xc8)
6957             first = first + 16;
6958           printf ("pop {D%d", first);
6959           if (last)
6960             printf ("-D%d", first + last);
6961           printf ("}");
6962         }
6963       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6964         {
6965           unsigned int count = op & 0x07;
6966
6967           printf ("pop {D8");
6968           if (count)
6969             printf ("-D%d", 8 + count);
6970           printf ("}");
6971         }
6972       else if (op >= 0xc0 && op <= 0xc5)
6973         {
6974           unsigned int count = op & 0x07;
6975
6976           printf ("     pop {wR10");
6977           if (count)
6978             printf ("-wR%d", 10 + count);
6979           printf ("}");
6980         }
6981       else if (op == 0xc6)
6982         {
6983           unsigned int first, last;
6984
6985           GET_OP (op2);
6986           first = op2 >> 4;
6987           last = op2 & 0x0f;
6988           printf ("pop {wR%d", first);
6989           if (last)
6990             printf ("-wR%d", first + last);
6991           printf ("}");
6992         }
6993       else if (op == 0xc7)
6994         {
6995           GET_OP (op2);
6996           if (op2 == 0 || (op2 & 0xf0) != 0)
6997             printf (_("[Spare]"));
6998           else
6999             {
7000               unsigned int mask = op2 & 0x0f;
7001               int first = 1;
7002               int i;
7003
7004               printf ("pop {");
7005               for (i = 0; i < 4; i++)
7006                 if (mask & (1 << i))
7007                   {
7008                     if (first)
7009                       first = 0;
7010                     else
7011                       printf (", ");
7012                     printf ("wCGR%d", i);
7013                   }
7014               printf ("}");
7015             }
7016         }
7017       else
7018         printf (_("     [unsupported opcode]"));
7019       printf ("\n");
7020     }
7021 }
7022
7023 static void
7024 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7025                             unsigned int word, unsigned int remaining,
7026                             unsigned int more_words,
7027                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7028                             struct arm_section *data_arm_sec)
7029 {
7030   struct absaddr addr;
7031
7032   /* Decode the unwinding instructions.  */
7033   while (1)
7034     {
7035       unsigned int op, op2;
7036
7037       ADVANCE;
7038       if (remaining == 0)
7039         break;
7040       remaining--;
7041       op = word >> 24;
7042       word <<= 8;
7043
7044       printf ("  0x%02x ", op);
7045
7046       if ((op & 0xc0) == 0x00)
7047         {
7048           int offset = ((op & 0x3f) << 3) + 8;
7049           printf ("     sp = sp + %d", offset);
7050         }
7051       else if ((op & 0xc0) == 0x80)
7052         {
7053           GET_OP (op2);
7054           if (op == 0x80 && op2 == 0)
7055             printf (_("Refuse to unwind"));
7056           else
7057             {
7058               unsigned int mask = ((op & 0x1f) << 8) | op2;
7059               if (op & 0x20)
7060                 printf ("pop compact {");
7061               else
7062                 printf ("pop {");
7063
7064               decode_tic6x_unwind_regmask (mask);
7065               printf("}");
7066             }
7067         }
7068       else if ((op & 0xf0) == 0xc0)
7069         {
7070           unsigned int reg;
7071           unsigned int nregs;
7072           unsigned int i;
7073           const char *name;
7074           struct
7075           {
7076               unsigned int offset;
7077               unsigned int reg;
7078           } regpos[16];
7079
7080           /* Scan entire instruction first so that GET_OP output is not
7081              interleaved with disassembly.  */
7082           nregs = 0;
7083           for (i = 0; nregs < (op & 0xf); i++)
7084             {
7085               GET_OP (op2);
7086               reg = op2 >> 4;
7087               if (reg != 0xf)
7088                 {
7089                   regpos[nregs].offset = i * 2;
7090                   regpos[nregs].reg = reg;
7091                   nregs++;
7092                 }
7093
7094               reg = op2 & 0xf;
7095               if (reg != 0xf)
7096                 {
7097                   regpos[nregs].offset = i * 2 + 1;
7098                   regpos[nregs].reg = reg;
7099                   nregs++;
7100                 }
7101             }
7102
7103           printf (_("pop frame {"));
7104           reg = nregs - 1;
7105           for (i = i * 2; i > 0; i--)
7106             {
7107               if (regpos[reg].offset == i - 1)
7108                 {
7109                   name = tic6x_unwind_regnames[regpos[reg].reg];
7110                   if (reg > 0)
7111                     reg--;
7112                 }
7113               else
7114                 name = _("[pad]");
7115
7116               fputs (name, stdout);
7117               if (i > 1)
7118                 printf (", ");
7119             }
7120
7121           printf ("}");
7122         }
7123       else if (op == 0xd0)
7124         printf ("     MOV FP, SP");
7125       else if (op == 0xd1)
7126         printf ("     __c6xabi_pop_rts");
7127       else if (op == 0xd2)
7128         {
7129           unsigned char buf[9];
7130           unsigned int i, len;
7131           unsigned long offset;
7132
7133           for (i = 0; i < sizeof (buf); i++)
7134             {
7135               GET_OP (buf[i]);
7136               if ((buf[i] & 0x80) == 0)
7137                 break;
7138             }
7139           assert (i < sizeof (buf));
7140           offset = read_uleb128 (buf, &len, buf + i + 1);
7141           assert (len == i + 1);
7142           offset = offset * 8 + 0x408;
7143           printf (_("sp = sp + %ld"), offset);
7144         }
7145       else if ((op & 0xf0) == 0xe0)
7146         {
7147           if ((op & 0x0f) == 7)
7148             printf ("     RETURN");
7149           else
7150             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7151         }
7152       else
7153         {
7154           printf (_("     [unsupported opcode]"));
7155         }
7156       putchar ('\n');
7157     }
7158 }
7159
7160 static bfd_vma
7161 arm_expand_prel31 (bfd_vma word, bfd_vma where)
7162 {
7163   bfd_vma offset;
7164
7165   offset = word & 0x7fffffff;
7166   if (offset & 0x40000000)
7167     offset |= ~ (bfd_vma) 0x7fffffff;
7168
7169   if (elf_header.e_machine == EM_TI_C6000)
7170     offset <<= 1;
7171
7172   return offset + where;
7173 }
7174
7175 static void
7176 decode_arm_unwind (struct arm_unw_aux_info *  aux,
7177                    unsigned int               word,
7178                    unsigned int               remaining,
7179                    bfd_vma                    data_offset,
7180                    Elf_Internal_Shdr *        data_sec,
7181                    struct arm_section *       data_arm_sec)
7182 {
7183   int per_index;
7184   unsigned int more_words = 0;
7185   struct absaddr addr;
7186   bfd_vma sym_name = (bfd_vma) -1;
7187
7188   if (remaining == 0)
7189     {
7190       /* Fetch the first word.
7191          Note - when decoding an object file the address extracted
7192          here will always be 0.  So we also pass in the sym_name
7193          parameter so that we can find the symbol associated with
7194          the personality routine.  */
7195       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7196                                      & word, & addr, & sym_name))
7197         return;
7198
7199       remaining = 4;
7200     }
7201
7202   if ((word & 0x80000000) == 0)
7203     {
7204       /* Expand prel31 for personality routine.  */
7205       bfd_vma fn;
7206       const char *procname;
7207
7208       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
7209       printf (_("  Personality routine: "));
7210       if (fn == 0
7211           && addr.section == SHN_UNDEF && addr.offset == 0
7212           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7213         {
7214           procname = aux->strtab + sym_name;
7215           print_vma (fn, PREFIX_HEX);
7216           if (procname)
7217             {
7218               fputs (" <", stdout);
7219               fputs (procname, stdout);
7220               fputc ('>', stdout);
7221             }
7222         }
7223       else
7224         procname = arm_print_vma_and_name (aux, fn, addr);
7225       fputc ('\n', stdout);
7226
7227       /* The GCC personality routines use the standard compact
7228          encoding, starting with one byte giving the number of
7229          words.  */
7230       if (procname != NULL
7231           && (const_strneq (procname, "__gcc_personality_v0")
7232               || const_strneq (procname, "__gxx_personality_v0")
7233               || const_strneq (procname, "__gcj_personality_v0")
7234               || const_strneq (procname, "__gnu_objc_personality_v0")))
7235         {
7236           remaining = 0;
7237           more_words = 1;
7238           ADVANCE;
7239           if (!remaining)
7240             {
7241               printf (_("  [Truncated data]\n"));
7242               return;
7243             }
7244           more_words = word >> 24;
7245           word <<= 8;
7246           remaining--;
7247           per_index = -1;
7248         }
7249       else
7250         return;
7251     }
7252   else
7253     {
7254       /* ARM EHABI Section 6.3:
7255
7256          An exception-handling table entry for the compact model looks like:
7257
7258            31 30-28 27-24 23-0
7259            -- ----- ----- ----
7260             1   0   index Data for personalityRoutine[index]    */
7261
7262       if (elf_header.e_machine == EM_ARM
7263           && (word & 0x70000000))
7264         warn (_("Corrupt ARM compact model table entry: %x \n"), word);
7265
7266       per_index = (word >> 24) & 0x7f;
7267       printf (_("  Compact model index: %d\n"), per_index);
7268       if (per_index == 0)
7269         {
7270           more_words = 0;
7271           word <<= 8;
7272           remaining--;
7273         }
7274       else if (per_index < 3)
7275         {
7276           more_words = (word >> 16) & 0xff;
7277           word <<= 16;
7278           remaining -= 2;
7279         }
7280     }
7281
7282   switch (elf_header.e_machine)
7283     {
7284     case EM_ARM:
7285       if (per_index < 3)
7286         {
7287           decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7288                                       data_offset, data_sec, data_arm_sec);
7289         }
7290       else
7291         {
7292           warn (_("Unknown ARM compact model index encountered\n"));
7293           printf (_("  [reserved]\n"));
7294         }
7295       break;
7296
7297     case EM_TI_C6000:
7298       if (per_index < 3)
7299         {
7300           decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
7301                                         data_offset, data_sec, data_arm_sec);
7302         }
7303       else if (per_index < 5)
7304         {
7305           if (((word >> 17) & 0x7f) == 0x7f)
7306             printf (_("  Restore stack from frame pointer\n"));
7307           else
7308             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
7309           printf (_("  Registers restored: "));
7310           if (per_index == 4)
7311             printf (" (compact) ");
7312           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7313           putchar ('\n');
7314           printf (_("  Return register: %s\n"),
7315                   tic6x_unwind_regnames[word & 0xf]);
7316         }
7317       else
7318         printf (_("  [reserved (%d)]\n"), per_index);
7319       break;
7320
7321     default:
7322       error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7323              elf_header.e_machine);
7324     }
7325
7326   /* Decode the descriptors.  Not implemented.  */
7327 }
7328
7329 static void
7330 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7331 {
7332   struct arm_section exidx_arm_sec, extab_arm_sec;
7333   unsigned int i, exidx_len;
7334
7335   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7336   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7337   exidx_len = exidx_sec->sh_size / 8;
7338
7339   for (i = 0; i < exidx_len; i++)
7340     {
7341       unsigned int exidx_fn, exidx_entry;
7342       struct absaddr fn_addr, entry_addr;
7343       bfd_vma fn;
7344
7345       fputc ('\n', stdout);
7346
7347       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7348                                      8 * i, & exidx_fn, & fn_addr, NULL)
7349           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7350                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
7351         {
7352           arm_free_section (& exidx_arm_sec);
7353           arm_free_section (& extab_arm_sec);
7354           return;
7355         }
7356
7357       /* ARM EHABI, Section 5:
7358          An index table entry consists of 2 words.
7359          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
7360       if (exidx_fn & 0x80000000)
7361         warn (_("corrupt index table entry: %x\n"), exidx_fn);
7362
7363       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
7364
7365       arm_print_vma_and_name (aux, fn, fn_addr);
7366       fputs (": ", stdout);
7367
7368       if (exidx_entry == 1)
7369         {
7370           print_vma (exidx_entry, PREFIX_HEX);
7371           fputs (" [cantunwind]\n", stdout);
7372         }
7373       else if (exidx_entry & 0x80000000)
7374         {
7375           print_vma (exidx_entry, PREFIX_HEX);
7376           fputc ('\n', stdout);
7377           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7378         }
7379       else
7380         {
7381           bfd_vma table, table_offset = 0;
7382           Elf_Internal_Shdr *table_sec;
7383
7384           fputs ("@", stdout);
7385           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
7386           print_vma (table, PREFIX_HEX);
7387           printf ("\n");
7388
7389           /* Locate the matching .ARM.extab.  */
7390           if (entry_addr.section != SHN_UNDEF
7391               && entry_addr.section < elf_header.e_shnum)
7392             {
7393               table_sec = section_headers + entry_addr.section;
7394               table_offset = entry_addr.offset;
7395             }
7396           else
7397             {
7398               table_sec = find_section_by_address (table);
7399               if (table_sec != NULL)
7400                 table_offset = table - table_sec->sh_addr;
7401             }
7402           if (table_sec == NULL)
7403             {
7404               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7405                     (unsigned long) table);
7406               continue;
7407             }
7408           decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7409                              &extab_arm_sec);
7410         }
7411     }
7412
7413   printf ("\n");
7414
7415   arm_free_section (&exidx_arm_sec);
7416   arm_free_section (&extab_arm_sec);
7417 }
7418
7419 /* Used for both ARM and C6X unwinding tables.  */
7420
7421 static void
7422 arm_process_unwind (FILE *file)
7423 {
7424   struct arm_unw_aux_info aux;
7425   Elf_Internal_Shdr *unwsec = NULL;
7426   Elf_Internal_Shdr *strsec;
7427   Elf_Internal_Shdr *sec;
7428   unsigned long i;
7429   unsigned int sec_type;
7430
7431   switch (elf_header.e_machine)
7432     {
7433     case EM_ARM:
7434       sec_type = SHT_ARM_EXIDX;
7435       break;
7436
7437     case EM_TI_C6000:
7438       sec_type = SHT_C6000_UNWIND;
7439       break;
7440
7441     default:
7442       error (_("Unsupported architecture type %d encountered when processing unwind table"),
7443              elf_header.e_machine);
7444       return;
7445     }
7446
7447   if (string_table == NULL)
7448     return;
7449
7450   memset (& aux, 0, sizeof (aux));
7451   aux.file = file;
7452
7453   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7454     {
7455       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7456         {
7457           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7458
7459           strsec = section_headers + sec->sh_link;
7460           assert (aux.strtab == NULL);
7461           aux.strtab = get_data (NULL, file, strsec->sh_offset,
7462                                  1, strsec->sh_size, _("string table"));
7463           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7464         }
7465       else if (sec->sh_type == sec_type)
7466         unwsec = sec;
7467     }
7468
7469   if (unwsec == NULL)
7470     printf (_("\nThere are no unwind sections in this file.\n"));
7471   else
7472     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7473       {
7474         if (sec->sh_type == sec_type)
7475           {
7476             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7477                     SECTION_NAME (sec),
7478                     (unsigned long) sec->sh_offset,
7479                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7480
7481             dump_arm_unwind (&aux, sec);
7482           }
7483       }
7484
7485   if (aux.symtab)
7486     free (aux.symtab);
7487   if (aux.strtab)
7488     free ((char *) aux.strtab);
7489 }
7490
7491 static void
7492 process_unwind (FILE * file)
7493 {
7494   struct unwind_handler
7495   {
7496     int machtype;
7497     void (* handler)(FILE *);
7498   } handlers[] =
7499   {
7500     { EM_ARM, arm_process_unwind },
7501     { EM_IA_64, ia64_process_unwind },
7502     { EM_PARISC, hppa_process_unwind },
7503     { EM_TI_C6000, arm_process_unwind },
7504     { 0, 0 }
7505   };
7506   int i;
7507
7508   if (!do_unwind)
7509     return;
7510
7511   for (i = 0; handlers[i].handler != NULL; i++)
7512     if (elf_header.e_machine == handlers[i].machtype)
7513       {
7514         handlers[i].handler (file);
7515         return;
7516       }
7517
7518   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7519           get_machine_name (elf_header.e_machine));
7520 }
7521
7522 static void
7523 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
7524 {
7525   switch (entry->d_tag)
7526     {
7527     case DT_MIPS_FLAGS:
7528       if (entry->d_un.d_val == 0)
7529         printf (_("NONE"));
7530       else
7531         {
7532           static const char * opts[] =
7533           {
7534             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7535             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7536             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7537             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7538             "RLD_ORDER_SAFE"
7539           };
7540           unsigned int cnt;
7541           int first = 1;
7542
7543           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
7544             if (entry->d_un.d_val & (1 << cnt))
7545               {
7546                 printf ("%s%s", first ? "" : " ", opts[cnt]);
7547                 first = 0;
7548               }
7549         }
7550       break;
7551
7552     case DT_MIPS_IVERSION:
7553       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7554         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
7555       else
7556         printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
7557       break;
7558
7559     case DT_MIPS_TIME_STAMP:
7560       {
7561         char timebuf[20];
7562         struct tm * tmp;
7563
7564         time_t atime = entry->d_un.d_val;
7565         tmp = gmtime (&atime);
7566         snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7567                   tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7568                   tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7569         printf (_("Time Stamp: %s"), timebuf);
7570       }
7571       break;
7572
7573     case DT_MIPS_RLD_VERSION:
7574     case DT_MIPS_LOCAL_GOTNO:
7575     case DT_MIPS_CONFLICTNO:
7576     case DT_MIPS_LIBLISTNO:
7577     case DT_MIPS_SYMTABNO:
7578     case DT_MIPS_UNREFEXTNO:
7579     case DT_MIPS_HIPAGENO:
7580     case DT_MIPS_DELTA_CLASS_NO:
7581     case DT_MIPS_DELTA_INSTANCE_NO:
7582     case DT_MIPS_DELTA_RELOC_NO:
7583     case DT_MIPS_DELTA_SYM_NO:
7584     case DT_MIPS_DELTA_CLASSSYM_NO:
7585     case DT_MIPS_COMPACT_SIZE:
7586       print_vma (entry->d_un.d_ptr, DEC);
7587       break;
7588
7589     default:
7590       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7591     }
7592     putchar ('\n');
7593 }
7594
7595 static void
7596 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
7597 {
7598   switch (entry->d_tag)
7599     {
7600     case DT_HP_DLD_FLAGS:
7601       {
7602         static struct
7603         {
7604           long int bit;
7605           const char * str;
7606         }
7607         flags[] =
7608         {
7609           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7610           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7611           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7612           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7613           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7614           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7615           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7616           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7617           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7618           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
7619           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7620           { DT_HP_GST, "HP_GST" },
7621           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7622           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7623           { DT_HP_NODELETE, "HP_NODELETE" },
7624           { DT_HP_GROUP, "HP_GROUP" },
7625           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
7626         };
7627         int first = 1;
7628         size_t cnt;
7629         bfd_vma val = entry->d_un.d_val;
7630
7631         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
7632           if (val & flags[cnt].bit)
7633             {
7634               if (! first)
7635                 putchar (' ');
7636               fputs (flags[cnt].str, stdout);
7637               first = 0;
7638               val ^= flags[cnt].bit;
7639             }
7640
7641         if (val != 0 || first)
7642           {
7643             if (! first)
7644               putchar (' ');
7645             print_vma (val, HEX);
7646           }
7647       }
7648       break;
7649
7650     default:
7651       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7652       break;
7653     }
7654   putchar ('\n');
7655 }
7656
7657 #ifdef BFD64
7658
7659 /* VMS vs Unix time offset and factor.  */
7660
7661 #define VMS_EPOCH_OFFSET 35067168000000000LL
7662 #define VMS_GRANULARITY_FACTOR 10000000
7663
7664 /* Display a VMS time in a human readable format.  */
7665
7666 static void
7667 print_vms_time (bfd_int64_t vmstime)
7668 {
7669   struct tm *tm;
7670   time_t unxtime;
7671
7672   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7673   tm = gmtime (&unxtime);
7674   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7675           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7676           tm->tm_hour, tm->tm_min, tm->tm_sec);
7677 }
7678 #endif /* BFD64 */
7679
7680 static void
7681 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
7682 {
7683   switch (entry->d_tag)
7684     {
7685     case DT_IA_64_PLT_RESERVE:
7686       /* First 3 slots reserved.  */
7687       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7688       printf (" -- ");
7689       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
7690       break;
7691
7692     case DT_IA_64_VMS_LINKTIME:
7693 #ifdef BFD64
7694       print_vms_time (entry->d_un.d_val);
7695 #endif
7696       break;
7697
7698     case DT_IA_64_VMS_LNKFLAGS:
7699       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7700       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7701         printf (" CALL_DEBUG");
7702       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7703         printf (" NOP0BUFS");
7704       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7705         printf (" P0IMAGE");
7706       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7707         printf (" MKTHREADS");
7708       if (entry->d_un.d_val & VMS_LF_UPCALLS)
7709         printf (" UPCALLS");
7710       if (entry->d_un.d_val & VMS_LF_IMGSTA)
7711         printf (" IMGSTA");
7712       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7713         printf (" INITIALIZE");
7714       if (entry->d_un.d_val & VMS_LF_MAIN)
7715         printf (" MAIN");
7716       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7717         printf (" EXE_INIT");
7718       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7719         printf (" TBK_IN_IMG");
7720       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7721         printf (" DBG_IN_IMG");
7722       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7723         printf (" TBK_IN_DSF");
7724       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7725         printf (" DBG_IN_DSF");
7726       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7727         printf (" SIGNATURES");
7728       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7729         printf (" REL_SEG_OFF");
7730       break;
7731
7732     default:
7733       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7734       break;
7735     }
7736   putchar ('\n');
7737 }
7738
7739 static int
7740 get_32bit_dynamic_section (FILE * file)
7741 {
7742   Elf32_External_Dyn * edyn;
7743   Elf32_External_Dyn * ext;
7744   Elf_Internal_Dyn * entry;
7745
7746   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7747                                           dynamic_size, _("dynamic section"));
7748   if (!edyn)
7749     return 0;
7750
7751 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7752    might not have the luxury of section headers.  Look for the DT_NULL
7753    terminator to determine the number of entries.  */
7754   for (ext = edyn, dynamic_nent = 0;
7755        (char *) ext < (char *) edyn + dynamic_size;
7756        ext++)
7757     {
7758       dynamic_nent++;
7759       if (BYTE_GET (ext->d_tag) == DT_NULL)
7760         break;
7761     }
7762
7763   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7764                                                   sizeof (* entry));
7765   if (dynamic_section == NULL)
7766     {
7767       error (_("Out of memory\n"));
7768       free (edyn);
7769       return 0;
7770     }
7771
7772   for (ext = edyn, entry = dynamic_section;
7773        entry < dynamic_section + dynamic_nent;
7774        ext++, entry++)
7775     {
7776       entry->d_tag      = BYTE_GET (ext->d_tag);
7777       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7778     }
7779
7780   free (edyn);
7781
7782   return 1;
7783 }
7784
7785 static int
7786 get_64bit_dynamic_section (FILE * file)
7787 {
7788   Elf64_External_Dyn * edyn;
7789   Elf64_External_Dyn * ext;
7790   Elf_Internal_Dyn * entry;
7791
7792   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7793                                           dynamic_size, _("dynamic section"));
7794   if (!edyn)
7795     return 0;
7796
7797 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7798    might not have the luxury of section headers.  Look for the DT_NULL
7799    terminator to determine the number of entries.  */
7800   for (ext = edyn, dynamic_nent = 0;
7801        (char *) ext < (char *) edyn + dynamic_size;
7802        ext++)
7803     {
7804       dynamic_nent++;
7805       if (BYTE_GET (ext->d_tag) == DT_NULL)
7806         break;
7807     }
7808
7809   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7810                                                   sizeof (* entry));
7811   if (dynamic_section == NULL)
7812     {
7813       error (_("Out of memory\n"));
7814       free (edyn);
7815       return 0;
7816     }
7817
7818   for (ext = edyn, entry = dynamic_section;
7819        entry < dynamic_section + dynamic_nent;
7820        ext++, entry++)
7821     {
7822       entry->d_tag      = BYTE_GET (ext->d_tag);
7823       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7824     }
7825
7826   free (edyn);
7827
7828   return 1;
7829 }
7830
7831 static void
7832 print_dynamic_flags (bfd_vma flags)
7833 {
7834   int first = 1;
7835
7836   while (flags)
7837     {
7838       bfd_vma flag;
7839
7840       flag = flags & - flags;
7841       flags &= ~ flag;
7842
7843       if (first)
7844         first = 0;
7845       else
7846         putc (' ', stdout);
7847
7848       switch (flag)
7849         {
7850         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
7851         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
7852         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
7853         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
7854         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
7855         default:                fputs (_("unknown"), stdout); break;
7856         }
7857     }
7858   puts ("");
7859 }
7860
7861 /* Parse and display the contents of the dynamic section.  */
7862
7863 static int
7864 process_dynamic_section (FILE * file)
7865 {
7866   Elf_Internal_Dyn * entry;
7867
7868   if (dynamic_size == 0)
7869     {
7870       if (do_dynamic)
7871         printf (_("\nThere is no dynamic section in this file.\n"));
7872
7873       return 1;
7874     }
7875
7876   if (is_32bit_elf)
7877     {
7878       if (! get_32bit_dynamic_section (file))
7879         return 0;
7880     }
7881   else if (! get_64bit_dynamic_section (file))
7882     return 0;
7883
7884   /* Find the appropriate symbol table.  */
7885   if (dynamic_symbols == NULL)
7886     {
7887       for (entry = dynamic_section;
7888            entry < dynamic_section + dynamic_nent;
7889            ++entry)
7890         {
7891           Elf_Internal_Shdr section;
7892
7893           if (entry->d_tag != DT_SYMTAB)
7894             continue;
7895
7896           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7897
7898           /* Since we do not know how big the symbol table is,
7899              we default to reading in the entire file (!) and
7900              processing that.  This is overkill, I know, but it
7901              should work.  */
7902           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
7903
7904           if (archive_file_offset != 0)
7905             section.sh_size = archive_file_size - section.sh_offset;
7906           else
7907             {
7908               if (fseek (file, 0, SEEK_END))
7909                 error (_("Unable to seek to end of file!\n"));
7910
7911               section.sh_size = ftell (file) - section.sh_offset;
7912             }
7913
7914           if (is_32bit_elf)
7915             section.sh_entsize = sizeof (Elf32_External_Sym);
7916           else
7917             section.sh_entsize = sizeof (Elf64_External_Sym);
7918
7919           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
7920           if (num_dynamic_syms < 1)
7921             {
7922               error (_("Unable to determine the number of symbols to load\n"));
7923               continue;
7924             }
7925         }
7926     }
7927
7928   /* Similarly find a string table.  */
7929   if (dynamic_strings == NULL)
7930     {
7931       for (entry = dynamic_section;
7932            entry < dynamic_section + dynamic_nent;
7933            ++entry)
7934         {
7935           unsigned long offset;
7936           long str_tab_len;
7937
7938           if (entry->d_tag != DT_STRTAB)
7939             continue;
7940
7941           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7942
7943           /* Since we do not know how big the string table is,
7944              we default to reading in the entire file (!) and
7945              processing that.  This is overkill, I know, but it
7946              should work.  */
7947
7948           offset = offset_from_vma (file, entry->d_un.d_val, 0);
7949
7950           if (archive_file_offset != 0)
7951             str_tab_len = archive_file_size - offset;
7952           else
7953             {
7954               if (fseek (file, 0, SEEK_END))
7955                 error (_("Unable to seek to end of file\n"));
7956               str_tab_len = ftell (file) - offset;
7957             }
7958
7959           if (str_tab_len < 1)
7960             {
7961               error
7962                 (_("Unable to determine the length of the dynamic string table\n"));
7963               continue;
7964             }
7965
7966           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7967                                                str_tab_len,
7968                                                _("dynamic string table"));
7969           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
7970           break;
7971         }
7972     }
7973
7974   /* And find the syminfo section if available.  */
7975   if (dynamic_syminfo == NULL)
7976     {
7977       unsigned long syminsz = 0;
7978
7979       for (entry = dynamic_section;
7980            entry < dynamic_section + dynamic_nent;
7981            ++entry)
7982         {
7983           if (entry->d_tag == DT_SYMINENT)
7984             {
7985               /* Note: these braces are necessary to avoid a syntax
7986                  error from the SunOS4 C compiler.  */
7987               assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7988             }
7989           else if (entry->d_tag == DT_SYMINSZ)
7990             syminsz = entry->d_un.d_val;
7991           else if (entry->d_tag == DT_SYMINFO)
7992             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7993                                                       syminsz);
7994         }
7995
7996       if (dynamic_syminfo_offset != 0 && syminsz != 0)
7997         {
7998           Elf_External_Syminfo * extsyminfo;
7999           Elf_External_Syminfo * extsym;
8000           Elf_Internal_Syminfo * syminfo;
8001
8002           /* There is a syminfo section.  Read the data.  */
8003           extsyminfo = (Elf_External_Syminfo *)
8004               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8005                         _("symbol information"));
8006           if (!extsyminfo)
8007             return 0;
8008
8009           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
8010           if (dynamic_syminfo == NULL)
8011             {
8012               error (_("Out of memory\n"));
8013               return 0;
8014             }
8015
8016           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
8017           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8018                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8019                ++syminfo, ++extsym)
8020             {
8021               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8022               syminfo->si_flags = BYTE_GET (extsym->si_flags);
8023             }
8024
8025           free (extsyminfo);
8026         }
8027     }
8028
8029   if (do_dynamic && dynamic_addr)
8030     printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
8031             dynamic_addr, dynamic_nent);
8032   if (do_dynamic)
8033     printf (_("  Tag        Type                         Name/Value\n"));
8034
8035   for (entry = dynamic_section;
8036        entry < dynamic_section + dynamic_nent;
8037        entry++)
8038     {
8039       if (do_dynamic)
8040         {
8041           const char * dtype;
8042
8043           putchar (' ');
8044           print_vma (entry->d_tag, FULL_HEX);
8045           dtype = get_dynamic_type (entry->d_tag);
8046           printf (" (%s)%*s", dtype,
8047                   ((is_32bit_elf ? 27 : 19)
8048                    - (int) strlen (dtype)),
8049                   " ");
8050         }
8051
8052       switch (entry->d_tag)
8053         {
8054         case DT_FLAGS:
8055           if (do_dynamic)
8056             print_dynamic_flags (entry->d_un.d_val);
8057           break;
8058
8059         case DT_AUXILIARY:
8060         case DT_FILTER:
8061         case DT_CONFIG:
8062         case DT_DEPAUDIT:
8063         case DT_AUDIT:
8064           if (do_dynamic)
8065             {
8066               switch (entry->d_tag)
8067                 {
8068                 case DT_AUXILIARY:
8069                   printf (_("Auxiliary library"));
8070                   break;
8071
8072                 case DT_FILTER:
8073                   printf (_("Filter library"));
8074                   break;
8075
8076                 case DT_CONFIG:
8077                   printf (_("Configuration file"));
8078                   break;
8079
8080                 case DT_DEPAUDIT:
8081                   printf (_("Dependency audit library"));
8082                   break;
8083
8084                 case DT_AUDIT:
8085                   printf (_("Audit library"));
8086                   break;
8087                 }
8088
8089               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8090                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
8091               else
8092                 {
8093                   printf (": ");
8094                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8095                   putchar ('\n');
8096                 }
8097             }
8098           break;
8099
8100         case DT_FEATURE:
8101           if (do_dynamic)
8102             {
8103               printf (_("Flags:"));
8104
8105               if (entry->d_un.d_val == 0)
8106                 printf (_(" None\n"));
8107               else
8108                 {
8109                   unsigned long int val = entry->d_un.d_val;
8110
8111                   if (val & DTF_1_PARINIT)
8112                     {
8113                       printf (" PARINIT");
8114                       val ^= DTF_1_PARINIT;
8115                     }
8116                   if (val & DTF_1_CONFEXP)
8117                     {
8118                       printf (" CONFEXP");
8119                       val ^= DTF_1_CONFEXP;
8120                     }
8121                   if (val != 0)
8122                     printf (" %lx", val);
8123                   puts ("");
8124                 }
8125             }
8126           break;
8127
8128         case DT_POSFLAG_1:
8129           if (do_dynamic)
8130             {
8131               printf (_("Flags:"));
8132
8133               if (entry->d_un.d_val == 0)
8134                 printf (_(" None\n"));
8135               else
8136                 {
8137                   unsigned long int val = entry->d_un.d_val;
8138
8139                   if (val & DF_P1_LAZYLOAD)
8140                     {
8141                       printf (" LAZYLOAD");
8142                       val ^= DF_P1_LAZYLOAD;
8143                     }
8144                   if (val & DF_P1_GROUPPERM)
8145                     {
8146                       printf (" GROUPPERM");
8147                       val ^= DF_P1_GROUPPERM;
8148                     }
8149                   if (val != 0)
8150                     printf (" %lx", val);
8151                   puts ("");
8152                 }
8153             }
8154           break;
8155
8156         case DT_FLAGS_1:
8157           if (do_dynamic)
8158             {
8159               printf (_("Flags:"));
8160               if (entry->d_un.d_val == 0)
8161                 printf (_(" None\n"));
8162               else
8163                 {
8164                   unsigned long int val = entry->d_un.d_val;
8165
8166                   if (val & DF_1_NOW)
8167                     {
8168                       printf (" NOW");
8169                       val ^= DF_1_NOW;
8170                     }
8171                   if (val & DF_1_GLOBAL)
8172                     {
8173                       printf (" GLOBAL");
8174                       val ^= DF_1_GLOBAL;
8175                     }
8176                   if (val & DF_1_GROUP)
8177                     {
8178                       printf (" GROUP");
8179                       val ^= DF_1_GROUP;
8180                     }
8181                   if (val & DF_1_NODELETE)
8182                     {
8183                       printf (" NODELETE");
8184                       val ^= DF_1_NODELETE;
8185                     }
8186                   if (val & DF_1_LOADFLTR)
8187                     {
8188                       printf (" LOADFLTR");
8189                       val ^= DF_1_LOADFLTR;
8190                     }
8191                   if (val & DF_1_INITFIRST)
8192                     {
8193                       printf (" INITFIRST");
8194                       val ^= DF_1_INITFIRST;
8195                     }
8196                   if (val & DF_1_NOOPEN)
8197                     {
8198                       printf (" NOOPEN");
8199                       val ^= DF_1_NOOPEN;
8200                     }
8201                   if (val & DF_1_ORIGIN)
8202                     {
8203                       printf (" ORIGIN");
8204                       val ^= DF_1_ORIGIN;
8205                     }
8206                   if (val & DF_1_DIRECT)
8207                     {
8208                       printf (" DIRECT");
8209                       val ^= DF_1_DIRECT;
8210                     }
8211                   if (val & DF_1_TRANS)
8212                     {
8213                       printf (" TRANS");
8214                       val ^= DF_1_TRANS;
8215                     }
8216                   if (val & DF_1_INTERPOSE)
8217                     {
8218                       printf (" INTERPOSE");
8219                       val ^= DF_1_INTERPOSE;
8220                     }
8221                   if (val & DF_1_NODEFLIB)
8222                     {
8223                       printf (" NODEFLIB");
8224                       val ^= DF_1_NODEFLIB;
8225                     }
8226                   if (val & DF_1_NODUMP)
8227                     {
8228                       printf (" NODUMP");
8229                       val ^= DF_1_NODUMP;
8230                     }
8231                   if (val & DF_1_CONFALT)
8232                     {
8233                       printf (" CONFALT");
8234                       val ^= DF_1_CONFALT;
8235                     }
8236                   if (val & DF_1_ENDFILTEE)
8237                     {
8238                       printf (" ENDFILTEE");
8239                       val ^= DF_1_ENDFILTEE;
8240                     }
8241                   if (val & DF_1_DISPRELDNE)
8242                     {
8243                       printf (" DISPRELDNE");
8244                       val ^= DF_1_DISPRELDNE;
8245                     }
8246                   if (val & DF_1_DISPRELPND)
8247                     {
8248                       printf (" DISPRELPND");
8249                       val ^= DF_1_DISPRELPND;
8250                     }
8251                   if (val & DF_1_NODIRECT)
8252                     {
8253                       printf (" NODIRECT");
8254                       val ^= DF_1_NODIRECT;
8255                     }
8256                   if (val & DF_1_IGNMULDEF)
8257                     {
8258                       printf (" IGNMULDEF");
8259                       val ^= DF_1_IGNMULDEF;
8260                     }
8261                   if (val & DF_1_NOKSYMS)
8262                     {
8263                       printf (" NOKSYMS");
8264                       val ^= DF_1_NOKSYMS;
8265                     }
8266                   if (val & DF_1_NOHDR)
8267                     {
8268                       printf (" NOHDR");
8269                       val ^= DF_1_NOHDR;
8270                     }
8271                   if (val & DF_1_EDITED)
8272                     {
8273                       printf (" EDITED");
8274                       val ^= DF_1_EDITED;
8275                     }
8276                   if (val & DF_1_NORELOC)
8277                     {
8278                       printf (" NORELOC");
8279                       val ^= DF_1_NORELOC;
8280                     }
8281                   if (val & DF_1_SYMINTPOSE)
8282                     {
8283                       printf (" SYMINTPOSE");
8284                       val ^= DF_1_SYMINTPOSE;
8285                     }
8286                   if (val & DF_1_GLOBAUDIT)
8287                     {
8288                       printf (" GLOBAUDIT");
8289                       val ^= DF_1_GLOBAUDIT;
8290                     }
8291                   if (val & DF_1_SINGLETON)
8292                     {
8293                       printf (" SINGLETON");
8294                       val ^= DF_1_SINGLETON;
8295                     }
8296                   if (val != 0)
8297                     printf (" %lx", val);
8298                   puts ("");
8299                 }
8300             }
8301           break;
8302
8303         case DT_PLTREL:
8304           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8305           if (do_dynamic)
8306             puts (get_dynamic_type (entry->d_un.d_val));
8307           break;
8308
8309         case DT_NULL    :
8310         case DT_NEEDED  :
8311         case DT_PLTGOT  :
8312         case DT_HASH    :
8313         case DT_STRTAB  :
8314         case DT_SYMTAB  :
8315         case DT_RELA    :
8316         case DT_INIT    :
8317         case DT_FINI    :
8318         case DT_SONAME  :
8319         case DT_RPATH   :
8320         case DT_SYMBOLIC:
8321         case DT_REL     :
8322         case DT_DEBUG   :
8323         case DT_TEXTREL :
8324         case DT_JMPREL  :
8325         case DT_RUNPATH :
8326           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8327
8328           if (do_dynamic)
8329             {
8330               char * name;
8331
8332               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8333                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8334               else
8335                 name = NULL;
8336
8337               if (name)
8338                 {
8339                   switch (entry->d_tag)
8340                     {
8341                     case DT_NEEDED:
8342                       printf (_("Shared library: [%s]"), name);
8343
8344                       if (streq (name, program_interpreter))
8345                         printf (_(" program interpreter"));
8346                       break;
8347
8348                     case DT_SONAME:
8349                       printf (_("Library soname: [%s]"), name);
8350                       break;
8351
8352                     case DT_RPATH:
8353                       printf (_("Library rpath: [%s]"), name);
8354                       break;
8355
8356                     case DT_RUNPATH:
8357                       printf (_("Library runpath: [%s]"), name);
8358                       break;
8359
8360                     default:
8361                       print_vma (entry->d_un.d_val, PREFIX_HEX);
8362                       break;
8363                     }
8364                 }
8365               else
8366                 print_vma (entry->d_un.d_val, PREFIX_HEX);
8367
8368               putchar ('\n');
8369             }
8370           break;
8371
8372         case DT_PLTRELSZ:
8373         case DT_RELASZ  :
8374         case DT_STRSZ   :
8375         case DT_RELSZ   :
8376         case DT_RELAENT :
8377         case DT_SYMENT  :
8378         case DT_RELENT  :
8379           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8380         case DT_PLTPADSZ:
8381         case DT_MOVEENT :
8382         case DT_MOVESZ  :
8383         case DT_INIT_ARRAYSZ:
8384         case DT_FINI_ARRAYSZ:
8385         case DT_GNU_CONFLICTSZ:
8386         case DT_GNU_LIBLISTSZ:
8387           if (do_dynamic)
8388             {
8389               print_vma (entry->d_un.d_val, UNSIGNED);
8390               printf (_(" (bytes)\n"));
8391             }
8392           break;
8393
8394         case DT_VERDEFNUM:
8395         case DT_VERNEEDNUM:
8396         case DT_RELACOUNT:
8397         case DT_RELCOUNT:
8398           if (do_dynamic)
8399             {
8400               print_vma (entry->d_un.d_val, UNSIGNED);
8401               putchar ('\n');
8402             }
8403           break;
8404
8405         case DT_SYMINSZ:
8406         case DT_SYMINENT:
8407         case DT_SYMINFO:
8408         case DT_USED:
8409         case DT_INIT_ARRAY:
8410         case DT_FINI_ARRAY:
8411           if (do_dynamic)
8412             {
8413               if (entry->d_tag == DT_USED
8414                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
8415                 {
8416                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8417
8418                   if (*name)
8419                     {
8420                       printf (_("Not needed object: [%s]\n"), name);
8421                       break;
8422                     }
8423                 }
8424
8425               print_vma (entry->d_un.d_val, PREFIX_HEX);
8426               putchar ('\n');
8427             }
8428           break;
8429
8430         case DT_BIND_NOW:
8431           /* The value of this entry is ignored.  */
8432           if (do_dynamic)
8433             putchar ('\n');
8434           break;
8435
8436         case DT_GNU_PRELINKED:
8437           if (do_dynamic)
8438             {
8439               struct tm * tmp;
8440               time_t atime = entry->d_un.d_val;
8441
8442               tmp = gmtime (&atime);
8443               printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8444                       tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8445                       tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8446
8447             }
8448           break;
8449
8450         case DT_GNU_HASH:
8451           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8452           if (do_dynamic)
8453             {
8454               print_vma (entry->d_un.d_val, PREFIX_HEX);
8455               putchar ('\n');
8456             }
8457           break;
8458
8459         default:
8460           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
8461             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
8462               entry->d_un.d_val;
8463
8464           if (do_dynamic)
8465             {
8466               switch (elf_header.e_machine)
8467                 {
8468                 case EM_MIPS:
8469                 case EM_MIPS_RS3_LE:
8470                   dynamic_section_mips_val (entry);
8471                   break;
8472                 case EM_PARISC:
8473                   dynamic_section_parisc_val (entry);
8474                   break;
8475                 case EM_IA_64:
8476                   dynamic_section_ia64_val (entry);
8477                   break;
8478                 default:
8479                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8480                   putchar ('\n');
8481                 }
8482             }
8483           break;
8484         }
8485     }
8486
8487   return 1;
8488 }
8489
8490 static char *
8491 get_ver_flags (unsigned int flags)
8492 {
8493   static char buff[32];
8494
8495   buff[0] = 0;
8496
8497   if (flags == 0)
8498     return _("none");
8499
8500   if (flags & VER_FLG_BASE)
8501     strcat (buff, "BASE ");
8502
8503   if (flags & VER_FLG_WEAK)
8504     {
8505       if (flags & VER_FLG_BASE)
8506         strcat (buff, "| ");
8507
8508       strcat (buff, "WEAK ");
8509     }
8510
8511   if (flags & VER_FLG_INFO)
8512     {
8513       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8514         strcat (buff, "| ");
8515
8516       strcat (buff, "INFO ");
8517     }
8518
8519   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
8520     strcat (buff, _("| <unknown>"));
8521
8522   return buff;
8523 }
8524
8525 /* Display the contents of the version sections.  */
8526
8527 static int
8528 process_version_sections (FILE * file)
8529 {
8530   Elf_Internal_Shdr * section;
8531   unsigned i;
8532   int found = 0;
8533
8534   if (! do_version)
8535     return 1;
8536
8537   for (i = 0, section = section_headers;
8538        i < elf_header.e_shnum;
8539        i++, section++)
8540     {
8541       switch (section->sh_type)
8542         {
8543         case SHT_GNU_verdef:
8544           {
8545             Elf_External_Verdef * edefs;
8546             unsigned int idx;
8547             unsigned int cnt;
8548             char * endbuf;
8549
8550             found = 1;
8551
8552             printf
8553               (_("\nVersion definition section '%s' contains %u entries:\n"),
8554                SECTION_NAME (section), section->sh_info);
8555
8556             printf (_("  Addr: 0x"));
8557             printf_vma (section->sh_addr);
8558             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8559                     (unsigned long) section->sh_offset, section->sh_link,
8560                     section->sh_link < elf_header.e_shnum
8561                     ? SECTION_NAME (section_headers + section->sh_link)
8562                     : _("<corrupt>"));
8563
8564             edefs = (Elf_External_Verdef *)
8565                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8566                           _("version definition section"));
8567             if (!edefs)
8568               break;
8569             endbuf = (char *) edefs + section->sh_size;
8570
8571             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8572               {
8573                 char * vstart;
8574                 Elf_External_Verdef * edef;
8575                 Elf_Internal_Verdef ent;
8576                 Elf_External_Verdaux * eaux;
8577                 Elf_Internal_Verdaux aux;
8578                 int j;
8579                 int isum;
8580
8581                 /* Check for very large indicies.  */
8582                 if (idx > (size_t) (endbuf - (char *) edefs))
8583                   break;
8584
8585                 vstart = ((char *) edefs) + idx;
8586                 if (vstart + sizeof (*edef) > endbuf)
8587                   break;
8588
8589                 edef = (Elf_External_Verdef *) vstart;
8590
8591                 ent.vd_version = BYTE_GET (edef->vd_version);
8592                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
8593                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
8594                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
8595                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
8596                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
8597                 ent.vd_next    = BYTE_GET (edef->vd_next);
8598
8599                 printf (_("  %#06x: Rev: %d  Flags: %s"),
8600                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8601
8602                 printf (_("  Index: %d  Cnt: %d  "),
8603                         ent.vd_ndx, ent.vd_cnt);
8604
8605                 /* Check for overflow.  */
8606                 if (ent.vd_aux > (size_t) (endbuf - vstart))
8607                   break;
8608
8609                 vstart += ent.vd_aux;
8610
8611                 eaux = (Elf_External_Verdaux *) vstart;
8612
8613                 aux.vda_name = BYTE_GET (eaux->vda_name);
8614                 aux.vda_next = BYTE_GET (eaux->vda_next);
8615
8616                 if (VALID_DYNAMIC_NAME (aux.vda_name))
8617                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
8618                 else
8619                   printf (_("Name index: %ld\n"), aux.vda_name);
8620
8621                 isum = idx + ent.vd_aux;
8622
8623                 for (j = 1; j < ent.vd_cnt; j++)
8624                   {
8625                     /* Check for overflow.  */
8626                     if (aux.vda_next > (size_t) (endbuf - vstart))
8627                       break;
8628
8629                     isum   += aux.vda_next;
8630                     vstart += aux.vda_next;
8631
8632                     eaux = (Elf_External_Verdaux *) vstart;
8633                     if (vstart + sizeof (*eaux) > endbuf)
8634                       break;
8635
8636                     aux.vda_name = BYTE_GET (eaux->vda_name);
8637                     aux.vda_next = BYTE_GET (eaux->vda_next);
8638
8639                     if (VALID_DYNAMIC_NAME (aux.vda_name))
8640                       printf (_("  %#06x: Parent %d: %s\n"),
8641                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
8642                     else
8643                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
8644                               isum, j, aux.vda_name);
8645                   }
8646
8647                 if (j < ent.vd_cnt)
8648                   printf (_("  Version def aux past end of section\n"));
8649
8650                 idx += ent.vd_next;
8651               }
8652
8653             if (cnt < section->sh_info)
8654               printf (_("  Version definition past end of section\n"));
8655
8656             free (edefs);
8657           }
8658           break;
8659
8660         case SHT_GNU_verneed:
8661           {
8662             Elf_External_Verneed * eneed;
8663             unsigned int idx;
8664             unsigned int cnt;
8665             char * endbuf;
8666
8667             found = 1;
8668
8669             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8670                     SECTION_NAME (section), section->sh_info);
8671
8672             printf (_(" Addr: 0x"));
8673             printf_vma (section->sh_addr);
8674             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8675                     (unsigned long) section->sh_offset, section->sh_link,
8676                     section->sh_link < elf_header.e_shnum
8677                     ? SECTION_NAME (section_headers + section->sh_link)
8678                     : _("<corrupt>"));
8679
8680             eneed = (Elf_External_Verneed *) get_data (NULL, file,
8681                                                        section->sh_offset, 1,
8682                                                        section->sh_size,
8683                                                        _("Version Needs section"));
8684             if (!eneed)
8685               break;
8686             endbuf = (char *) eneed + section->sh_size;
8687
8688             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8689               {
8690                 Elf_External_Verneed * entry;
8691                 Elf_Internal_Verneed ent;
8692                 int j;
8693                 int isum;
8694                 char * vstart;
8695
8696                 if (idx > (size_t) (endbuf - (char *) eneed))
8697                   break;
8698
8699                 vstart = ((char *) eneed) + idx;
8700                 if (vstart + sizeof (*entry) > endbuf)
8701                   break;
8702
8703                 entry = (Elf_External_Verneed *) vstart;
8704
8705                 ent.vn_version = BYTE_GET (entry->vn_version);
8706                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
8707                 ent.vn_file    = BYTE_GET (entry->vn_file);
8708                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
8709                 ent.vn_next    = BYTE_GET (entry->vn_next);
8710
8711                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
8712
8713                 if (VALID_DYNAMIC_NAME (ent.vn_file))
8714                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
8715                 else
8716                   printf (_("  File: %lx"), ent.vn_file);
8717
8718                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
8719
8720                 /* Check for overflow.  */
8721                 if (ent.vn_aux > (size_t) (endbuf - vstart))
8722                   break;
8723
8724                 vstart += ent.vn_aux;
8725
8726                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8727                   {
8728                     Elf_External_Vernaux * eaux;
8729                     Elf_Internal_Vernaux aux;
8730
8731                     if (vstart + sizeof (*eaux) > endbuf)
8732                       break;
8733                     eaux = (Elf_External_Vernaux *) vstart;
8734
8735                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
8736                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
8737                     aux.vna_other = BYTE_GET (eaux->vna_other);
8738                     aux.vna_name  = BYTE_GET (eaux->vna_name);
8739                     aux.vna_next  = BYTE_GET (eaux->vna_next);
8740
8741                     if (VALID_DYNAMIC_NAME (aux.vna_name))
8742                       printf (_("  %#06x:   Name: %s"),
8743                               isum, GET_DYNAMIC_NAME (aux.vna_name));
8744                     else
8745                       printf (_("  %#06x:   Name index: %lx"),
8746                               isum, aux.vna_name);
8747
8748                     printf (_("  Flags: %s  Version: %d\n"),
8749                             get_ver_flags (aux.vna_flags), aux.vna_other);
8750
8751                     /* Check for overflow.  */
8752                     if (aux.vna_next > (size_t) (endbuf - vstart))
8753                       break;
8754
8755                     isum   += aux.vna_next;
8756                     vstart += aux.vna_next;
8757                   }
8758
8759                 if (j < ent.vn_cnt)
8760                   warn (_("Missing Version Needs auxillary information\n"));
8761
8762                 idx += ent.vn_next;
8763               }
8764
8765             if (cnt < section->sh_info)
8766               warn (_("Missing Version Needs information\n"));
8767
8768             free (eneed);
8769           }
8770           break;
8771
8772         case SHT_GNU_versym:
8773           {
8774             Elf_Internal_Shdr * link_section;
8775             int total;
8776             int cnt;
8777             unsigned char * edata;
8778             unsigned short * data;
8779             char * strtab;
8780             Elf_Internal_Sym * symbols;
8781             Elf_Internal_Shdr * string_sec;
8782             unsigned long num_syms;
8783             long off;
8784
8785             if (section->sh_link >= elf_header.e_shnum)
8786               break;
8787
8788             link_section = section_headers + section->sh_link;
8789             total = section->sh_size / sizeof (Elf_External_Versym);
8790
8791             if (link_section->sh_link >= elf_header.e_shnum)
8792               break;
8793
8794             found = 1;
8795
8796             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
8797             if (symbols == NULL)
8798               break;
8799
8800             string_sec = section_headers + link_section->sh_link;
8801
8802             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8803                                         string_sec->sh_size,
8804                                         _("version string table"));
8805             if (!strtab)
8806               {
8807                 free (symbols);
8808                 break;
8809               }
8810
8811             printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8812                     SECTION_NAME (section), total);
8813
8814             printf (_(" Addr: "));
8815             printf_vma (section->sh_addr);
8816             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8817                     (unsigned long) section->sh_offset, section->sh_link,
8818                     SECTION_NAME (link_section));
8819
8820             off = offset_from_vma (file,
8821                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8822                                    total * sizeof (short));
8823             edata = (unsigned char *) get_data (NULL, file, off, total,
8824                                                 sizeof (short),
8825                                                 _("version symbol data"));
8826             if (!edata)
8827               {
8828                 free (strtab);
8829                 free (symbols);
8830                 break;
8831               }
8832
8833             data = (short unsigned int *) cmalloc (total, sizeof (short));
8834
8835             for (cnt = total; cnt --;)
8836               data[cnt] = byte_get (edata + cnt * sizeof (short),
8837                                     sizeof (short));
8838
8839             free (edata);
8840
8841             for (cnt = 0; cnt < total; cnt += 4)
8842               {
8843                 int j, nn;
8844                 int check_def, check_need;
8845                 char * name;
8846
8847                 printf ("  %03x:", cnt);
8848
8849                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
8850                   switch (data[cnt + j])
8851                     {
8852                     case 0:
8853                       fputs (_("   0 (*local*)    "), stdout);
8854                       break;
8855
8856                     case 1:
8857                       fputs (_("   1 (*global*)   "), stdout);
8858                       break;
8859
8860                     default:
8861                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8862                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
8863
8864                       /* If this index value is greater than the size of the symbols
8865                          array, break to avoid an out-of-bounds read.  */
8866                       if ((unsigned long)(cnt + j) >= num_syms)
8867                         {
8868                           warn (_("invalid index into symbol array\n"));
8869                           break;
8870                         }
8871
8872                       check_def = 1;
8873                       check_need = 1;
8874                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8875                           || section_headers[symbols[cnt + j].st_shndx].sh_type
8876                              != SHT_NOBITS)
8877                         {
8878                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
8879                             check_def = 0;
8880                           else
8881                             check_need = 0;
8882                         }
8883
8884                       if (check_need
8885                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
8886                         {
8887                           Elf_Internal_Verneed ivn;
8888                           unsigned long offset;
8889
8890                           offset = offset_from_vma
8891                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8892                              sizeof (Elf_External_Verneed));
8893
8894                           do
8895                             {
8896                               Elf_Internal_Vernaux ivna;
8897                               Elf_External_Verneed evn;
8898                               Elf_External_Vernaux evna;
8899                               unsigned long a_off;
8900
8901                               if (get_data (&evn, file, offset, sizeof (evn), 1,
8902                                             _("version need")) == NULL)
8903                                 break;
8904
8905                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
8906                               ivn.vn_next = BYTE_GET (evn.vn_next);
8907
8908                               a_off = offset + ivn.vn_aux;
8909
8910                               do
8911                                 {
8912                                   if (get_data (&evna, file, a_off, sizeof (evna),
8913                                                 1, _("version need aux (2)")) == NULL)
8914                                     {
8915                                       ivna.vna_next  = 0;
8916                                       ivna.vna_other = 0;
8917                                     }
8918                                   else
8919                                     {
8920                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
8921                                       ivna.vna_other = BYTE_GET (evna.vna_other);
8922                                     }
8923
8924                                   a_off += ivna.vna_next;
8925                                 }
8926                               while (ivna.vna_other != data[cnt + j]
8927                                      && ivna.vna_next != 0);
8928
8929                               if (ivna.vna_other == data[cnt + j])
8930                                 {
8931                                   ivna.vna_name = BYTE_GET (evna.vna_name);
8932
8933                                   if (ivna.vna_name >= string_sec->sh_size)
8934                                     name = _("*invalid*");
8935                                   else
8936                                     name = strtab + ivna.vna_name;
8937                                   nn += printf ("(%s%-*s",
8938                                                 name,
8939                                                 12 - (int) strlen (name),
8940                                                 ")");
8941                                   check_def = 0;
8942                                   break;
8943                                 }
8944
8945                               offset += ivn.vn_next;
8946                             }
8947                           while (ivn.vn_next);
8948                         }
8949
8950                       if (check_def && data[cnt + j] != 0x8001
8951                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8952                         {
8953                           Elf_Internal_Verdef ivd;
8954                           Elf_External_Verdef evd;
8955                           unsigned long offset;
8956
8957                           offset = offset_from_vma
8958                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8959                              sizeof evd);
8960
8961                           do
8962                             {
8963                               if (get_data (&evd, file, offset, sizeof (evd), 1,
8964                                             _("version def")) == NULL)
8965                                 {
8966                                   ivd.vd_next = 0;
8967                                   ivd.vd_ndx  = 0;
8968                                 }
8969                               else
8970                                 {
8971                                   ivd.vd_next = BYTE_GET (evd.vd_next);
8972                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
8973                                 }
8974
8975                               offset += ivd.vd_next;
8976                             }
8977                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
8978                                  && ivd.vd_next != 0);
8979
8980                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
8981                             {
8982                               Elf_External_Verdaux evda;
8983                               Elf_Internal_Verdaux ivda;
8984
8985                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
8986
8987                               if (get_data (&evda, file,
8988                                             offset - ivd.vd_next + ivd.vd_aux,
8989                                             sizeof (evda), 1,
8990                                             _("version def aux")) == NULL)
8991                                 break;
8992
8993                               ivda.vda_name = BYTE_GET (evda.vda_name);
8994
8995                               if (ivda.vda_name >= string_sec->sh_size)
8996                                 name = _("*invalid*");
8997                               else
8998                                 name = strtab + ivda.vda_name;
8999                               nn += printf ("(%s%-*s",
9000                                             name,
9001                                             12 - (int) strlen (name),
9002                                             ")");
9003                             }
9004                         }
9005
9006                       if (nn < 18)
9007                         printf ("%*c", 18 - nn, ' ');
9008                     }
9009
9010                 putchar ('\n');
9011               }
9012
9013             free (data);
9014             free (strtab);
9015             free (symbols);
9016           }
9017           break;
9018
9019         default:
9020           break;
9021         }
9022     }
9023
9024   if (! found)
9025     printf (_("\nNo version information found in this file.\n"));
9026
9027   return 1;
9028 }
9029
9030 static const char *
9031 get_symbol_binding (unsigned int binding)
9032 {
9033   static char buff[32];
9034
9035   switch (binding)
9036     {
9037     case STB_LOCAL:     return "LOCAL";
9038     case STB_GLOBAL:    return "GLOBAL";
9039     case STB_WEAK:      return "WEAK";
9040     default:
9041       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
9042         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9043                   binding);
9044       else if (binding >= STB_LOOS && binding <= STB_HIOS)
9045         {
9046           if (binding == STB_GNU_UNIQUE
9047               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9048                   /* GNU is still using the default value 0.  */
9049                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9050             return "UNIQUE";
9051           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9052         }
9053       else
9054         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
9055       return buff;
9056     }
9057 }
9058
9059 static const char *
9060 get_symbol_type (unsigned int type)
9061 {
9062   static char buff[32];
9063
9064   switch (type)
9065     {
9066     case STT_NOTYPE:    return "NOTYPE";
9067     case STT_OBJECT:    return "OBJECT";
9068     case STT_FUNC:      return "FUNC";
9069     case STT_SECTION:   return "SECTION";
9070     case STT_FILE:      return "FILE";
9071     case STT_COMMON:    return "COMMON";
9072     case STT_TLS:       return "TLS";
9073     case STT_RELC:      return "RELC";
9074     case STT_SRELC:     return "SRELC";
9075     default:
9076       if (type >= STT_LOPROC && type <= STT_HIPROC)
9077         {
9078           if (elf_header.e_machine == EM_ARM)
9079             {
9080               if (type == STT_ARM_TFUNC)
9081                 return "THUMB_FUNC";
9082               if (type == STT_ARM_16BIT)
9083                 return "THUMB_LABEL";
9084             }
9085
9086           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
9087             return "REGISTER";
9088
9089           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9090             return "PARISC_MILLI";
9091
9092           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
9093         }
9094       else if (type >= STT_LOOS && type <= STT_HIOS)
9095         {
9096           if (elf_header.e_machine == EM_PARISC)
9097             {
9098               if (type == STT_HP_OPAQUE)
9099                 return "HP_OPAQUE";
9100               if (type == STT_HP_STUB)
9101                 return "HP_STUB";
9102             }
9103
9104           if (type == STT_GNU_IFUNC
9105               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9106                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9107                   /* GNU is still using the default value 0.  */
9108                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9109             return "IFUNC";
9110
9111           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
9112         }
9113       else
9114         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
9115       return buff;
9116     }
9117 }
9118
9119 static const char *
9120 get_symbol_visibility (unsigned int visibility)
9121 {
9122   switch (visibility)
9123     {
9124     case STV_DEFAULT:   return "DEFAULT";
9125     case STV_INTERNAL:  return "INTERNAL";
9126     case STV_HIDDEN:    return "HIDDEN";
9127     case STV_PROTECTED: return "PROTECTED";
9128     default: abort ();
9129     }
9130 }
9131
9132 static const char *
9133 get_mips_symbol_other (unsigned int other)
9134 {
9135   switch (other)
9136     {
9137     case STO_OPTIONAL:
9138       return "OPTIONAL";
9139     case STO_MIPS_PLT:
9140       return "MIPS PLT";
9141     case STO_MIPS_PIC:
9142       return "MIPS PIC";
9143     case STO_MICROMIPS:
9144       return "MICROMIPS";
9145     case STO_MICROMIPS | STO_MIPS_PIC:
9146       return "MICROMIPS, MIPS PIC";
9147     case STO_MIPS16:
9148       return "MIPS16";
9149     default:
9150       return NULL;
9151     }
9152 }
9153
9154 static const char *
9155 get_ia64_symbol_other (unsigned int other)
9156 {
9157   if (is_ia64_vms ())
9158     {
9159       static char res[32];
9160
9161       res[0] = 0;
9162
9163       /* Function types is for images and .STB files only.  */
9164       switch (elf_header.e_type)
9165         {
9166         case ET_DYN:
9167         case ET_EXEC:
9168           switch (VMS_ST_FUNC_TYPE (other))
9169             {
9170             case VMS_SFT_CODE_ADDR:
9171               strcat (res, " CA");
9172               break;
9173             case VMS_SFT_SYMV_IDX:
9174               strcat (res, " VEC");
9175               break;
9176             case VMS_SFT_FD:
9177               strcat (res, " FD");
9178               break;
9179             case VMS_SFT_RESERVE:
9180               strcat (res, " RSV");
9181               break;
9182             default:
9183               abort ();
9184             }
9185           break;
9186         default:
9187           break;
9188         }
9189       switch (VMS_ST_LINKAGE (other))
9190         {
9191         case VMS_STL_IGNORE:
9192           strcat (res, " IGN");
9193           break;
9194         case VMS_STL_RESERVE:
9195           strcat (res, " RSV");
9196           break;
9197         case VMS_STL_STD:
9198           strcat (res, " STD");
9199           break;
9200         case VMS_STL_LNK:
9201           strcat (res, " LNK");
9202           break;
9203         default:
9204           abort ();
9205         }
9206
9207       if (res[0] != 0)
9208         return res + 1;
9209       else
9210         return res;
9211     }
9212   return NULL;
9213 }
9214
9215 static const char *
9216 get_ppc64_symbol_other (unsigned int other)
9217 {
9218   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
9219     {
9220       static char buf[32];
9221       snprintf (buf, sizeof buf, _("<localentry>: %d"),
9222                 PPC64_LOCAL_ENTRY_OFFSET (other));
9223       return buf;
9224     }
9225   return NULL;
9226 }
9227
9228 static const char *
9229 get_symbol_other (unsigned int other)
9230 {
9231   const char * result = NULL;
9232   static char buff [32];
9233
9234   if (other == 0)
9235     return "";
9236
9237   switch (elf_header.e_machine)
9238     {
9239     case EM_MIPS:
9240       result = get_mips_symbol_other (other);
9241       break;
9242     case EM_IA_64:
9243       result = get_ia64_symbol_other (other);
9244       break;
9245     case EM_PPC64:
9246       result = get_ppc64_symbol_other (other);
9247       break;
9248     default:
9249       break;
9250     }
9251
9252   if (result)
9253     return result;
9254
9255   snprintf (buff, sizeof buff, _("<other>: %x"), other);
9256   return buff;
9257 }
9258
9259 static const char *
9260 get_symbol_index_type (unsigned int type)
9261 {
9262   static char buff[32];
9263
9264   switch (type)
9265     {
9266     case SHN_UNDEF:     return "UND";
9267     case SHN_ABS:       return "ABS";
9268     case SHN_COMMON:    return "COM";
9269     default:
9270       if (type == SHN_IA_64_ANSI_COMMON
9271           && elf_header.e_machine == EM_IA_64
9272           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9273         return "ANSI_COM";
9274       else if ((elf_header.e_machine == EM_X86_64
9275                 || elf_header.e_machine == EM_L1OM
9276                 || elf_header.e_machine == EM_K1OM)
9277                && type == SHN_X86_64_LCOMMON)
9278         return "LARGE_COM";
9279       else if ((type == SHN_MIPS_SCOMMON
9280                 && elf_header.e_machine == EM_MIPS)
9281                || (type == SHN_TIC6X_SCOMMON
9282                    && elf_header.e_machine == EM_TI_C6000))
9283         return "SCOM";
9284       else if (type == SHN_MIPS_SUNDEFINED
9285                && elf_header.e_machine == EM_MIPS)
9286         return "SUND";
9287       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
9288         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
9289       else if (type >= SHN_LOOS && type <= SHN_HIOS)
9290         sprintf (buff, "OS [0x%04x]", type & 0xffff);
9291       else if (type >= SHN_LORESERVE)
9292         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
9293       else if (type >= elf_header.e_shnum)
9294         sprintf (buff, "bad section index[%3d]", type);
9295       else
9296         sprintf (buff, "%3d", type);
9297       break;
9298     }
9299
9300   return buff;
9301 }
9302
9303 static bfd_vma *
9304 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
9305 {
9306   unsigned char * e_data;
9307   bfd_vma * i_data;
9308
9309   e_data = (unsigned char *) cmalloc (number, ent_size);
9310
9311   if (e_data == NULL)
9312     {
9313       error (_("Out of memory\n"));
9314       return NULL;
9315     }
9316
9317   if (fread (e_data, ent_size, number, file) != number)
9318     {
9319       error (_("Unable to read in dynamic data\n"));
9320       return NULL;
9321     }
9322
9323   i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
9324
9325   if (i_data == NULL)
9326     {
9327       error (_("Out of memory\n"));
9328       free (e_data);
9329       return NULL;
9330     }
9331
9332   while (number--)
9333     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
9334
9335   free (e_data);
9336
9337   return i_data;
9338 }
9339
9340 static void
9341 print_dynamic_symbol (bfd_vma si, unsigned long hn)
9342 {
9343   Elf_Internal_Sym * psym;
9344   int n;
9345
9346   psym = dynamic_symbols + si;
9347
9348   n = print_vma (si, DEC_5);
9349   if (n < 5)
9350     fputs (&"     "[n], stdout);
9351   printf (" %3lu: ", hn);
9352   print_vma (psym->st_value, LONG_HEX);
9353   putchar (' ');
9354   print_vma (psym->st_size, DEC_5);
9355
9356   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9357   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9358   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9359   /* Check to see if any other bits in the st_other field are set.
9360      Note - displaying this information disrupts the layout of the
9361      table being generated, but for the moment this case is very
9362      rare.  */
9363   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9364     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9365   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9366   if (VALID_DYNAMIC_NAME (psym->st_name))
9367     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9368   else
9369     printf (_(" <corrupt: %14ld>"), psym->st_name);
9370   putchar ('\n');
9371 }
9372
9373 /* Dump the symbol table.  */
9374 static int
9375 process_symbol_table (FILE * file)
9376 {
9377   Elf_Internal_Shdr * section;
9378   bfd_vma nbuckets = 0;
9379   bfd_vma nchains = 0;
9380   bfd_vma * buckets = NULL;
9381   bfd_vma * chains = NULL;
9382   bfd_vma ngnubuckets = 0;
9383   bfd_vma * gnubuckets = NULL;
9384   bfd_vma * gnuchains = NULL;
9385   bfd_vma gnusymidx = 0;
9386
9387   if (!do_syms && !do_dyn_syms && !do_histogram)
9388     return 1;
9389
9390   if (dynamic_info[DT_HASH]
9391       && (do_histogram
9392           || (do_using_dynamic
9393               && !do_dyn_syms
9394               && dynamic_strings != NULL)))
9395     {
9396       unsigned char nb[8];
9397       unsigned char nc[8];
9398       int hash_ent_size = 4;
9399
9400       if ((elf_header.e_machine == EM_ALPHA
9401            || elf_header.e_machine == EM_S390
9402            || elf_header.e_machine == EM_S390_OLD)
9403           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9404         hash_ent_size = 8;
9405
9406       if (fseek (file,
9407                  (archive_file_offset
9408                   + offset_from_vma (file, dynamic_info[DT_HASH],
9409                                      sizeof nb + sizeof nc)),
9410                  SEEK_SET))
9411         {
9412           error (_("Unable to seek to start of dynamic information\n"));
9413           goto no_hash;
9414         }
9415
9416       if (fread (nb, hash_ent_size, 1, file) != 1)
9417         {
9418           error (_("Failed to read in number of buckets\n"));
9419           goto no_hash;
9420         }
9421
9422       if (fread (nc, hash_ent_size, 1, file) != 1)
9423         {
9424           error (_("Failed to read in number of chains\n"));
9425           goto no_hash;
9426         }
9427
9428       nbuckets = byte_get (nb, hash_ent_size);
9429       nchains  = byte_get (nc, hash_ent_size);
9430
9431       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9432       chains  = get_dynamic_data (file, nchains, hash_ent_size);
9433
9434     no_hash:
9435       if (buckets == NULL || chains == NULL)
9436         {
9437           if (do_using_dynamic)
9438             return 0;
9439           free (buckets);
9440           free (chains);
9441           buckets = NULL;
9442           chains = NULL;
9443           nbuckets = 0;
9444           nchains = 0;
9445         }
9446     }
9447
9448   if (dynamic_info_DT_GNU_HASH
9449       && (do_histogram
9450           || (do_using_dynamic
9451               && !do_dyn_syms
9452               && dynamic_strings != NULL)))
9453     {
9454       unsigned char nb[16];
9455       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9456       bfd_vma buckets_vma;
9457
9458       if (fseek (file,
9459                  (archive_file_offset
9460                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9461                                      sizeof nb)),
9462                  SEEK_SET))
9463         {
9464           error (_("Unable to seek to start of dynamic information\n"));
9465           goto no_gnu_hash;
9466         }
9467
9468       if (fread (nb, 16, 1, file) != 1)
9469         {
9470           error (_("Failed to read in number of buckets\n"));
9471           goto no_gnu_hash;
9472         }
9473
9474       ngnubuckets = byte_get (nb, 4);
9475       gnusymidx = byte_get (nb + 4, 4);
9476       bitmaskwords = byte_get (nb + 8, 4);
9477       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
9478       if (is_32bit_elf)
9479         buckets_vma += bitmaskwords * 4;
9480       else
9481         buckets_vma += bitmaskwords * 8;
9482
9483       if (fseek (file,
9484                  (archive_file_offset
9485                   + offset_from_vma (file, buckets_vma, 4)),
9486                  SEEK_SET))
9487         {
9488           error (_("Unable to seek to start of dynamic information\n"));
9489           goto no_gnu_hash;
9490         }
9491
9492       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
9493
9494       if (gnubuckets == NULL)
9495         goto no_gnu_hash;
9496
9497       for (i = 0; i < ngnubuckets; i++)
9498         if (gnubuckets[i] != 0)
9499           {
9500             if (gnubuckets[i] < gnusymidx)
9501               return 0;
9502
9503             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9504               maxchain = gnubuckets[i];
9505           }
9506
9507       if (maxchain == 0xffffffff)
9508         goto no_gnu_hash;
9509
9510       maxchain -= gnusymidx;
9511
9512       if (fseek (file,
9513                  (archive_file_offset
9514                   + offset_from_vma (file, buckets_vma
9515                                            + 4 * (ngnubuckets + maxchain), 4)),
9516                  SEEK_SET))
9517         {
9518           error (_("Unable to seek to start of dynamic information\n"));
9519           goto no_gnu_hash;
9520         }
9521
9522       do
9523         {
9524           if (fread (nb, 4, 1, file) != 1)
9525             {
9526               error (_("Failed to determine last chain length\n"));
9527               goto no_gnu_hash;
9528             }
9529
9530           if (maxchain + 1 == 0)
9531             goto no_gnu_hash;
9532
9533           ++maxchain;
9534         }
9535       while ((byte_get (nb, 4) & 1) == 0);
9536
9537       if (fseek (file,
9538                  (archive_file_offset
9539                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9540                  SEEK_SET))
9541         {
9542           error (_("Unable to seek to start of dynamic information\n"));
9543           goto no_gnu_hash;
9544         }
9545
9546       gnuchains = get_dynamic_data (file, maxchain, 4);
9547
9548     no_gnu_hash:
9549       if (gnuchains == NULL)
9550         {
9551           free (gnubuckets);
9552           gnubuckets = NULL;
9553           ngnubuckets = 0;
9554           if (do_using_dynamic)
9555             return 0;
9556         }
9557     }
9558
9559   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9560       && do_syms
9561       && do_using_dynamic
9562       && dynamic_strings != NULL)
9563     {
9564       unsigned long hn;
9565
9566       if (dynamic_info[DT_HASH])
9567         {
9568           bfd_vma si;
9569
9570           printf (_("\nSymbol table for image:\n"));
9571           if (is_32bit_elf)
9572             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9573           else
9574             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9575
9576           for (hn = 0; hn < nbuckets; hn++)
9577             {
9578               if (! buckets[hn])
9579                 continue;
9580
9581               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9582                 print_dynamic_symbol (si, hn);
9583             }
9584         }
9585
9586       if (dynamic_info_DT_GNU_HASH)
9587         {
9588           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9589           if (is_32bit_elf)
9590             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9591           else
9592             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9593
9594           for (hn = 0; hn < ngnubuckets; ++hn)
9595             if (gnubuckets[hn] != 0)
9596               {
9597                 bfd_vma si = gnubuckets[hn];
9598                 bfd_vma off = si - gnusymidx;
9599
9600                 do
9601                   {
9602                     print_dynamic_symbol (si, hn);
9603                     si++;
9604                   }
9605                 while ((gnuchains[off++] & 1) == 0);
9606               }
9607         }
9608     }
9609   else if (do_dyn_syms || (do_syms && !do_using_dynamic))
9610     {
9611       unsigned int i;
9612
9613       for (i = 0, section = section_headers;
9614            i < elf_header.e_shnum;
9615            i++, section++)
9616         {
9617           unsigned int si;
9618           char * strtab = NULL;
9619           unsigned long int strtab_size = 0;
9620           Elf_Internal_Sym * symtab;
9621           Elf_Internal_Sym * psym;
9622           unsigned long num_syms;
9623
9624           if ((section->sh_type != SHT_SYMTAB
9625                && section->sh_type != SHT_DYNSYM)
9626               || (!do_syms
9627                   && section->sh_type == SHT_SYMTAB))
9628             continue;
9629
9630           if (section->sh_entsize == 0)
9631             {
9632               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9633                       SECTION_NAME (section));
9634               continue;
9635             }
9636
9637           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9638                   SECTION_NAME (section),
9639                   (unsigned long) (section->sh_size / section->sh_entsize));
9640
9641           if (is_32bit_elf)
9642             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
9643           else
9644             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
9645
9646           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
9647           if (symtab == NULL)
9648             continue;
9649
9650           if (section->sh_link == elf_header.e_shstrndx)
9651             {
9652               strtab = string_table;
9653               strtab_size = string_table_length;
9654             }
9655           else if (section->sh_link < elf_header.e_shnum)
9656             {
9657               Elf_Internal_Shdr * string_sec;
9658
9659               string_sec = section_headers + section->sh_link;
9660
9661               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9662                                           1, string_sec->sh_size,
9663                                           _("string table"));
9664               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
9665             }
9666
9667           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
9668             {
9669               printf ("%6d: ", si);
9670               print_vma (psym->st_value, LONG_HEX);
9671               putchar (' ');
9672               print_vma (psym->st_size, DEC_5);
9673               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9674               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9675               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9676               /* Check to see if any other bits in the st_other field are set.
9677                  Note - displaying this information disrupts the layout of the
9678                  table being generated, but for the moment this case is very rare.  */
9679               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9680                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9681               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
9682               print_symbol (25, psym->st_name < strtab_size
9683                             ? strtab + psym->st_name : _("<corrupt>"));
9684
9685               if (section->sh_type == SHT_DYNSYM
9686                   && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9687                 {
9688                   unsigned char data[2];
9689                   unsigned short vers_data;
9690                   unsigned long offset;
9691                   int is_nobits;
9692                   int check_def;
9693
9694                   offset = offset_from_vma
9695                     (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9696                      sizeof data + si * sizeof (vers_data));
9697
9698                   if (get_data (&data, file, offset + si * sizeof (vers_data),
9699                                 sizeof (data), 1, _("version data")) == NULL)
9700                     break;
9701
9702                   vers_data = byte_get (data, 2);
9703
9704                   is_nobits = (psym->st_shndx < elf_header.e_shnum
9705                                && section_headers[psym->st_shndx].sh_type
9706                                   == SHT_NOBITS);
9707
9708                   check_def = (psym->st_shndx != SHN_UNDEF);
9709
9710                   if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
9711                     {
9712                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
9713                           && (is_nobits || ! check_def))
9714                         {
9715                           Elf_External_Verneed evn;
9716                           Elf_Internal_Verneed ivn;
9717                           Elf_Internal_Vernaux ivna;
9718
9719                           /* We must test both.  */
9720                           offset = offset_from_vma
9721                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9722                              sizeof evn);
9723
9724                           do
9725                             {
9726                               unsigned long vna_off;
9727
9728                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9729                                             _("version need")) == NULL)
9730                                 {
9731                                   ivna.vna_next = 0;
9732                                   ivna.vna_other = 0;
9733                                   ivna.vna_name = 0;
9734                                   break;
9735                                 }
9736
9737                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9738                               ivn.vn_next = BYTE_GET (evn.vn_next);
9739
9740                               vna_off = offset + ivn.vn_aux;
9741
9742                               do
9743                                 {
9744                                   Elf_External_Vernaux evna;
9745
9746                                   if (get_data (&evna, file, vna_off,
9747                                                 sizeof (evna), 1,
9748                                                 _("version need aux (3)")) == NULL)
9749                                     {
9750                                       ivna.vna_next = 0;
9751                                       ivna.vna_other = 0;
9752                                       ivna.vna_name = 0;
9753                                     }
9754                                   else
9755                                     {
9756                                       ivna.vna_other = BYTE_GET (evna.vna_other);
9757                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
9758                                       ivna.vna_name  = BYTE_GET (evna.vna_name);
9759                                     }
9760
9761                                   vna_off += ivna.vna_next;
9762                                 }
9763                               while (ivna.vna_other != vers_data
9764                                      && ivna.vna_next != 0);
9765
9766                               if (ivna.vna_other == vers_data)
9767                                 break;
9768
9769                               offset += ivn.vn_next;
9770                             }
9771                           while (ivn.vn_next != 0);
9772
9773                           if (ivna.vna_other == vers_data)
9774                             {
9775                               printf ("@%s (%d)",
9776                                       ivna.vna_name < strtab_size
9777                                       ? strtab + ivna.vna_name : _("<corrupt>"),
9778                                       ivna.vna_other);
9779                               check_def = 0;
9780                             }
9781                           else if (! is_nobits)
9782                             error (_("bad dynamic symbol\n"));
9783                           else
9784                             check_def = 1;
9785                         }
9786
9787                       if (check_def)
9788                         {
9789                           if (vers_data != 0x8001
9790                               && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9791                             {
9792                               Elf_Internal_Verdef ivd;
9793                               Elf_Internal_Verdaux ivda;
9794                               Elf_External_Verdaux evda;
9795                               unsigned long off;
9796
9797                               off = offset_from_vma
9798                                 (file,
9799                                  version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9800                                  sizeof (Elf_External_Verdef));
9801
9802                               do
9803                                 {
9804                                   Elf_External_Verdef evd;
9805
9806                                   if (get_data (&evd, file, off, sizeof (evd),
9807                                                 1, _("version def")) == NULL)
9808                                     {
9809                                       ivd.vd_ndx = 0;
9810                                       ivd.vd_aux = 0;
9811                                       ivd.vd_next = 0;
9812                                     }
9813                                   else
9814                                     {
9815                                       ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9816                                       ivd.vd_aux = BYTE_GET (evd.vd_aux);
9817                                       ivd.vd_next = BYTE_GET (evd.vd_next);
9818                                     }
9819
9820                                   off += ivd.vd_next;
9821                                 }
9822                               while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
9823                                      && ivd.vd_next != 0);
9824
9825                               off -= ivd.vd_next;
9826                               off += ivd.vd_aux;
9827
9828                               if (get_data (&evda, file, off, sizeof (evda),
9829                                             1, _("version def aux")) == NULL)
9830                                 break;
9831
9832                               ivda.vda_name = BYTE_GET (evda.vda_name);
9833
9834                               if (psym->st_name != ivda.vda_name)
9835                                 printf ((vers_data & VERSYM_HIDDEN)
9836                                         ? "@%s" : "@@%s",
9837                                         ivda.vda_name < strtab_size
9838                                         ? strtab + ivda.vda_name : _("<corrupt>"));
9839                             }
9840                         }
9841                     }
9842                 }
9843
9844               putchar ('\n');
9845             }
9846
9847           free (symtab);
9848           if (strtab != string_table)
9849             free (strtab);
9850         }
9851     }
9852   else if (do_syms)
9853     printf
9854       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9855
9856   if (do_histogram && buckets != NULL)
9857     {
9858       unsigned long * lengths;
9859       unsigned long * counts;
9860       unsigned long hn;
9861       bfd_vma si;
9862       unsigned long maxlength = 0;
9863       unsigned long nzero_counts = 0;
9864       unsigned long nsyms = 0;
9865
9866       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9867               (unsigned long) nbuckets);
9868       printf (_(" Length  Number     %% of total  Coverage\n"));
9869
9870       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
9871       if (lengths == NULL)
9872         {
9873           error (_("Out of memory\n"));
9874           return 0;
9875         }
9876       for (hn = 0; hn < nbuckets; ++hn)
9877         {
9878           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
9879             {
9880               ++nsyms;
9881               if (maxlength < ++lengths[hn])
9882                 ++maxlength;
9883             }
9884         }
9885
9886       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9887       if (counts == NULL)
9888         {
9889           free (lengths);
9890           error (_("Out of memory\n"));
9891           return 0;
9892         }
9893
9894       for (hn = 0; hn < nbuckets; ++hn)
9895         ++counts[lengths[hn]];
9896
9897       if (nbuckets > 0)
9898         {
9899           unsigned long i;
9900           printf ("      0  %-10lu (%5.1f%%)\n",
9901                   counts[0], (counts[0] * 100.0) / nbuckets);
9902           for (i = 1; i <= maxlength; ++i)
9903             {
9904               nzero_counts += counts[i] * i;
9905               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
9906                       i, counts[i], (counts[i] * 100.0) / nbuckets,
9907                       (nzero_counts * 100.0) / nsyms);
9908             }
9909         }
9910
9911       free (counts);
9912       free (lengths);
9913     }
9914
9915   if (buckets != NULL)
9916     {
9917       free (buckets);
9918       free (chains);
9919     }
9920
9921   if (do_histogram && gnubuckets != NULL)
9922     {
9923       unsigned long * lengths;
9924       unsigned long * counts;
9925       unsigned long hn;
9926       unsigned long maxlength = 0;
9927       unsigned long nzero_counts = 0;
9928       unsigned long nsyms = 0;
9929
9930       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
9931       if (lengths == NULL)
9932         {
9933           error (_("Out of memory\n"));
9934           return 0;
9935         }
9936
9937       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9938               (unsigned long) ngnubuckets);
9939       printf (_(" Length  Number     %% of total  Coverage\n"));
9940
9941       for (hn = 0; hn < ngnubuckets; ++hn)
9942         if (gnubuckets[hn] != 0)
9943           {
9944             bfd_vma off, length = 1;
9945
9946             for (off = gnubuckets[hn] - gnusymidx;
9947                  (gnuchains[off] & 1) == 0; ++off)
9948               ++length;
9949             lengths[hn] = length;
9950             if (length > maxlength)
9951               maxlength = length;
9952             nsyms += length;
9953           }
9954
9955       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9956       if (counts == NULL)
9957         {
9958           free (lengths);
9959           error (_("Out of memory\n"));
9960           return 0;
9961         }
9962
9963       for (hn = 0; hn < ngnubuckets; ++hn)
9964         ++counts[lengths[hn]];
9965
9966       if (ngnubuckets > 0)
9967         {
9968           unsigned long j;
9969           printf ("      0  %-10lu (%5.1f%%)\n",
9970                   counts[0], (counts[0] * 100.0) / ngnubuckets);
9971           for (j = 1; j <= maxlength; ++j)
9972             {
9973               nzero_counts += counts[j] * j;
9974               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
9975                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9976                       (nzero_counts * 100.0) / nsyms);
9977             }
9978         }
9979
9980       free (counts);
9981       free (lengths);
9982       free (gnubuckets);
9983       free (gnuchains);
9984     }
9985
9986   return 1;
9987 }
9988
9989 static int
9990 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
9991 {
9992   unsigned int i;
9993
9994   if (dynamic_syminfo == NULL
9995       || !do_dynamic)
9996     /* No syminfo, this is ok.  */
9997     return 1;
9998
9999   /* There better should be a dynamic symbol section.  */
10000   if (dynamic_symbols == NULL || dynamic_strings == NULL)
10001     return 0;
10002
10003   if (dynamic_addr)
10004     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10005             dynamic_syminfo_offset, dynamic_syminfo_nent);
10006
10007   printf (_(" Num: Name                           BoundTo     Flags\n"));
10008   for (i = 0; i < dynamic_syminfo_nent; ++i)
10009     {
10010       unsigned short int flags = dynamic_syminfo[i].si_flags;
10011
10012       printf ("%4d: ", i);
10013       if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
10014         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10015       else
10016         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
10017       putchar (' ');
10018
10019       switch (dynamic_syminfo[i].si_boundto)
10020         {
10021         case SYMINFO_BT_SELF:
10022           fputs ("SELF       ", stdout);
10023           break;
10024         case SYMINFO_BT_PARENT:
10025           fputs ("PARENT     ", stdout);
10026           break;
10027         default:
10028           if (dynamic_syminfo[i].si_boundto > 0
10029               && dynamic_syminfo[i].si_boundto < dynamic_nent
10030               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
10031             {
10032               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
10033               putchar (' ' );
10034             }
10035           else
10036             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10037           break;
10038         }
10039
10040       if (flags & SYMINFO_FLG_DIRECT)
10041         printf (" DIRECT");
10042       if (flags & SYMINFO_FLG_PASSTHRU)
10043         printf (" PASSTHRU");
10044       if (flags & SYMINFO_FLG_COPY)
10045         printf (" COPY");
10046       if (flags & SYMINFO_FLG_LAZYLOAD)
10047         printf (" LAZYLOAD");
10048
10049       puts ("");
10050     }
10051
10052   return 1;
10053 }
10054
10055 /* Check to see if the given reloc needs to be handled in a target specific
10056    manner.  If so then process the reloc and return TRUE otherwise return
10057    FALSE.  */
10058
10059 static bfd_boolean
10060 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10061                                 unsigned char *     start,
10062                                 Elf_Internal_Sym *  symtab)
10063 {
10064   unsigned int reloc_type = get_reloc_type (reloc->r_info);
10065
10066   switch (elf_header.e_machine)
10067     {
10068     case EM_MSP430:
10069     case EM_MSP430_OLD:
10070       {
10071         static Elf_Internal_Sym * saved_sym = NULL;
10072
10073         switch (reloc_type)
10074           {
10075           case 10: /* R_MSP430_SYM_DIFF */
10076             if (uses_msp430x_relocs ())
10077               break;
10078           case 21: /* R_MSP430X_SYM_DIFF */
10079             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10080             return TRUE;
10081
10082           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10083           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10084             goto handle_sym_diff;
10085
10086           case 5: /* R_MSP430_16_BYTE */
10087           case 9: /* R_MSP430_8 */
10088             if (uses_msp430x_relocs ())
10089               break;
10090             goto handle_sym_diff;
10091
10092           case 2: /* R_MSP430_ABS16 */
10093           case 15: /* R_MSP430X_ABS16 */
10094             if (! uses_msp430x_relocs ())
10095               break;
10096             goto handle_sym_diff;
10097
10098           handle_sym_diff:
10099             if (saved_sym != NULL)
10100               {
10101                 bfd_vma value;
10102
10103                 value = reloc->r_addend
10104                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10105                      - saved_sym->st_value);
10106
10107                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10108
10109                 saved_sym = NULL;
10110                 return TRUE;
10111               }
10112             break;
10113
10114           default:
10115             if (saved_sym != NULL)
10116               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc"));
10117             break;
10118           }
10119         break;
10120       }
10121
10122     case EM_MN10300:
10123     case EM_CYGNUS_MN10300:
10124       {
10125         static Elf_Internal_Sym * saved_sym = NULL;
10126
10127         switch (reloc_type)
10128           {
10129           case 34: /* R_MN10300_ALIGN */
10130             return TRUE;
10131           case 33: /* R_MN10300_SYM_DIFF */
10132             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10133             return TRUE;
10134           case 1: /* R_MN10300_32 */
10135           case 2: /* R_MN10300_16 */
10136             if (saved_sym != NULL)
10137               {
10138                 bfd_vma value;
10139
10140                 value = reloc->r_addend
10141                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10142                      - saved_sym->st_value);
10143
10144                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10145
10146                 saved_sym = NULL;
10147                 return TRUE;
10148               }
10149             break;
10150           default:
10151             if (saved_sym != NULL)
10152               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10153             break;
10154           }
10155         break;
10156       }
10157     }
10158
10159   return FALSE;
10160 }
10161
10162 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10163    DWARF debug sections.  This is a target specific test.  Note - we do not
10164    go through the whole including-target-headers-multiple-times route, (as
10165    we have already done with <elf/h8.h>) because this would become very
10166    messy and even then this function would have to contain target specific
10167    information (the names of the relocs instead of their numeric values).
10168    FIXME: This is not the correct way to solve this problem.  The proper way
10169    is to have target specific reloc sizing and typing functions created by
10170    the reloc-macros.h header, in the same way that it already creates the
10171    reloc naming functions.  */
10172
10173 static bfd_boolean
10174 is_32bit_abs_reloc (unsigned int reloc_type)
10175 {
10176   switch (elf_header.e_machine)
10177     {
10178     case EM_386:
10179     case EM_486:
10180       return reloc_type == 1; /* R_386_32.  */
10181     case EM_68K:
10182       return reloc_type == 1; /* R_68K_32.  */
10183     case EM_860:
10184       return reloc_type == 1; /* R_860_32.  */
10185     case EM_960:
10186       return reloc_type == 2; /* R_960_32.  */
10187     case EM_AARCH64:
10188       return reloc_type == 258; /* R_AARCH64_ABS32 */
10189     case EM_ALPHA:
10190       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
10191     case EM_ARC:
10192       return reloc_type == 1; /* R_ARC_32.  */
10193     case EM_ARM:
10194       return reloc_type == 2; /* R_ARM_ABS32 */
10195     case EM_AVR_OLD:
10196     case EM_AVR:
10197       return reloc_type == 1;
10198     case EM_ADAPTEVA_EPIPHANY:
10199       return reloc_type == 3;
10200     case EM_BLACKFIN:
10201       return reloc_type == 0x12; /* R_byte4_data.  */
10202     case EM_CRIS:
10203       return reloc_type == 3; /* R_CRIS_32.  */
10204     case EM_CR16:
10205       return reloc_type == 3; /* R_CR16_NUM32.  */
10206     case EM_CRX:
10207       return reloc_type == 15; /* R_CRX_NUM32.  */
10208     case EM_CYGNUS_FRV:
10209       return reloc_type == 1;
10210     case EM_CYGNUS_D10V:
10211     case EM_D10V:
10212       return reloc_type == 6; /* R_D10V_32.  */
10213     case EM_CYGNUS_D30V:
10214     case EM_D30V:
10215       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
10216     case EM_DLX:
10217       return reloc_type == 3; /* R_DLX_RELOC_32.  */
10218     case EM_CYGNUS_FR30:
10219     case EM_FR30:
10220       return reloc_type == 3; /* R_FR30_32.  */
10221     case EM_H8S:
10222     case EM_H8_300:
10223     case EM_H8_300H:
10224       return reloc_type == 1; /* R_H8_DIR32.  */
10225     case EM_IA_64:
10226       return reloc_type == 0x65; /* R_IA64_SECREL32LSB.  */
10227     case EM_IP2K_OLD:
10228     case EM_IP2K:
10229       return reloc_type == 2; /* R_IP2K_32.  */
10230     case EM_IQ2000:
10231       return reloc_type == 2; /* R_IQ2000_32.  */
10232     case EM_LATTICEMICO32:
10233       return reloc_type == 3; /* R_LM32_32.  */
10234     case EM_M32C_OLD:
10235     case EM_M32C:
10236       return reloc_type == 3; /* R_M32C_32.  */
10237     case EM_M32R:
10238       return reloc_type == 34; /* R_M32R_32_RELA.  */
10239     case EM_MCORE:
10240       return reloc_type == 1; /* R_MCORE_ADDR32.  */
10241     case EM_CYGNUS_MEP:
10242       return reloc_type == 4; /* R_MEP_32.  */
10243     case EM_METAG:
10244       return reloc_type == 2; /* R_METAG_ADDR32.  */
10245     case EM_MICROBLAZE:
10246       return reloc_type == 1; /* R_MICROBLAZE_32.  */
10247     case EM_MIPS:
10248       return reloc_type == 2; /* R_MIPS_32.  */
10249     case EM_MMIX:
10250       return reloc_type == 4; /* R_MMIX_32.  */
10251     case EM_CYGNUS_MN10200:
10252     case EM_MN10200:
10253       return reloc_type == 1; /* R_MN10200_32.  */
10254     case EM_CYGNUS_MN10300:
10255     case EM_MN10300:
10256       return reloc_type == 1; /* R_MN10300_32.  */
10257     case EM_MOXIE:
10258       return reloc_type == 1; /* R_MOXIE_32.  */
10259     case EM_MSP430_OLD:
10260     case EM_MSP430:
10261       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
10262     case EM_MT:
10263       return reloc_type == 2; /* R_MT_32.  */
10264     case EM_ALTERA_NIOS2:
10265       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
10266     case EM_NIOS32:
10267       return reloc_type == 1; /* R_NIOS_32.  */
10268     case EM_OPENRISC:
10269     case EM_OR32:
10270       return reloc_type == 1; /* R_OR32_32.  */
10271     case EM_PARISC:
10272       return (reloc_type == 1 /* R_PARISC_DIR32.  */
10273               || reloc_type == 41); /* R_PARISC_SECREL32.  */
10274     case EM_PJ:
10275     case EM_PJ_OLD:
10276       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
10277     case EM_PPC64:
10278       return reloc_type == 1; /* R_PPC64_ADDR32.  */
10279     case EM_PPC:
10280       return reloc_type == 1; /* R_PPC_ADDR32.  */
10281     case EM_RL78:
10282       return reloc_type == 1; /* R_RL78_DIR32.  */
10283     case EM_RX:
10284       return reloc_type == 1; /* R_RX_DIR32.  */
10285     case EM_S370:
10286       return reloc_type == 1; /* R_I370_ADDR31.  */
10287     case EM_S390_OLD:
10288     case EM_S390:
10289       return reloc_type == 4; /* R_S390_32.  */
10290     case EM_SCORE:
10291       return reloc_type == 8; /* R_SCORE_ABS32.  */
10292     case EM_SH:
10293       return reloc_type == 1; /* R_SH_DIR32.  */
10294     case EM_SPARC32PLUS:
10295     case EM_SPARCV9:
10296     case EM_SPARC:
10297       return reloc_type == 3 /* R_SPARC_32.  */
10298         || reloc_type == 23; /* R_SPARC_UA32.  */
10299     case EM_SPU:
10300       return reloc_type == 6; /* R_SPU_ADDR32 */
10301     case EM_TI_C6000:
10302       return reloc_type == 1; /* R_C6000_ABS32.  */
10303     case EM_TILEGX:
10304       return reloc_type == 2; /* R_TILEGX_32.  */
10305     case EM_TILEPRO:
10306       return reloc_type == 1; /* R_TILEPRO_32.  */
10307     case EM_CYGNUS_V850:
10308     case EM_V850:
10309       return reloc_type == 6; /* R_V850_ABS32.  */
10310     case EM_V800:
10311       return reloc_type == 0x33; /* R_V810_WORD.  */
10312     case EM_VAX:
10313       return reloc_type == 1; /* R_VAX_32.  */
10314     case EM_X86_64:
10315     case EM_L1OM:
10316     case EM_K1OM:
10317       return reloc_type == 10; /* R_X86_64_32.  */
10318     case EM_XC16X:
10319     case EM_C166:
10320       return reloc_type == 3; /* R_XC16C_ABS_32.  */
10321     case EM_XGATE:
10322       return reloc_type == 4; /* R_XGATE_32.  */
10323     case EM_XSTORMY16:
10324       return reloc_type == 1; /* R_XSTROMY16_32.  */
10325     case EM_XTENSA_OLD:
10326     case EM_XTENSA:
10327       return reloc_type == 1; /* R_XTENSA_32.  */
10328     default:
10329       error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10330              elf_header.e_machine);
10331       abort ();
10332     }
10333 }
10334
10335 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10336    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
10337
10338 static bfd_boolean
10339 is_32bit_pcrel_reloc (unsigned int reloc_type)
10340 {
10341   switch (elf_header.e_machine)
10342     {
10343     case EM_386:
10344     case EM_486:
10345       return reloc_type == 2;  /* R_386_PC32.  */
10346     case EM_68K:
10347       return reloc_type == 4;  /* R_68K_PC32.  */
10348     case EM_AARCH64:
10349       return reloc_type == 261; /* R_AARCH64_PREL32 */
10350     case EM_ADAPTEVA_EPIPHANY:
10351       return reloc_type == 6;
10352     case EM_ALPHA:
10353       return reloc_type == 10; /* R_ALPHA_SREL32.  */
10354     case EM_ARM:
10355       return reloc_type == 3;  /* R_ARM_REL32 */
10356     case EM_MICROBLAZE:
10357       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
10358     case EM_PARISC:
10359       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
10360     case EM_PPC:
10361       return reloc_type == 26; /* R_PPC_REL32.  */
10362     case EM_PPC64:
10363       return reloc_type == 26; /* R_PPC64_REL32.  */
10364     case EM_S390_OLD:
10365     case EM_S390:
10366       return reloc_type == 5;  /* R_390_PC32.  */
10367     case EM_SH:
10368       return reloc_type == 2;  /* R_SH_REL32.  */
10369     case EM_SPARC32PLUS:
10370     case EM_SPARCV9:
10371     case EM_SPARC:
10372       return reloc_type == 6;  /* R_SPARC_DISP32.  */
10373     case EM_SPU:
10374       return reloc_type == 13; /* R_SPU_REL32.  */
10375     case EM_TILEGX:
10376       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
10377     case EM_TILEPRO:
10378       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
10379     case EM_X86_64:
10380     case EM_L1OM:
10381     case EM_K1OM:
10382       return reloc_type == 2;  /* R_X86_64_PC32.  */
10383     case EM_XTENSA_OLD:
10384     case EM_XTENSA:
10385       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
10386     default:
10387       /* Do not abort or issue an error message here.  Not all targets use
10388          pc-relative 32-bit relocs in their DWARF debug information and we
10389          have already tested for target coverage in is_32bit_abs_reloc.  A
10390          more helpful warning message will be generated by apply_relocations
10391          anyway, so just return.  */
10392       return FALSE;
10393     }
10394 }
10395
10396 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10397    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
10398
10399 static bfd_boolean
10400 is_64bit_abs_reloc (unsigned int reloc_type)
10401 {
10402   switch (elf_header.e_machine)
10403     {
10404     case EM_AARCH64:
10405       return reloc_type == 257; /* R_AARCH64_ABS64.  */
10406     case EM_ALPHA:
10407       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
10408     case EM_IA_64:
10409       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
10410     case EM_PARISC:
10411       return reloc_type == 80; /* R_PARISC_DIR64.  */
10412     case EM_PPC64:
10413       return reloc_type == 38; /* R_PPC64_ADDR64.  */
10414     case EM_SPARC32PLUS:
10415     case EM_SPARCV9:
10416     case EM_SPARC:
10417       return reloc_type == 54; /* R_SPARC_UA64.  */
10418     case EM_X86_64:
10419     case EM_L1OM:
10420     case EM_K1OM:
10421       return reloc_type == 1; /* R_X86_64_64.  */
10422     case EM_S390_OLD:
10423     case EM_S390:
10424       return reloc_type == 22;  /* R_S390_64.  */
10425     case EM_TILEGX:
10426       return reloc_type == 1; /* R_TILEGX_64.  */
10427     case EM_MIPS:
10428       return reloc_type == 18;  /* R_MIPS_64.  */
10429     default:
10430       return FALSE;
10431     }
10432 }
10433
10434 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10435    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
10436
10437 static bfd_boolean
10438 is_64bit_pcrel_reloc (unsigned int reloc_type)
10439 {
10440   switch (elf_header.e_machine)
10441     {
10442     case EM_AARCH64:
10443       return reloc_type == 260; /* R_AARCH64_PREL64.  */
10444     case EM_ALPHA:
10445       return reloc_type == 11; /* R_ALPHA_SREL64.  */
10446     case EM_IA_64:
10447       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
10448     case EM_PARISC:
10449       return reloc_type == 72; /* R_PARISC_PCREL64.  */
10450     case EM_PPC64:
10451       return reloc_type == 44; /* R_PPC64_REL64.  */
10452     case EM_SPARC32PLUS:
10453     case EM_SPARCV9:
10454     case EM_SPARC:
10455       return reloc_type == 46; /* R_SPARC_DISP64.  */
10456     case EM_X86_64:
10457     case EM_L1OM:
10458     case EM_K1OM:
10459       return reloc_type == 24; /* R_X86_64_PC64.  */
10460     case EM_S390_OLD:
10461     case EM_S390:
10462       return reloc_type == 23;  /* R_S390_PC64.  */
10463     case EM_TILEGX:
10464       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
10465     default:
10466       return FALSE;
10467     }
10468 }
10469
10470 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10471    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
10472
10473 static bfd_boolean
10474 is_24bit_abs_reloc (unsigned int reloc_type)
10475 {
10476   switch (elf_header.e_machine)
10477     {
10478     case EM_CYGNUS_MN10200:
10479     case EM_MN10200:
10480       return reloc_type == 4; /* R_MN10200_24.  */
10481     default:
10482       return FALSE;
10483     }
10484 }
10485
10486 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10487    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
10488
10489 static bfd_boolean
10490 is_16bit_abs_reloc (unsigned int reloc_type)
10491 {
10492   switch (elf_header.e_machine)
10493     {
10494     case EM_AVR_OLD:
10495     case EM_AVR:
10496       return reloc_type == 4; /* R_AVR_16.  */
10497     case EM_ADAPTEVA_EPIPHANY:
10498       return reloc_type == 5;
10499     case EM_CYGNUS_D10V:
10500     case EM_D10V:
10501       return reloc_type == 3; /* R_D10V_16.  */
10502     case EM_H8S:
10503     case EM_H8_300:
10504     case EM_H8_300H:
10505       return reloc_type == R_H8_DIR16;
10506     case EM_IP2K_OLD:
10507     case EM_IP2K:
10508       return reloc_type == 1; /* R_IP2K_16.  */
10509     case EM_M32C_OLD:
10510     case EM_M32C:
10511       return reloc_type == 1; /* R_M32C_16 */
10512     case EM_MSP430:
10513       if (uses_msp430x_relocs ())
10514         return reloc_type == 2; /* R_MSP430_ABS16.  */
10515     case EM_MSP430_OLD:
10516       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
10517     case EM_ALTERA_NIOS2:
10518       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
10519     case EM_NIOS32:
10520       return reloc_type == 9; /* R_NIOS_16.  */
10521     case EM_TI_C6000:
10522       return reloc_type == 2; /* R_C6000_ABS16.  */
10523     case EM_XC16X:
10524     case EM_C166:
10525       return reloc_type == 2; /* R_XC16C_ABS_16.  */
10526     case EM_CYGNUS_MN10200:
10527     case EM_MN10200:
10528       return reloc_type == 2; /* R_MN10200_16.  */
10529     case EM_CYGNUS_MN10300:
10530     case EM_MN10300:
10531       return reloc_type == 2; /* R_MN10300_16.  */
10532     case EM_XGATE:
10533       return reloc_type == 3; /* R_XGATE_16.  */
10534     default:
10535       return FALSE;
10536     }
10537 }
10538
10539 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10540    relocation entries (possibly formerly used for SHT_GROUP sections).  */
10541
10542 static bfd_boolean
10543 is_none_reloc (unsigned int reloc_type)
10544 {
10545   switch (elf_header.e_machine)
10546     {
10547     case EM_68K:     /* R_68K_NONE.  */
10548     case EM_386:     /* R_386_NONE.  */
10549     case EM_SPARC32PLUS:
10550     case EM_SPARCV9:
10551     case EM_SPARC:   /* R_SPARC_NONE.  */
10552     case EM_MIPS:    /* R_MIPS_NONE.  */
10553     case EM_PARISC:  /* R_PARISC_NONE.  */
10554     case EM_ALPHA:   /* R_ALPHA_NONE.  */
10555     case EM_ADAPTEVA_EPIPHANY:
10556     case EM_PPC:     /* R_PPC_NONE.  */
10557     case EM_PPC64:   /* R_PPC64_NONE.  */
10558     case EM_ARM:     /* R_ARM_NONE.  */
10559     case EM_IA_64:   /* R_IA64_NONE.  */
10560     case EM_SH:      /* R_SH_NONE.  */
10561     case EM_S390_OLD:
10562     case EM_S390:    /* R_390_NONE.  */
10563     case EM_CRIS:    /* R_CRIS_NONE.  */
10564     case EM_X86_64:  /* R_X86_64_NONE.  */
10565     case EM_L1OM:    /* R_X86_64_NONE.  */
10566     case EM_K1OM:    /* R_X86_64_NONE.  */
10567     case EM_MN10300: /* R_MN10300_NONE.  */
10568     case EM_MOXIE:   /* R_MOXIE_NONE.  */
10569     case EM_M32R:    /* R_M32R_NONE.  */
10570     case EM_TI_C6000:/* R_C6000_NONE.  */
10571     case EM_TILEGX:  /* R_TILEGX_NONE.  */
10572     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
10573     case EM_XC16X:
10574     case EM_C166:    /* R_XC16X_NONE.  */
10575     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
10576     case EM_NIOS32:  /* R_NIOS_NONE.  */
10577       return reloc_type == 0;
10578     case EM_AARCH64:
10579       return reloc_type == 0 || reloc_type == 256;
10580     case EM_XTENSA_OLD:
10581     case EM_XTENSA:
10582       return (reloc_type == 0      /* R_XTENSA_NONE.  */
10583               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
10584               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
10585               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
10586     case EM_METAG:
10587       return reloc_type == 3; /* R_METAG_NONE.  */
10588     }
10589   return FALSE;
10590 }
10591
10592 /* Apply relocations to a section.
10593    Note: So far support has been added only for those relocations
10594    which can be found in debug sections.
10595    FIXME: Add support for more relocations ?  */
10596
10597 static void
10598 apply_relocations (void * file,
10599                    Elf_Internal_Shdr * section,
10600                    unsigned char * start)
10601 {
10602   Elf_Internal_Shdr * relsec;
10603   unsigned char * end = start + section->sh_size;
10604
10605   if (elf_header.e_type != ET_REL)
10606     return;
10607
10608   /* Find the reloc section associated with the section.  */
10609   for (relsec = section_headers;
10610        relsec < section_headers + elf_header.e_shnum;
10611        ++relsec)
10612     {
10613       bfd_boolean is_rela;
10614       unsigned long num_relocs;
10615       Elf_Internal_Rela * relocs;
10616       Elf_Internal_Rela * rp;
10617       Elf_Internal_Shdr * symsec;
10618       Elf_Internal_Sym * symtab;
10619       unsigned long num_syms;
10620       Elf_Internal_Sym * sym;
10621
10622       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10623           || relsec->sh_info >= elf_header.e_shnum
10624           || section_headers + relsec->sh_info != section
10625           || relsec->sh_size == 0
10626           || relsec->sh_link >= elf_header.e_shnum)
10627         continue;
10628
10629       is_rela = relsec->sh_type == SHT_RELA;
10630
10631       if (is_rela)
10632         {
10633           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10634                                   relsec->sh_size, & relocs, & num_relocs))
10635             return;
10636         }
10637       else
10638         {
10639           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10640                                  relsec->sh_size, & relocs, & num_relocs))
10641             return;
10642         }
10643
10644       /* SH uses RELA but uses in place value instead of the addend field.  */
10645       if (elf_header.e_machine == EM_SH)
10646         is_rela = FALSE;
10647
10648       symsec = section_headers + relsec->sh_link;
10649       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
10650
10651       for (rp = relocs; rp < relocs + num_relocs; ++rp)
10652         {
10653           bfd_vma         addend;
10654           unsigned int    reloc_type;
10655           unsigned int    reloc_size;
10656           unsigned char * rloc;
10657           unsigned long   sym_index;
10658
10659           reloc_type = get_reloc_type (rp->r_info);
10660
10661           if (target_specific_reloc_handling (rp, start, symtab))
10662             continue;
10663           else if (is_none_reloc (reloc_type))
10664             continue;
10665           else if (is_32bit_abs_reloc (reloc_type)
10666                    || is_32bit_pcrel_reloc (reloc_type))
10667             reloc_size = 4;
10668           else if (is_64bit_abs_reloc (reloc_type)
10669                    || is_64bit_pcrel_reloc (reloc_type))
10670             reloc_size = 8;
10671           else if (is_24bit_abs_reloc (reloc_type))
10672             reloc_size = 3;
10673           else if (is_16bit_abs_reloc (reloc_type))
10674             reloc_size = 2;
10675           else
10676             {
10677               warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10678                     reloc_type, SECTION_NAME (section));
10679               continue;
10680             }
10681
10682           rloc = start + rp->r_offset;
10683           if ((rloc + reloc_size) > end || (rloc < start))
10684             {
10685               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10686                     (unsigned long) rp->r_offset,
10687                     SECTION_NAME (section));
10688               continue;
10689             }
10690
10691           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10692           if (sym_index >= num_syms)
10693             {
10694               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10695                     sym_index, SECTION_NAME (section));
10696               continue;
10697             }
10698           sym = symtab + sym_index;
10699
10700           /* If the reloc has a symbol associated with it,
10701              make sure that it is of an appropriate type.
10702
10703              Relocations against symbols without type can happen.
10704              Gcc -feliminate-dwarf2-dups may generate symbols
10705              without type for debug info.
10706
10707              Icc generates relocations against function symbols
10708              instead of local labels.
10709
10710              Relocations against object symbols can happen, eg when
10711              referencing a global array.  For an example of this see
10712              the _clz.o binary in libgcc.a.  */
10713           if (sym != symtab
10714               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
10715             {
10716               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10717                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
10718                     (long int)(rp - relocs),
10719                     SECTION_NAME (relsec));
10720               continue;
10721             }
10722
10723           addend = 0;
10724           if (is_rela)
10725             addend += rp->r_addend;
10726           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10727              partial_inplace.  */
10728           if (!is_rela
10729               || (elf_header.e_machine == EM_XTENSA
10730                   && reloc_type == 1)
10731               || ((elf_header.e_machine == EM_PJ
10732                    || elf_header.e_machine == EM_PJ_OLD)
10733                   && reloc_type == 1)
10734               || ((elf_header.e_machine == EM_D30V
10735                    || elf_header.e_machine == EM_CYGNUS_D30V)
10736                   && reloc_type == 12))
10737             addend += byte_get (rloc, reloc_size);
10738
10739           if (is_32bit_pcrel_reloc (reloc_type)
10740               || is_64bit_pcrel_reloc (reloc_type))
10741             {
10742               /* On HPPA, all pc-relative relocations are biased by 8.  */
10743               if (elf_header.e_machine == EM_PARISC)
10744                 addend -= 8;
10745               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
10746                         reloc_size);
10747             }
10748           else
10749             byte_put (rloc, addend + sym->st_value, reloc_size);
10750         }
10751
10752       free (symtab);
10753       free (relocs);
10754       break;
10755     }
10756 }
10757
10758 #ifdef SUPPORT_DISASSEMBLY
10759 static int
10760 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10761 {
10762   printf (_("\nAssembly dump of section %s\n"),
10763           SECTION_NAME (section));
10764
10765   /* XXX -- to be done --- XXX */
10766
10767   return 1;
10768 }
10769 #endif
10770
10771 /* Reads in the contents of SECTION from FILE, returning a pointer
10772    to a malloc'ed buffer or NULL if something went wrong.  */
10773
10774 static char *
10775 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10776 {
10777   bfd_size_type num_bytes;
10778
10779   num_bytes = section->sh_size;
10780
10781   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10782     {
10783       printf (_("\nSection '%s' has no data to dump.\n"),
10784               SECTION_NAME (section));
10785       return NULL;
10786     }
10787
10788   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10789                              _("section contents"));
10790 }
10791
10792
10793 static void
10794 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10795 {
10796   Elf_Internal_Shdr * relsec;
10797   bfd_size_type num_bytes;
10798   char * data;
10799   char * end;
10800   char * start;
10801   char * name = SECTION_NAME (section);
10802   bfd_boolean some_strings_shown;
10803
10804   start = get_section_contents (section, file);
10805   if (start == NULL)
10806     return;
10807
10808   printf (_("\nString dump of section '%s':\n"), name);
10809
10810   /* If the section being dumped has relocations against it the user might
10811      be expecting these relocations to have been applied.  Check for this
10812      case and issue a warning message in order to avoid confusion.
10813      FIXME: Maybe we ought to have an option that dumps a section with
10814      relocs applied ?  */
10815   for (relsec = section_headers;
10816        relsec < section_headers + elf_header.e_shnum;
10817        ++relsec)
10818     {
10819       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10820           || relsec->sh_info >= elf_header.e_shnum
10821           || section_headers + relsec->sh_info != section
10822           || relsec->sh_size == 0
10823           || relsec->sh_link >= elf_header.e_shnum)
10824         continue;
10825
10826       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10827       break;
10828     }
10829
10830   num_bytes = section->sh_size;
10831   data = start;
10832   end  = start + num_bytes;
10833   some_strings_shown = FALSE;
10834
10835   while (data < end)
10836     {
10837       while (!ISPRINT (* data))
10838         if (++ data >= end)
10839           break;
10840
10841       if (data < end)
10842         {
10843 #ifndef __MSVCRT__
10844           /* PR 11128: Use two separate invocations in order to work
10845              around bugs in the Solaris 8 implementation of printf.  */
10846           printf ("  [%6tx]  ", data - start);
10847           printf ("%s\n", data);
10848 #else
10849           printf ("  [%6Ix]  %s\n", (size_t) (data - start), data);
10850 #endif
10851           data += strlen (data);
10852           some_strings_shown = TRUE;
10853         }
10854     }
10855
10856   if (! some_strings_shown)
10857     printf (_("  No strings found in this section."));
10858
10859   free (start);
10860
10861   putchar ('\n');
10862 }
10863
10864 static void
10865 dump_section_as_bytes (Elf_Internal_Shdr * section,
10866                        FILE * file,
10867                        bfd_boolean relocate)
10868 {
10869   Elf_Internal_Shdr * relsec;
10870   bfd_size_type bytes;
10871   bfd_vma addr;
10872   unsigned char * data;
10873   unsigned char * start;
10874
10875   start = (unsigned char *) get_section_contents (section, file);
10876   if (start == NULL)
10877     return;
10878
10879   printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10880
10881   if (relocate)
10882     {
10883       apply_relocations (file, section, start);
10884     }
10885   else
10886     {
10887       /* If the section being dumped has relocations against it the user might
10888          be expecting these relocations to have been applied.  Check for this
10889          case and issue a warning message in order to avoid confusion.
10890          FIXME: Maybe we ought to have an option that dumps a section with
10891          relocs applied ?  */
10892       for (relsec = section_headers;
10893            relsec < section_headers + elf_header.e_shnum;
10894            ++relsec)
10895         {
10896           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10897               || relsec->sh_info >= elf_header.e_shnum
10898               || section_headers + relsec->sh_info != section
10899               || relsec->sh_size == 0
10900               || relsec->sh_link >= elf_header.e_shnum)
10901             continue;
10902
10903           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10904           break;
10905         }
10906     }
10907
10908   addr = section->sh_addr;
10909   bytes = section->sh_size;
10910   data = start;
10911
10912   while (bytes)
10913     {
10914       int j;
10915       int k;
10916       int lbytes;
10917
10918       lbytes = (bytes > 16 ? 16 : bytes);
10919
10920       printf ("  0x%8.8lx ", (unsigned long) addr);
10921
10922       for (j = 0; j < 16; j++)
10923         {
10924           if (j < lbytes)
10925             printf ("%2.2x", data[j]);
10926           else
10927             printf ("  ");
10928
10929           if ((j & 3) == 3)
10930             printf (" ");
10931         }
10932
10933       for (j = 0; j < lbytes; j++)
10934         {
10935           k = data[j];
10936           if (k >= ' ' && k < 0x7f)
10937             printf ("%c", k);
10938           else
10939             printf (".");
10940         }
10941
10942       putchar ('\n');
10943
10944       data  += lbytes;
10945       addr  += lbytes;
10946       bytes -= lbytes;
10947     }
10948
10949   free (start);
10950
10951   putchar ('\n');
10952 }
10953
10954 /* Uncompresses a section that was compressed using zlib, in place.  */
10955
10956 static int
10957 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10958                              dwarf_size_type *size ATTRIBUTE_UNUSED)
10959 {
10960 #ifndef HAVE_ZLIB_H
10961   return FALSE;
10962 #else
10963   dwarf_size_type compressed_size = *size;
10964   unsigned char * compressed_buffer = *buffer;
10965   dwarf_size_type uncompressed_size;
10966   unsigned char * uncompressed_buffer;
10967   z_stream strm;
10968   int rc;
10969   dwarf_size_type header_size = 12;
10970
10971   /* Read the zlib header.  In this case, it should be "ZLIB" followed
10972      by the uncompressed section size, 8 bytes in big-endian order.  */
10973   if (compressed_size < header_size
10974       || ! streq ((char *) compressed_buffer, "ZLIB"))
10975     return 0;
10976
10977   uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10978   uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10979   uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10980   uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10981   uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10982   uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10983   uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10984   uncompressed_size += compressed_buffer[11];
10985
10986   /* It is possible the section consists of several compressed
10987      buffers concatenated together, so we uncompress in a loop.  */
10988   strm.zalloc = NULL;
10989   strm.zfree = NULL;
10990   strm.opaque = NULL;
10991   strm.avail_in = compressed_size - header_size;
10992   strm.next_in = (Bytef *) compressed_buffer + header_size;
10993   strm.avail_out = uncompressed_size;
10994   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
10995
10996   rc = inflateInit (& strm);
10997   while (strm.avail_in > 0)
10998     {
10999       if (rc != Z_OK)
11000         goto fail;
11001       strm.next_out = ((Bytef *) uncompressed_buffer
11002                        + (uncompressed_size - strm.avail_out));
11003       rc = inflate (&strm, Z_FINISH);
11004       if (rc != Z_STREAM_END)
11005         goto fail;
11006       rc = inflateReset (& strm);
11007     }
11008   rc = inflateEnd (& strm);
11009   if (rc != Z_OK
11010       || strm.avail_out != 0)
11011     goto fail;
11012
11013   free (compressed_buffer);
11014   *buffer = uncompressed_buffer;
11015   *size = uncompressed_size;
11016   return 1;
11017
11018  fail:
11019   free (uncompressed_buffer);
11020   /* Indicate decompression failure.  */
11021   *buffer = NULL;
11022   return 0;
11023 #endif  /* HAVE_ZLIB_H */
11024 }
11025
11026 static int
11027 load_specific_debug_section (enum dwarf_section_display_enum debug,
11028                              Elf_Internal_Shdr * sec, void * file)
11029 {
11030   struct dwarf_section * section = &debug_displays [debug].section;
11031   char buf [64];
11032
11033   /* If it is already loaded, do nothing.  */
11034   if (section->start != NULL)
11035     return 1;
11036
11037   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11038   section->address = sec->sh_addr;
11039   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11040                                                sec->sh_offset, 1,
11041                                                sec->sh_size, buf);
11042   if (section->start == NULL)
11043     section->size = 0;
11044   else
11045     {
11046       section->size = sec->sh_size;
11047       if (uncompress_section_contents (&section->start, &section->size))
11048         sec->sh_size = section->size;
11049     }
11050
11051   if (section->start == NULL)
11052     return 0;
11053
11054   if (debug_displays [debug].relocate)
11055     apply_relocations ((FILE *) file, sec, section->start);
11056
11057   return 1;
11058 }
11059
11060 /* If this is not NULL, load_debug_section will only look for sections
11061    within the list of sections given here.  */
11062 unsigned int *section_subset = NULL;
11063
11064 int
11065 load_debug_section (enum dwarf_section_display_enum debug, void * file)
11066 {
11067   struct dwarf_section * section = &debug_displays [debug].section;
11068   Elf_Internal_Shdr * sec;
11069
11070   /* Locate the debug section.  */
11071   sec = find_section_in_set (section->uncompressed_name, section_subset);
11072   if (sec != NULL)
11073     section->name = section->uncompressed_name;
11074   else
11075     {
11076       sec = find_section_in_set (section->compressed_name, section_subset);
11077       if (sec != NULL)
11078         section->name = section->compressed_name;
11079     }
11080   if (sec == NULL)
11081     return 0;
11082
11083   /* If we're loading from a subset of sections, and we've loaded
11084      a section matching this name before, it's likely that it's a
11085      different one.  */
11086   if (section_subset != NULL)
11087     free_debug_section (debug);
11088
11089   return load_specific_debug_section (debug, sec, (FILE *) file);
11090 }
11091
11092 void
11093 free_debug_section (enum dwarf_section_display_enum debug)
11094 {
11095   struct dwarf_section * section = &debug_displays [debug].section;
11096
11097   if (section->start == NULL)
11098     return;
11099
11100   free ((char *) section->start);
11101   section->start = NULL;
11102   section->address = 0;
11103   section->size = 0;
11104 }
11105
11106 static int
11107 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
11108 {
11109   char * name = SECTION_NAME (section);
11110   bfd_size_type length;
11111   int result = 1;
11112   int i;
11113
11114   length = section->sh_size;
11115   if (length == 0)
11116     {
11117       printf (_("\nSection '%s' has no debugging data.\n"), name);
11118       return 0;
11119     }
11120   if (section->sh_type == SHT_NOBITS)
11121     {
11122       /* There is no point in dumping the contents of a debugging section
11123          which has the NOBITS type - the bits in the file will be random.
11124          This can happen when a file containing a .eh_frame section is
11125          stripped with the --only-keep-debug command line option.  */
11126       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
11127       return 0;
11128     }
11129
11130   if (const_strneq (name, ".gnu.linkonce.wi."))
11131     name = ".debug_info";
11132
11133   /* See if we know how to display the contents of this section.  */
11134   for (i = 0; i < max; i++)
11135     if (streq (debug_displays[i].section.uncompressed_name, name)
11136         || (i == line && const_strneq (name, ".debug_line."))
11137         || streq (debug_displays[i].section.compressed_name, name))
11138       {
11139         struct dwarf_section * sec = &debug_displays [i].section;
11140         int secondary = (section != find_section (name));
11141
11142         if (secondary)
11143           free_debug_section ((enum dwarf_section_display_enum) i);
11144
11145         if (i == line && const_strneq (name, ".debug_line."))
11146           sec->name = name;
11147         else if (streq (sec->uncompressed_name, name))
11148           sec->name = sec->uncompressed_name;
11149         else
11150           sec->name = sec->compressed_name;
11151         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
11152                                          section, file))
11153           {
11154             /* If this debug section is part of a CU/TU set in a .dwp file,
11155                restrict load_debug_section to the sections in that set.  */
11156             section_subset = find_cu_tu_set (file, shndx);
11157
11158             result &= debug_displays[i].display (sec, file);
11159
11160             section_subset = NULL;
11161
11162             if (secondary || (i != info && i != abbrev))
11163               free_debug_section ((enum dwarf_section_display_enum) i);
11164           }
11165
11166         break;
11167       }
11168
11169   if (i == max)
11170     {
11171       printf (_("Unrecognized debug section: %s\n"), name);
11172       result = 0;
11173     }
11174
11175   return result;
11176 }
11177
11178 /* Set DUMP_SECTS for all sections where dumps were requested
11179    based on section name.  */
11180
11181 static void
11182 initialise_dumps_byname (void)
11183 {
11184   struct dump_list_entry * cur;
11185
11186   for (cur = dump_sects_byname; cur; cur = cur->next)
11187     {
11188       unsigned int i;
11189       int any;
11190
11191       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11192         if (streq (SECTION_NAME (section_headers + i), cur->name))
11193           {
11194             request_dump_bynumber (i, cur->type);
11195             any = 1;
11196           }
11197
11198       if (!any)
11199         warn (_("Section '%s' was not dumped because it does not exist!\n"),
11200               cur->name);
11201     }
11202 }
11203
11204 static void
11205 process_section_contents (FILE * file)
11206 {
11207   Elf_Internal_Shdr * section;
11208   unsigned int i;
11209
11210   if (! do_dump)
11211     return;
11212
11213   initialise_dumps_byname ();
11214
11215   for (i = 0, section = section_headers;
11216        i < elf_header.e_shnum && i < num_dump_sects;
11217        i++, section++)
11218     {
11219 #ifdef SUPPORT_DISASSEMBLY
11220       if (dump_sects[i] & DISASS_DUMP)
11221         disassemble_section (section, file);
11222 #endif
11223       if (dump_sects[i] & HEX_DUMP)
11224         dump_section_as_bytes (section, file, FALSE);
11225
11226       if (dump_sects[i] & RELOC_DUMP)
11227         dump_section_as_bytes (section, file, TRUE);
11228
11229       if (dump_sects[i] & STRING_DUMP)
11230         dump_section_as_strings (section, file);
11231
11232       if (dump_sects[i] & DEBUG_DUMP)
11233         display_debug_section (i, section, file);
11234     }
11235
11236   /* Check to see if the user requested a
11237      dump of a section that does not exist.  */
11238   while (i++ < num_dump_sects)
11239     if (dump_sects[i])
11240       warn (_("Section %d was not dumped because it does not exist!\n"), i);
11241 }
11242
11243 static void
11244 process_mips_fpe_exception (int mask)
11245 {
11246   if (mask)
11247     {
11248       int first = 1;
11249       if (mask & OEX_FPU_INEX)
11250         fputs ("INEX", stdout), first = 0;
11251       if (mask & OEX_FPU_UFLO)
11252         printf ("%sUFLO", first ? "" : "|"), first = 0;
11253       if (mask & OEX_FPU_OFLO)
11254         printf ("%sOFLO", first ? "" : "|"), first = 0;
11255       if (mask & OEX_FPU_DIV0)
11256         printf ("%sDIV0", first ? "" : "|"), first = 0;
11257       if (mask & OEX_FPU_INVAL)
11258         printf ("%sINVAL", first ? "" : "|");
11259     }
11260   else
11261     fputs ("0", stdout);
11262 }
11263
11264 /* Display's the value of TAG at location P.  If TAG is
11265    greater than 0 it is assumed to be an unknown tag, and
11266    a message is printed to this effect.  Otherwise it is
11267    assumed that a message has already been printed.
11268
11269    If the bottom bit of TAG is set it assumed to have a
11270    string value, otherwise it is assumed to have an integer
11271    value.
11272
11273    Returns an updated P pointing to the first unread byte
11274    beyond the end of TAG's value.
11275
11276    Reads at or beyond END will not be made.  */
11277
11278 static unsigned char *
11279 display_tag_value (int tag,
11280                    unsigned char * p,
11281                    const unsigned char * const end)
11282 {
11283   unsigned long val;
11284
11285   if (tag > 0)
11286     printf ("  Tag_unknown_%d: ", tag);
11287
11288   if (p >= end)
11289     {
11290       warn (_("corrupt tag\n"));
11291     }
11292   else if (tag & 1)
11293     {
11294       /* FIXME: we could read beyond END here.  */
11295       printf ("\"%s\"\n", p);
11296       p += strlen ((char *) p) + 1;
11297     }
11298   else
11299     {
11300       unsigned int len;
11301
11302       val = read_uleb128 (p, &len, end);
11303       p += len;
11304       printf ("%ld (0x%lx)\n", val, val);
11305     }
11306
11307   return p;
11308 }
11309
11310 /* ARM EABI attributes section.  */
11311 typedef struct
11312 {
11313   int tag;
11314   const char * name;
11315   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
11316   int type;
11317   const char ** table;
11318 } arm_attr_public_tag;
11319
11320 static const char * arm_attr_tag_CPU_arch[] =
11321   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11322    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11323 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11324 static const char * arm_attr_tag_THUMB_ISA_use[] =
11325   {"No", "Thumb-1", "Thumb-2"};
11326 static const char * arm_attr_tag_FP_arch[] =
11327   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11328    "FP for ARMv8"};
11329 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
11330 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
11331   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11332 static const char * arm_attr_tag_PCS_config[] =
11333   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11334    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11335 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11336   {"V6", "SB", "TLS", "Unused"};
11337 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11338   {"Absolute", "PC-relative", "SB-relative", "None"};
11339 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11340   {"Absolute", "PC-relative", "None"};
11341 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11342   {"None", "direct", "GOT-indirect"};
11343 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11344   {"None", "??? 1", "2", "??? 3", "4"};
11345 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11346 static const char * arm_attr_tag_ABI_FP_denormal[] =
11347   {"Unused", "Needed", "Sign only"};
11348 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11349 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11350 static const char * arm_attr_tag_ABI_FP_number_model[] =
11351   {"Unused", "Finite", "RTABI", "IEEE 754"};
11352 static const char * arm_attr_tag_ABI_enum_size[] =
11353   {"Unused", "small", "int", "forced to int"};
11354 static const char * arm_attr_tag_ABI_HardFP_use[] =
11355   {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11356 static const char * arm_attr_tag_ABI_VFP_args[] =
11357   {"AAPCS", "VFP registers", "custom"};
11358 static const char * arm_attr_tag_ABI_WMMX_args[] =
11359   {"AAPCS", "WMMX registers", "custom"};
11360 static const char * arm_attr_tag_ABI_optimization_goals[] =
11361   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11362     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11363 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11364   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11365     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11366 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
11367 static const char * arm_attr_tag_FP_HP_extension[] =
11368   {"Not Allowed", "Allowed"};
11369 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
11370   {"None", "IEEE 754", "Alternative Format"};
11371 static const char * arm_attr_tag_MPextension_use[] =
11372   {"Not Allowed", "Allowed"};
11373 static const char * arm_attr_tag_DIV_use[] =
11374   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11375     "Allowed in v7-A with integer division extension"};
11376 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11377 static const char * arm_attr_tag_Virtualization_use[] =
11378   {"Not Allowed", "TrustZone", "Virtualization Extensions",
11379     "TrustZone and Virtualization Extensions"};
11380 static const char * arm_attr_tag_MPextension_use_legacy[] =
11381   {"Not Allowed", "Allowed"};
11382
11383 #define LOOKUP(id, name) \
11384   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11385 static arm_attr_public_tag arm_attr_public_tags[] =
11386 {
11387   {4, "CPU_raw_name", 1, NULL},
11388   {5, "CPU_name", 1, NULL},
11389   LOOKUP(6, CPU_arch),
11390   {7, "CPU_arch_profile", 0, NULL},
11391   LOOKUP(8, ARM_ISA_use),
11392   LOOKUP(9, THUMB_ISA_use),
11393   LOOKUP(10, FP_arch),
11394   LOOKUP(11, WMMX_arch),
11395   LOOKUP(12, Advanced_SIMD_arch),
11396   LOOKUP(13, PCS_config),
11397   LOOKUP(14, ABI_PCS_R9_use),
11398   LOOKUP(15, ABI_PCS_RW_data),
11399   LOOKUP(16, ABI_PCS_RO_data),
11400   LOOKUP(17, ABI_PCS_GOT_use),
11401   LOOKUP(18, ABI_PCS_wchar_t),
11402   LOOKUP(19, ABI_FP_rounding),
11403   LOOKUP(20, ABI_FP_denormal),
11404   LOOKUP(21, ABI_FP_exceptions),
11405   LOOKUP(22, ABI_FP_user_exceptions),
11406   LOOKUP(23, ABI_FP_number_model),
11407   {24, "ABI_align_needed", 0, NULL},
11408   {25, "ABI_align_preserved", 0, NULL},
11409   LOOKUP(26, ABI_enum_size),
11410   LOOKUP(27, ABI_HardFP_use),
11411   LOOKUP(28, ABI_VFP_args),
11412   LOOKUP(29, ABI_WMMX_args),
11413   LOOKUP(30, ABI_optimization_goals),
11414   LOOKUP(31, ABI_FP_optimization_goals),
11415   {32, "compatibility", 0, NULL},
11416   LOOKUP(34, CPU_unaligned_access),
11417   LOOKUP(36, FP_HP_extension),
11418   LOOKUP(38, ABI_FP_16bit_format),
11419   LOOKUP(42, MPextension_use),
11420   LOOKUP(44, DIV_use),
11421   {64, "nodefaults", 0, NULL},
11422   {65, "also_compatible_with", 0, NULL},
11423   LOOKUP(66, T2EE_use),
11424   {67, "conformance", 1, NULL},
11425   LOOKUP(68, Virtualization_use),
11426   LOOKUP(70, MPextension_use_legacy)
11427 };
11428 #undef LOOKUP
11429
11430 static unsigned char *
11431 display_arm_attribute (unsigned char * p,
11432                        const unsigned char * const end)
11433 {
11434   int tag;
11435   unsigned int len;
11436   int val;
11437   arm_attr_public_tag * attr;
11438   unsigned i;
11439   int type;
11440
11441   tag = read_uleb128 (p, &len, end);
11442   p += len;
11443   attr = NULL;
11444   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11445     {
11446       if (arm_attr_public_tags[i].tag == tag)
11447         {
11448           attr = &arm_attr_public_tags[i];
11449           break;
11450         }
11451     }
11452
11453   if (attr)
11454     {
11455       printf ("  Tag_%s: ", attr->name);
11456       switch (attr->type)
11457         {
11458         case 0:
11459           switch (tag)
11460             {
11461             case 7: /* Tag_CPU_arch_profile.  */
11462               val = read_uleb128 (p, &len, end);
11463               p += len;
11464               switch (val)
11465                 {
11466                 case 0: printf (_("None\n")); break;
11467                 case 'A': printf (_("Application\n")); break;
11468                 case 'R': printf (_("Realtime\n")); break;
11469                 case 'M': printf (_("Microcontroller\n")); break;
11470                 case 'S': printf (_("Application or Realtime\n")); break;
11471                 default: printf ("??? (%d)\n", val); break;
11472                 }
11473               break;
11474
11475             case 24: /* Tag_align_needed.  */
11476               val = read_uleb128 (p, &len, end);
11477               p += len;
11478               switch (val)
11479                 {
11480                 case 0: printf (_("None\n")); break;
11481                 case 1: printf (_("8-byte\n")); break;
11482                 case 2: printf (_("4-byte\n")); break;
11483                 case 3: printf ("??? 3\n"); break;
11484                 default:
11485                   if (val <= 12)
11486                     printf (_("8-byte and up to %d-byte extended\n"),
11487                             1 << val);
11488                   else
11489                     printf ("??? (%d)\n", val);
11490                   break;
11491                 }
11492               break;
11493
11494             case 25: /* Tag_align_preserved.  */
11495               val = read_uleb128 (p, &len, end);
11496               p += len;
11497               switch (val)
11498                 {
11499                 case 0: printf (_("None\n")); break;
11500                 case 1: printf (_("8-byte, except leaf SP\n")); break;
11501                 case 2: printf (_("8-byte\n")); break;
11502                 case 3: printf ("??? 3\n"); break;
11503                 default:
11504                   if (val <= 12)
11505                     printf (_("8-byte and up to %d-byte extended\n"),
11506                             1 << val);
11507                   else
11508                     printf ("??? (%d)\n", val);
11509                   break;
11510                 }
11511               break;
11512
11513             case 32: /* Tag_compatibility.  */
11514               val = read_uleb128 (p, &len, end);
11515               p += len;
11516               printf (_("flag = %d, vendor = %s\n"), val, p);
11517               p += strlen ((char *) p) + 1;
11518               break;
11519
11520             case 64: /* Tag_nodefaults.  */
11521               p++;
11522               printf (_("True\n"));
11523               break;
11524
11525             case 65: /* Tag_also_compatible_with.  */
11526               val = read_uleb128 (p, &len, end);
11527               p += len;
11528               if (val == 6 /* Tag_CPU_arch.  */)
11529                 {
11530                   val = read_uleb128 (p, &len, end);
11531                   p += len;
11532                   if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
11533                     printf ("??? (%d)\n", val);
11534                   else
11535                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11536                 }
11537               else
11538                 printf ("???\n");
11539               while (*(p++) != '\0' /* NUL terminator.  */);
11540               break;
11541
11542             default:
11543               abort ();
11544             }
11545           return p;
11546
11547         case 1:
11548           return display_tag_value (-1, p, end);
11549         case 2:
11550           return display_tag_value (0, p, end);
11551
11552         default:
11553           assert (attr->type & 0x80);
11554           val = read_uleb128 (p, &len, end);
11555           p += len;
11556           type = attr->type & 0x7f;
11557           if (val >= type)
11558             printf ("??? (%d)\n", val);
11559           else
11560             printf ("%s\n", attr->table[val]);
11561           return p;
11562         }
11563     }
11564
11565   return display_tag_value (tag, p, end);
11566 }
11567
11568 static unsigned char *
11569 display_gnu_attribute (unsigned char * p,
11570                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
11571                        const unsigned char * const end)
11572 {
11573   int tag;
11574   unsigned int len;
11575   int val;
11576
11577   tag = read_uleb128 (p, &len, end);
11578   p += len;
11579
11580   /* Tag_compatibility is the only generic GNU attribute defined at
11581      present.  */
11582   if (tag == 32)
11583     {
11584       val = read_uleb128 (p, &len, end);
11585       p += len;
11586       if (p == end)
11587         {
11588           printf (_("flag = %d, vendor = <corrupt>\n"), val);
11589           warn (_("corrupt vendor attribute\n"));
11590         }
11591       else
11592         {
11593           printf (_("flag = %d, vendor = %s\n"), val, p);
11594           p += strlen ((char *) p) + 1;
11595         }
11596       return p;
11597     }
11598
11599   if ((tag & 2) == 0 && display_proc_gnu_attribute)
11600     return display_proc_gnu_attribute (p, tag, end);
11601
11602   return display_tag_value (tag, p, end);
11603 }
11604
11605 static unsigned char *
11606 display_power_gnu_attribute (unsigned char * p,
11607                              int tag,
11608                              const unsigned char * const end)
11609 {
11610   unsigned int len;
11611   int val;
11612
11613   if (tag == Tag_GNU_Power_ABI_FP)
11614     {
11615       val = read_uleb128 (p, &len, end);
11616       p += len;
11617       printf ("  Tag_GNU_Power_ABI_FP: ");
11618
11619       switch (val)
11620         {
11621         case 0:
11622           printf (_("Hard or soft float\n"));
11623           break;
11624         case 1:
11625           printf (_("Hard float\n"));
11626           break;
11627         case 2:
11628           printf (_("Soft float\n"));
11629           break;
11630         case 3:
11631           printf (_("Single-precision hard float\n"));
11632           break;
11633         default:
11634           printf ("??? (%d)\n", val);
11635           break;
11636         }
11637       return p;
11638    }
11639
11640   if (tag == Tag_GNU_Power_ABI_Vector)
11641     {
11642       val = read_uleb128 (p, &len, end);
11643       p += len;
11644       printf ("  Tag_GNU_Power_ABI_Vector: ");
11645       switch (val)
11646         {
11647         case 0:
11648           printf (_("Any\n"));
11649           break;
11650         case 1:
11651           printf (_("Generic\n"));
11652           break;
11653         case 2:
11654           printf ("AltiVec\n");
11655           break;
11656         case 3:
11657           printf ("SPE\n");
11658           break;
11659         default:
11660           printf ("??? (%d)\n", val);
11661           break;
11662         }
11663       return p;
11664    }
11665
11666   if (tag == Tag_GNU_Power_ABI_Struct_Return)
11667     {
11668       if (p == end)
11669         {
11670           warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
11671           return p;
11672         }
11673
11674       val = read_uleb128 (p, &len, end);
11675       p += len;
11676       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
11677       switch (val)
11678        {
11679        case 0:
11680          printf (_("Any\n"));
11681          break;
11682        case 1:
11683          printf ("r3/r4\n");
11684          break;
11685        case 2:
11686          printf (_("Memory\n"));
11687          break;
11688        default:
11689          printf ("??? (%d)\n", val);
11690          break;
11691        }
11692       return p;
11693     }
11694
11695   return display_tag_value (tag & 1, p, end);
11696 }
11697
11698 static void
11699 display_sparc_hwcaps (int mask)
11700 {
11701   if (mask)
11702     {
11703       int first = 1;
11704       if (mask & ELF_SPARC_HWCAP_MUL32)
11705         fputs ("mul32", stdout), first = 0;
11706       if (mask & ELF_SPARC_HWCAP_DIV32)
11707         printf ("%sdiv32", first ? "" : "|"), first = 0;
11708       if (mask & ELF_SPARC_HWCAP_FSMULD)
11709         printf ("%sfsmuld", first ? "" : "|"), first = 0;
11710       if (mask & ELF_SPARC_HWCAP_V8PLUS)
11711         printf ("%sv8plus", first ? "" : "|"), first = 0;
11712       if (mask & ELF_SPARC_HWCAP_POPC)
11713         printf ("%spopc", first ? "" : "|"), first = 0;
11714       if (mask & ELF_SPARC_HWCAP_VIS)
11715         printf ("%svis", first ? "" : "|"), first = 0;
11716       if (mask & ELF_SPARC_HWCAP_VIS2)
11717         printf ("%svis2", first ? "" : "|"), first = 0;
11718       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11719         printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11720       if (mask & ELF_SPARC_HWCAP_FMAF)
11721         printf ("%sfmaf", first ? "" : "|"), first = 0;
11722       if (mask & ELF_SPARC_HWCAP_VIS3)
11723         printf ("%svis3", first ? "" : "|"), first = 0;
11724       if (mask & ELF_SPARC_HWCAP_HPC)
11725         printf ("%shpc", first ? "" : "|"), first = 0;
11726       if (mask & ELF_SPARC_HWCAP_RANDOM)
11727         printf ("%srandom", first ? "" : "|"), first = 0;
11728       if (mask & ELF_SPARC_HWCAP_TRANS)
11729         printf ("%strans", first ? "" : "|"), first = 0;
11730       if (mask & ELF_SPARC_HWCAP_FJFMAU)
11731         printf ("%sfjfmau", first ? "" : "|"), first = 0;
11732       if (mask & ELF_SPARC_HWCAP_IMA)
11733         printf ("%sima", first ? "" : "|"), first = 0;
11734       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11735         printf ("%scspare", first ? "" : "|"), first = 0;
11736     }
11737   else
11738     fputc('0', stdout);
11739   fputc('\n', stdout);
11740 }
11741
11742 static unsigned char *
11743 display_sparc_gnu_attribute (unsigned char * p,
11744                              int tag,
11745                              const unsigned char * const end)
11746 {
11747   if (tag == Tag_GNU_Sparc_HWCAPS)
11748     {
11749       unsigned int len;
11750       int val;
11751
11752       val = read_uleb128 (p, &len, end);
11753       p += len;
11754       printf ("  Tag_GNU_Sparc_HWCAPS: ");
11755       display_sparc_hwcaps (val);
11756       return p;
11757    }
11758
11759   return display_tag_value (tag, p, end);
11760 }
11761
11762 static unsigned char *
11763 display_mips_gnu_attribute (unsigned char * p,
11764                             int tag,
11765                             const unsigned char * const end)
11766 {
11767   if (tag == Tag_GNU_MIPS_ABI_FP)
11768     {
11769       unsigned int len;
11770       int val;
11771
11772       val = read_uleb128 (p, &len, end);
11773       p += len;
11774       printf ("  Tag_GNU_MIPS_ABI_FP: ");
11775
11776       switch (val)
11777         {
11778         case Val_GNU_MIPS_ABI_FP_ANY:
11779           printf (_("Hard or soft float\n"));
11780           break;
11781         case Val_GNU_MIPS_ABI_FP_DOUBLE:
11782           printf (_("Hard float (double precision)\n"));
11783           break;
11784         case Val_GNU_MIPS_ABI_FP_SINGLE:
11785           printf (_("Hard float (single precision)\n"));
11786           break;
11787         case Val_GNU_MIPS_ABI_FP_SOFT:
11788           printf (_("Soft float\n"));
11789           break;
11790         case Val_GNU_MIPS_ABI_FP_64:
11791           printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
11792           break;
11793         default:
11794           printf ("??? (%d)\n", val);
11795           break;
11796         }
11797       return p;
11798    }
11799
11800   if (tag == Tag_GNU_MIPS_ABI_MSA)
11801     {
11802       unsigned int len;
11803       int val;
11804
11805       val = read_uleb128 (p, &len, end);
11806       p += len;
11807       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
11808
11809       switch (val)
11810         {
11811         case Val_GNU_MIPS_ABI_MSA_ANY:
11812           printf (_("Any MSA or not\n"));
11813           break;
11814         case Val_GNU_MIPS_ABI_MSA_128:
11815           printf (_("128-bit MSA\n"));
11816           break;
11817         default:
11818           printf ("??? (%d)\n", val);
11819           break;
11820         }
11821       return p;
11822     }
11823
11824   return display_tag_value (tag & 1, p, end);
11825 }
11826
11827 static unsigned char *
11828 display_tic6x_attribute (unsigned char * p,
11829                          const unsigned char * const end)
11830 {
11831   int tag;
11832   unsigned int len;
11833   int val;
11834
11835   tag = read_uleb128 (p, &len, end);
11836   p += len;
11837
11838   switch (tag)
11839     {
11840     case Tag_ISA:
11841       val = read_uleb128 (p, &len, end);
11842       p += len;
11843       printf ("  Tag_ISA: ");
11844
11845       switch (val)
11846         {
11847         case C6XABI_Tag_ISA_none:
11848           printf (_("None\n"));
11849           break;
11850         case C6XABI_Tag_ISA_C62X:
11851           printf ("C62x\n");
11852           break;
11853         case C6XABI_Tag_ISA_C67X:
11854           printf ("C67x\n");
11855           break;
11856         case C6XABI_Tag_ISA_C67XP:
11857           printf ("C67x+\n");
11858           break;
11859         case C6XABI_Tag_ISA_C64X:
11860           printf ("C64x\n");
11861           break;
11862         case C6XABI_Tag_ISA_C64XP:
11863           printf ("C64x+\n");
11864           break;
11865         case C6XABI_Tag_ISA_C674X:
11866           printf ("C674x\n");
11867           break;
11868         default:
11869           printf ("??? (%d)\n", val);
11870           break;
11871         }
11872       return p;
11873
11874     case Tag_ABI_wchar_t:
11875       val = read_uleb128 (p, &len, end);
11876       p += len;
11877       printf ("  Tag_ABI_wchar_t: ");
11878       switch (val)
11879         {
11880         case 0:
11881           printf (_("Not used\n"));
11882           break;
11883         case 1:
11884           printf (_("2 bytes\n"));
11885           break;
11886         case 2:
11887           printf (_("4 bytes\n"));
11888           break;
11889         default:
11890           printf ("??? (%d)\n", val);
11891           break;
11892         }
11893       return p;
11894
11895     case Tag_ABI_stack_align_needed:
11896       val = read_uleb128 (p, &len, end);
11897       p += len;
11898       printf ("  Tag_ABI_stack_align_needed: ");
11899       switch (val)
11900         {
11901         case 0:
11902           printf (_("8-byte\n"));
11903           break;
11904         case 1:
11905           printf (_("16-byte\n"));
11906           break;
11907         default:
11908           printf ("??? (%d)\n", val);
11909           break;
11910         }
11911       return p;
11912
11913     case Tag_ABI_stack_align_preserved:
11914       val = read_uleb128 (p, &len, end);
11915       p += len;
11916       printf ("  Tag_ABI_stack_align_preserved: ");
11917       switch (val)
11918         {
11919         case 0:
11920           printf (_("8-byte\n"));
11921           break;
11922         case 1:
11923           printf (_("16-byte\n"));
11924           break;
11925         default:
11926           printf ("??? (%d)\n", val);
11927           break;
11928         }
11929       return p;
11930
11931     case Tag_ABI_DSBT:
11932       val = read_uleb128 (p, &len, end);
11933       p += len;
11934       printf ("  Tag_ABI_DSBT: ");
11935       switch (val)
11936         {
11937         case 0:
11938           printf (_("DSBT addressing not used\n"));
11939           break;
11940         case 1:
11941           printf (_("DSBT addressing used\n"));
11942           break;
11943         default:
11944           printf ("??? (%d)\n", val);
11945           break;
11946         }
11947       return p;
11948
11949     case Tag_ABI_PID:
11950       val = read_uleb128 (p, &len, end);
11951       p += len;
11952       printf ("  Tag_ABI_PID: ");
11953       switch (val)
11954         {
11955         case 0:
11956           printf (_("Data addressing position-dependent\n"));
11957           break;
11958         case 1:
11959           printf (_("Data addressing position-independent, GOT near DP\n"));
11960           break;
11961         case 2:
11962           printf (_("Data addressing position-independent, GOT far from DP\n"));
11963           break;
11964         default:
11965           printf ("??? (%d)\n", val);
11966           break;
11967         }
11968       return p;
11969
11970     case Tag_ABI_PIC:
11971       val = read_uleb128 (p, &len, end);
11972       p += len;
11973       printf ("  Tag_ABI_PIC: ");
11974       switch (val)
11975         {
11976         case 0:
11977           printf (_("Code addressing position-dependent\n"));
11978           break;
11979         case 1:
11980           printf (_("Code addressing position-independent\n"));
11981           break;
11982         default:
11983           printf ("??? (%d)\n", val);
11984           break;
11985         }
11986       return p;
11987
11988     case Tag_ABI_array_object_alignment:
11989       val = read_uleb128 (p, &len, end);
11990       p += len;
11991       printf ("  Tag_ABI_array_object_alignment: ");
11992       switch (val)
11993         {
11994         case 0:
11995           printf (_("8-byte\n"));
11996           break;
11997         case 1:
11998           printf (_("4-byte\n"));
11999           break;
12000         case 2:
12001           printf (_("16-byte\n"));
12002           break;
12003         default:
12004           printf ("??? (%d)\n", val);
12005           break;
12006         }
12007       return p;
12008
12009     case Tag_ABI_array_object_align_expected:
12010       val = read_uleb128 (p, &len, end);
12011       p += len;
12012       printf ("  Tag_ABI_array_object_align_expected: ");
12013       switch (val)
12014         {
12015         case 0:
12016           printf (_("8-byte\n"));
12017           break;
12018         case 1:
12019           printf (_("4-byte\n"));
12020           break;
12021         case 2:
12022           printf (_("16-byte\n"));
12023           break;
12024         default:
12025           printf ("??? (%d)\n", val);
12026           break;
12027         }
12028       return p;
12029
12030     case Tag_ABI_compatibility:
12031       val = read_uleb128 (p, &len, end);
12032       p += len;
12033       printf ("  Tag_ABI_compatibility: ");
12034       printf (_("flag = %d, vendor = %s\n"), val, p);
12035       p += strlen ((char *) p) + 1;
12036       return p;
12037
12038     case Tag_ABI_conformance:
12039       printf ("  Tag_ABI_conformance: ");
12040       printf ("\"%s\"\n", p);
12041       p += strlen ((char *) p) + 1;
12042       return p;
12043     }
12044
12045   return display_tag_value (tag, p, end);
12046 }
12047
12048 static void
12049 display_raw_attribute (unsigned char * p, unsigned char * end)
12050 {
12051   unsigned long addr = 0;
12052   size_t bytes = end - p;
12053
12054   while (bytes)
12055     {
12056       int j;
12057       int k;
12058       int lbytes = (bytes > 16 ? 16 : bytes);
12059
12060       printf ("  0x%8.8lx ", addr);
12061
12062       for (j = 0; j < 16; j++)
12063         {
12064           if (j < lbytes)
12065             printf ("%2.2x", p[j]);
12066           else
12067             printf ("  ");
12068
12069           if ((j & 3) == 3)
12070             printf (" ");
12071         }
12072
12073       for (j = 0; j < lbytes; j++)
12074         {
12075           k = p[j];
12076           if (k >= ' ' && k < 0x7f)
12077             printf ("%c", k);
12078           else
12079             printf (".");
12080         }
12081
12082       putchar ('\n');
12083
12084       p  += lbytes;
12085       bytes -= lbytes;
12086       addr += lbytes;
12087     }
12088
12089   putchar ('\n');
12090 }
12091
12092 static unsigned char *
12093 display_msp430x_attribute (unsigned char * p,
12094                            const unsigned char * const end)
12095 {
12096   unsigned int len;
12097   int val;
12098   int tag;
12099
12100   tag = read_uleb128 (p, & len, end);
12101   p += len;
12102
12103   switch (tag)
12104     {
12105     case OFBA_MSPABI_Tag_ISA:
12106       val = read_uleb128 (p, &len, end);
12107       p += len;
12108       printf ("  Tag_ISA: ");
12109       switch (val)
12110         {
12111         case 0: printf (_("None\n")); break;
12112         case 1: printf (_("MSP430\n")); break;
12113         case 2: printf (_("MSP430X\n")); break;
12114         default: printf ("??? (%d)\n", val); break;
12115         }
12116       break;
12117
12118     case OFBA_MSPABI_Tag_Code_Model:
12119       val = read_uleb128 (p, &len, end);
12120       p += len;
12121       printf ("  Tag_Code_Model: ");
12122       switch (val)
12123         {
12124         case 0: printf (_("None\n")); break;
12125         case 1: printf (_("Small\n")); break;
12126         case 2: printf (_("Large\n")); break;
12127         default: printf ("??? (%d)\n", val); break;
12128         }
12129       break;
12130
12131     case OFBA_MSPABI_Tag_Data_Model:
12132       val = read_uleb128 (p, &len, end);
12133       p += len;
12134       printf ("  Tag_Data_Model: ");
12135       switch (val)
12136         {
12137         case 0: printf (_("None\n")); break;
12138         case 1: printf (_("Small\n")); break;
12139         case 2: printf (_("Large\n")); break;
12140         case 3: printf (_("Restricted Large\n")); break;
12141         default: printf ("??? (%d)\n", val); break;
12142         }
12143       break;
12144
12145     default:
12146       printf (_("  <unknown tag %d>: "), tag);
12147
12148       if (tag & 1)
12149         {
12150           printf ("\"%s\"\n", p);
12151           p += strlen ((char *) p) + 1;
12152         }
12153       else
12154         {
12155           val = read_uleb128 (p, &len, end);
12156           p += len;
12157           printf ("%d (0x%x)\n", val, val);
12158         }
12159       break;
12160    }
12161
12162   return p;
12163 }
12164
12165 static int
12166 process_attributes (FILE * file,
12167                     const char * public_name,
12168                     unsigned int proc_type,
12169                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
12170                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
12171 {
12172   Elf_Internal_Shdr * sect;
12173   unsigned char * contents;
12174   unsigned char * p;
12175   unsigned char * end;
12176   bfd_vma section_len;
12177   bfd_vma len;
12178   unsigned i;
12179
12180   /* Find the section header so that we get the size.  */
12181   for (i = 0, sect = section_headers;
12182        i < elf_header.e_shnum;
12183        i++, sect++)
12184     {
12185       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
12186         continue;
12187
12188       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
12189                                              sect->sh_size, _("attributes"));
12190       if (contents == NULL)
12191         continue;
12192
12193       p = contents;
12194       if (*p == 'A')
12195         {
12196           len = sect->sh_size - 1;
12197           p++;
12198
12199           while (len > 0)
12200             {
12201               int namelen;
12202               bfd_boolean public_section;
12203               bfd_boolean gnu_section;
12204
12205               section_len = byte_get (p, 4);
12206               p += 4;
12207
12208               if (section_len > len)
12209                 {
12210                   printf (_("ERROR: Bad section length (%d > %d)\n"),
12211                           (int) section_len, (int) len);
12212                   section_len = len;
12213                 }
12214
12215               len -= section_len;
12216               printf (_("Attribute Section: %s\n"), p);
12217
12218               if (public_name && streq ((char *) p, public_name))
12219                 public_section = TRUE;
12220               else
12221                 public_section = FALSE;
12222
12223               if (streq ((char *) p, "gnu"))
12224                 gnu_section = TRUE;
12225               else
12226                 gnu_section = FALSE;
12227
12228               namelen = strlen ((char *) p) + 1;
12229               p += namelen;
12230               section_len -= namelen + 4;
12231
12232               while (section_len > 0)
12233                 {
12234                   int tag = *(p++);
12235                   int val;
12236                   bfd_vma size;
12237
12238                   size = byte_get (p, 4);
12239                   if (size > section_len)
12240                     {
12241                       printf (_("ERROR: Bad subsection length (%d > %d)\n"),
12242                               (int) size, (int) section_len);
12243                       size = section_len;
12244                     }
12245
12246                   section_len -= size;
12247                   end = p + size - 1;
12248                   p += 4;
12249
12250                   switch (tag)
12251                     {
12252                     case 1:
12253                       printf (_("File Attributes\n"));
12254                       break;
12255                     case 2:
12256                       printf (_("Section Attributes:"));
12257                       goto do_numlist;
12258                     case 3:
12259                       printf (_("Symbol Attributes:"));
12260                     do_numlist:
12261                       for (;;)
12262                         {
12263                           unsigned int j;
12264
12265                           val = read_uleb128 (p, &j, end);
12266                           p += j;
12267                           if (val == 0)
12268                             break;
12269                           printf (" %d", val);
12270                         }
12271                       printf ("\n");
12272                       break;
12273                     default:
12274                       printf (_("Unknown tag: %d\n"), tag);
12275                       public_section = FALSE;
12276                       break;
12277                     }
12278
12279                   if (public_section)
12280                     {
12281                       while (p < end)
12282                         p = display_pub_attribute (p, end);
12283                     }
12284                   else if (gnu_section)
12285                     {
12286                       while (p < end)
12287                         p = display_gnu_attribute (p,
12288                                                    display_proc_gnu_attribute,
12289                                                    end);
12290                     }
12291                   else
12292                     {
12293                       printf (_("  Unknown section contexts\n"));
12294                       display_raw_attribute (p, end);
12295                       p = end;
12296                     }
12297                 }
12298             }
12299         }
12300       else
12301         printf (_("Unknown format '%c'\n"), *p);
12302
12303       free (contents);
12304     }
12305   return 1;
12306 }
12307
12308 static int
12309 process_arm_specific (FILE * file)
12310 {
12311   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
12312                              display_arm_attribute, NULL);
12313 }
12314
12315 static int
12316 process_power_specific (FILE * file)
12317 {
12318   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12319                              display_power_gnu_attribute);
12320 }
12321
12322 static int
12323 process_sparc_specific (FILE * file)
12324 {
12325   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12326                              display_sparc_gnu_attribute);
12327 }
12328
12329 static int
12330 process_tic6x_specific (FILE * file)
12331 {
12332   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
12333                              display_tic6x_attribute, NULL);
12334 }
12335
12336 static int
12337 process_msp430x_specific (FILE * file)
12338 {
12339   return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
12340                              display_msp430x_attribute, NULL);
12341 }
12342
12343 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12344    Print the Address, Access and Initial fields of an entry at VMA ADDR
12345    and return the VMA of the next entry.  */
12346
12347 static bfd_vma
12348 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12349 {
12350   printf ("  ");
12351   print_vma (addr, LONG_HEX);
12352   printf (" ");
12353   if (addr < pltgot + 0xfff0)
12354     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
12355   else
12356     printf ("%10s", "");
12357   printf (" ");
12358   if (data == NULL)
12359     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12360   else
12361     {
12362       bfd_vma entry;
12363
12364       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12365       print_vma (entry, LONG_HEX);
12366     }
12367   return addr + (is_32bit_elf ? 4 : 8);
12368 }
12369
12370 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12371    PLTGOT.  Print the Address and Initial fields of an entry at VMA
12372    ADDR and return the VMA of the next entry.  */
12373
12374 static bfd_vma
12375 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12376 {
12377   printf ("  ");
12378   print_vma (addr, LONG_HEX);
12379   printf (" ");
12380   if (data == NULL)
12381     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12382   else
12383     {
12384       bfd_vma entry;
12385
12386       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12387       print_vma (entry, LONG_HEX);
12388     }
12389   return addr + (is_32bit_elf ? 4 : 8);
12390 }
12391
12392 static int
12393 process_mips_specific (FILE * file)
12394 {
12395   Elf_Internal_Dyn * entry;
12396   size_t liblist_offset = 0;
12397   size_t liblistno = 0;
12398   size_t conflictsno = 0;
12399   size_t options_offset = 0;
12400   size_t conflicts_offset = 0;
12401   size_t pltrelsz = 0;
12402   size_t pltrel = 0;
12403   bfd_vma pltgot = 0;
12404   bfd_vma mips_pltgot = 0;
12405   bfd_vma jmprel = 0;
12406   bfd_vma local_gotno = 0;
12407   bfd_vma gotsym = 0;
12408   bfd_vma symtabno = 0;
12409
12410   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12411                       display_mips_gnu_attribute);
12412
12413   /* We have a lot of special sections.  Thanks SGI!  */
12414   if (dynamic_section == NULL)
12415     /* No information available.  */
12416     return 0;
12417
12418   for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
12419     switch (entry->d_tag)
12420       {
12421       case DT_MIPS_LIBLIST:
12422         liblist_offset
12423           = offset_from_vma (file, entry->d_un.d_val,
12424                              liblistno * sizeof (Elf32_External_Lib));
12425         break;
12426       case DT_MIPS_LIBLISTNO:
12427         liblistno = entry->d_un.d_val;
12428         break;
12429       case DT_MIPS_OPTIONS:
12430         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
12431         break;
12432       case DT_MIPS_CONFLICT:
12433         conflicts_offset
12434           = offset_from_vma (file, entry->d_un.d_val,
12435                              conflictsno * sizeof (Elf32_External_Conflict));
12436         break;
12437       case DT_MIPS_CONFLICTNO:
12438         conflictsno = entry->d_un.d_val;
12439         break;
12440       case DT_PLTGOT:
12441         pltgot = entry->d_un.d_ptr;
12442         break;
12443       case DT_MIPS_LOCAL_GOTNO:
12444         local_gotno = entry->d_un.d_val;
12445         break;
12446       case DT_MIPS_GOTSYM:
12447         gotsym = entry->d_un.d_val;
12448         break;
12449       case DT_MIPS_SYMTABNO:
12450         symtabno = entry->d_un.d_val;
12451         break;
12452       case DT_MIPS_PLTGOT:
12453         mips_pltgot = entry->d_un.d_ptr;
12454         break;
12455       case DT_PLTREL:
12456         pltrel = entry->d_un.d_val;
12457         break;
12458       case DT_PLTRELSZ:
12459         pltrelsz = entry->d_un.d_val;
12460         break;
12461       case DT_JMPREL:
12462         jmprel = entry->d_un.d_ptr;
12463         break;
12464       default:
12465         break;
12466       }
12467
12468   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
12469     {
12470       Elf32_External_Lib * elib;
12471       size_t cnt;
12472
12473       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
12474                                               liblistno,
12475                                               sizeof (Elf32_External_Lib),
12476                                               _("liblist section data"));
12477       if (elib)
12478         {
12479           printf (_("\nSection '.liblist' contains %lu entries:\n"),
12480                   (unsigned long) liblistno);
12481           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
12482                  stdout);
12483
12484           for (cnt = 0; cnt < liblistno; ++cnt)
12485             {
12486               Elf32_Lib liblist;
12487               time_t atime;
12488               char timebuf[20];
12489               struct tm * tmp;
12490
12491               liblist.l_name = BYTE_GET (elib[cnt].l_name);
12492               atime = BYTE_GET (elib[cnt].l_time_stamp);
12493               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12494               liblist.l_version = BYTE_GET (elib[cnt].l_version);
12495               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12496
12497               tmp = gmtime (&atime);
12498               snprintf (timebuf, sizeof (timebuf),
12499                         "%04u-%02u-%02uT%02u:%02u:%02u",
12500                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12501                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12502
12503               printf ("%3lu: ", (unsigned long) cnt);
12504               if (VALID_DYNAMIC_NAME (liblist.l_name))
12505                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
12506               else
12507                 printf (_("<corrupt: %9ld>"), liblist.l_name);
12508               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
12509                       liblist.l_version);
12510
12511               if (liblist.l_flags == 0)
12512                 puts (_(" NONE"));
12513               else
12514                 {
12515                   static const struct
12516                   {
12517                     const char * name;
12518                     int bit;
12519                   }
12520                   l_flags_vals[] =
12521                   {
12522                     { " EXACT_MATCH", LL_EXACT_MATCH },
12523                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
12524                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
12525                     { " EXPORTS", LL_EXPORTS },
12526                     { " DELAY_LOAD", LL_DELAY_LOAD },
12527                     { " DELTA", LL_DELTA }
12528                   };
12529                   int flags = liblist.l_flags;
12530                   size_t fcnt;
12531
12532                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
12533                     if ((flags & l_flags_vals[fcnt].bit) != 0)
12534                       {
12535                         fputs (l_flags_vals[fcnt].name, stdout);
12536                         flags ^= l_flags_vals[fcnt].bit;
12537                       }
12538                   if (flags != 0)
12539                     printf (" %#x", (unsigned int) flags);
12540
12541                   puts ("");
12542                 }
12543             }
12544
12545           free (elib);
12546         }
12547     }
12548
12549   if (options_offset != 0)
12550     {
12551       Elf_External_Options * eopt;
12552       Elf_Internal_Shdr * sect = section_headers;
12553       Elf_Internal_Options * iopt;
12554       Elf_Internal_Options * option;
12555       size_t offset;
12556       int cnt;
12557
12558       /* Find the section header so that we get the size.  */
12559       while (sect->sh_type != SHT_MIPS_OPTIONS)
12560         ++sect;
12561
12562       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
12563                                                 sect->sh_size, _("options"));
12564       if (eopt)
12565         {
12566           iopt = (Elf_Internal_Options *)
12567               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
12568           if (iopt == NULL)
12569             {
12570               error (_("Out of memory\n"));
12571               return 0;
12572             }
12573
12574           offset = cnt = 0;
12575           option = iopt;
12576
12577           while (offset < sect->sh_size)
12578             {
12579               Elf_External_Options * eoption;
12580
12581               eoption = (Elf_External_Options *) ((char *) eopt + offset);
12582
12583               option->kind = BYTE_GET (eoption->kind);
12584               option->size = BYTE_GET (eoption->size);
12585               option->section = BYTE_GET (eoption->section);
12586               option->info = BYTE_GET (eoption->info);
12587
12588               offset += option->size;
12589
12590               ++option;
12591               ++cnt;
12592             }
12593
12594           printf (_("\nSection '%s' contains %d entries:\n"),
12595                   SECTION_NAME (sect), cnt);
12596
12597           option = iopt;
12598
12599           while (cnt-- > 0)
12600             {
12601               size_t len;
12602
12603               switch (option->kind)
12604                 {
12605                 case ODK_NULL:
12606                   /* This shouldn't happen.  */
12607                   printf (" NULL       %d %lx", option->section, option->info);
12608                   break;
12609                 case ODK_REGINFO:
12610                   printf (" REGINFO    ");
12611                   if (elf_header.e_machine == EM_MIPS)
12612                     {
12613                       /* 32bit form.  */
12614                       Elf32_External_RegInfo * ereg;
12615                       Elf32_RegInfo reginfo;
12616
12617                       ereg = (Elf32_External_RegInfo *) (option + 1);
12618                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12619                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12620                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12621                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12622                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12623                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12624
12625                       printf ("GPR %08lx  GP 0x%lx\n",
12626                               reginfo.ri_gprmask,
12627                               (unsigned long) reginfo.ri_gp_value);
12628                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
12629                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12630                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12631                     }
12632                   else
12633                     {
12634                       /* 64 bit form.  */
12635                       Elf64_External_RegInfo * ereg;
12636                       Elf64_Internal_RegInfo reginfo;
12637
12638                       ereg = (Elf64_External_RegInfo *) (option + 1);
12639                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
12640                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12641                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12642                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12643                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12644                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
12645
12646                       printf ("GPR %08lx  GP 0x",
12647                               reginfo.ri_gprmask);
12648                       printf_vma (reginfo.ri_gp_value);
12649                       printf ("\n");
12650
12651                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
12652                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12653                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12654                     }
12655                   ++option;
12656                   continue;
12657                 case ODK_EXCEPTIONS:
12658                   fputs (" EXCEPTIONS fpe_min(", stdout);
12659                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12660                   fputs (") fpe_max(", stdout);
12661                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12662                   fputs (")", stdout);
12663
12664                   if (option->info & OEX_PAGE0)
12665                     fputs (" PAGE0", stdout);
12666                   if (option->info & OEX_SMM)
12667                     fputs (" SMM", stdout);
12668                   if (option->info & OEX_FPDBUG)
12669                     fputs (" FPDBUG", stdout);
12670                   if (option->info & OEX_DISMISS)
12671                     fputs (" DISMISS", stdout);
12672                   break;
12673                 case ODK_PAD:
12674                   fputs (" PAD       ", stdout);
12675                   if (option->info & OPAD_PREFIX)
12676                     fputs (" PREFIX", stdout);
12677                   if (option->info & OPAD_POSTFIX)
12678                     fputs (" POSTFIX", stdout);
12679                   if (option->info & OPAD_SYMBOL)
12680                     fputs (" SYMBOL", stdout);
12681                   break;
12682                 case ODK_HWPATCH:
12683                   fputs (" HWPATCH   ", stdout);
12684                   if (option->info & OHW_R4KEOP)
12685                     fputs (" R4KEOP", stdout);
12686                   if (option->info & OHW_R8KPFETCH)
12687                     fputs (" R8KPFETCH", stdout);
12688                   if (option->info & OHW_R5KEOP)
12689                     fputs (" R5KEOP", stdout);
12690                   if (option->info & OHW_R5KCVTL)
12691                     fputs (" R5KCVTL", stdout);
12692                   break;
12693                 case ODK_FILL:
12694                   fputs (" FILL       ", stdout);
12695                   /* XXX Print content of info word?  */
12696                   break;
12697                 case ODK_TAGS:
12698                   fputs (" TAGS       ", stdout);
12699                   /* XXX Print content of info word?  */
12700                   break;
12701                 case ODK_HWAND:
12702                   fputs (" HWAND     ", stdout);
12703                   if (option->info & OHWA0_R4KEOP_CHECKED)
12704                     fputs (" R4KEOP_CHECKED", stdout);
12705                   if (option->info & OHWA0_R4KEOP_CLEAN)
12706                     fputs (" R4KEOP_CLEAN", stdout);
12707                   break;
12708                 case ODK_HWOR:
12709                   fputs (" HWOR      ", stdout);
12710                   if (option->info & OHWA0_R4KEOP_CHECKED)
12711                     fputs (" R4KEOP_CHECKED", stdout);
12712                   if (option->info & OHWA0_R4KEOP_CLEAN)
12713                     fputs (" R4KEOP_CLEAN", stdout);
12714                   break;
12715                 case ODK_GP_GROUP:
12716                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
12717                           option->info & OGP_GROUP,
12718                           (option->info & OGP_SELF) >> 16);
12719                   break;
12720                 case ODK_IDENT:
12721                   printf (" IDENT     %#06lx  self-contained %#06lx",
12722                           option->info & OGP_GROUP,
12723                           (option->info & OGP_SELF) >> 16);
12724                   break;
12725                 default:
12726                   /* This shouldn't happen.  */
12727                   printf (" %3d ???     %d %lx",
12728                           option->kind, option->section, option->info);
12729                   break;
12730                 }
12731
12732               len = sizeof (* eopt);
12733               while (len < option->size)
12734                 if (((char *) option)[len] >= ' '
12735                     && ((char *) option)[len] < 0x7f)
12736                   printf ("%c", ((char *) option)[len++]);
12737                 else
12738                   printf ("\\%03o", ((char *) option)[len++]);
12739
12740               fputs ("\n", stdout);
12741               ++option;
12742             }
12743
12744           free (eopt);
12745         }
12746     }
12747
12748   if (conflicts_offset != 0 && conflictsno != 0)
12749     {
12750       Elf32_Conflict * iconf;
12751       size_t cnt;
12752
12753       if (dynamic_symbols == NULL)
12754         {
12755           error (_("conflict list found without a dynamic symbol table\n"));
12756           return 0;
12757         }
12758
12759       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
12760       if (iconf == NULL)
12761         {
12762           error (_("Out of memory\n"));
12763           return 0;
12764         }
12765
12766       if (is_32bit_elf)
12767         {
12768           Elf32_External_Conflict * econf32;
12769
12770           econf32 = (Elf32_External_Conflict *)
12771               get_data (NULL, file, conflicts_offset, conflictsno,
12772                         sizeof (* econf32), _("conflict"));
12773           if (!econf32)
12774             return 0;
12775
12776           for (cnt = 0; cnt < conflictsno; ++cnt)
12777             iconf[cnt] = BYTE_GET (econf32[cnt]);
12778
12779           free (econf32);
12780         }
12781       else
12782         {
12783           Elf64_External_Conflict * econf64;
12784
12785           econf64 = (Elf64_External_Conflict *)
12786               get_data (NULL, file, conflicts_offset, conflictsno,
12787                         sizeof (* econf64), _("conflict"));
12788           if (!econf64)
12789             return 0;
12790
12791           for (cnt = 0; cnt < conflictsno; ++cnt)
12792             iconf[cnt] = BYTE_GET (econf64[cnt]);
12793
12794           free (econf64);
12795         }
12796
12797       printf (_("\nSection '.conflict' contains %lu entries:\n"),
12798               (unsigned long) conflictsno);
12799       puts (_("  Num:    Index       Value  Name"));
12800
12801       for (cnt = 0; cnt < conflictsno; ++cnt)
12802         {
12803           Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
12804
12805           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
12806           print_vma (psym->st_value, FULL_HEX);
12807           putchar (' ');
12808           if (VALID_DYNAMIC_NAME (psym->st_name))
12809             print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
12810           else
12811             printf (_("<corrupt: %14ld>"), psym->st_name);
12812           putchar ('\n');
12813         }
12814
12815       free (iconf);
12816     }
12817
12818   if (pltgot != 0 && local_gotno != 0)
12819     {
12820       bfd_vma ent, local_end, global_end;
12821       size_t i, offset;
12822       unsigned char * data;
12823       int addr_size;
12824
12825       ent = pltgot;
12826       addr_size = (is_32bit_elf ? 4 : 8);
12827       local_end = pltgot + local_gotno * addr_size;
12828       global_end = local_end + (symtabno - gotsym) * addr_size;
12829
12830       offset = offset_from_vma (file, pltgot, global_end - pltgot);
12831       data = (unsigned char *) get_data (NULL, file, offset,
12832                                          global_end - pltgot, 1,
12833                                          _("Global Offset Table data"));
12834       if (data == NULL)
12835         return 0;
12836
12837       printf (_("\nPrimary GOT:\n"));
12838       printf (_(" Canonical gp value: "));
12839       print_vma (pltgot + 0x7ff0, LONG_HEX);
12840       printf ("\n\n");
12841
12842       printf (_(" Reserved entries:\n"));
12843       printf (_("  %*s %10s %*s Purpose\n"),
12844               addr_size * 2, _("Address"), _("Access"),
12845               addr_size * 2, _("Initial"));
12846       ent = print_mips_got_entry (data, pltgot, ent);
12847       printf (_(" Lazy resolver\n"));
12848       if (data
12849           && (byte_get (data + ent - pltgot, addr_size)
12850               >> (addr_size * 8 - 1)) != 0)
12851         {
12852           ent = print_mips_got_entry (data, pltgot, ent);
12853           printf (_(" Module pointer (GNU extension)\n"));
12854         }
12855       printf ("\n");
12856
12857       if (ent < local_end)
12858         {
12859           printf (_(" Local entries:\n"));
12860           printf ("  %*s %10s %*s\n",
12861                   addr_size * 2, _("Address"), _("Access"),
12862                   addr_size * 2, _("Initial"));
12863           while (ent < local_end)
12864             {
12865               ent = print_mips_got_entry (data, pltgot, ent);
12866               printf ("\n");
12867             }
12868           printf ("\n");
12869         }
12870
12871       if (gotsym < symtabno)
12872         {
12873           int sym_width;
12874
12875           printf (_(" Global entries:\n"));
12876           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
12877                   addr_size * 2, _("Address"),
12878                   _("Access"),
12879                   addr_size * 2, _("Initial"),
12880                   addr_size * 2, _("Sym.Val."),
12881                   _("Type"),
12882                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
12883                   _("Ndx"), _("Name"));
12884
12885           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12886           for (i = gotsym; i < symtabno; i++)
12887             {
12888               Elf_Internal_Sym * psym;
12889
12890               psym = dynamic_symbols + i;
12891               ent = print_mips_got_entry (data, pltgot, ent);
12892               printf (" ");
12893               print_vma (psym->st_value, LONG_HEX);
12894               printf (" %-7s %3s ",
12895                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12896                       get_symbol_index_type (psym->st_shndx));
12897               if (VALID_DYNAMIC_NAME (psym->st_name))
12898                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12899               else
12900                 printf (_("<corrupt: %14ld>"), psym->st_name);
12901               printf ("\n");
12902             }
12903           printf ("\n");
12904         }
12905
12906       if (data)
12907         free (data);
12908     }
12909
12910   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12911     {
12912       bfd_vma ent, end;
12913       size_t offset, rel_offset;
12914       unsigned long count, i;
12915       unsigned char * data;
12916       int addr_size, sym_width;
12917       Elf_Internal_Rela * rels;
12918
12919       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12920       if (pltrel == DT_RELA)
12921         {
12922           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12923             return 0;
12924         }
12925       else
12926         {
12927           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12928             return 0;
12929         }
12930
12931       ent = mips_pltgot;
12932       addr_size = (is_32bit_elf ? 4 : 8);
12933       end = mips_pltgot + (2 + count) * addr_size;
12934
12935       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
12936       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
12937                                          1, _("Procedure Linkage Table data"));
12938       if (data == NULL)
12939         return 0;
12940
12941       printf ("\nPLT GOT:\n\n");
12942       printf (_(" Reserved entries:\n"));
12943       printf (_("  %*s %*s Purpose\n"),
12944               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
12945       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12946       printf (_(" PLT lazy resolver\n"));
12947       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12948       printf (_(" Module pointer\n"));
12949       printf ("\n");
12950
12951       printf (_(" Entries:\n"));
12952       printf ("  %*s %*s %*s %-7s %3s %s\n",
12953               addr_size * 2, _("Address"),
12954               addr_size * 2, _("Initial"),
12955               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12956       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12957       for (i = 0; i < count; i++)
12958         {
12959           Elf_Internal_Sym * psym;
12960
12961           psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
12962           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12963           printf (" ");
12964           print_vma (psym->st_value, LONG_HEX);
12965           printf (" %-7s %3s ",
12966                   get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12967                   get_symbol_index_type (psym->st_shndx));
12968           if (VALID_DYNAMIC_NAME (psym->st_name))
12969             print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12970           else
12971             printf (_("<corrupt: %14ld>"), psym->st_name);
12972           printf ("\n");
12973         }
12974       printf ("\n");
12975
12976       if (data)
12977         free (data);
12978       free (rels);
12979     }
12980
12981   return 1;
12982 }
12983
12984 static int
12985 process_gnu_liblist (FILE * file)
12986 {
12987   Elf_Internal_Shdr * section;
12988   Elf_Internal_Shdr * string_sec;
12989   Elf32_External_Lib * elib;
12990   char * strtab;
12991   size_t strtab_size;
12992   size_t cnt;
12993   unsigned i;
12994
12995   if (! do_arch)
12996     return 0;
12997
12998   for (i = 0, section = section_headers;
12999        i < elf_header.e_shnum;
13000        i++, section++)
13001     {
13002       switch (section->sh_type)
13003         {
13004         case SHT_GNU_LIBLIST:
13005           if (section->sh_link >= elf_header.e_shnum)
13006             break;
13007
13008           elib = (Elf32_External_Lib *)
13009               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
13010                         _("liblist section data"));
13011
13012           if (elib == NULL)
13013             break;
13014           string_sec = section_headers + section->sh_link;
13015
13016           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
13017                                       string_sec->sh_size,
13018                                       _("liblist string table"));
13019           if (strtab == NULL
13020               || section->sh_entsize != sizeof (Elf32_External_Lib))
13021             {
13022               free (elib);
13023               free (strtab);
13024               break;
13025             }
13026           strtab_size = string_sec->sh_size;
13027
13028           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
13029                   SECTION_NAME (section),
13030                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
13031
13032           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
13033
13034           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
13035                ++cnt)
13036             {
13037               Elf32_Lib liblist;
13038               time_t atime;
13039               char timebuf[20];
13040               struct tm * tmp;
13041
13042               liblist.l_name = BYTE_GET (elib[cnt].l_name);
13043               atime = BYTE_GET (elib[cnt].l_time_stamp);
13044               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13045               liblist.l_version = BYTE_GET (elib[cnt].l_version);
13046               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13047
13048               tmp = gmtime (&atime);
13049               snprintf (timebuf, sizeof (timebuf),
13050                         "%04u-%02u-%02uT%02u:%02u:%02u",
13051                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13052                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
13053
13054               printf ("%3lu: ", (unsigned long) cnt);
13055               if (do_wide)
13056                 printf ("%-20s", liblist.l_name < strtab_size
13057                         ? strtab + liblist.l_name : _("<corrupt>"));
13058               else
13059                 printf ("%-20.20s", liblist.l_name < strtab_size
13060                         ? strtab + liblist.l_name : _("<corrupt>"));
13061               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
13062                       liblist.l_version, liblist.l_flags);
13063             }
13064
13065           free (elib);
13066           free (strtab);
13067         }
13068     }
13069
13070   return 1;
13071 }
13072
13073 static const char *
13074 get_note_type (unsigned e_type)
13075 {
13076   static char buff[64];
13077
13078   if (elf_header.e_type == ET_CORE)
13079     switch (e_type)
13080       {
13081       case NT_AUXV:
13082         return _("NT_AUXV (auxiliary vector)");
13083       case NT_PRSTATUS:
13084         return _("NT_PRSTATUS (prstatus structure)");
13085       case NT_FPREGSET:
13086         return _("NT_FPREGSET (floating point registers)");
13087       case NT_PRPSINFO:
13088         return _("NT_PRPSINFO (prpsinfo structure)");
13089       case NT_TASKSTRUCT:
13090         return _("NT_TASKSTRUCT (task structure)");
13091       case NT_PRXFPREG:
13092         return _("NT_PRXFPREG (user_xfpregs structure)");
13093       case NT_PPC_VMX:
13094         return _("NT_PPC_VMX (ppc Altivec registers)");
13095       case NT_PPC_VSX:
13096         return _("NT_PPC_VSX (ppc VSX registers)");
13097       case NT_386_TLS:
13098         return _("NT_386_TLS (x86 TLS information)");
13099       case NT_386_IOPERM:
13100         return _("NT_386_IOPERM (x86 I/O permissions)");
13101       case NT_X86_XSTATE:
13102         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
13103       case NT_S390_HIGH_GPRS:
13104         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
13105       case NT_S390_TIMER:
13106         return _("NT_S390_TIMER (s390 timer register)");
13107       case NT_S390_TODCMP:
13108         return _("NT_S390_TODCMP (s390 TOD comparator register)");
13109       case NT_S390_TODPREG:
13110         return _("NT_S390_TODPREG (s390 TOD programmable register)");
13111       case NT_S390_CTRS:
13112         return _("NT_S390_CTRS (s390 control registers)");
13113       case NT_S390_PREFIX:
13114         return _("NT_S390_PREFIX (s390 prefix register)");
13115       case NT_S390_LAST_BREAK:
13116         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
13117       case NT_S390_SYSTEM_CALL:
13118         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
13119       case NT_S390_TDB:
13120         return _("NT_S390_TDB (s390 transaction diagnostic block)");
13121       case NT_ARM_VFP:
13122         return _("NT_ARM_VFP (arm VFP registers)");
13123       case NT_ARM_TLS:
13124         return _("NT_ARM_TLS (AArch TLS registers)");
13125       case NT_ARM_HW_BREAK:
13126         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
13127       case NT_ARM_HW_WATCH:
13128         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
13129       case NT_PSTATUS:
13130         return _("NT_PSTATUS (pstatus structure)");
13131       case NT_FPREGS:
13132         return _("NT_FPREGS (floating point registers)");
13133       case NT_PSINFO:
13134         return _("NT_PSINFO (psinfo structure)");
13135       case NT_LWPSTATUS:
13136         return _("NT_LWPSTATUS (lwpstatus_t structure)");
13137       case NT_LWPSINFO:
13138         return _("NT_LWPSINFO (lwpsinfo_t structure)");
13139       case NT_WIN32PSTATUS:
13140         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
13141       case NT_SIGINFO:
13142         return _("NT_SIGINFO (siginfo_t data)");
13143       case NT_FILE:
13144         return _("NT_FILE (mapped files)");
13145       default:
13146         break;
13147       }
13148   else
13149     switch (e_type)
13150       {
13151       case NT_VERSION:
13152         return _("NT_VERSION (version)");
13153       case NT_ARCH:
13154         return _("NT_ARCH (architecture)");
13155       default:
13156         break;
13157       }
13158
13159   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13160   return buff;
13161 }
13162
13163 static int
13164 print_core_note (Elf_Internal_Note *pnote)
13165 {
13166   unsigned int addr_size = is_32bit_elf ? 4 : 8;
13167   bfd_vma count, page_size;
13168   unsigned char *descdata, *filenames, *descend;
13169
13170   if (pnote->type != NT_FILE)
13171     return 1;
13172
13173 #ifndef BFD64
13174   if (!is_32bit_elf)
13175     {
13176       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
13177       /* Still "successful".  */
13178       return 1;
13179     }
13180 #endif
13181
13182   if (pnote->descsz < 2 * addr_size)
13183     {
13184       printf (_("    Malformed note - too short for header\n"));
13185       return 0;
13186     }
13187
13188   descdata = (unsigned char *) pnote->descdata;
13189   descend = descdata + pnote->descsz;
13190
13191   if (descdata[pnote->descsz - 1] != '\0')
13192     {
13193       printf (_("    Malformed note - does not end with \\0\n"));
13194       return 0;
13195     }
13196
13197   count = byte_get (descdata, addr_size);
13198   descdata += addr_size;
13199
13200   page_size = byte_get (descdata, addr_size);
13201   descdata += addr_size;
13202
13203   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
13204     {
13205       printf (_("    Malformed note - too short for supplied file count\n"));
13206       return 0;
13207     }
13208
13209   printf (_("    Page size: "));
13210   print_vma (page_size, DEC);
13211   printf ("\n");
13212
13213   printf (_("    %*s%*s%*s\n"),
13214           (int) (2 + 2 * addr_size), _("Start"),
13215           (int) (4 + 2 * addr_size), _("End"),
13216           (int) (4 + 2 * addr_size), _("Page Offset"));
13217   filenames = descdata + count * 3 * addr_size;
13218   while (--count > 0)
13219     {
13220       bfd_vma start, end, file_ofs;
13221
13222       if (filenames == descend)
13223         {
13224           printf (_("    Malformed note - filenames end too early\n"));
13225           return 0;
13226         }
13227
13228       start = byte_get (descdata, addr_size);
13229       descdata += addr_size;
13230       end = byte_get (descdata, addr_size);
13231       descdata += addr_size;
13232       file_ofs = byte_get (descdata, addr_size);
13233       descdata += addr_size;
13234
13235       printf ("    ");
13236       print_vma (start, FULL_HEX);
13237       printf ("  ");
13238       print_vma (end, FULL_HEX);
13239       printf ("  ");
13240       print_vma (file_ofs, FULL_HEX);
13241       printf ("\n        %s\n", filenames);
13242
13243       filenames += 1 + strlen ((char *) filenames);
13244     }
13245
13246   return 1;
13247 }
13248
13249 static const char *
13250 get_gnu_elf_note_type (unsigned e_type)
13251 {
13252   static char buff[64];
13253
13254   switch (e_type)
13255     {
13256     case NT_GNU_ABI_TAG:
13257       return _("NT_GNU_ABI_TAG (ABI version tag)");
13258     case NT_GNU_HWCAP:
13259       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
13260     case NT_GNU_BUILD_ID:
13261       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
13262     case NT_GNU_GOLD_VERSION:
13263       return _("NT_GNU_GOLD_VERSION (gold version)");
13264     default:
13265       break;
13266     }
13267
13268   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13269   return buff;
13270 }
13271
13272 static int
13273 print_gnu_note (Elf_Internal_Note *pnote)
13274 {
13275   switch (pnote->type)
13276     {
13277     case NT_GNU_BUILD_ID:
13278       {
13279         unsigned long i;
13280
13281         printf (_("    Build ID: "));
13282         for (i = 0; i < pnote->descsz; ++i)
13283           printf ("%02x", pnote->descdata[i] & 0xff);
13284         printf ("\n");
13285       }
13286       break;
13287
13288     case NT_GNU_ABI_TAG:
13289       {
13290         unsigned long os, major, minor, subminor;
13291         const char *osname;
13292
13293         os = byte_get ((unsigned char *) pnote->descdata, 4);
13294         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
13295         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
13296         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
13297
13298         switch (os)
13299           {
13300           case GNU_ABI_TAG_LINUX:
13301             osname = "Linux";
13302             break;
13303           case GNU_ABI_TAG_HURD:
13304             osname = "Hurd";
13305             break;
13306           case GNU_ABI_TAG_SOLARIS:
13307             osname = "Solaris";
13308             break;
13309           case GNU_ABI_TAG_FREEBSD:
13310             osname = "FreeBSD";
13311             break;
13312           case GNU_ABI_TAG_NETBSD:
13313             osname = "NetBSD";
13314             break;
13315           default:
13316             osname = "Unknown";
13317             break;
13318           }
13319
13320         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
13321                 major, minor, subminor);
13322       }
13323       break;
13324     }
13325
13326   return 1;
13327 }
13328
13329 static const char *
13330 get_netbsd_elfcore_note_type (unsigned e_type)
13331 {
13332   static char buff[64];
13333
13334   if (e_type == NT_NETBSDCORE_PROCINFO)
13335     {
13336       /* NetBSD core "procinfo" structure.  */
13337       return _("NetBSD procinfo structure");
13338     }
13339
13340   /* As of Jan 2002 there are no other machine-independent notes
13341      defined for NetBSD core files.  If the note type is less
13342      than the start of the machine-dependent note types, we don't
13343      understand it.  */
13344
13345   if (e_type < NT_NETBSDCORE_FIRSTMACH)
13346     {
13347       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13348       return buff;
13349     }
13350
13351   switch (elf_header.e_machine)
13352     {
13353     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13354        and PT_GETFPREGS == mach+2.  */
13355
13356     case EM_OLD_ALPHA:
13357     case EM_ALPHA:
13358     case EM_SPARC:
13359     case EM_SPARC32PLUS:
13360     case EM_SPARCV9:
13361       switch (e_type)
13362         {
13363         case NT_NETBSDCORE_FIRSTMACH + 0:
13364           return _("PT_GETREGS (reg structure)");
13365         case NT_NETBSDCORE_FIRSTMACH + 2:
13366           return _("PT_GETFPREGS (fpreg structure)");
13367         default:
13368           break;
13369         }
13370       break;
13371
13372     /* On all other arch's, PT_GETREGS == mach+1 and
13373        PT_GETFPREGS == mach+3.  */
13374     default:
13375       switch (e_type)
13376         {
13377         case NT_NETBSDCORE_FIRSTMACH + 1:
13378           return _("PT_GETREGS (reg structure)");
13379         case NT_NETBSDCORE_FIRSTMACH + 3:
13380           return _("PT_GETFPREGS (fpreg structure)");
13381         default:
13382           break;
13383         }
13384     }
13385
13386   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
13387             e_type - NT_NETBSDCORE_FIRSTMACH);
13388   return buff;
13389 }
13390
13391 static const char *
13392 get_stapsdt_note_type (unsigned e_type)
13393 {
13394   static char buff[64];
13395
13396   switch (e_type)
13397     {
13398     case NT_STAPSDT:
13399       return _("NT_STAPSDT (SystemTap probe descriptors)");
13400
13401     default:
13402       break;
13403     }
13404
13405   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13406   return buff;
13407 }
13408
13409 static int
13410 print_stapsdt_note (Elf_Internal_Note *pnote)
13411 {
13412   int addr_size = is_32bit_elf ? 4 : 8;
13413   char *data = pnote->descdata;
13414   char *data_end = pnote->descdata + pnote->descsz;
13415   bfd_vma pc, base_addr, semaphore;
13416   char *provider, *probe, *arg_fmt;
13417
13418   pc = byte_get ((unsigned char *) data, addr_size);
13419   data += addr_size;
13420   base_addr = byte_get ((unsigned char *) data, addr_size);
13421   data += addr_size;
13422   semaphore = byte_get ((unsigned char *) data, addr_size);
13423   data += addr_size;
13424
13425   provider = data;
13426   data += strlen (data) + 1;
13427   probe = data;
13428   data += strlen (data) + 1;
13429   arg_fmt = data;
13430   data += strlen (data) + 1;
13431
13432   printf (_("    Provider: %s\n"), provider);
13433   printf (_("    Name: %s\n"), probe);
13434   printf (_("    Location: "));
13435   print_vma (pc, FULL_HEX);
13436   printf (_(", Base: "));
13437   print_vma (base_addr, FULL_HEX);
13438   printf (_(", Semaphore: "));
13439   print_vma (semaphore, FULL_HEX);
13440   printf ("\n");
13441   printf (_("    Arguments: %s\n"), arg_fmt);
13442
13443   return data == data_end;
13444 }
13445
13446 static const char *
13447 get_ia64_vms_note_type (unsigned e_type)
13448 {
13449   static char buff[64];
13450
13451   switch (e_type)
13452     {
13453     case NT_VMS_MHD:
13454       return _("NT_VMS_MHD (module header)");
13455     case NT_VMS_LNM:
13456       return _("NT_VMS_LNM (language name)");
13457     case NT_VMS_SRC:
13458       return _("NT_VMS_SRC (source files)");
13459     case NT_VMS_TITLE:
13460       return "NT_VMS_TITLE";
13461     case NT_VMS_EIDC:
13462       return _("NT_VMS_EIDC (consistency check)");
13463     case NT_VMS_FPMODE:
13464       return _("NT_VMS_FPMODE (FP mode)");
13465     case NT_VMS_LINKTIME:
13466       return "NT_VMS_LINKTIME";
13467     case NT_VMS_IMGNAM:
13468       return _("NT_VMS_IMGNAM (image name)");
13469     case NT_VMS_IMGID:
13470       return _("NT_VMS_IMGID (image id)");
13471     case NT_VMS_LINKID:
13472       return _("NT_VMS_LINKID (link id)");
13473     case NT_VMS_IMGBID:
13474       return _("NT_VMS_IMGBID (build id)");
13475     case NT_VMS_GSTNAM:
13476       return _("NT_VMS_GSTNAM (sym table name)");
13477     case NT_VMS_ORIG_DYN:
13478       return "NT_VMS_ORIG_DYN";
13479     case NT_VMS_PATCHTIME:
13480       return "NT_VMS_PATCHTIME";
13481     default:
13482       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13483       return buff;
13484     }
13485 }
13486
13487 static int
13488 print_ia64_vms_note (Elf_Internal_Note * pnote)
13489 {
13490   switch (pnote->type)
13491     {
13492     case NT_VMS_MHD:
13493       if (pnote->descsz > 36)
13494         {
13495           size_t l = strlen (pnote->descdata + 34);
13496           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
13497           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
13498           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
13499           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
13500         }
13501       else
13502         printf (_("    Invalid size\n"));
13503       break;
13504     case NT_VMS_LNM:
13505       printf (_("   Language: %s\n"), pnote->descdata);
13506       break;
13507 #ifdef BFD64
13508     case NT_VMS_FPMODE:
13509       printf (_("   Floating Point mode: "));
13510       printf ("0x%016" BFD_VMA_FMT "x\n",
13511               (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
13512       break;
13513     case NT_VMS_LINKTIME:
13514       printf (_("   Link time: "));
13515       print_vms_time
13516         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13517       printf ("\n");
13518       break;
13519     case NT_VMS_PATCHTIME:
13520       printf (_("   Patch time: "));
13521       print_vms_time
13522         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13523       printf ("\n");
13524       break;
13525     case NT_VMS_ORIG_DYN:
13526       printf (_("   Major id: %u,  minor id: %u\n"),
13527               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
13528               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
13529       printf (_("   Last modified  : "));
13530       print_vms_time
13531         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
13532       printf (_("\n   Link flags  : "));
13533       printf ("0x%016" BFD_VMA_FMT "x\n",
13534               (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
13535       printf (_("   Header flags: 0x%08x\n"),
13536               (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
13537       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
13538       break;
13539 #endif
13540     case NT_VMS_IMGNAM:
13541       printf (_("    Image name: %s\n"), pnote->descdata);
13542       break;
13543     case NT_VMS_GSTNAM:
13544       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
13545       break;
13546     case NT_VMS_IMGID:
13547       printf (_("    Image id: %s\n"), pnote->descdata);
13548       break;
13549     case NT_VMS_LINKID:
13550       printf (_("    Linker id: %s\n"), pnote->descdata);
13551       break;
13552     default:
13553       break;
13554     }
13555   return 1;
13556 }
13557
13558 /* Note that by the ELF standard, the name field is already null byte
13559    terminated, and namesz includes the terminating null byte.
13560    I.E. the value of namesz for the name "FSF" is 4.
13561
13562    If the value of namesz is zero, there is no name present.  */
13563 static int
13564 process_note (Elf_Internal_Note * pnote)
13565 {
13566   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
13567   const char * nt;
13568
13569   if (pnote->namesz == 0)
13570     /* If there is no note name, then use the default set of
13571        note type strings.  */
13572     nt = get_note_type (pnote->type);
13573
13574   else if (const_strneq (pnote->namedata, "GNU"))
13575     /* GNU-specific object file notes.  */
13576     nt = get_gnu_elf_note_type (pnote->type);
13577
13578   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
13579     /* NetBSD-specific core file notes.  */
13580     nt = get_netbsd_elfcore_note_type (pnote->type);
13581
13582   else if (strneq (pnote->namedata, "SPU/", 4))
13583     {
13584       /* SPU-specific core file notes.  */
13585       nt = pnote->namedata + 4;
13586       name = "SPU";
13587     }
13588
13589   else if (const_strneq (pnote->namedata, "IPF/VMS"))
13590     /* VMS/ia64-specific file notes.  */
13591     nt = get_ia64_vms_note_type (pnote->type);
13592
13593   else if (const_strneq (pnote->namedata, "stapsdt"))
13594     nt = get_stapsdt_note_type (pnote->type);
13595
13596   else
13597     /* Don't recognize this note name; just use the default set of
13598        note type strings.  */
13599     nt = get_note_type (pnote->type);
13600
13601   printf ("  %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
13602
13603   if (const_strneq (pnote->namedata, "IPF/VMS"))
13604     return print_ia64_vms_note (pnote);
13605   else if (const_strneq (pnote->namedata, "GNU"))
13606     return print_gnu_note (pnote);
13607   else if (const_strneq (pnote->namedata, "stapsdt"))
13608     return print_stapsdt_note (pnote);
13609   else if (const_strneq (pnote->namedata, "CORE"))
13610     return print_core_note (pnote);
13611   else
13612     return 1;
13613 }
13614
13615
13616 static int
13617 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
13618 {
13619   Elf_External_Note * pnotes;
13620   Elf_External_Note * external;
13621   int res = 1;
13622
13623   if (length <= 0)
13624     return 0;
13625
13626   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
13627                                            _("notes"));
13628   if (pnotes == NULL)
13629     return 0;
13630
13631   external = pnotes;
13632
13633   printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
13634           (unsigned long) offset, (unsigned long) length);
13635   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
13636
13637   while ((char *) external < (char *) pnotes + length)
13638     {
13639       Elf_Internal_Note inote;
13640       size_t min_notesz;
13641       char *next;
13642       char * temp = NULL;
13643       size_t data_remaining = ((char *) pnotes + length) - (char *) external;
13644
13645       if (!is_ia64_vms ())
13646         {
13647           /* PR binutils/15191
13648              Make sure that there is enough data to read.  */
13649           min_notesz = offsetof (Elf_External_Note, name);
13650           if (data_remaining < min_notesz)
13651             {
13652               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13653                     (int) data_remaining);
13654               break;
13655             }
13656           inote.type     = BYTE_GET (external->type);
13657           inote.namesz   = BYTE_GET (external->namesz);
13658           inote.namedata = external->name;
13659           inote.descsz   = BYTE_GET (external->descsz);
13660           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
13661           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
13662           next = inote.descdata + align_power (inote.descsz, 2);
13663         }
13664       else
13665         {
13666           Elf64_External_VMS_Note *vms_external;
13667
13668           /* PR binutils/15191
13669              Make sure that there is enough data to read.  */
13670           min_notesz = offsetof (Elf64_External_VMS_Note, name);
13671           if (data_remaining < min_notesz)
13672             {
13673               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13674                     (int) data_remaining);
13675               break;
13676             }
13677
13678           vms_external = (Elf64_External_VMS_Note *) external;
13679           inote.type     = BYTE_GET (vms_external->type);
13680           inote.namesz   = BYTE_GET (vms_external->namesz);
13681           inote.namedata = vms_external->name;
13682           inote.descsz   = BYTE_GET (vms_external->descsz);
13683           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
13684           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
13685           next = inote.descdata + align_power (inote.descsz, 3);
13686         }
13687
13688       if (inote.descdata < (char *) external + min_notesz
13689           || next < (char *) external + min_notesz
13690           || data_remaining < (size_t)(next - (char *) external))
13691         {
13692           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
13693                 (unsigned long) ((char *) external - (char *) pnotes));
13694           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
13695                 inote.type, inote.namesz, inote.descsz);
13696           break;
13697         }
13698
13699       external = (Elf_External_Note *) next;
13700
13701       /* Verify that name is null terminated.  It appears that at least
13702          one version of Linux (RedHat 6.0) generates corefiles that don't
13703          comply with the ELF spec by failing to include the null byte in
13704          namesz.  */
13705       if (inote.namedata[inote.namesz - 1] != '\0')
13706         {
13707           temp = (char *) malloc (inote.namesz + 1);
13708
13709           if (temp == NULL)
13710             {
13711               error (_("Out of memory\n"));
13712               res = 0;
13713               break;
13714             }
13715
13716           strncpy (temp, inote.namedata, inote.namesz);
13717           temp[inote.namesz] = 0;
13718
13719           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
13720           inote.namedata = temp;
13721         }
13722
13723       res &= process_note (& inote);
13724
13725       if (temp != NULL)
13726         {
13727           free (temp);
13728           temp = NULL;
13729         }
13730     }
13731
13732   free (pnotes);
13733
13734   return res;
13735 }
13736
13737 static int
13738 process_corefile_note_segments (FILE * file)
13739 {
13740   Elf_Internal_Phdr * segment;
13741   unsigned int i;
13742   int res = 1;
13743
13744   if (! get_program_headers (file))
13745       return 0;
13746
13747   for (i = 0, segment = program_headers;
13748        i < elf_header.e_phnum;
13749        i++, segment++)
13750     {
13751       if (segment->p_type == PT_NOTE)
13752         res &= process_corefile_note_segment (file,
13753                                               (bfd_vma) segment->p_offset,
13754                                               (bfd_vma) segment->p_filesz);
13755     }
13756
13757   return res;
13758 }
13759
13760 static int
13761 process_note_sections (FILE * file)
13762 {
13763   Elf_Internal_Shdr * section;
13764   unsigned long i;
13765   int res = 1;
13766
13767   for (i = 0, section = section_headers;
13768        i < elf_header.e_shnum && section != NULL;
13769        i++, section++)
13770     if (section->sh_type == SHT_NOTE)
13771       res &= process_corefile_note_segment (file,
13772                                             (bfd_vma) section->sh_offset,
13773                                             (bfd_vma) section->sh_size);
13774
13775   return res;
13776 }
13777
13778 static int
13779 process_notes (FILE * file)
13780 {
13781   /* If we have not been asked to display the notes then do nothing.  */
13782   if (! do_notes)
13783     return 1;
13784
13785   if (elf_header.e_type != ET_CORE)
13786     return process_note_sections (file);
13787
13788   /* No program headers means no NOTE segment.  */
13789   if (elf_header.e_phnum > 0)
13790     return process_corefile_note_segments (file);
13791
13792   printf (_("No note segments present in the core file.\n"));
13793   return 1;
13794 }
13795
13796 static int
13797 process_arch_specific (FILE * file)
13798 {
13799   if (! do_arch)
13800     return 1;
13801
13802   switch (elf_header.e_machine)
13803     {
13804     case EM_ARM:
13805       return process_arm_specific (file);
13806     case EM_MIPS:
13807     case EM_MIPS_RS3_LE:
13808       return process_mips_specific (file);
13809       break;
13810     case EM_PPC:
13811       return process_power_specific (file);
13812       break;
13813     case EM_SPARC:
13814     case EM_SPARC32PLUS:
13815     case EM_SPARCV9:
13816       return process_sparc_specific (file);
13817       break;
13818     case EM_TI_C6000:
13819       return process_tic6x_specific (file);
13820       break;
13821     case EM_MSP430:
13822       return process_msp430x_specific (file);
13823     default:
13824       break;
13825     }
13826   return 1;
13827 }
13828
13829 static int
13830 get_file_header (FILE * file)
13831 {
13832   /* Read in the identity array.  */
13833   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
13834     return 0;
13835
13836   /* Determine how to read the rest of the header.  */
13837   switch (elf_header.e_ident[EI_DATA])
13838     {
13839     default: /* fall through */
13840     case ELFDATANONE: /* fall through */
13841     case ELFDATA2LSB:
13842       byte_get = byte_get_little_endian;
13843       byte_put = byte_put_little_endian;
13844       break;
13845     case ELFDATA2MSB:
13846       byte_get = byte_get_big_endian;
13847       byte_put = byte_put_big_endian;
13848       break;
13849     }
13850
13851   /* For now we only support 32 bit and 64 bit ELF files.  */
13852   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
13853
13854   /* Read in the rest of the header.  */
13855   if (is_32bit_elf)
13856     {
13857       Elf32_External_Ehdr ehdr32;
13858
13859       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
13860         return 0;
13861
13862       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
13863       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
13864       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
13865       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
13866       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
13867       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
13868       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
13869       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
13870       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
13871       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
13872       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
13873       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
13874       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
13875     }
13876   else
13877     {
13878       Elf64_External_Ehdr ehdr64;
13879
13880       /* If we have been compiled with sizeof (bfd_vma) == 4, then
13881          we will not be able to cope with the 64bit data found in
13882          64 ELF files.  Detect this now and abort before we start
13883          overwriting things.  */
13884       if (sizeof (bfd_vma) < 8)
13885         {
13886           error (_("This instance of readelf has been built without support for a\n\
13887 64 bit data type and so it cannot read 64 bit ELF files.\n"));
13888           return 0;
13889         }
13890
13891       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
13892         return 0;
13893
13894       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
13895       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
13896       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
13897       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
13898       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
13899       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
13900       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
13901       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
13902       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
13903       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
13904       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
13905       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
13906       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
13907     }
13908
13909   if (elf_header.e_shoff)
13910     {
13911       /* There may be some extensions in the first section header.  Don't
13912          bomb if we can't read it.  */
13913       if (is_32bit_elf)
13914         get_32bit_section_headers (file, 1);
13915       else
13916         get_64bit_section_headers (file, 1);
13917     }
13918
13919   return 1;
13920 }
13921
13922 /* Process one ELF object file according to the command line options.
13923    This file may actually be stored in an archive.  The file is
13924    positioned at the start of the ELF object.  */
13925
13926 static int
13927 process_object (char * file_name, FILE * file)
13928 {
13929   unsigned int i;
13930
13931   if (! get_file_header (file))
13932     {
13933       error (_("%s: Failed to read file header\n"), file_name);
13934       return 1;
13935     }
13936
13937   /* Initialise per file variables.  */
13938   for (i = ARRAY_SIZE (version_info); i--;)
13939     version_info[i] = 0;
13940
13941   for (i = ARRAY_SIZE (dynamic_info); i--;)
13942     dynamic_info[i] = 0;
13943   dynamic_info_DT_GNU_HASH = 0;
13944
13945   /* Process the file.  */
13946   if (show_name)
13947     printf (_("\nFile: %s\n"), file_name);
13948
13949   /* Initialise the dump_sects array from the cmdline_dump_sects array.
13950      Note we do this even if cmdline_dump_sects is empty because we
13951      must make sure that the dump_sets array is zeroed out before each
13952      object file is processed.  */
13953   if (num_dump_sects > num_cmdline_dump_sects)
13954     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
13955
13956   if (num_cmdline_dump_sects > 0)
13957     {
13958       if (num_dump_sects == 0)
13959         /* A sneaky way of allocating the dump_sects array.  */
13960         request_dump_bynumber (num_cmdline_dump_sects, 0);
13961
13962       assert (num_dump_sects >= num_cmdline_dump_sects);
13963       memcpy (dump_sects, cmdline_dump_sects,
13964               num_cmdline_dump_sects * sizeof (* dump_sects));
13965     }
13966
13967   if (! process_file_header ())
13968     return 1;
13969
13970   if (! process_section_headers (file))
13971     {
13972       /* Without loaded section headers we cannot process lots of
13973          things.  */
13974       do_unwind = do_version = do_dump = do_arch = 0;
13975
13976       if (! do_using_dynamic)
13977         do_syms = do_dyn_syms = do_reloc = 0;
13978     }
13979
13980   if (! process_section_groups (file))
13981     {
13982       /* Without loaded section groups we cannot process unwind.  */
13983       do_unwind = 0;
13984     }
13985
13986   if (process_program_headers (file))
13987     process_dynamic_section (file);
13988
13989   process_relocs (file);
13990
13991   process_unwind (file);
13992
13993   process_symbol_table (file);
13994
13995   process_syminfo (file);
13996
13997   process_version_sections (file);
13998
13999   process_section_contents (file);
14000
14001   process_notes (file);
14002
14003   process_gnu_liblist (file);
14004
14005   process_arch_specific (file);
14006
14007   if (program_headers)
14008     {
14009       free (program_headers);
14010       program_headers = NULL;
14011     }
14012
14013   if (section_headers)
14014     {
14015       free (section_headers);
14016       section_headers = NULL;
14017     }
14018
14019   if (string_table)
14020     {
14021       free (string_table);
14022       string_table = NULL;
14023       string_table_length = 0;
14024     }
14025
14026   if (dynamic_strings)
14027     {
14028       free (dynamic_strings);
14029       dynamic_strings = NULL;
14030       dynamic_strings_length = 0;
14031     }
14032
14033   if (dynamic_symbols)
14034     {
14035       free (dynamic_symbols);
14036       dynamic_symbols = NULL;
14037       num_dynamic_syms = 0;
14038     }
14039
14040   if (dynamic_syminfo)
14041     {
14042       free (dynamic_syminfo);
14043       dynamic_syminfo = NULL;
14044     }
14045
14046   if (dynamic_section)
14047     {
14048       free (dynamic_section);
14049       dynamic_section = NULL;
14050     }
14051
14052   if (section_headers_groups)
14053     {
14054       free (section_headers_groups);
14055       section_headers_groups = NULL;
14056     }
14057
14058   if (section_groups)
14059     {
14060       struct group_list * g;
14061       struct group_list * next;
14062
14063       for (i = 0; i < group_count; i++)
14064         {
14065           for (g = section_groups [i].root; g != NULL; g = next)
14066             {
14067               next = g->next;
14068               free (g);
14069             }
14070         }
14071
14072       free (section_groups);
14073       section_groups = NULL;
14074     }
14075
14076   free_debug_memory ();
14077
14078   return 0;
14079 }
14080
14081 /* Process an ELF archive.
14082    On entry the file is positioned just after the ARMAG string.  */
14083
14084 static int
14085 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
14086 {
14087   struct archive_info arch;
14088   struct archive_info nested_arch;
14089   size_t got;
14090   int ret;
14091
14092   show_name = 1;
14093
14094   /* The ARCH structure is used to hold information about this archive.  */
14095   arch.file_name = NULL;
14096   arch.file = NULL;
14097   arch.index_array = NULL;
14098   arch.sym_table = NULL;
14099   arch.longnames = NULL;
14100
14101   /* The NESTED_ARCH structure is used as a single-item cache of information
14102      about a nested archive (when members of a thin archive reside within
14103      another regular archive file).  */
14104   nested_arch.file_name = NULL;
14105   nested_arch.file = NULL;
14106   nested_arch.index_array = NULL;
14107   nested_arch.sym_table = NULL;
14108   nested_arch.longnames = NULL;
14109
14110   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
14111     {
14112       ret = 1;
14113       goto out;
14114     }
14115
14116   if (do_archive_index)
14117     {
14118       if (arch.sym_table == NULL)
14119         error (_("%s: unable to dump the index as none was found\n"), file_name);
14120       else
14121         {
14122           unsigned int i, l;
14123           unsigned long current_pos;
14124
14125           printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
14126                   file_name, (long) arch.index_num, arch.sym_size);
14127           current_pos = ftell (file);
14128
14129           for (i = l = 0; i < arch.index_num; i++)
14130             {
14131               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
14132                 {
14133                   char * member_name;
14134
14135                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
14136
14137                   if (member_name != NULL)
14138                     {
14139                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
14140
14141                       if (qualified_name != NULL)
14142                         {
14143                           printf (_("Contents of binary %s at offset "), qualified_name);
14144                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
14145                           putchar ('\n');
14146                           free (qualified_name);
14147                         }
14148                     }
14149                 }
14150
14151               if (l >= arch.sym_size)
14152                 {
14153                   error (_("%s: end of the symbol table reached before the end of the index\n"),
14154                          file_name);
14155                   break;
14156                 }
14157               printf ("\t%s\n", arch.sym_table + l);
14158               l += strlen (arch.sym_table + l) + 1;
14159             }
14160
14161           if (arch.uses_64bit_indicies)
14162             l = (l + 7) & ~ 7;
14163           else
14164             l += l & 1;
14165
14166           if (l < arch.sym_size)
14167             error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
14168                    file_name, arch.sym_size - l);
14169
14170           if (fseek (file, current_pos, SEEK_SET) != 0)
14171             {
14172               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
14173               ret = 1;
14174               goto out;
14175             }
14176         }
14177
14178       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
14179           && !do_segments && !do_header && !do_dump && !do_version
14180           && !do_histogram && !do_debugging && !do_arch && !do_notes
14181           && !do_section_groups && !do_dyn_syms)
14182         {
14183           ret = 0; /* Archive index only.  */
14184           goto out;
14185         }
14186     }
14187
14188   ret = 0;
14189
14190   while (1)
14191     {
14192       char * name;
14193       size_t namelen;
14194       char * qualified_name;
14195
14196       /* Read the next archive header.  */
14197       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
14198         {
14199           error (_("%s: failed to seek to next archive header\n"), file_name);
14200           return 1;
14201         }
14202       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
14203       if (got != sizeof arch.arhdr)
14204         {
14205           if (got == 0)
14206             break;
14207           error (_("%s: failed to read archive header\n"), file_name);
14208           ret = 1;
14209           break;
14210         }
14211       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
14212         {
14213           error (_("%s: did not find a valid archive header\n"), arch.file_name);
14214           ret = 1;
14215           break;
14216         }
14217
14218       arch.next_arhdr_offset += sizeof arch.arhdr;
14219
14220       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
14221       if (archive_file_size & 01)
14222         ++archive_file_size;
14223
14224       name = get_archive_member_name (&arch, &nested_arch);
14225       if (name == NULL)
14226         {
14227           error (_("%s: bad archive file name\n"), file_name);
14228           ret = 1;
14229           break;
14230         }
14231       namelen = strlen (name);
14232
14233       qualified_name = make_qualified_name (&arch, &nested_arch, name);
14234       if (qualified_name == NULL)
14235         {
14236           error (_("%s: bad archive file name\n"), file_name);
14237           ret = 1;
14238           break;
14239         }
14240
14241       if (is_thin_archive && arch.nested_member_origin == 0)
14242         {
14243           /* This is a proxy for an external member of a thin archive.  */
14244           FILE * member_file;
14245           char * member_file_name = adjust_relative_path (file_name, name, namelen);
14246           if (member_file_name == NULL)
14247             {
14248               ret = 1;
14249               break;
14250             }
14251
14252           member_file = fopen (member_file_name, "rb");
14253           if (member_file == NULL)
14254             {
14255               error (_("Input file '%s' is not readable.\n"), member_file_name);
14256               free (member_file_name);
14257               ret = 1;
14258               break;
14259             }
14260
14261           archive_file_offset = arch.nested_member_origin;
14262
14263           ret |= process_object (qualified_name, member_file);
14264
14265           fclose (member_file);
14266           free (member_file_name);
14267         }
14268       else if (is_thin_archive)
14269         {
14270           /* PR 15140: Allow for corrupt thin archives.  */
14271           if (nested_arch.file == NULL)
14272             {
14273               error (_("%s: contains corrupt thin archive: %s\n"),
14274                      file_name, name);
14275               ret = 1;
14276               break;
14277             }
14278
14279           /* This is a proxy for a member of a nested archive.  */
14280           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
14281
14282           /* The nested archive file will have been opened and setup by
14283              get_archive_member_name.  */
14284           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
14285             {
14286               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
14287               ret = 1;
14288               break;
14289             }
14290
14291           ret |= process_object (qualified_name, nested_arch.file);
14292         }
14293       else
14294         {
14295           archive_file_offset = arch.next_arhdr_offset;
14296           arch.next_arhdr_offset += archive_file_size;
14297
14298           ret |= process_object (qualified_name, file);
14299         }
14300
14301       if (dump_sects != NULL)
14302         {
14303           free (dump_sects);
14304           dump_sects = NULL;
14305           num_dump_sects = 0;
14306         }
14307
14308       free (qualified_name);
14309     }
14310
14311  out:
14312   if (nested_arch.file != NULL)
14313     fclose (nested_arch.file);
14314   release_archive (&nested_arch);
14315   release_archive (&arch);
14316
14317   return ret;
14318 }
14319
14320 static int
14321 process_file (char * file_name)
14322 {
14323   FILE * file;
14324   struct stat statbuf;
14325   char armag[SARMAG];
14326   int ret;
14327
14328   if (stat (file_name, &statbuf) < 0)
14329     {
14330       if (errno == ENOENT)
14331         error (_("'%s': No such file\n"), file_name);
14332       else
14333         error (_("Could not locate '%s'.  System error message: %s\n"),
14334                file_name, strerror (errno));
14335       return 1;
14336     }
14337
14338   if (! S_ISREG (statbuf.st_mode))
14339     {
14340       error (_("'%s' is not an ordinary file\n"), file_name);
14341       return 1;
14342     }
14343
14344   file = fopen (file_name, "rb");
14345   if (file == NULL)
14346     {
14347       error (_("Input file '%s' is not readable.\n"), file_name);
14348       return 1;
14349     }
14350
14351   if (fread (armag, SARMAG, 1, file) != 1)
14352     {
14353       error (_("%s: Failed to read file's magic number\n"), file_name);
14354       fclose (file);
14355       return 1;
14356     }
14357
14358   if (memcmp (armag, ARMAG, SARMAG) == 0)
14359     ret = process_archive (file_name, file, FALSE);
14360   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
14361     ret = process_archive (file_name, file, TRUE);
14362   else
14363     {
14364       if (do_archive_index)
14365         error (_("File %s is not an archive so its index cannot be displayed.\n"),
14366                file_name);
14367
14368       rewind (file);
14369       archive_file_size = archive_file_offset = 0;
14370       ret = process_object (file_name, file);
14371     }
14372
14373   fclose (file);
14374
14375   return ret;
14376 }
14377
14378 #ifdef SUPPORT_DISASSEMBLY
14379 /* Needed by the i386 disassembler.  For extra credit, someone could
14380    fix this so that we insert symbolic addresses here, esp for GOT/PLT
14381    symbols.  */
14382
14383 void
14384 print_address (unsigned int addr, FILE * outfile)
14385 {
14386   fprintf (outfile,"0x%8.8x", addr);
14387 }
14388
14389 /* Needed by the i386 disassembler.  */
14390 void
14391 db_task_printsym (unsigned int addr)
14392 {
14393   print_address (addr, stderr);
14394 }
14395 #endif
14396
14397 int
14398 main (int argc, char ** argv)
14399 {
14400   int err;
14401
14402 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14403   setlocale (LC_MESSAGES, "");
14404 #endif
14405 #if defined (HAVE_SETLOCALE)
14406   setlocale (LC_CTYPE, "");
14407 #endif
14408   bindtextdomain (PACKAGE, LOCALEDIR);
14409   textdomain (PACKAGE);
14410
14411   expandargv (&argc, &argv);
14412
14413   parse_args (argc, argv);
14414
14415   if (num_dump_sects > 0)
14416     {
14417       /* Make a copy of the dump_sects array.  */
14418       cmdline_dump_sects = (dump_type *)
14419           malloc (num_dump_sects * sizeof (* dump_sects));
14420       if (cmdline_dump_sects == NULL)
14421         error (_("Out of memory allocating dump request table.\n"));
14422       else
14423         {
14424           memcpy (cmdline_dump_sects, dump_sects,
14425                   num_dump_sects * sizeof (* dump_sects));
14426           num_cmdline_dump_sects = num_dump_sects;
14427         }
14428     }
14429
14430   if (optind < (argc - 1))
14431     show_name = 1;
14432
14433   err = 0;
14434   while (optind < argc)
14435     err |= process_file (argv[optind++]);
14436
14437   if (dump_sects != NULL)
14438     free (dump_sects);
14439   if (cmdline_dump_sects != NULL)
14440     free (cmdline_dump_sects);
14441
14442   return err;
14443 }