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