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