contrib/binutils-2.24/binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright 1998-2013 Free Software Foundation, Inc.
   3
   4    Originally developed by Eric Youngdale <eric@andante.jic.com>
   5    Modifications by Nick Clifton <nickc@redhat.com>
   6
   7    This file is part of GNU Binutils.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  22    02110-1301, USA.  */
  23 \f
  24 /* The difference between readelf and objdump:
  25
  26   Both programs are capable of displaying the contents of ELF format files,
  27   so why does the binutils project have two file dumpers ?
  28
  29   The reason is that objdump sees an ELF file through a BFD filter of the
  30   world; if BFD has a bug where, say, it disagrees about a machine constant
  31   in e_flags, then the odds are good that it will remain internally
  32   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
  33   GAS sees it the BFD way.  There was need for a tool to go find out what
  34   the file actually says.
  35
  36   This is why the readelf program does not link against the BFD library - it
  37   exists as an independent program to help verify the correct working of BFD.
  38
  39   There is also the case that readelf can provide more information about an
  40   ELF file than is provided by objdump.  In particular it can display DWARF
  41   debugging information which (at the moment) objdump cannot.  */
  42 \f
  43 #include "sysdep.h"
  44 #include <assert.h>
  45 #include <time.h>
  46 #ifdef HAVE_ZLIB_H
  47 #include <zlib.h>
  48 #endif
  49 #ifdef HAVE_WCHAR_H
  50 #include <wchar.h>
  51 #endif
  52
  53 #if __GNUC__ >= 2
  54 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  55    as this will allow us to read in and parse 64bit and 32bit ELF files.
  56    Only do this if we believe that the compiler can support a 64 bit
  57    data type.  For now we only rely on GCC being able to do this.  */
  58 #define BFD64
  59 #endif
  60
  61 #include "bfd.h"
  62 #include "bucomm.h"
  63 #include "elfcomm.h"
  64 #include "dwarf.h"
  65
  66 #include "elf/common.h"
  67 #include "elf/external.h"
  68 #include "elf/internal.h"
  69
  70
  71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  72    we can obtain the H8 reloc numbers.  We need these for the
  73    get_reloc_size() function.  We include h8.h again after defining
  74    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  75
  76 #include "elf/h8.h"
  77 #undef _ELF_H8_H
  78
  79 /* Undo the effects of #including reloc-macros.h.  */
  80
  81 #undef START_RELOC_NUMBERS
  82 #undef RELOC_NUMBER
  83 #undef FAKE_RELOC
  84 #undef EMPTY_RELOC
  85 #undef END_RELOC_NUMBERS
  86 #undef _RELOC_MACROS_H
  87
  88 /* The following headers use the elf/reloc-macros.h file to
  89    automatically generate relocation recognition functions
  90    such as elf_mips_reloc_type()  */
  91
  92 #define RELOC_MACROS_GEN_FUNC
  93
  94 #include "elf/aarch64.h"
  95 #include "elf/alpha.h"
  96 #include "elf/arc.h"
  97 #include "elf/arm.h"
  98 #include "elf/avr.h"
  99 #include "elf/bfin.h"
 100 #include "elf/cr16.h"
 101 #include "elf/cris.h"
 102 #include "elf/crx.h"
 103 #include "elf/d10v.h"
 104 #include "elf/d30v.h"
 105 #include "elf/dlx.h"
 106 #include "elf/epiphany.h"
 107 #include "elf/fr30.h"
 108 #include "elf/frv.h"
 109 #include "elf/h8.h"
 110 #include "elf/hppa.h"
 111 #include "elf/i386.h"
 112 #include "elf/i370.h"
 113 #include "elf/i860.h"
 114 #include "elf/i960.h"
 115 #include "elf/ia64.h"
 116 #include "elf/ip2k.h"
 117 #include "elf/lm32.h"
 118 #include "elf/iq2000.h"
 119 #include "elf/m32c.h"
 120 #include "elf/m32r.h"
 121 #include "elf/m68k.h"
 122 #include "elf/m68hc11.h"
 123 #include "elf/mcore.h"
 124 #include "elf/mep.h"
 125 #include "elf/metag.h"
 126 #include "elf/microblaze.h"
 127 #include "elf/mips.h"
 128 #include "elf/mmix.h"
 129 #include "elf/mn10200.h"
 130 #include "elf/mn10300.h"
 131 #include "elf/moxie.h"
 132 #include "elf/mt.h"
 133 #include "elf/msp430.h"
 134 #include "elf/nios2.h"
 135 #include "elf/or32.h"
 136 #include "elf/pj.h"
 137 #include "elf/ppc.h"
 138 #include "elf/ppc64.h"
 139 #include "elf/rl78.h"
 140 #include "elf/rx.h"
 141 #include "elf/s390.h"
 142 #include "elf/score.h"
 143 #include "elf/sh.h"
 144 #include "elf/sparc.h"
 145 #include "elf/spu.h"
 146 #include "elf/tic6x.h"
 147 #include "elf/tilegx.h"
 148 #include "elf/tilepro.h"
 149 #include "elf/v850.h"
 150 #include "elf/vax.h"
 151 #include "elf/x86-64.h"
 152 #include "elf/xc16x.h"
 153 #include "elf/xgate.h"
 154 #include "elf/xstormy16.h"
 155 #include "elf/xtensa.h"
 156
 157 #include "getopt.h"
 158 #include "libiberty.h"
 159 #include "safe-ctype.h"
 160 #include "filenames.h"
 161
 162 #ifndef offsetof
 163 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 164 #endif
 165
 166 char * program_name = "readelf";
 167 static long archive_file_offset;
 168 static unsigned long archive_file_size;
 169 static unsigned long dynamic_addr;
 170 static bfd_size_type dynamic_size;
 171 static unsigned int dynamic_nent;
 172 static char * dynamic_strings;
 173 static unsigned long dynamic_strings_length;
 174 static char * string_table;
 175 static unsigned long string_table_length;
 176 static unsigned long num_dynamic_syms;
 177 static Elf_Internal_Sym * dynamic_symbols;
 178 static Elf_Internal_Syminfo * dynamic_syminfo;
 179 static unsigned long dynamic_syminfo_offset;
 180 static unsigned int dynamic_syminfo_nent;
 181 static char program_interpreter[PATH_MAX];
 182 static bfd_vma dynamic_info[DT_ENCODING];
 183 static bfd_vma dynamic_info_DT_GNU_HASH;
 184 static bfd_vma version_info[16];
 185 static Elf_Internal_Ehdr elf_header;
 186 static Elf_Internal_Shdr * section_headers;
 187 static Elf_Internal_Phdr * program_headers;
 188 static Elf_Internal_Dyn *  dynamic_section;
 189 static Elf_Internal_Shdr * symtab_shndx_hdr;
 190 static int show_name;
 191 static int do_dynamic;
 192 static int do_syms;
 193 static int do_dyn_syms;
 194 static int do_reloc;
 195 static int do_sections;
 196 static int do_section_groups;
 197 static int do_section_details;
 198 static int do_segments;
 199 static int do_unwind;
 200 static int do_using_dynamic;
 201 static int do_header;
 202 static int do_dump;
 203 static int do_version;
 204 static int do_histogram;
 205 static int do_debugging;
 206 static int do_arch;
 207 static int do_notes;
 208 static int do_archive_index;
 209 static int is_32bit_elf;
 210
 211 struct group_list
 212 {
 213   struct group_list * next;
 214   unsigned int section_index;
 215 };
 216
 217 struct group
 218 {
 219   struct group_list * root;
 220   unsigned int group_index;
 221 };
 222
 223 static size_t group_count;
 224 static struct group * section_groups;
 225 static struct group ** section_headers_groups;
 226
 227
 228 /* Flag bits indicating particular types of dump.  */
 229 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 230 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 231 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 232 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 233 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 234
 235 typedef unsigned char dump_type;
 236
 237 /* A linked list of the section names for which dumps were requested.  */
 238 struct dump_list_entry
 239 {
 240   char * name;
 241   dump_type type;
 242   struct dump_list_entry * next;
 243 };
 244 static struct dump_list_entry * dump_sects_byname;
 245
 246 /* A dynamic array of flags indicating for which sections a dump
 247    has been requested via command line switches.  */
 248 static dump_type *   cmdline_dump_sects = NULL;
 249 static unsigned int  num_cmdline_dump_sects = 0;
 250
 251 /* A dynamic array of flags indicating for which sections a dump of
 252    some kind has been requested.  It is reset on a per-object file
 253    basis and then initialised from the cmdline_dump_sects array,
 254    the results of interpreting the -w switch, and the
 255    dump_sects_byname list.  */
 256 static dump_type *   dump_sects = NULL;
 257 static unsigned int  num_dump_sects = 0;
 258
 259
 260 /* How to print a vma value.  */
 261 typedef enum print_mode
 262 {
 263   HEX,
 264   DEC,
 265   DEC_5,
 266   UNSIGNED,
 267   PREFIX_HEX,
 268   FULL_HEX,
 269   LONG_HEX
 270 }
 271 print_mode;
 272
 273 #define UNKNOWN -1
 274
 275 #define SECTION_NAME(X)                                         \
 276   ((X) == NULL ? _("<none>")                                    \
 277    : string_table == NULL ? _("<no-name>")                      \
 278    : ((X)->sh_name >= string_table_length ? _("<corrupt>")      \
 279   : string_table + (X)->sh_name))
 280
 281 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 282
 283 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 284   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 285    : get_64bit_elf_symbols (file, section, sym_count))
 286
 287 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 288 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 289    already been called and verified that the string exists.  */
 290 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 291
 292 #define REMOVE_ARCH_BITS(ADDR)                  \
 293   do                                            \
 294     {                                           \
 295       if (elf_header.e_machine == EM_ARM)       \
 296         (ADDR) &= ~1;                           \
 297     }                                           \
 298   while (0)
 299 \f
 300 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
 301    Put the retrieved data into VAR, if it is not NULL.  Otherwise allocate a buffer
 302    using malloc and fill that.  In either case return the pointer to the start of
 303    the retrieved data or NULL if something went wrong.  If something does go wrong
 304    emit an error message using REASON as part of the context.  */
 305
 306 static void *
 307 get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
 308           const char * reason)
 309 {
 310   void * mvar;
 311
 312   if (size == 0 || nmemb == 0)
 313     return NULL;
 314
 315   if (fseek (file, archive_file_offset + offset, SEEK_SET))
 316     {
 317       error (_("Unable to seek to 0x%lx for %s\n"),
 318              (unsigned long) archive_file_offset + offset, reason);
 319       return NULL;
 320     }
 321
 322   mvar = var;
 323   if (mvar == NULL)
 324     {
 325       /* Check for overflow.  */
 326       if (nmemb < (~(size_t) 0 - 1) / size)
 327         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 328         mvar = malloc (size * nmemb + 1);
 329
 330       if (mvar == NULL)
 331         {
 332           error (_("Out of memory allocating 0x%lx bytes for %s\n"),
 333                  (unsigned long)(size * nmemb), reason);
 334           return NULL;
 335         }
 336
 337       ((char *) mvar)[size * nmemb] = '\0';
 338     }
 339
 340   if (fread (mvar, size, nmemb, file) != nmemb)
 341     {
 342       error (_("Unable to read in 0x%lx bytes of %s\n"),
 343              (unsigned long)(size * nmemb), reason);
 344       if (mvar != var)
 345         free (mvar);
 346       return NULL;
 347     }
 348
 349   return mvar;
 350 }
 351
 352 /* Print a VMA value.  */
 353
 354 static int
 355 print_vma (bfd_vma vma, print_mode mode)
 356 {
 357   int nc = 0;
 358
 359   switch (mode)
 360     {
 361     case FULL_HEX:
 362       nc = printf ("0x");
 363       /* Drop through.  */
 364
 365     case LONG_HEX:
 366 #ifdef BFD64
 367       if (is_32bit_elf)
 368         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 369 #endif
 370       printf_vma (vma);
 371       return nc + 16;
 372
 373     case DEC_5:
 374       if (vma <= 99999)
 375         return printf ("%5" BFD_VMA_FMT "d", vma);
 376       /* Drop through.  */
 377
 378     case PREFIX_HEX:
 379       nc = printf ("0x");
 380       /* Drop through.  */
 381
 382     case HEX:
 383       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 384
 385     case DEC:
 386       return printf ("%" BFD_VMA_FMT "d", vma);
 387
 388     case UNSIGNED:
 389       return printf ("%" BFD_VMA_FMT "u", vma);
 390     }
 391   return 0;
 392 }
 393
 394 /* Display a symbol on stdout.  Handles the display of control characters and
 395    multibye characters (assuming the host environment supports them).
 396
 397    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 398
 399    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 400    padding as necessary.
 401
 402    Returns the number of emitted characters.  */
 403
 404 static unsigned int
 405 print_symbol (int width, const char *symbol)
 406 {
 407   bfd_boolean extra_padding = FALSE;
 408   int num_printed = 0;
 409 #ifdef HAVE_MBSTATE_T
 410   mbstate_t state;
 411 #endif
 412   int width_remaining;
 413
 414   if (width < 0)
 415     {
 416       /* Keep the width positive.  This also helps.  */
 417       width = - width;
 418       extra_padding = TRUE;
 419     }
 420
 421   if (do_wide)
 422     /* Set the remaining width to a very large value.
 423        This simplifies the code below.  */
 424     width_remaining = INT_MAX;
 425   else
 426     width_remaining = width;
 427
 428 #ifdef HAVE_MBSTATE_T
 429   /* Initialise the multibyte conversion state.  */
 430   memset (& state, 0, sizeof (state));
 431 #endif
 432
 433   while (width_remaining)
 434     {
 435       size_t  n;
 436       const char c = *symbol++;
 437
 438       if (c == 0)
 439         break;
 440
 441       /* Do not print control characters directly as they can affect terminal
 442          settings.  Such characters usually appear in the names generated
 443          by the assembler for local labels.  */
 444       if (ISCNTRL (c))
 445         {
 446           if (width_remaining < 2)
 447             break;
 448
 449           printf ("^%c", c + 0x40);
 450           width_remaining -= 2;
 451           num_printed += 2;
 452         }
 453       else if (ISPRINT (c))
 454         {
 455           putchar (c);
 456           width_remaining --;
 457           num_printed ++;
 458         }
 459       else
 460         {
 461 #ifdef HAVE_MBSTATE_T
 462           wchar_t w;
 463 #endif
 464           /* Let printf do the hard work of displaying multibyte characters.  */
 465           printf ("%.1s", symbol - 1);
 466           width_remaining --;
 467           num_printed ++;
 468
 469 #ifdef HAVE_MBSTATE_T
 470           /* Try to find out how many bytes made up the character that was
 471              just printed.  Advance the symbol pointer past the bytes that
 472              were displayed.  */
 473           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 474 #else
 475           n = 1;
 476 #endif
 477           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 478             symbol += (n - 1);
 479         }
 480     }
 481
 482   if (extra_padding && num_printed < width)
 483     {
 484       /* Fill in the remaining spaces.  */
 485       printf ("%-*s", width - num_printed, " ");
 486       num_printed = width;
 487     }
 488
 489   return num_printed;
 490 }
 491
 492 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 493
 494 static Elf_Internal_Shdr *
 495 find_section (const char * name)
 496 {
 497   unsigned int i;
 498
 499   for (i = 0; i < elf_header.e_shnum; i++)
 500     if (streq (SECTION_NAME (section_headers + i), name))
 501       return section_headers + i;
 502
 503   return NULL;
 504 }
 505
 506 /* Return a pointer to a section containing ADDR, or NULL if no such
 507    section exists.  */
 508
 509 static Elf_Internal_Shdr *
 510 find_section_by_address (bfd_vma addr)
 511 {
 512   unsigned int i;
 513
 514   for (i = 0; i < elf_header.e_shnum; i++)
 515     {
 516       Elf_Internal_Shdr *sec = section_headers + i;
 517       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 518         return sec;
 519     }
 520
 521   return NULL;
 522 }
 523
 524 /* Return a pointer to section NAME, or NULL if no such section exists,
 525    restricted to the list of sections given in SET.  */
 526
 527 static Elf_Internal_Shdr *
 528 find_section_in_set (const char * name, unsigned int * set)
 529 {
 530   unsigned int i;
 531
 532   if (set != NULL)
 533     {
 534       while ((i = *set++) > 0)
 535         if (streq (SECTION_NAME (section_headers + i), name))
 536           return section_headers + i;
 537     }
 538
 539   return find_section (name);
 540 }
 541
 542 /* Read an unsigned LEB128 encoded value from p.  Set *PLEN to the number of
 543    bytes read.  */
 544
 545 static inline unsigned long
 546 read_uleb128 (unsigned char *data,
 547               unsigned int *length_return,
 548               const unsigned char * const end)
 549 {
 550   return read_leb128 (data, length_return, FALSE, end);
 551 }
 552
 553 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
 554    This OS has so many departures from the ELF standard that we test it at
 555    many places.  */
 556
 557 static inline int
 558 is_ia64_vms (void)
 559 {
 560   return elf_header.e_machine == EM_IA_64
 561     && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 562 }
 563
 564 /* Guess the relocation size commonly used by the specific machines.  */
 565
 566 static int
 567 guess_is_rela (unsigned int e_machine)
 568 {
 569   switch (e_machine)
 570     {
 571       /* Targets that use REL relocations.  */
 572     case EM_386:
 573     case EM_486:
 574     case EM_960:
 575     case EM_ARM:
 576     case EM_D10V:
 577     case EM_CYGNUS_D10V:
 578     case EM_DLX:
 579     case EM_MIPS:
 580     case EM_MIPS_RS3_LE:
 581     case EM_CYGNUS_M32R:
 582     case EM_OPENRISC:
 583     case EM_OR32:
 584     case EM_SCORE:
 585     case EM_XGATE:
 586       return FALSE;
 587
 588       /* Targets that use RELA relocations.  */
 589     case EM_68K:
 590     case EM_860:
 591     case EM_AARCH64:
 592     case EM_ADAPTEVA_EPIPHANY:
 593     case EM_ALPHA:
 594     case EM_ALTERA_NIOS2:
 595     case EM_AVR:
 596     case EM_AVR_OLD:
 597     case EM_BLACKFIN:
 598     case EM_CR16:
 599     case EM_CRIS:
 600     case EM_CRX:
 601     case EM_D30V:
 602     case EM_CYGNUS_D30V:
 603     case EM_FR30:
 604     case EM_CYGNUS_FR30:
 605     case EM_CYGNUS_FRV:
 606     case EM_H8S:
 607     case EM_H8_300:
 608     case EM_H8_300H:
 609     case EM_IA_64:
 610     case EM_IP2K:
 611     case EM_IP2K_OLD:
 612     case EM_IQ2000:
 613     case EM_LATTICEMICO32:
 614     case EM_M32C_OLD:
 615     case EM_M32C:
 616     case EM_M32R:
 617     case EM_MCORE:
 618     case EM_CYGNUS_MEP:
 619     case EM_METAG:
 620     case EM_MMIX:
 621     case EM_MN10200:
 622     case EM_CYGNUS_MN10200:
 623     case EM_MN10300:
 624     case EM_CYGNUS_MN10300:
 625     case EM_MOXIE:
 626     case EM_MSP430:
 627     case EM_MSP430_OLD:
 628     case EM_MT:
 629     case EM_NIOS32:
 630     case EM_PPC64:
 631     case EM_PPC:
 632     case EM_RL78:
 633     case EM_RX:
 634     case EM_S390:
 635     case EM_S390_OLD:
 636     case EM_SH:
 637     case EM_SPARC:
 638     case EM_SPARC32PLUS:
 639     case EM_SPARCV9:
 640     case EM_SPU:
 641     case EM_TI_C6000:
 642     case EM_TILEGX:
 643     case EM_TILEPRO:
 644     case EM_V800:
 645     case EM_V850:
 646     case EM_CYGNUS_V850:
 647     case EM_VAX:
 648     case EM_X86_64:
 649     case EM_L1OM:
 650     case EM_K1OM:
 651     case EM_XSTORMY16:
 652     case EM_XTENSA:
 653     case EM_XTENSA_OLD:
 654     case EM_MICROBLAZE:
 655     case EM_MICROBLAZE_OLD:
 656       return TRUE;
 657
 658     case EM_68HC05:
 659     case EM_68HC08:
 660     case EM_68HC11:
 661     case EM_68HC16:
 662     case EM_FX66:
 663     case EM_ME16:
 664     case EM_MMA:
 665     case EM_NCPU:
 666     case EM_NDR1:
 667     case EM_PCP:
 668     case EM_ST100:
 669     case EM_ST19:
 670     case EM_ST7:
 671     case EM_ST9PLUS:
 672     case EM_STARCORE:
 673     case EM_SVX:
 674     case EM_TINYJ:
 675     default:
 676       warn (_("Don't know about relocations on this machine architecture\n"));
 677       return FALSE;
 678     }
 679 }
 680
 681 static int
 682 slurp_rela_relocs (FILE * file,
 683                    unsigned long rel_offset,
 684                    unsigned long rel_size,
 685                    Elf_Internal_Rela ** relasp,
 686                    unsigned long * nrelasp)
 687 {
 688   Elf_Internal_Rela * relas;
 689   unsigned long nrelas;
 690   unsigned int i;
 691
 692   if (is_32bit_elf)
 693     {
 694       Elf32_External_Rela * erelas;
 695
 696       erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
 697                                                  rel_size, _("32-bit relocation data"));
 698       if (!erelas)
 699         return 0;
 700
 701       nrelas = rel_size / sizeof (Elf32_External_Rela);
 702
 703       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 704                                              sizeof (Elf_Internal_Rela));
 705
 706       if (relas == NULL)
 707         {
 708           free (erelas);
 709           error (_("out of memory parsing relocs\n"));
 710           return 0;
 711         }
 712
 713       for (i = 0; i < nrelas; i++)
 714         {
 715           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 716           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 717           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 718         }
 719
 720       free (erelas);
 721     }
 722   else
 723     {
 724       Elf64_External_Rela * erelas;
 725
 726       erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
 727                                                  rel_size, _("64-bit relocation data"));
 728       if (!erelas)
 729         return 0;
 730
 731       nrelas = rel_size / sizeof (Elf64_External_Rela);
 732
 733       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 734                                              sizeof (Elf_Internal_Rela));
 735
 736       if (relas == NULL)
 737         {
 738           free (erelas);
 739           error (_("out of memory parsing relocs\n"));
 740           return 0;
 741         }
 742
 743       for (i = 0; i < nrelas; i++)
 744         {
 745           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 746           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 747           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 748
 749           /* The #ifdef BFD64 below is to prevent a compile time
 750              warning.  We know that if we do not have a 64 bit data
 751              type that we will never execute this code anyway.  */
 752 #ifdef BFD64
 753           if (elf_header.e_machine == EM_MIPS
 754               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 755             {
 756               /* In little-endian objects, r_info isn't really a
 757                  64-bit little-endian value: it has a 32-bit
 758                  little-endian symbol index followed by four
 759                  individual byte fields.  Reorder INFO
 760                  accordingly.  */
 761               bfd_vma inf = relas[i].r_info;
 762               inf = (((inf & 0xffffffff) << 32)
 763                       | ((inf >> 56) & 0xff)
 764                       | ((inf >> 40) & 0xff00)
 765                       | ((inf >> 24) & 0xff0000)
 766                       | ((inf >> 8) & 0xff000000));
 767               relas[i].r_info = inf;
 768             }
 769 #endif /* BFD64 */
 770         }
 771
 772       free (erelas);
 773     }
 774   *relasp = relas;
 775   *nrelasp = nrelas;
 776   return 1;
 777 }
 778
 779 static int
 780 slurp_rel_relocs (FILE * file,
 781                   unsigned long rel_offset,
 782                   unsigned long rel_size,
 783                   Elf_Internal_Rela ** relsp,
 784                   unsigned long * nrelsp)
 785 {
 786   Elf_Internal_Rela * rels;
 787   unsigned long nrels;
 788   unsigned int i;
 789
 790   if (is_32bit_elf)
 791     {
 792       Elf32_External_Rel * erels;
 793
 794       erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
 795                                                rel_size, _("32-bit relocation data"));
 796       if (!erels)
 797         return 0;
 798
 799       nrels = rel_size / sizeof (Elf32_External_Rel);
 800
 801       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 802
 803       if (rels == NULL)
 804         {
 805           free (erels);
 806           error (_("out of memory parsing relocs\n"));
 807           return 0;
 808         }
 809
 810       for (i = 0; i < nrels; i++)
 811         {
 812           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 813           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 814           rels[i].r_addend = 0;
 815         }
 816
 817       free (erels);
 818     }
 819   else
 820     {
 821       Elf64_External_Rel * erels;
 822
 823       erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
 824                                                rel_size, _("64-bit relocation data"));
 825       if (!erels)
 826         return 0;
 827
 828       nrels = rel_size / sizeof (Elf64_External_Rel);
 829
 830       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 831
 832       if (rels == NULL)
 833         {
 834           free (erels);
 835           error (_("out of memory parsing relocs\n"));
 836           return 0;
 837         }
 838
 839       for (i = 0; i < nrels; i++)
 840         {
 841           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 842           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 843           rels[i].r_addend = 0;
 844
 845           /* The #ifdef BFD64 below is to prevent a compile time
 846              warning.  We know that if we do not have a 64 bit data
 847              type that we will never execute this code anyway.  */
 848 #ifdef BFD64
 849           if (elf_header.e_machine == EM_MIPS
 850               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 851             {
 852               /* In little-endian objects, r_info isn't really a
 853                  64-bit little-endian value: it has a 32-bit
 854                  little-endian symbol index followed by four
 855                  individual byte fields.  Reorder INFO
 856                  accordingly.  */
 857               bfd_vma inf = rels[i].r_info;
 858               inf = (((inf & 0xffffffff) << 32)
 859                      | ((inf >> 56) & 0xff)
 860                      | ((inf >> 40) & 0xff00)
 861                      | ((inf >> 24) & 0xff0000)
 862                      | ((inf >> 8) & 0xff000000));
 863               rels[i].r_info = inf;
 864             }
 865 #endif /* BFD64 */
 866         }
 867
 868       free (erels);
 869     }
 870   *relsp = rels;
 871   *nrelsp = nrels;
 872   return 1;
 873 }
 874
 875 /* Returns the reloc type extracted from the reloc info field.  */
 876
 877 static unsigned int
 878 get_reloc_type (bfd_vma reloc_info)
 879 {
 880   if (is_32bit_elf)
 881     return ELF32_R_TYPE (reloc_info);
 882
 883   switch (elf_header.e_machine)
 884     {
 885     case EM_MIPS:
 886       /* Note: We assume that reloc_info has already been adjusted for us.  */
 887       return ELF64_MIPS_R_TYPE (reloc_info);
 888
 889     case EM_SPARCV9:
 890       return ELF64_R_TYPE_ID (reloc_info);
 891
 892     default:
 893       return ELF64_R_TYPE (reloc_info);
 894     }
 895 }
 896
 897 /* Return the symbol index extracted from the reloc info field.  */
 898
 899 static bfd_vma
 900 get_reloc_symindex (bfd_vma reloc_info)
 901 {
 902   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
 903 }
 904
 905 static inline bfd_boolean
 906 uses_msp430x_relocs (void)
 907 {
 908   return
 909     elf_header.e_machine == EM_MSP430 /* Paranoia.  */
 910     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
 911     && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
 912         /* TI compiler uses ELFOSABI_NONE.  */
 913         || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
 914 }
 915
 916 /* Display the contents of the relocation data found at the specified
 917    offset.  */
 918
 919 static void
 920 dump_relocations (FILE * file,
 921                   unsigned long rel_offset,
 922                   unsigned long rel_size,
 923                   Elf_Internal_Sym * symtab,
 924                   unsigned long nsyms,
 925                   char * strtab,
 926                   unsigned long strtablen,
 927                   int is_rela)
 928 {
 929   unsigned int i;
 930   Elf_Internal_Rela * rels;
 931
 932   if (is_rela == UNKNOWN)
 933     is_rela = guess_is_rela (elf_header.e_machine);
 934
 935   if (is_rela)
 936     {
 937       if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
 938         return;
 939     }
 940   else
 941     {
 942       if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
 943         return;
 944     }
 945
 946   if (is_32bit_elf)
 947     {
 948       if (is_rela)
 949         {
 950           if (do_wide)
 951             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
 952           else
 953             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
 954         }
 955       else
 956         {
 957           if (do_wide)
 958             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
 959           else
 960             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
 961         }
 962     }
 963   else
 964     {
 965       if (is_rela)
 966         {
 967           if (do_wide)
 968             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
 969           else
 970             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
 971         }
 972       else
 973         {
 974           if (do_wide)
 975             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
 976           else
 977             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
 978         }
 979     }
 980
 981   for (i = 0; i < rel_size; i++)
 982     {
 983       const char * rtype;
 984       bfd_vma offset;
 985       bfd_vma inf;
 986       bfd_vma symtab_index;
 987       bfd_vma type;
 988
 989       offset = rels[i].r_offset;
 990       inf    = rels[i].r_info;
 991
 992       type = get_reloc_type (inf);
 993       symtab_index = get_reloc_symindex  (inf);
 994
 995       if (is_32bit_elf)
 996         {
 997           printf ("%8.8lx  %8.8lx ",
 998                   (unsigned long) offset & 0xffffffff,
 999                   (unsigned long) inf & 0xffffffff);
1000         }
1001       else
1002         {
1003 #if BFD_HOST_64BIT_LONG
1004           printf (do_wide
1005                   ? "%16.16lx  %16.16lx "
1006                   : "%12.12lx  %12.12lx ",
1007                   offset, inf);
1008 #elif BFD_HOST_64BIT_LONG_LONG
1009 #ifndef __MSVCRT__
1010           printf (do_wide
1011                   ? "%16.16llx  %16.16llx "
1012                   : "%12.12llx  %12.12llx ",
1013                   offset, inf);
1014 #else
1015           printf (do_wide
1016                   ? "%16.16I64x  %16.16I64x "
1017                   : "%12.12I64x  %12.12I64x ",
1018                   offset, inf);
1019 #endif
1020 #else
1021           printf (do_wide
1022                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1023                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1024                   _bfd_int64_high (offset),
1025                   _bfd_int64_low (offset),
1026                   _bfd_int64_high (inf),
1027                   _bfd_int64_low (inf));
1028 #endif
1029         }
1030
1031       switch (elf_header.e_machine)
1032         {
1033         default:
1034           rtype = NULL;
1035           break;
1036
1037         case EM_AARCH64:
1038           rtype = elf_aarch64_reloc_type (type);
1039           break;
1040
1041         case EM_M32R:
1042         case EM_CYGNUS_M32R:
1043           rtype = elf_m32r_reloc_type (type);
1044           break;
1045
1046         case EM_386:
1047         case EM_486:
1048           rtype = elf_i386_reloc_type (type);
1049           break;
1050
1051         case EM_68HC11:
1052         case EM_68HC12:
1053           rtype = elf_m68hc11_reloc_type (type);
1054           break;
1055
1056         case EM_68K:
1057           rtype = elf_m68k_reloc_type (type);
1058           break;
1059
1060         case EM_960:
1061           rtype = elf_i960_reloc_type (type);
1062           break;
1063
1064         case EM_AVR:
1065         case EM_AVR_OLD:
1066           rtype = elf_avr_reloc_type (type);
1067           break;
1068
1069         case EM_OLD_SPARCV9:
1070         case EM_SPARC32PLUS:
1071         case EM_SPARCV9:
1072         case EM_SPARC:
1073           rtype = elf_sparc_reloc_type (type);
1074           break;
1075
1076         case EM_SPU:
1077           rtype = elf_spu_reloc_type (type);
1078           break;
1079
1080         case EM_V800:
1081           rtype = v800_reloc_type (type);
1082           break;
1083         case EM_V850:
1084         case EM_CYGNUS_V850:
1085           rtype = v850_reloc_type (type);
1086           break;
1087
1088         case EM_D10V:
1089         case EM_CYGNUS_D10V:
1090           rtype = elf_d10v_reloc_type (type);
1091           break;
1092
1093         case EM_D30V:
1094         case EM_CYGNUS_D30V:
1095           rtype = elf_d30v_reloc_type (type);
1096           break;
1097
1098         case EM_DLX:
1099           rtype = elf_dlx_reloc_type (type);
1100           break;
1101
1102         case EM_SH:
1103           rtype = elf_sh_reloc_type (type);
1104           break;
1105
1106         case EM_MN10300:
1107         case EM_CYGNUS_MN10300:
1108           rtype = elf_mn10300_reloc_type (type);
1109           break;
1110
1111         case EM_MN10200:
1112         case EM_CYGNUS_MN10200:
1113           rtype = elf_mn10200_reloc_type (type);
1114           break;
1115
1116         case EM_FR30:
1117         case EM_CYGNUS_FR30:
1118           rtype = elf_fr30_reloc_type (type);
1119           break;
1120
1121         case EM_CYGNUS_FRV:
1122           rtype = elf_frv_reloc_type (type);
1123           break;
1124
1125         case EM_MCORE:
1126           rtype = elf_mcore_reloc_type (type);
1127           break;
1128
1129         case EM_MMIX:
1130           rtype = elf_mmix_reloc_type (type);
1131           break;
1132
1133         case EM_MOXIE:
1134           rtype = elf_moxie_reloc_type (type);
1135           break;
1136
1137         case EM_MSP430:
1138           if (uses_msp430x_relocs ())
1139             {
1140               rtype = elf_msp430x_reloc_type (type);
1141               break;
1142             }
1143         case EM_MSP430_OLD:
1144           rtype = elf_msp430_reloc_type (type);
1145           break;
1146
1147         case EM_PPC:
1148           rtype = elf_ppc_reloc_type (type);
1149           break;
1150
1151         case EM_PPC64:
1152           rtype = elf_ppc64_reloc_type (type);
1153           break;
1154
1155         case EM_MIPS:
1156         case EM_MIPS_RS3_LE:
1157           rtype = elf_mips_reloc_type (type);
1158           break;
1159
1160         case EM_ALPHA:
1161           rtype = elf_alpha_reloc_type (type);
1162           break;
1163
1164         case EM_ARM:
1165           rtype = elf_arm_reloc_type (type);
1166           break;
1167
1168         case EM_ARC:
1169           rtype = elf_arc_reloc_type (type);
1170           break;
1171
1172         case EM_PARISC:
1173           rtype = elf_hppa_reloc_type (type);
1174           break;
1175
1176         case EM_H8_300:
1177         case EM_H8_300H:
1178         case EM_H8S:
1179           rtype = elf_h8_reloc_type (type);
1180           break;
1181
1182         case EM_OPENRISC:
1183         case EM_OR32:
1184           rtype = elf_or32_reloc_type (type);
1185           break;
1186
1187         case EM_PJ:
1188         case EM_PJ_OLD:
1189           rtype = elf_pj_reloc_type (type);
1190           break;
1191         case EM_IA_64:
1192           rtype = elf_ia64_reloc_type (type);
1193           break;
1194
1195         case EM_CRIS:
1196           rtype = elf_cris_reloc_type (type);
1197           break;
1198
1199         case EM_860:
1200           rtype = elf_i860_reloc_type (type);
1201           break;
1202
1203         case EM_X86_64:
1204         case EM_L1OM:
1205         case EM_K1OM:
1206           rtype = elf_x86_64_reloc_type (type);
1207           break;
1208
1209         case EM_S370:
1210           rtype = i370_reloc_type (type);
1211           break;
1212
1213         case EM_S390_OLD:
1214         case EM_S390:
1215           rtype = elf_s390_reloc_type (type);
1216           break;
1217
1218         case EM_SCORE:
1219           rtype = elf_score_reloc_type (type);
1220           break;
1221
1222         case EM_XSTORMY16:
1223           rtype = elf_xstormy16_reloc_type (type);
1224           break;
1225
1226         case EM_CRX:
1227           rtype = elf_crx_reloc_type (type);
1228           break;
1229
1230         case EM_VAX:
1231           rtype = elf_vax_reloc_type (type);
1232           break;
1233
1234         case EM_ADAPTEVA_EPIPHANY:
1235           rtype = elf_epiphany_reloc_type (type);
1236           break;
1237
1238         case EM_IP2K:
1239         case EM_IP2K_OLD:
1240           rtype = elf_ip2k_reloc_type (type);
1241           break;
1242
1243         case EM_IQ2000:
1244           rtype = elf_iq2000_reloc_type (type);
1245           break;
1246
1247         case EM_XTENSA_OLD:
1248         case EM_XTENSA:
1249           rtype = elf_xtensa_reloc_type (type);
1250           break;
1251
1252         case EM_LATTICEMICO32:
1253           rtype = elf_lm32_reloc_type (type);
1254           break;
1255
1256         case EM_M32C_OLD:
1257         case EM_M32C:
1258           rtype = elf_m32c_reloc_type (type);
1259           break;
1260
1261         case EM_MT:
1262           rtype = elf_mt_reloc_type (type);
1263           break;
1264
1265         case EM_BLACKFIN:
1266           rtype = elf_bfin_reloc_type (type);
1267           break;
1268
1269         case EM_CYGNUS_MEP:
1270           rtype = elf_mep_reloc_type (type);
1271           break;
1272
1273         case EM_CR16:
1274           rtype = elf_cr16_reloc_type (type);
1275           break;
1276
1277         case EM_MICROBLAZE:
1278         case EM_MICROBLAZE_OLD:
1279           rtype = elf_microblaze_reloc_type (type);
1280           break;
1281
1282         case EM_RL78:
1283           rtype = elf_rl78_reloc_type (type);
1284           break;
1285
1286         case EM_RX:
1287           rtype = elf_rx_reloc_type (type);
1288           break;
1289
1290         case EM_METAG:
1291           rtype = elf_metag_reloc_type (type);
1292           break;
1293
1294         case EM_XC16X:
1295         case EM_C166:
1296           rtype = elf_xc16x_reloc_type (type);
1297           break;
1298
1299         case EM_TI_C6000:
1300           rtype = elf_tic6x_reloc_type (type);
1301           break;
1302
1303         case EM_TILEGX:
1304           rtype = elf_tilegx_reloc_type (type);
1305           break;
1306
1307         case EM_TILEPRO:
1308           rtype = elf_tilepro_reloc_type (type);
1309           break;
1310
1311         case EM_XGATE:
1312           rtype = elf_xgate_reloc_type (type);
1313           break;
1314
1315         case EM_ALTERA_NIOS2:
1316           rtype = elf_nios2_reloc_type (type);
1317           break;
1318         }
1319
1320       if (rtype == NULL)
1321         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1322       else
1323         printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1324
1325       if (elf_header.e_machine == EM_ALPHA
1326           && rtype != NULL
1327           && streq (rtype, "R_ALPHA_LITUSE")
1328           && is_rela)
1329         {
1330           switch (rels[i].r_addend)
1331             {
1332             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1333             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1334             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1335             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1336             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1337             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1338             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1339             default: rtype = NULL;
1340             }
1341           if (rtype)
1342             printf (" (%s)", rtype);
1343           else
1344             {
1345               putchar (' ');
1346               printf (_("<unknown addend: %lx>"),
1347                       (unsigned long) rels[i].r_addend);
1348             }
1349         }
1350       else if (symtab_index)
1351         {
1352           if (symtab == NULL || symtab_index >= nsyms)
1353             printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1354           else
1355             {
1356               Elf_Internal_Sym * psym;
1357
1358               psym = symtab + symtab_index;
1359
1360               printf (" ");
1361
1362               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1363                 {
1364                   const char * name;
1365                   unsigned int len;
1366                   unsigned int width = is_32bit_elf ? 8 : 14;
1367
1368                   /* Relocations against GNU_IFUNC symbols do not use the value
1369                      of the symbol as the address to relocate against.  Instead
1370                      they invoke the function named by the symbol and use its
1371                      result as the address for relocation.
1372
1373                      To indicate this to the user, do not display the value of
1374                      the symbol in the "Symbols's Value" field.  Instead show
1375                      its name followed by () as a hint that the symbol is
1376                      invoked.  */
1377
1378                   if (strtab == NULL
1379                       || psym->st_name == 0
1380                       || psym->st_name >= strtablen)
1381                     name = "??";
1382                   else
1383                     name = strtab + psym->st_name;
1384
1385                   len = print_symbol (width, name);
1386                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1387                 }
1388               else
1389                 {
1390                   print_vma (psym->st_value, LONG_HEX);
1391
1392                   printf (is_32bit_elf ? "   " : " ");
1393                 }
1394
1395               if (psym->st_name == 0)
1396                 {
1397                   const char * sec_name = "<null>";
1398                   char name_buf[40];
1399
1400                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1401                     {
1402                       if (psym->st_shndx < elf_header.e_shnum)
1403                         sec_name
1404                           = SECTION_NAME (section_headers + psym->st_shndx);
1405                       else if (psym->st_shndx == SHN_ABS)
1406                         sec_name = "ABS";
1407                       else if (psym->st_shndx == SHN_COMMON)
1408                         sec_name = "COMMON";
1409                       else if ((elf_header.e_machine == EM_MIPS
1410                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1411                                || (elf_header.e_machine == EM_TI_C6000
1412                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1413                         sec_name = "SCOMMON";
1414                       else if (elf_header.e_machine == EM_MIPS
1415                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1416                         sec_name = "SUNDEF";
1417                       else if ((elf_header.e_machine == EM_X86_64
1418                                 || elf_header.e_machine == EM_L1OM
1419                                 || elf_header.e_machine == EM_K1OM)
1420                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1421                         sec_name = "LARGE_COMMON";
1422                       else if (elf_header.e_machine == EM_IA_64
1423                                && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1424                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1425                         sec_name = "ANSI_COM";
1426                       else if (is_ia64_vms ()
1427                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1428                         sec_name = "VMS_SYMVEC";
1429                       else
1430                         {
1431                           sprintf (name_buf, "<section 0x%x>",
1432                                    (unsigned int) psym->st_shndx);
1433                           sec_name = name_buf;
1434                         }
1435                     }
1436                   print_symbol (22, sec_name);
1437                 }
1438               else if (strtab == NULL)
1439                 printf (_("<string table index: %3ld>"), psym->st_name);
1440               else if (psym->st_name >= strtablen)
1441                 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1442               else
1443                 print_symbol (22, strtab + psym->st_name);
1444
1445               if (is_rela)
1446                 {
1447                   bfd_signed_vma off = rels[i].r_addend;
1448
1449                   if (off < 0)
1450                     printf (" - %" BFD_VMA_FMT "x", - off);
1451                   else
1452                     printf (" + %" BFD_VMA_FMT "x", off);
1453                 }
1454             }
1455         }
1456       else if (is_rela)
1457         {
1458           bfd_signed_vma off = rels[i].r_addend;
1459
1460           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1461           if (off < 0)
1462             printf ("-%" BFD_VMA_FMT "x", - off);
1463           else
1464             printf ("%" BFD_VMA_FMT "x", off);
1465         }
1466
1467       if (elf_header.e_machine == EM_SPARCV9
1468           && rtype != NULL
1469           && streq (rtype, "R_SPARC_OLO10"))
1470         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1471
1472       putchar ('\n');
1473
1474 #ifdef BFD64
1475       if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1476         {
1477           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1478           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1479           const char * rtype2 = elf_mips_reloc_type (type2);
1480           const char * rtype3 = elf_mips_reloc_type (type3);
1481
1482           printf ("                    Type2: ");
1483
1484           if (rtype2 == NULL)
1485             printf (_("unrecognized: %-7lx"),
1486                     (unsigned long) type2 & 0xffffffff);
1487           else
1488             printf ("%-17.17s", rtype2);
1489
1490           printf ("\n                    Type3: ");
1491
1492           if (rtype3 == NULL)
1493             printf (_("unrecognized: %-7lx"),
1494                     (unsigned long) type3 & 0xffffffff);
1495           else
1496             printf ("%-17.17s", rtype3);
1497
1498           putchar ('\n');
1499         }
1500 #endif /* BFD64 */
1501     }
1502
1503   free (rels);
1504 }
1505
1506 static const char *
1507 get_mips_dynamic_type (unsigned long type)
1508 {
1509   switch (type)
1510     {
1511     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1512     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1513     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1514     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1515     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1516     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1517     case DT_MIPS_MSYM: return "MIPS_MSYM";
1518     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1519     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1520     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1521     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1522     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1523     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1524     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1525     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1526     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1527     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1528     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1529     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1530     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1531     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1532     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1533     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1534     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1535     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1536     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1537     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1538     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1539     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1540     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1541     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1542     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1543     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1544     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1545     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1546     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1547     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1548     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1549     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1550     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1551     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1552     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1553     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1554     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1555     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1556     default:
1557       return NULL;
1558     }
1559 }
1560
1561 static const char *
1562 get_sparc64_dynamic_type (unsigned long type)
1563 {
1564   switch (type)
1565     {
1566     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1567     default:
1568       return NULL;
1569     }
1570 }
1571
1572 static const char *
1573 get_ppc_dynamic_type (unsigned long type)
1574 {
1575   switch (type)
1576     {
1577     case DT_PPC_GOT:    return "PPC_GOT";
1578     case DT_PPC_OPT:    return "PPC_OPT";
1579     default:
1580       return NULL;
1581     }
1582 }
1583
1584 static const char *
1585 get_ppc64_dynamic_type (unsigned long type)
1586 {
1587   switch (type)
1588     {
1589     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1590     case DT_PPC64_OPD:    return "PPC64_OPD";
1591     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1592     case DT_PPC64_OPT:    return "PPC64_OPT";
1593     default:
1594       return NULL;
1595     }
1596 }
1597
1598 static const char *
1599 get_parisc_dynamic_type (unsigned long type)
1600 {
1601   switch (type)
1602     {
1603     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1604     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1605     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1606     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1607     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1608     case DT_HP_PREINIT:         return "HP_PREINIT";
1609     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1610     case DT_HP_NEEDED:          return "HP_NEEDED";
1611     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1612     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1613     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1614     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1615     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1616     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1617     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1618     case DT_HP_FILTERED:        return "HP_FILTERED";
1619     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1620     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1621     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1622     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1623     case DT_PLT:                return "PLT";
1624     case DT_PLT_SIZE:           return "PLT_SIZE";
1625     case DT_DLT:                return "DLT";
1626     case DT_DLT_SIZE:           return "DLT_SIZE";
1627     default:
1628       return NULL;
1629     }
1630 }
1631
1632 static const char *
1633 get_ia64_dynamic_type (unsigned long type)
1634 {
1635   switch (type)
1636     {
1637     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1638     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1639     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1640     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1641     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1642     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1643     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1644     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1645     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1646     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1647     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1648     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1649     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1650     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1651     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1652     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1653     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1654     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1655     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1656     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1657     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1658     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1659     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1660     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1661     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1662     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1663     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1664     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1665     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1666     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1667     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1668     default:
1669       return NULL;
1670     }
1671 }
1672
1673 static const char *
1674 get_alpha_dynamic_type (unsigned long type)
1675 {
1676   switch (type)
1677     {
1678     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1679     default:
1680       return NULL;
1681     }
1682 }
1683
1684 static const char *
1685 get_score_dynamic_type (unsigned long type)
1686 {
1687   switch (type)
1688     {
1689     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1690     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1691     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1692     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1693     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1694     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1695     default:
1696       return NULL;
1697     }
1698 }
1699
1700 static const char *
1701 get_tic6x_dynamic_type (unsigned long type)
1702 {
1703   switch (type)
1704     {
1705     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1706     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1707     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
1708     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
1709     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
1710     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
1711     default:
1712       return NULL;
1713     }
1714 }
1715
1716 static const char *
1717 get_nios2_dynamic_type (unsigned long type)
1718 {
1719   switch (type)
1720     {
1721     case DT_NIOS2_GP: return "NIOS2_GP";
1722     default:
1723       return NULL;
1724     }
1725 }
1726
1727 static const char *
1728 get_dynamic_type (unsigned long type)
1729 {
1730   static char buff[64];
1731
1732   switch (type)
1733     {
1734     case DT_NULL:       return "NULL";
1735     case DT_NEEDED:     return "NEEDED";
1736     case DT_PLTRELSZ:   return "PLTRELSZ";
1737     case DT_PLTGOT:     return "PLTGOT";
1738     case DT_HASH:       return "HASH";
1739     case DT_STRTAB:     return "STRTAB";
1740     case DT_SYMTAB:     return "SYMTAB";
1741     case DT_RELA:       return "RELA";
1742     case DT_RELASZ:     return "RELASZ";
1743     case DT_RELAENT:    return "RELAENT";
1744     case DT_STRSZ:      return "STRSZ";
1745     case DT_SYMENT:     return "SYMENT";
1746     case DT_INIT:       return "INIT";
1747     case DT_FINI:       return "FINI";
1748     case DT_SONAME:     return "SONAME";
1749     case DT_RPATH:      return "RPATH";
1750     case DT_SYMBOLIC:   return "SYMBOLIC";
1751     case DT_REL:        return "REL";
1752     case DT_RELSZ:      return "RELSZ";
1753     case DT_RELENT:     return "RELENT";
1754     case DT_PLTREL:     return "PLTREL";
1755     case DT_DEBUG:      return "DEBUG";
1756     case DT_TEXTREL:    return "TEXTREL";
1757     case DT_JMPREL:     return "JMPREL";
1758     case DT_BIND_NOW:   return "BIND_NOW";
1759     case DT_INIT_ARRAY: return "INIT_ARRAY";
1760     case DT_FINI_ARRAY: return "FINI_ARRAY";
1761     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1762     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1763     case DT_RUNPATH:    return "RUNPATH";
1764     case DT_FLAGS:      return "FLAGS";
1765
1766     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1767     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1768
1769     case DT_CHECKSUM:   return "CHECKSUM";
1770     case DT_PLTPADSZ:   return "PLTPADSZ";
1771     case DT_MOVEENT:    return "MOVEENT";
1772     case DT_MOVESZ:     return "MOVESZ";
1773     case DT_FEATURE:    return "FEATURE";
1774     case DT_POSFLAG_1:  return "POSFLAG_1";
1775     case DT_SYMINSZ:    return "SYMINSZ";
1776     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
1777
1778     case DT_ADDRRNGLO:  return "ADDRRNGLO";
1779     case DT_CONFIG:     return "CONFIG";
1780     case DT_DEPAUDIT:   return "DEPAUDIT";
1781     case DT_AUDIT:      return "AUDIT";
1782     case DT_PLTPAD:     return "PLTPAD";
1783     case DT_MOVETAB:    return "MOVETAB";
1784     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
1785
1786     case DT_VERSYM:     return "VERSYM";
1787
1788     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1789     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1790     case DT_RELACOUNT:  return "RELACOUNT";
1791     case DT_RELCOUNT:   return "RELCOUNT";
1792     case DT_FLAGS_1:    return "FLAGS_1";
1793     case DT_VERDEF:     return "VERDEF";
1794     case DT_VERDEFNUM:  return "VERDEFNUM";
1795     case DT_VERNEED:    return "VERNEED";
1796     case DT_VERNEEDNUM: return "VERNEEDNUM";
1797
1798     case DT_AUXILIARY:  return "AUXILIARY";
1799     case DT_USED:       return "USED";
1800     case DT_FILTER:     return "FILTER";
1801
1802     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1803     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1804     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1805     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1806     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1807     case DT_GNU_HASH:   return "GNU_HASH";
1808
1809     default:
1810       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1811         {
1812           const char * result;
1813
1814           switch (elf_header.e_machine)
1815             {
1816             case EM_MIPS:
1817             case EM_MIPS_RS3_LE:
1818               result = get_mips_dynamic_type (type);
1819               break;
1820             case EM_SPARCV9:
1821               result = get_sparc64_dynamic_type (type);
1822               break;
1823             case EM_PPC:
1824               result = get_ppc_dynamic_type (type);
1825               break;
1826             case EM_PPC64:
1827               result = get_ppc64_dynamic_type (type);
1828               break;
1829             case EM_IA_64:
1830               result = get_ia64_dynamic_type (type);
1831               break;
1832             case EM_ALPHA:
1833               result = get_alpha_dynamic_type (type);
1834               break;
1835             case EM_SCORE:
1836               result = get_score_dynamic_type (type);
1837               break;
1838             case EM_TI_C6000:
1839               result = get_tic6x_dynamic_type (type);
1840               break;
1841             case EM_ALTERA_NIOS2:
1842               result = get_nios2_dynamic_type (type);
1843               break;
1844             default:
1845               result = NULL;
1846               break;
1847             }
1848
1849           if (result != NULL)
1850             return result;
1851
1852           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1853         }
1854       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1855                || (elf_header.e_machine == EM_PARISC
1856                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1857         {
1858           const char * result;
1859
1860           switch (elf_header.e_machine)
1861             {
1862             case EM_PARISC:
1863               result = get_parisc_dynamic_type (type);
1864               break;
1865             case EM_IA_64:
1866               result = get_ia64_dynamic_type (type);
1867               break;
1868             default:
1869               result = NULL;
1870               break;
1871             }
1872
1873           if (result != NULL)
1874             return result;
1875
1876           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1877                     type);
1878         }
1879       else
1880         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1881
1882       return buff;
1883     }
1884 }
1885
1886 static char *
1887 get_file_type (unsigned e_type)
1888 {
1889   static char buff[32];
1890
1891   switch (e_type)
1892     {
1893     case ET_NONE:       return _("NONE (None)");
1894     case ET_REL:        return _("REL (Relocatable file)");
1895     case ET_EXEC:       return _("EXEC (Executable file)");
1896     case ET_DYN:        return _("DYN (Shared object file)");
1897     case ET_CORE:       return _("CORE (Core file)");
1898
1899     default:
1900       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1901         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1902       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1903         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1904       else
1905         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1906       return buff;
1907     }
1908 }
1909
1910 static char *
1911 get_machine_name (unsigned e_machine)
1912 {
1913   static char buff[64]; /* XXX */
1914
1915   switch (e_machine)
1916     {
1917     case EM_NONE:               return _("None");
1918     case EM_AARCH64:            return "AArch64";
1919     case EM_M32:                return "WE32100";
1920     case EM_SPARC:              return "Sparc";
1921     case EM_SPU:                return "SPU";
1922     case EM_386:                return "Intel 80386";
1923     case EM_68K:                return "MC68000";
1924     case EM_88K:                return "MC88000";
1925     case EM_486:                return "Intel 80486";
1926     case EM_860:                return "Intel 80860";
1927     case EM_MIPS:               return "MIPS R3000";
1928     case EM_S370:               return "IBM System/370";
1929     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
1930     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
1931     case EM_PARISC:             return "HPPA";
1932     case EM_PPC_OLD:            return "Power PC (old)";
1933     case EM_SPARC32PLUS:        return "Sparc v8+" ;
1934     case EM_960:                return "Intel 90860";
1935     case EM_PPC:                return "PowerPC";
1936     case EM_PPC64:              return "PowerPC64";
1937     case EM_FR20:               return "Fujitsu FR20";
1938     case EM_RH32:               return "TRW RH32";
1939     case EM_MCORE:              return "MCORE";
1940     case EM_ARM:                return "ARM";
1941     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
1942     case EM_SH:                 return "Renesas / SuperH SH";
1943     case EM_SPARCV9:            return "Sparc v9";
1944     case EM_TRICORE:            return "Siemens Tricore";
1945     case EM_ARC:                return "ARC";
1946     case EM_H8_300:             return "Renesas H8/300";
1947     case EM_H8_300H:            return "Renesas H8/300H";
1948     case EM_H8S:                return "Renesas H8S";
1949     case EM_H8_500:             return "Renesas H8/500";
1950     case EM_IA_64:              return "Intel IA-64";
1951     case EM_MIPS_X:             return "Stanford MIPS-X";
1952     case EM_COLDFIRE:           return "Motorola Coldfire";
1953     case EM_ALPHA:              return "Alpha";
1954     case EM_CYGNUS_D10V:
1955     case EM_D10V:               return "d10v";
1956     case EM_CYGNUS_D30V:
1957     case EM_D30V:               return "d30v";
1958     case EM_CYGNUS_M32R:
1959     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
1960     case EM_CYGNUS_V850:
1961     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
1962     case EM_V850:               return "Renesas V850";
1963     case EM_CYGNUS_MN10300:
1964     case EM_MN10300:            return "mn10300";
1965     case EM_CYGNUS_MN10200:
1966     case EM_MN10200:            return "mn10200";
1967     case EM_MOXIE:              return "Moxie";
1968     case EM_CYGNUS_FR30:
1969     case EM_FR30:               return "Fujitsu FR30";
1970     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
1971     case EM_PJ_OLD:
1972     case EM_PJ:                 return "picoJava";
1973     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
1974     case EM_PCP:                return "Siemens PCP";
1975     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
1976     case EM_NDR1:               return "Denso NDR1 microprocesspr";
1977     case EM_STARCORE:           return "Motorola Star*Core processor";
1978     case EM_ME16:               return "Toyota ME16 processor";
1979     case EM_ST100:              return "STMicroelectronics ST100 processor";
1980     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
1981     case EM_PDSP:               return "Sony DSP processor";
1982     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
1983     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
1984     case EM_FX66:               return "Siemens FX66 microcontroller";
1985     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1986     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
1987     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
1988     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
1989     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
1990     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
1991     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
1992     case EM_SVX:                return "Silicon Graphics SVx";
1993     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
1994     case EM_VAX:                return "Digital VAX";
1995     case EM_AVR_OLD:
1996     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
1997     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
1998     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
1999     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2000     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2001     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2002     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2003     case EM_PRISM:              return "Vitesse Prism";
2004     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2005     case EM_L1OM:               return "Intel L1OM";
2006     case EM_K1OM:               return "Intel K1OM";
2007     case EM_S390_OLD:
2008     case EM_S390:               return "IBM S/390";
2009     case EM_SCORE:              return "SUNPLUS S+Core";
2010     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2011     case EM_OPENRISC:
2012     case EM_OR32:               return "OpenRISC";
2013     case EM_ARC_A5:             return "ARC International ARCompact processor";
2014     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2015     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2016     case EM_DLX:                return "OpenDLX";
2017     case EM_IP2K_OLD:
2018     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2019     case EM_IQ2000:             return "Vitesse IQ2000";
2020     case EM_XTENSA_OLD:
2021     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2022     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2023     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2024     case EM_NS32K:              return "National Semiconductor 32000 series";
2025     case EM_TPC:                return "Tenor Network TPC processor";
2026     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2027     case EM_MAX:                return "MAX Processor";
2028     case EM_CR:                 return "National Semiconductor CompactRISC";
2029     case EM_F2MC16:             return "Fujitsu F2MC16";
2030     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2031     case EM_LATTICEMICO32:      return "Lattice Mico32";
2032     case EM_M32C_OLD:
2033     case EM_M32C:               return "Renesas M32c";
2034     case EM_MT:                 return "Morpho Techologies MT processor";
2035     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2036     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2037     case EM_SEP:                return "Sharp embedded microprocessor";
2038     case EM_ARCA:               return "Arca RISC microprocessor";
2039     case EM_UNICORE:            return "Unicore";
2040     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2041     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2042     case EM_NIOS32:             return "Altera Nios";
2043     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2044     case EM_C166:
2045     case EM_XC16X:              return "Infineon Technologies xc16x";
2046     case EM_M16C:               return "Renesas M16C series microprocessors";
2047     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2048     case EM_CE:                 return "Freescale Communication Engine RISC core";
2049     case EM_TSK3000:            return "Altium TSK3000 core";
2050     case EM_RS08:               return "Freescale RS08 embedded processor";
2051     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2052     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2053     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2054     case EM_SE_C17:             return "Seiko Epson C17 family";
2055     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2056     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2057     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2058     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2059     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2060     case EM_R32C:               return "Renesas R32C series microprocessors";
2061     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2062     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2063     case EM_8051:               return "Intel 8051 and variants";
2064     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2065     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2066     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2067     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2068     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2069     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2070     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2071     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2072     case EM_CR16:
2073     case EM_MICROBLAZE:
2074     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2075     case EM_RL78:               return "Renesas RL78";
2076     case EM_RX:                 return "Renesas RX";
2077     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2078     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2079     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2080     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2081     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2082     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor family";
2083     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2084     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2085     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2086     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2087     case EM_CUDA:               return "NVIDIA CUDA architecture";
2088     case EM_XGATE:              return "Motorola XGATE embedded processor";
2089     default:
2090       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2091       return buff;
2092     }
2093 }
2094
2095 static void
2096 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2097 {
2098   unsigned eabi;
2099   int unknown = 0;
2100
2101   eabi = EF_ARM_EABI_VERSION (e_flags);
2102   e_flags &= ~ EF_ARM_EABIMASK;
2103
2104   /* Handle "generic" ARM flags.  */
2105   if (e_flags & EF_ARM_RELEXEC)
2106     {
2107       strcat (buf, ", relocatable executable");
2108       e_flags &= ~ EF_ARM_RELEXEC;
2109     }
2110
2111   if (e_flags & EF_ARM_HASENTRY)
2112     {
2113       strcat (buf, ", has entry point");
2114       e_flags &= ~ EF_ARM_HASENTRY;
2115     }
2116
2117   /* Now handle EABI specific flags.  */
2118   switch (eabi)
2119     {
2120     default:
2121       strcat (buf, ", <unrecognized EABI>");
2122       if (e_flags)
2123         unknown = 1;
2124       break;
2125
2126     case EF_ARM_EABI_VER1:
2127       strcat (buf, ", Version1 EABI");
2128       while (e_flags)
2129         {
2130           unsigned flag;
2131
2132           /* Process flags one bit at a time.  */
2133           flag = e_flags & - e_flags;
2134           e_flags &= ~ flag;
2135
2136           switch (flag)
2137             {
2138             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2139               strcat (buf, ", sorted symbol tables");
2140               break;
2141
2142             default:
2143               unknown = 1;
2144               break;
2145             }
2146         }
2147       break;
2148
2149     case EF_ARM_EABI_VER2:
2150       strcat (buf, ", Version2 EABI");
2151       while (e_flags)
2152         {
2153           unsigned flag;
2154
2155           /* Process flags one bit at a time.  */
2156           flag = e_flags & - e_flags;
2157           e_flags &= ~ flag;
2158
2159           switch (flag)
2160             {
2161             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2162               strcat (buf, ", sorted symbol tables");
2163               break;
2164
2165             case EF_ARM_DYNSYMSUSESEGIDX:
2166               strcat (buf, ", dynamic symbols use segment index");
2167               break;
2168
2169             case EF_ARM_MAPSYMSFIRST:
2170               strcat (buf, ", mapping symbols precede others");
2171               break;
2172
2173             default:
2174               unknown = 1;
2175               break;
2176             }
2177         }
2178       break;
2179
2180     case EF_ARM_EABI_VER3:
2181       strcat (buf, ", Version3 EABI");
2182       break;
2183
2184     case EF_ARM_EABI_VER4:
2185       strcat (buf, ", Version4 EABI");
2186       while (e_flags)
2187         {
2188           unsigned flag;
2189
2190           /* Process flags one bit at a time.  */
2191           flag = e_flags & - e_flags;
2192           e_flags &= ~ flag;
2193
2194           switch (flag)
2195             {
2196             case EF_ARM_BE8:
2197               strcat (buf, ", BE8");
2198               break;
2199
2200             case EF_ARM_LE8:
2201               strcat (buf, ", LE8");
2202               break;
2203
2204             default:
2205               unknown = 1;
2206               break;
2207             }
2208       break;
2209         }
2210       break;
2211
2212     case EF_ARM_EABI_VER5:
2213       strcat (buf, ", Version5 EABI");
2214       while (e_flags)
2215         {
2216           unsigned flag;
2217
2218           /* Process flags one bit at a time.  */
2219           flag = e_flags & - e_flags;
2220           e_flags &= ~ flag;
2221
2222           switch (flag)
2223             {
2224             case EF_ARM_BE8:
2225               strcat (buf, ", BE8");
2226               break;
2227
2228             case EF_ARM_LE8:
2229               strcat (buf, ", LE8");
2230               break;
2231
2232             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2233               strcat (buf, ", soft-float ABI");
2234               break;
2235
2236             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2237               strcat (buf, ", hard-float ABI");
2238               break;
2239
2240             default:
2241               unknown = 1;
2242               break;
2243             }
2244         }
2245       break;
2246
2247     case EF_ARM_EABI_UNKNOWN:
2248       strcat (buf, ", GNU EABI");
2249       while (e_flags)
2250         {
2251           unsigned flag;
2252
2253           /* Process flags one bit at a time.  */
2254           flag = e_flags & - e_flags;
2255           e_flags &= ~ flag;
2256
2257           switch (flag)
2258             {
2259             case EF_ARM_INTERWORK:
2260               strcat (buf, ", interworking enabled");
2261               break;
2262
2263             case EF_ARM_APCS_26:
2264               strcat (buf, ", uses APCS/26");
2265               break;
2266
2267             case EF_ARM_APCS_FLOAT:
2268               strcat (buf, ", uses APCS/float");
2269               break;
2270
2271             case EF_ARM_PIC:
2272               strcat (buf, ", position independent");
2273               break;
2274
2275             case EF_ARM_ALIGN8:
2276               strcat (buf, ", 8 bit structure alignment");
2277               break;
2278
2279             case EF_ARM_NEW_ABI:
2280               strcat (buf, ", uses new ABI");
2281               break;
2282
2283             case EF_ARM_OLD_ABI:
2284               strcat (buf, ", uses old ABI");
2285               break;
2286
2287             case EF_ARM_SOFT_FLOAT:
2288               strcat (buf, ", software FP");
2289               break;
2290
2291             case EF_ARM_VFP_FLOAT:
2292               strcat (buf, ", VFP");
2293               break;
2294
2295             case EF_ARM_MAVERICK_FLOAT:
2296               strcat (buf, ", Maverick FP");
2297               break;
2298
2299             default:
2300               unknown = 1;
2301               break;
2302             }
2303         }
2304     }
2305
2306   if (unknown)
2307     strcat (buf,_(", <unknown>"));
2308 }
2309
2310 static char *
2311 get_machine_flags (unsigned e_flags, unsigned e_machine)
2312 {
2313   static char buf[1024];
2314
2315   buf[0] = '\0';
2316
2317   if (e_flags)
2318     {
2319       switch (e_machine)
2320         {
2321         default:
2322           break;
2323
2324         case EM_ARM:
2325           decode_ARM_machine_flags (e_flags, buf);
2326           break;
2327
2328         case EM_BLACKFIN:
2329           if (e_flags & EF_BFIN_PIC)
2330             strcat (buf, ", PIC");
2331
2332           if (e_flags & EF_BFIN_FDPIC)
2333             strcat (buf, ", FDPIC");
2334
2335           if (e_flags & EF_BFIN_CODE_IN_L1)
2336             strcat (buf, ", code in L1");
2337
2338           if (e_flags & EF_BFIN_DATA_IN_L1)
2339             strcat (buf, ", data in L1");
2340
2341           break;
2342
2343         case EM_CYGNUS_FRV:
2344           switch (e_flags & EF_FRV_CPU_MASK)
2345             {
2346             case EF_FRV_CPU_GENERIC:
2347               break;
2348
2349             default:
2350               strcat (buf, ", fr???");
2351               break;
2352
2353             case EF_FRV_CPU_FR300:
2354               strcat (buf, ", fr300");
2355               break;
2356
2357             case EF_FRV_CPU_FR400:
2358               strcat (buf, ", fr400");
2359               break;
2360             case EF_FRV_CPU_FR405:
2361               strcat (buf, ", fr405");
2362               break;
2363
2364             case EF_FRV_CPU_FR450:
2365               strcat (buf, ", fr450");
2366               break;
2367
2368             case EF_FRV_CPU_FR500:
2369               strcat (buf, ", fr500");
2370               break;
2371             case EF_FRV_CPU_FR550:
2372               strcat (buf, ", fr550");
2373               break;
2374
2375             case EF_FRV_CPU_SIMPLE:
2376               strcat (buf, ", simple");
2377               break;
2378             case EF_FRV_CPU_TOMCAT:
2379               strcat (buf, ", tomcat");
2380               break;
2381             }
2382           break;
2383
2384         case EM_68K:
2385           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2386             strcat (buf, ", m68000");
2387           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2388             strcat (buf, ", cpu32");
2389           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2390             strcat (buf, ", fido_a");
2391           else
2392             {
2393               char const * isa = _("unknown");
2394               char const * mac = _("unknown mac");
2395               char const * additional = NULL;
2396
2397               switch (e_flags & EF_M68K_CF_ISA_MASK)
2398                 {
2399                 case EF_M68K_CF_ISA_A_NODIV:
2400                   isa = "A";
2401                   additional = ", nodiv";
2402                   break;
2403                 case EF_M68K_CF_ISA_A:
2404                   isa = "A";
2405                   break;
2406                 case EF_M68K_CF_ISA_A_PLUS:
2407                   isa = "A+";
2408                   break;
2409                 case EF_M68K_CF_ISA_B_NOUSP:
2410                   isa = "B";
2411                   additional = ", nousp";
2412                   break;
2413                 case EF_M68K_CF_ISA_B:
2414                   isa = "B";
2415                   break;
2416                 case EF_M68K_CF_ISA_C:
2417                   isa = "C";
2418                   break;
2419                 case EF_M68K_CF_ISA_C_NODIV:
2420                   isa = "C";
2421                   additional = ", nodiv";
2422                   break;
2423                 }
2424               strcat (buf, ", cf, isa ");
2425               strcat (buf, isa);
2426               if (additional)
2427                 strcat (buf, additional);
2428               if (e_flags & EF_M68K_CF_FLOAT)
2429                 strcat (buf, ", float");
2430               switch (e_flags & EF_M68K_CF_MAC_MASK)
2431                 {
2432                 case 0:
2433                   mac = NULL;
2434                   break;
2435                 case EF_M68K_CF_MAC:
2436                   mac = "mac";
2437                   break;
2438                 case EF_M68K_CF_EMAC:
2439                   mac = "emac";
2440                   break;
2441                 case EF_M68K_CF_EMAC_B:
2442                   mac = "emac_b";
2443                   break;
2444                 }
2445               if (mac)
2446                 {
2447                   strcat (buf, ", ");
2448                   strcat (buf, mac);
2449                 }
2450             }
2451           break;
2452
2453         case EM_PPC:
2454           if (e_flags & EF_PPC_EMB)
2455             strcat (buf, ", emb");
2456
2457           if (e_flags & EF_PPC_RELOCATABLE)
2458             strcat (buf, _(", relocatable"));
2459
2460           if (e_flags & EF_PPC_RELOCATABLE_LIB)
2461             strcat (buf, _(", relocatable-lib"));
2462           break;
2463
2464         case EM_PPC64:
2465           if (e_flags & EF_PPC64_ABI)
2466             {
2467               char abi[] = ", abiv0";
2468
2469               abi[6] += e_flags & EF_PPC64_ABI;
2470               strcat (buf, abi);
2471             }
2472           break;
2473
2474         case EM_V800:
2475           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2476             strcat (buf, ", RH850 ABI");
2477
2478           if (e_flags & EF_V800_850E3)
2479             strcat (buf, ", V3 architecture");
2480
2481           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2482             strcat (buf, ", FPU not used");
2483
2484           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2485             strcat (buf, ", regmode: COMMON");
2486
2487           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2488             strcat (buf, ", r4 not used");
2489
2490           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2491             strcat (buf, ", r30 not used");
2492
2493           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2494             strcat (buf, ", r5 not used");
2495
2496           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2497             strcat (buf, ", r2 not used");
2498
2499           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2500             {
2501               switch (e_flags & - e_flags)
2502                 {
2503                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2504                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2505                 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2506                 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2507                 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2508                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2509                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2510                 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2511                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2512                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2513                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2514                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2515                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2516                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2517                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2518                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2519                 default: break;
2520                 }
2521             }
2522           break;
2523
2524         case EM_V850:
2525         case EM_CYGNUS_V850:
2526           switch (e_flags & EF_V850_ARCH)
2527             {
2528             case E_V850E3V5_ARCH:
2529               strcat (buf, ", v850e3v5");
2530               break;
2531             case E_V850E2V3_ARCH:
2532               strcat (buf, ", v850e2v3");
2533               break;
2534             case E_V850E2_ARCH:
2535               strcat (buf, ", v850e2");
2536               break;
2537             case E_V850E1_ARCH:
2538               strcat (buf, ", v850e1");
2539               break;
2540             case E_V850E_ARCH:
2541               strcat (buf, ", v850e");
2542               break;
2543             case E_V850_ARCH:
2544               strcat (buf, ", v850");
2545               break;
2546             default:
2547               strcat (buf, _(", unknown v850 architecture variant"));
2548               break;
2549             }
2550           break;
2551
2552         case EM_M32R:
2553         case EM_CYGNUS_M32R:
2554           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2555             strcat (buf, ", m32r");
2556           break;
2557
2558         case EM_MIPS:
2559         case EM_MIPS_RS3_LE:
2560           if (e_flags & EF_MIPS_NOREORDER)
2561             strcat (buf, ", noreorder");
2562
2563           if (e_flags & EF_MIPS_PIC)
2564             strcat (buf, ", pic");
2565
2566           if (e_flags & EF_MIPS_CPIC)
2567             strcat (buf, ", cpic");
2568
2569           if (e_flags & EF_MIPS_UCODE)
2570             strcat (buf, ", ugen_reserved");
2571
2572           if (e_flags & EF_MIPS_ABI2)
2573             strcat (buf, ", abi2");
2574
2575           if (e_flags & EF_MIPS_OPTIONS_FIRST)
2576             strcat (buf, ", odk first");
2577
2578           if (e_flags & EF_MIPS_32BITMODE)
2579             strcat (buf, ", 32bitmode");
2580
2581           if (e_flags & EF_MIPS_NAN2008)
2582             strcat (buf, ", nan2008");
2583
2584           if (e_flags & EF_MIPS_FP64)
2585             strcat (buf, ", fp64");
2586
2587           switch ((e_flags & EF_MIPS_MACH))
2588             {
2589             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2590             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2591             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2592             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2593             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2594             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2595             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2596             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2597             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
2598             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2599             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2600             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2601             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
2602             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2603             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2604             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
2605             case 0:
2606             /* We simply ignore the field in this case to avoid confusion:
2607                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2608                extension.  */
2609               break;
2610             default: strcat (buf, _(", unknown CPU")); break;
2611             }
2612
2613           switch ((e_flags & EF_MIPS_ABI))
2614             {
2615             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2616             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2617             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2618             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2619             case 0:
2620             /* We simply ignore the field in this case to avoid confusion:
2621                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2622                This means it is likely to be an o32 file, but not for
2623                sure.  */
2624               break;
2625             default: strcat (buf, _(", unknown ABI")); break;
2626             }
2627
2628           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2629             strcat (buf, ", mdmx");
2630
2631           if (e_flags & EF_MIPS_ARCH_ASE_M16)
2632             strcat (buf, ", mips16");
2633
2634           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2635             strcat (buf, ", micromips");
2636
2637           switch ((e_flags & EF_MIPS_ARCH))
2638             {
2639             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2640             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2641             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2642             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2643             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2644             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2645             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2646             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2647             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2648             default: strcat (buf, _(", unknown ISA")); break;
2649             }
2650           break;
2651
2652         case EM_SH:
2653           switch ((e_flags & EF_SH_MACH_MASK))
2654             {
2655             case EF_SH1: strcat (buf, ", sh1"); break;
2656             case EF_SH2: strcat (buf, ", sh2"); break;
2657             case EF_SH3: strcat (buf, ", sh3"); break;
2658             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2659             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2660             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2661             case EF_SH3E: strcat (buf, ", sh3e"); break;
2662             case EF_SH4: strcat (buf, ", sh4"); break;
2663             case EF_SH5: strcat (buf, ", sh5"); break;
2664             case EF_SH2E: strcat (buf, ", sh2e"); break;
2665             case EF_SH4A: strcat (buf, ", sh4a"); break;
2666             case EF_SH2A: strcat (buf, ", sh2a"); break;
2667             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2668             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2669             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2670             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2671             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2672             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2673             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2674             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2675             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2676             default: strcat (buf, _(", unknown ISA")); break;
2677             }
2678
2679           if (e_flags & EF_SH_PIC)
2680             strcat (buf, ", pic");
2681
2682           if (e_flags & EF_SH_FDPIC)
2683             strcat (buf, ", fdpic");
2684           break;
2685
2686         case EM_SPARCV9:
2687           if (e_flags & EF_SPARC_32PLUS)
2688             strcat (buf, ", v8+");
2689
2690           if (e_flags & EF_SPARC_SUN_US1)
2691             strcat (buf, ", ultrasparcI");
2692
2693           if (e_flags & EF_SPARC_SUN_US3)
2694             strcat (buf, ", ultrasparcIII");
2695
2696           if (e_flags & EF_SPARC_HAL_R1)
2697             strcat (buf, ", halr1");
2698
2699           if (e_flags & EF_SPARC_LEDATA)
2700             strcat (buf, ", ledata");
2701
2702           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2703             strcat (buf, ", tso");
2704
2705           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2706             strcat (buf, ", pso");
2707
2708           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2709             strcat (buf, ", rmo");
2710           break;
2711
2712         case EM_PARISC:
2713           switch (e_flags & EF_PARISC_ARCH)
2714             {
2715             case EFA_PARISC_1_0:
2716               strcpy (buf, ", PA-RISC 1.0");
2717               break;
2718             case EFA_PARISC_1_1:
2719               strcpy (buf, ", PA-RISC 1.1");
2720               break;
2721             case EFA_PARISC_2_0:
2722               strcpy (buf, ", PA-RISC 2.0");
2723               break;
2724             default:
2725               break;
2726             }
2727           if (e_flags & EF_PARISC_TRAPNIL)
2728             strcat (buf, ", trapnil");
2729           if (e_flags & EF_PARISC_EXT)
2730             strcat (buf, ", ext");
2731           if (e_flags & EF_PARISC_LSB)
2732             strcat (buf, ", lsb");
2733           if (e_flags & EF_PARISC_WIDE)
2734             strcat (buf, ", wide");
2735           if (e_flags & EF_PARISC_NO_KABP)
2736             strcat (buf, ", no kabp");
2737           if (e_flags & EF_PARISC_LAZYSWAP)
2738             strcat (buf, ", lazyswap");
2739           break;
2740
2741         case EM_PJ:
2742         case EM_PJ_OLD:
2743           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2744             strcat (buf, ", new calling convention");
2745
2746           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2747             strcat (buf, ", gnu calling convention");
2748           break;
2749
2750         case EM_IA_64:
2751           if ((e_flags & EF_IA_64_ABI64))
2752             strcat (buf, ", 64-bit");
2753           else
2754             strcat (buf, ", 32-bit");
2755           if ((e_flags & EF_IA_64_REDUCEDFP))
2756             strcat (buf, ", reduced fp model");
2757           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2758             strcat (buf, ", no function descriptors, constant gp");
2759           else if ((e_flags & EF_IA_64_CONS_GP))
2760             strcat (buf, ", constant gp");
2761           if ((e_flags & EF_IA_64_ABSOLUTE))
2762             strcat (buf, ", absolute");
2763           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2764             {
2765               if ((e_flags & EF_IA_64_VMS_LINKAGES))
2766                 strcat (buf, ", vms_linkages");
2767               switch ((e_flags & EF_IA_64_VMS_COMCOD))
2768                 {
2769                 case EF_IA_64_VMS_COMCOD_SUCCESS:
2770                   break;
2771                 case EF_IA_64_VMS_COMCOD_WARNING:
2772                   strcat (buf, ", warning");
2773                   break;
2774                 case EF_IA_64_VMS_COMCOD_ERROR:
2775                   strcat (buf, ", error");
2776                   break;
2777                 case EF_IA_64_VMS_COMCOD_ABORT:
2778                   strcat (buf, ", abort");
2779                   break;
2780                 default:
2781                   abort ();
2782                 }
2783             }
2784           break;
2785
2786         case EM_VAX:
2787           if ((e_flags & EF_VAX_NONPIC))
2788             strcat (buf, ", non-PIC");
2789           if ((e_flags & EF_VAX_DFLOAT))
2790             strcat (buf, ", D-Float");
2791           if ((e_flags & EF_VAX_GFLOAT))
2792             strcat (buf, ", G-Float");
2793           break;
2794
2795         case EM_RL78:
2796           if (e_flags & E_FLAG_RL78_G10)
2797             strcat (buf, ", G10");
2798           break;
2799
2800         case EM_RX:
2801           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2802             strcat (buf, ", 64-bit doubles");
2803           if (e_flags & E_FLAG_RX_DSP)
2804             strcat (buf, ", dsp");
2805           if (e_flags & E_FLAG_RX_PID)
2806             strcat (buf, ", pid");
2807           if (e_flags & E_FLAG_RX_ABI)
2808             strcat (buf, ", RX ABI");
2809           break;
2810
2811         case EM_S390:
2812           if (e_flags & EF_S390_HIGH_GPRS)
2813             strcat (buf, ", highgprs");
2814           break;
2815
2816         case EM_TI_C6000:
2817           if ((e_flags & EF_C6000_REL))
2818             strcat (buf, ", relocatable module");
2819           break;
2820
2821         case EM_MSP430:
2822           strcat (buf, _(": architecture variant: "));
2823           switch (e_flags & EF_MSP430_MACH)
2824             {
2825             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
2826             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
2827             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
2828             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
2829             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
2830             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
2831             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
2832             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
2833             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
2834             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
2835             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
2836             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
2837             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
2838             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
2839             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
2840             default:
2841               strcat (buf, _(": unknown")); break;
2842             }
2843
2844           if (e_flags & ~ EF_MSP430_MACH)
2845             strcat (buf, _(": unknown extra flag bits also present"));
2846         }
2847     }
2848
2849   return buf;
2850 }
2851
2852 static const char *
2853 get_osabi_name (unsigned int osabi)
2854 {
2855   static char buff[32];
2856
2857   switch (osabi)
2858     {
2859     case ELFOSABI_NONE:         return "UNIX - System V";
2860     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
2861     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
2862     case ELFOSABI_GNU:          return "UNIX - GNU";
2863     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
2864     case ELFOSABI_AIX:          return "UNIX - AIX";
2865     case ELFOSABI_IRIX:         return "UNIX - IRIX";
2866     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
2867     case ELFOSABI_TRU64:        return "UNIX - TRU64";
2868     case ELFOSABI_MODESTO:      return "Novell - Modesto";
2869     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
2870     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
2871     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
2872     case ELFOSABI_AROS:         return "AROS";
2873     case ELFOSABI_FENIXOS:      return "FenixOS";
2874     default:
2875       if (osabi >= 64)
2876         switch (elf_header.e_machine)
2877           {
2878           case EM_ARM:
2879             switch (osabi)
2880               {
2881               case ELFOSABI_ARM:        return "ARM";
2882               default:
2883                 break;
2884               }
2885             break;
2886
2887           case EM_MSP430:
2888           case EM_MSP430_OLD:
2889             switch (osabi)
2890               {
2891               case ELFOSABI_STANDALONE: return _("Standalone App");
2892               default:
2893                 break;
2894               }
2895             break;
2896
2897           case EM_TI_C6000:
2898             switch (osabi)
2899               {
2900               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
2901               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
2902               default:
2903                 break;
2904               }
2905             break;
2906
2907           default:
2908             break;
2909           }
2910       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2911       return buff;
2912     }
2913 }
2914
2915 static const char *
2916 get_aarch64_segment_type (unsigned long type)
2917 {
2918   switch (type)
2919     {
2920     case PT_AARCH64_ARCHEXT:
2921       return "AARCH64_ARCHEXT";
2922     default:
2923       break;
2924     }
2925
2926   return NULL;
2927 }
2928
2929 static const char *
2930 get_arm_segment_type (unsigned long type)
2931 {
2932   switch (type)
2933     {
2934     case PT_ARM_EXIDX:
2935       return "EXIDX";
2936     default:
2937       break;
2938     }
2939
2940   return NULL;
2941 }
2942
2943 static const char *
2944 get_mips_segment_type (unsigned long type)
2945 {
2946   switch (type)
2947     {
2948     case PT_MIPS_REGINFO:
2949       return "REGINFO";
2950     case PT_MIPS_RTPROC:
2951       return "RTPROC";
2952     case PT_MIPS_OPTIONS:
2953       return "OPTIONS";
2954     default:
2955       break;
2956     }
2957
2958   return NULL;
2959 }
2960
2961 static const char *
2962 get_parisc_segment_type (unsigned long type)
2963 {
2964   switch (type)
2965     {
2966     case PT_HP_TLS:             return "HP_TLS";
2967     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
2968     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
2969     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
2970     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
2971     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
2972     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
2973     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
2974     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
2975     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
2976     case PT_HP_PARALLEL:        return "HP_PARALLEL";
2977     case PT_HP_FASTBIND:        return "HP_FASTBIND";
2978     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
2979     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
2980     case PT_HP_STACK:           return "HP_STACK";
2981     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
2982     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
2983     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
2984     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
2985     default:
2986       break;
2987     }
2988
2989   return NULL;
2990 }
2991
2992 static const char *
2993 get_ia64_segment_type (unsigned long type)
2994 {
2995   switch (type)
2996     {
2997     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
2998     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
2999     case PT_HP_TLS:             return "HP_TLS";
3000     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3001     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3002     case PT_IA_64_HP_STACK:     return "HP_STACK";
3003     default:
3004       break;
3005     }
3006
3007   return NULL;
3008 }
3009
3010 static const char *
3011 get_tic6x_segment_type (unsigned long type)
3012 {
3013   switch (type)
3014     {
3015     case PT_C6000_PHATTR:       return "C6000_PHATTR";
3016     default:
3017       break;
3018     }
3019
3020   return NULL;
3021 }
3022
3023 static const char *
3024 get_segment_type (unsigned long p_type)
3025 {
3026   static char buff[32];
3027
3028   switch (p_type)
3029     {
3030     case PT_NULL:       return "NULL";
3031     case PT_LOAD:       return "LOAD";
3032     case PT_DYNAMIC:    return "DYNAMIC";
3033     case PT_INTERP:     return "INTERP";
3034     case PT_NOTE:       return "NOTE";
3035     case PT_SHLIB:      return "SHLIB";
3036     case PT_PHDR:       return "PHDR";
3037     case PT_TLS:        return "TLS";
3038
3039     case PT_GNU_EH_FRAME:
3040                         return "GNU_EH_FRAME";
3041     case PT_GNU_STACK:  return "GNU_STACK";
3042     case PT_GNU_RELRO:  return "GNU_RELRO";
3043
3044     default:
3045       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3046         {
3047           const char * result;
3048
3049           switch (elf_header.e_machine)
3050             {
3051             case EM_AARCH64:
3052               result = get_aarch64_segment_type (p_type);
3053               break;
3054             case EM_ARM:
3055               result = get_arm_segment_type (p_type);
3056               break;
3057             case EM_MIPS:
3058             case EM_MIPS_RS3_LE:
3059               result = get_mips_segment_type (p_type);
3060               break;
3061             case EM_PARISC:
3062               result = get_parisc_segment_type (p_type);
3063               break;
3064             case EM_IA_64:
3065               result = get_ia64_segment_type (p_type);
3066               break;
3067             case EM_TI_C6000:
3068               result = get_tic6x_segment_type (p_type);
3069               break;
3070             default:
3071               result = NULL;
3072               break;
3073             }
3074
3075           if (result != NULL)
3076             return result;
3077
3078           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3079         }
3080       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3081         {
3082           const char * result;
3083
3084           switch (elf_header.e_machine)
3085             {
3086             case EM_PARISC:
3087               result = get_parisc_segment_type (p_type);
3088               break;
3089             case EM_IA_64:
3090               result = get_ia64_segment_type (p_type);
3091               break;
3092             default:
3093               result = NULL;
3094               break;
3095             }
3096
3097           if (result != NULL)
3098             return result;
3099
3100           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3101         }
3102       else
3103         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3104
3105       return buff;
3106     }
3107 }
3108
3109 static const char *
3110 get_mips_section_type_name (unsigned int sh_type)
3111 {
3112   switch (sh_type)
3113     {
3114     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3115     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3116     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3117     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3118     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3119     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3120     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3121     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3122     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3123     case SHT_MIPS_RELD:          return "MIPS_RELD";
3124     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3125     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3126     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3127     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3128     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3129     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3130     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3131     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3132     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3133     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3134     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3135     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3136     case SHT_MIPS_LINE:          return "MIPS_LINE";
3137     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3138     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3139     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3140     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3141     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3142     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3143     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3144     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3145     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3146     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3147     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3148     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3149     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3150     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3151     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3152     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3153     default:
3154       break;
3155     }
3156   return NULL;
3157 }
3158
3159 static const char *
3160 get_parisc_section_type_name (unsigned int sh_type)
3161 {
3162   switch (sh_type)
3163     {
3164     case SHT_PARISC_EXT:        return "PARISC_EXT";
3165     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
3166     case SHT_PARISC_DOC:        return "PARISC_DOC";
3167     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
3168     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
3169     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
3170     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
3171     default:
3172       break;
3173     }
3174   return NULL;
3175 }
3176
3177 static const char *
3178 get_ia64_section_type_name (unsigned int sh_type)
3179 {
3180   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
3181   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3182     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3183
3184   switch (sh_type)
3185     {
3186     case SHT_IA_64_EXT:                return "IA_64_EXT";
3187     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
3188     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
3189     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
3190     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3191     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
3192     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
3193     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
3194     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
3195     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
3196     default:
3197       break;
3198     }
3199   return NULL;
3200 }
3201
3202 static const char *
3203 get_x86_64_section_type_name (unsigned int sh_type)
3204 {
3205   switch (sh_type)
3206     {
3207     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
3208     default:
3209       break;
3210     }
3211   return NULL;
3212 }
3213
3214 static const char *
3215 get_aarch64_section_type_name (unsigned int sh_type)
3216 {
3217   switch (sh_type)
3218     {
3219     case SHT_AARCH64_ATTRIBUTES:
3220       return "AARCH64_ATTRIBUTES";
3221     default:
3222       break;
3223     }
3224   return NULL;
3225 }
3226
3227 static const char *
3228 get_arm_section_type_name (unsigned int sh_type)
3229 {
3230   switch (sh_type)
3231     {
3232     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
3233     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
3234     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
3235     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
3236     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
3237     default:
3238       break;
3239     }
3240   return NULL;
3241 }
3242
3243 static const char *
3244 get_tic6x_section_type_name (unsigned int sh_type)
3245 {
3246   switch (sh_type)
3247     {
3248     case SHT_C6000_UNWIND:
3249       return "C6000_UNWIND";
3250     case SHT_C6000_PREEMPTMAP:
3251       return "C6000_PREEMPTMAP";
3252     case SHT_C6000_ATTRIBUTES:
3253       return "C6000_ATTRIBUTES";
3254     case SHT_TI_ICODE:
3255       return "TI_ICODE";
3256     case SHT_TI_XREF:
3257       return "TI_XREF";
3258     case SHT_TI_HANDLER:
3259       return "TI_HANDLER";
3260     case SHT_TI_INITINFO:
3261       return "TI_INITINFO";
3262     case SHT_TI_PHATTRS:
3263       return "TI_PHATTRS";
3264     default:
3265       break;
3266     }
3267   return NULL;
3268 }
3269
3270 static const char *
3271 get_msp430x_section_type_name (unsigned int sh_type)
3272 {
3273   switch (sh_type)
3274     {
3275     case SHT_MSP430_SEC_FLAGS:   return "MSP430_SEC_FLAGS";
3276     case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3277     case SHT_MSP430_ATTRIBUTES:  return "MSP430_ATTRIBUTES";
3278     default: return NULL;
3279     }
3280 }
3281
3282 static const char *
3283 get_section_type_name (unsigned int sh_type)
3284 {
3285   static char buff[32];
3286
3287   switch (sh_type)
3288     {
3289     case SHT_NULL:              return "NULL";
3290     case SHT_PROGBITS:          return "PROGBITS";
3291     case SHT_SYMTAB:            return "SYMTAB";
3292     case SHT_STRTAB:            return "STRTAB";
3293     case SHT_RELA:              return "RELA";
3294     case SHT_HASH:              return "HASH";
3295     case SHT_DYNAMIC:           return "DYNAMIC";
3296     case SHT_NOTE:              return "NOTE";
3297     case SHT_NOBITS:            return "NOBITS";
3298     case SHT_REL:               return "REL";
3299     case SHT_SHLIB:             return "SHLIB";
3300     case SHT_DYNSYM:            return "DYNSYM";
3301     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
3302     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
3303     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
3304     case SHT_GNU_HASH:          return "GNU_HASH";
3305     case SHT_GROUP:             return "GROUP";
3306     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
3307     case SHT_GNU_verdef:        return "VERDEF";
3308     case SHT_GNU_verneed:       return "VERNEED";
3309     case SHT_GNU_versym:        return "VERSYM";
3310     case 0x6ffffff0:            return "VERSYM";
3311     case 0x6ffffffc:            return "VERDEF";
3312     case 0x7ffffffd:            return "AUXILIARY";
3313     case 0x7fffffff:            return "FILTER";
3314     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
3315
3316     default:
3317       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3318         {
3319           const char * result;
3320
3321           switch (elf_header.e_machine)
3322             {
3323             case EM_MIPS:
3324             case EM_MIPS_RS3_LE:
3325               result = get_mips_section_type_name (sh_type);
3326               break;
3327             case EM_PARISC:
3328               result = get_parisc_section_type_name (sh_type);
3329               break;
3330             case EM_IA_64:
3331               result = get_ia64_section_type_name (sh_type);
3332               break;
3333             case EM_X86_64:
3334             case EM_L1OM:
3335             case EM_K1OM:
3336               result = get_x86_64_section_type_name (sh_type);
3337               break;
3338             case EM_AARCH64:
3339               result = get_aarch64_section_type_name (sh_type);
3340               break;
3341             case EM_ARM:
3342               result = get_arm_section_type_name (sh_type);
3343               break;
3344             case EM_TI_C6000:
3345               result = get_tic6x_section_type_name (sh_type);
3346               break;
3347             case EM_MSP430:
3348               result = get_msp430x_section_type_name (sh_type);
3349               break;
3350             default:
3351               result = NULL;
3352               break;
3353             }
3354
3355           if (result != NULL)
3356             return result;
3357
3358           sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3359         }
3360       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3361         {
3362           const char * result;
3363
3364           switch (elf_header.e_machine)
3365             {
3366             case EM_IA_64:
3367               result = get_ia64_section_type_name (sh_type);
3368               break;
3369             default:
3370               result = NULL;
3371               break;
3372             }
3373
3374           if (result != NULL)
3375             return result;
3376
3377           sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3378         }
3379       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3380         sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3381       else
3382         /* This message is probably going to be displayed in a 15
3383            character wide field, so put the hex value first.  */
3384         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3385
3386       return buff;
3387     }
3388 }
3389
3390 #define OPTION_DEBUG_DUMP       512
3391 #define OPTION_DYN_SYMS         513
3392 #define OPTION_DWARF_DEPTH      514
3393 #define OPTION_DWARF_START      515
3394 #define OPTION_DWARF_CHECK      516
3395
3396 static struct option options[] =
3397 {
3398   {"all",              no_argument, 0, 'a'},
3399   {"file-header",      no_argument, 0, 'h'},
3400   {"program-headers",  no_argument, 0, 'l'},
3401   {"headers",          no_argument, 0, 'e'},
3402   {"histogram",        no_argument, 0, 'I'},
3403   {"segments",         no_argument, 0, 'l'},
3404   {"sections",         no_argument, 0, 'S'},
3405   {"section-headers",  no_argument, 0, 'S'},
3406   {"section-groups",   no_argument, 0, 'g'},
3407   {"section-details",  no_argument, 0, 't'},
3408   {"full-section-name",no_argument, 0, 'N'},
3409   {"symbols",          no_argument, 0, 's'},
3410   {"syms",             no_argument, 0, 's'},
3411   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
3412   {"relocs",           no_argument, 0, 'r'},
3413   {"notes",            no_argument, 0, 'n'},
3414   {"dynamic",          no_argument, 0, 'd'},
3415   {"arch-specific",    no_argument, 0, 'A'},
3416   {"version-info",     no_argument, 0, 'V'},
3417   {"use-dynamic",      no_argument, 0, 'D'},
3418   {"unwind",           no_argument, 0, 'u'},
3419   {"archive-index",    no_argument, 0, 'c'},
3420   {"hex-dump",         required_argument, 0, 'x'},
3421   {"relocated-dump",   required_argument, 0, 'R'},
3422   {"string-dump",      required_argument, 0, 'p'},
3423 #ifdef SUPPORT_DISASSEMBLY
3424   {"instruction-dump", required_argument, 0, 'i'},
3425 #endif
3426   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
3427
3428   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
3429   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
3430   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
3431
3432   {"version",          no_argument, 0, 'v'},
3433   {"wide",             no_argument, 0, 'W'},
3434   {"help",             no_argument, 0, 'H'},
3435   {0,                  no_argument, 0, 0}
3436 };
3437
3438 static void
3439 usage (FILE * stream)
3440 {
3441   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3442   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3443   fprintf (stream, _(" Options are:\n\
3444   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3445   -h --file-header       Display the ELF file header\n\
3446   -l --program-headers   Display the program headers\n\
3447      --segments          An alias for --program-headers\n\
3448   -S --section-headers   Display the sections' header\n\
3449      --sections          An alias for --section-headers\n\
3450   -g --section-groups    Display the section groups\n\
3451   -t --section-details   Display the section details\n\
3452   -e --headers           Equivalent to: -h -l -S\n\
3453   -s --syms              Display the symbol table\n\
3454      --symbols           An alias for --syms\n\
3455   --dyn-syms             Display the dynamic symbol table\n\
3456   -n --notes             Display the core notes (if present)\n\
3457   -r --relocs            Display the relocations (if present)\n\
3458   -u --unwind            Display the unwind info (if present)\n\
3459   -d --dynamic           Display the dynamic section (if present)\n\
3460   -V --version-info      Display the version sections (if present)\n\
3461   -A --arch-specific     Display architecture specific information (if any)\n\
3462   -c --archive-index     Display the symbol/file index in an archive\n\
3463   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
3464   -x --hex-dump=<number|name>\n\
3465                          Dump the contents of section <number|name> as bytes\n\
3466   -p --string-dump=<number|name>\n\
3467                          Dump the contents of section <number|name> as strings\n\
3468   -R --relocated-dump=<number|name>\n\
3469                          Dump the contents of section <number|name> as relocated bytes\n\
3470   -w[lLiaprmfFsoRt] or\n\
3471   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3472                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3473                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3474                =addr,=cu_index]\n\
3475                          Display the contents of DWARF2 debug sections\n"));
3476   fprintf (stream, _("\
3477   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
3478   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
3479                          or deeper\n"));
3480 #ifdef SUPPORT_DISASSEMBLY
3481   fprintf (stream, _("\
3482   -i --instruction-dump=<number|name>\n\
3483                          Disassemble the contents of section <number|name>\n"));
3484 #endif
3485   fprintf (stream, _("\
3486   -I --histogram         Display histogram of bucket list lengths\n\
3487   -W --wide              Allow output width to exceed 80 characters\n\
3488   @<file>                Read options from <file>\n\
3489   -H --help              Display this information\n\
3490   -v --version           Display the version number of readelf\n"));
3491
3492   if (REPORT_BUGS_TO[0] && stream == stdout)
3493     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3494
3495   exit (stream == stdout ? 0 : 1);
3496 }
3497
3498 /* Record the fact that the user wants the contents of section number
3499    SECTION to be displayed using the method(s) encoded as flags bits
3500    in TYPE.  Note, TYPE can be zero if we are creating the array for
3501    the first time.  */
3502
3503 static void
3504 request_dump_bynumber (unsigned int section, dump_type type)
3505 {
3506   if (section >= num_dump_sects)
3507     {
3508       dump_type * new_dump_sects;
3509
3510       new_dump_sects = (dump_type *) calloc (section + 1,
3511                                              sizeof (* dump_sects));
3512
3513       if (new_dump_sects == NULL)
3514         error (_("Out of memory allocating dump request table.\n"));
3515       else
3516         {
3517           /* Copy current flag settings.  */
3518           memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3519
3520           free (dump_sects);
3521
3522           dump_sects = new_dump_sects;
3523           num_dump_sects = section + 1;
3524         }
3525     }
3526
3527   if (dump_sects)
3528     dump_sects[section] |= type;
3529
3530   return;
3531 }
3532
3533 /* Request a dump by section name.  */
3534
3535 static void
3536 request_dump_byname (const char * section, dump_type type)
3537 {
3538   struct dump_list_entry * new_request;
3539
3540   new_request = (struct dump_list_entry *)
3541       malloc (sizeof (struct dump_list_entry));
3542   if (!new_request)
3543     error (_("Out of memory allocating dump request table.\n"));
3544
3545   new_request->name = strdup (section);
3546   if (!new_request->name)
3547     error (_("Out of memory allocating dump request table.\n"));
3548
3549   new_request->type = type;
3550
3551   new_request->next = dump_sects_byname;
3552   dump_sects_byname = new_request;
3553 }
3554
3555 static inline void
3556 request_dump (dump_type type)
3557 {
3558   int section;
3559   char * cp;
3560
3561   do_dump++;
3562   section = strtoul (optarg, & cp, 0);
3563
3564   if (! *cp && section >= 0)
3565     request_dump_bynumber (section, type);
3566   else
3567     request_dump_byname (optarg, type);
3568 }
3569
3570
3571 static void
3572 parse_args (int argc, char ** argv)
3573 {
3574   int c;
3575
3576   if (argc < 2)
3577     usage (stderr);
3578
3579   while ((c = getopt_long
3580           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3581     {
3582       switch (c)
3583         {
3584         case 0:
3585           /* Long options.  */
3586           break;
3587         case 'H':
3588           usage (stdout);
3589           break;
3590
3591         case 'a':
3592           do_syms++;
3593           do_reloc++;
3594           do_unwind++;
3595           do_dynamic++;
3596           do_header++;
3597           do_sections++;
3598           do_section_groups++;
3599           do_segments++;
3600           do_version++;
3601           do_histogram++;
3602           do_arch++;
3603           do_notes++;
3604           break;
3605         case 'g':
3606           do_section_groups++;
3607           break;
3608         case 't':
3609         case 'N':
3610           do_sections++;
3611           do_section_details++;
3612           break;
3613         case 'e':
3614           do_header++;
3615           do_sections++;
3616           do_segments++;
3617           break;
3618         case 'A':
3619           do_arch++;
3620           break;
3621         case 'D':
3622           do_using_dynamic++;
3623           break;
3624         case 'r':
3625           do_reloc++;
3626           break;
3627         case 'u':
3628           do_unwind++;
3629           break;
3630         case 'h':
3631           do_header++;
3632           break;
3633         case 'l':
3634           do_segments++;
3635           break;
3636         case 's':
3637           do_syms++;
3638           break;
3639         case 'S':
3640           do_sections++;
3641           break;
3642         case 'd':
3643           do_dynamic++;
3644           break;
3645         case 'I':
3646           do_histogram++;
3647           break;
3648         case 'n':
3649           do_notes++;
3650           break;
3651         case 'c':
3652           do_archive_index++;
3653           break;
3654         case 'x':
3655           request_dump (HEX_DUMP);
3656           break;
3657         case 'p':
3658           request_dump (STRING_DUMP);
3659           break;
3660         case 'R':
3661           request_dump (RELOC_DUMP);
3662           break;
3663         case 'w':
3664           do_dump++;
3665           if (optarg == 0)
3666             {
3667               do_debugging = 1;
3668               dwarf_select_sections_all ();
3669             }
3670           else
3671             {
3672               do_debugging = 0;
3673               dwarf_select_sections_by_letters (optarg);
3674             }
3675           break;
3676         case OPTION_DEBUG_DUMP:
3677           do_dump++;
3678           if (optarg == 0)
3679             do_debugging = 1;
3680           else
3681             {
3682               do_debugging = 0;
3683               dwarf_select_sections_by_names (optarg);
3684             }
3685           break;
3686         case OPTION_DWARF_DEPTH:
3687           {
3688             char *cp;
3689
3690             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3691           }
3692           break;
3693         case OPTION_DWARF_START:
3694           {
3695             char *cp;
3696
3697             dwarf_start_die = strtoul (optarg, & cp, 0);
3698           }
3699           break;
3700         case OPTION_DWARF_CHECK:
3701           dwarf_check = 1;
3702           break;
3703         case OPTION_DYN_SYMS:
3704           do_dyn_syms++;
3705           break;
3706 #ifdef SUPPORT_DISASSEMBLY
3707         case 'i':
3708           request_dump (DISASS_DUMP);
3709           break;
3710 #endif
3711         case 'v':
3712           print_version (program_name);
3713           break;
3714         case 'V':
3715           do_version++;
3716           break;
3717         case 'W':
3718           do_wide++;
3719           break;
3720         default:
3721           /* xgettext:c-format */
3722           error (_("Invalid option '-%c'\n"), c);
3723           /* Drop through.  */
3724         case '?':
3725           usage (stderr);
3726         }
3727     }
3728
3729   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3730       && !do_segments && !do_header && !do_dump && !do_version
3731       && !do_histogram && !do_debugging && !do_arch && !do_notes
3732       && !do_section_groups && !do_archive_index
3733       && !do_dyn_syms)
3734     usage (stderr);
3735   else if (argc < 3)
3736     {
3737       warn (_("Nothing to do.\n"));
3738       usage (stderr);
3739     }
3740 }
3741
3742 static const char *
3743 get_elf_class (unsigned int elf_class)
3744 {
3745   static char buff[32];
3746
3747   switch (elf_class)
3748     {
3749     case ELFCLASSNONE: return _("none");
3750     case ELFCLASS32:   return "ELF32";
3751     case ELFCLASS64:   return "ELF64";
3752     default:
3753       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3754       return buff;
3755     }
3756 }
3757
3758 static const char *
3759 get_data_encoding (unsigned int encoding)
3760 {
3761   static char buff[32];
3762
3763   switch (encoding)
3764     {
3765     case ELFDATANONE: return _("none");
3766     case ELFDATA2LSB: return _("2's complement, little endian");
3767     case ELFDATA2MSB: return _("2's complement, big endian");
3768     default:
3769       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3770       return buff;
3771     }
3772 }
3773
3774 /* Decode the data held in 'elf_header'.  */
3775
3776 static int
3777 process_file_header (void)
3778 {
3779   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
3780       || elf_header.e_ident[EI_MAG1] != ELFMAG1
3781       || elf_header.e_ident[EI_MAG2] != ELFMAG2
3782       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3783     {
3784       error
3785         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3786       return 0;
3787     }
3788
3789   init_dwarf_regnames (elf_header.e_machine);
3790
3791   if (do_header)
3792     {
3793       int i;
3794
3795       printf (_("ELF Header:\n"));
3796       printf (_("  Magic:   "));
3797       for (i = 0; i < EI_NIDENT; i++)
3798         printf ("%2.2x ", elf_header.e_ident[i]);
3799       printf ("\n");
3800       printf (_("  Class:                             %s\n"),
3801               get_elf_class (elf_header.e_ident[EI_CLASS]));
3802       printf (_("  Data:                              %s\n"),
3803               get_data_encoding (elf_header.e_ident[EI_DATA]));
3804       printf (_("  Version:                           %d %s\n"),
3805               elf_header.e_ident[EI_VERSION],
3806               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3807                ? "(current)"
3808                : (elf_header.e_ident[EI_VERSION] != EV_NONE
3809                   ? _("<unknown: %lx>")
3810                   : "")));
3811       printf (_("  OS/ABI:                            %s\n"),
3812               get_osabi_name (elf_header.e_ident[EI_OSABI]));
3813       printf (_("  ABI Version:                       %d\n"),
3814               elf_header.e_ident[EI_ABIVERSION]);
3815       printf (_("  Type:                              %s\n"),
3816               get_file_type (elf_header.e_type));
3817       printf (_("  Machine:                           %s\n"),
3818               get_machine_name (elf_header.e_machine));
3819       printf (_("  Version:                           0x%lx\n"),
3820               (unsigned long) elf_header.e_version);
3821
3822       printf (_("  Entry point address:               "));
3823       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3824       printf (_("\n  Start of program headers:          "));
3825       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3826       printf (_(" (bytes into file)\n  Start of section headers:          "));
3827       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3828       printf (_(" (bytes into file)\n"));
3829
3830       printf (_("  Flags:                             0x%lx%s\n"),
3831               (unsigned long) elf_header.e_flags,
3832               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3833       printf (_("  Size of this header:               %ld (bytes)\n"),
3834               (long) elf_header.e_ehsize);
3835       printf (_("  Size of program headers:           %ld (bytes)\n"),
3836               (long) elf_header.e_phentsize);
3837       printf (_("  Number of program headers:         %ld"),
3838               (long) elf_header.e_phnum);
3839       if (section_headers != NULL
3840           && elf_header.e_phnum == PN_XNUM
3841           && section_headers[0].sh_info != 0)
3842         printf (" (%ld)", (long) section_headers[0].sh_info);
3843       putc ('\n', stdout);
3844       printf (_("  Size of section headers:           %ld (bytes)\n"),
3845               (long) elf_header.e_shentsize);
3846       printf (_("  Number of section headers:         %ld"),
3847               (long) elf_header.e_shnum);
3848       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
3849         printf (" (%ld)", (long) section_headers[0].sh_size);
3850       putc ('\n', stdout);
3851       printf (_("  Section header string table index: %ld"),
3852               (long) elf_header.e_shstrndx);
3853       if (section_headers != NULL
3854           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3855         printf (" (%u)", section_headers[0].sh_link);
3856       else if (elf_header.e_shstrndx != SHN_UNDEF
3857                && elf_header.e_shstrndx >= elf_header.e_shnum)
3858         printf (_(" <corrupt: out of range>"));
3859       putc ('\n', stdout);
3860     }
3861
3862   if (section_headers != NULL)
3863     {
3864       if (elf_header.e_phnum == PN_XNUM
3865           && section_headers[0].sh_info != 0)
3866         elf_header.e_phnum = section_headers[0].sh_info;
3867       if (elf_header.e_shnum == SHN_UNDEF)
3868         elf_header.e_shnum = section_headers[0].sh_size;
3869       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3870         elf_header.e_shstrndx = section_headers[0].sh_link;
3871       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3872         elf_header.e_shstrndx = SHN_UNDEF;
3873       free (section_headers);
3874       section_headers = NULL;
3875     }
3876
3877   return 1;
3878 }
3879
3880
3881 static int
3882 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3883 {
3884   Elf32_External_Phdr * phdrs;
3885   Elf32_External_Phdr * external;
3886   Elf_Internal_Phdr *   internal;
3887   unsigned int i;
3888
3889   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3890                                             elf_header.e_phentsize,
3891                                             elf_header.e_phnum,
3892                                             _("program headers"));
3893   if (!phdrs)
3894     return 0;
3895
3896   for (i = 0, internal = pheaders, external = phdrs;
3897        i < elf_header.e_phnum;
3898        i++, internal++, external++)
3899     {
3900       internal->p_type   = BYTE_GET (external->p_type);
3901       internal->p_offset = BYTE_GET (external->p_offset);
3902       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
3903       internal->p_paddr  = BYTE_GET (external->p_paddr);
3904       internal->p_filesz = BYTE_GET (external->p_filesz);
3905       internal->p_memsz  = BYTE_GET (external->p_memsz);
3906       internal->p_flags  = BYTE_GET (external->p_flags);
3907       internal->p_align  = BYTE_GET (external->p_align);
3908     }
3909
3910   free (phdrs);
3911
3912   return 1;
3913 }
3914
3915 static int
3916 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3917 {
3918   Elf64_External_Phdr * phdrs;
3919   Elf64_External_Phdr * external;
3920   Elf_Internal_Phdr *   internal;
3921   unsigned int i;
3922
3923   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3924                                             elf_header.e_phentsize,
3925                                             elf_header.e_phnum,
3926                                             _("program headers"));
3927   if (!phdrs)
3928     return 0;
3929
3930   for (i = 0, internal = pheaders, external = phdrs;
3931        i < elf_header.e_phnum;
3932        i++, internal++, external++)
3933     {
3934       internal->p_type   = BYTE_GET (external->p_type);
3935       internal->p_flags  = BYTE_GET (external->p_flags);
3936       internal->p_offset = BYTE_GET (external->p_offset);
3937       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
3938       internal->p_paddr  = BYTE_GET (external->p_paddr);
3939       internal->p_filesz = BYTE_GET (external->p_filesz);
3940       internal->p_memsz  = BYTE_GET (external->p_memsz);
3941       internal->p_align  = BYTE_GET (external->p_align);
3942     }
3943
3944   free (phdrs);
3945
3946   return 1;
3947 }
3948
3949 /* Returns 1 if the program headers were read into `program_headers'.  */
3950
3951 static int
3952 get_program_headers (FILE * file)
3953 {
3954   Elf_Internal_Phdr * phdrs;
3955
3956   /* Check cache of prior read.  */
3957   if (program_headers != NULL)
3958     return 1;
3959
3960   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3961                                          sizeof (Elf_Internal_Phdr));
3962
3963   if (phdrs == NULL)
3964     {
3965       error (_("Out of memory\n"));
3966       return 0;
3967     }
3968
3969   if (is_32bit_elf
3970       ? get_32bit_program_headers (file, phdrs)
3971       : get_64bit_program_headers (file, phdrs))
3972     {
3973       program_headers = phdrs;
3974       return 1;
3975     }
3976
3977   free (phdrs);
3978   return 0;
3979 }
3980
3981 /* Returns 1 if the program headers were loaded.  */
3982
3983 static int
3984 process_program_headers (FILE * file)
3985 {
3986   Elf_Internal_Phdr * segment;
3987   unsigned int i;
3988
3989   if (elf_header.e_phnum == 0)
3990     {
3991       /* PR binutils/12467.  */
3992       if (elf_header.e_phoff != 0)
3993         warn (_("possibly corrupt ELF header - it has a non-zero program"
3994                 " header offset, but no program headers"));
3995       else if (do_segments)
3996         printf (_("\nThere are no program headers in this file.\n"));
3997       return 0;
3998     }
3999
4000   if (do_segments && !do_header)
4001     {
4002       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4003       printf (_("Entry point "));
4004       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4005       printf (_("\nThere are %d program headers, starting at offset "),
4006               elf_header.e_phnum);
4007       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4008       printf ("\n");
4009     }
4010
4011   if (! get_program_headers (file))
4012       return 0;
4013
4014   if (do_segments)
4015     {
4016       if (elf_header.e_phnum > 1)
4017         printf (_("\nProgram Headers:\n"));
4018       else
4019         printf (_("\nProgram Headers:\n"));
4020
4021       if (is_32bit_elf)
4022         printf
4023           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4024       else if (do_wide)
4025         printf
4026           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4027       else
4028         {
4029           printf
4030             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4031           printf
4032             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4033         }
4034     }
4035
4036   dynamic_addr = 0;
4037   dynamic_size = 0;
4038
4039   for (i = 0, segment = program_headers;
4040        i < elf_header.e_phnum;
4041        i++, segment++)
4042     {
4043       if (do_segments)
4044         {
4045           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4046
4047           if (is_32bit_elf)
4048             {
4049               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4050               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4051               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4052               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4053               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4054               printf ("%c%c%c ",
4055                       (segment->p_flags & PF_R ? 'R' : ' '),
4056                       (segment->p_flags & PF_W ? 'W' : ' '),
4057                       (segment->p_flags & PF_X ? 'E' : ' '));
4058               printf ("%#lx", (unsigned long) segment->p_align);
4059             }
4060           else if (do_wide)
4061             {
4062               if ((unsigned long) segment->p_offset == segment->p_offset)
4063                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4064               else
4065                 {
4066                   print_vma (segment->p_offset, FULL_HEX);
4067                   putchar (' ');
4068                 }
4069
4070               print_vma (segment->p_vaddr, FULL_HEX);
4071               putchar (' ');
4072               print_vma (segment->p_paddr, FULL_HEX);
4073               putchar (' ');
4074
4075               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4076                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4077               else
4078                 {
4079                   print_vma (segment->p_filesz, FULL_HEX);
4080                   putchar (' ');
4081                 }
4082
4083               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4084                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4085               else
4086                 {
4087                   print_vma (segment->p_memsz, FULL_HEX);
4088                 }
4089
4090               printf (" %c%c%c ",
4091                       (segment->p_flags & PF_R ? 'R' : ' '),
4092                       (segment->p_flags & PF_W ? 'W' : ' '),
4093                       (segment->p_flags & PF_X ? 'E' : ' '));
4094
4095               if ((unsigned long) segment->p_align == segment->p_align)
4096                 printf ("%#lx", (unsigned long) segment->p_align);
4097               else
4098                 {
4099                   print_vma (segment->p_align, PREFIX_HEX);
4100                 }
4101             }
4102           else
4103             {
4104               print_vma (segment->p_offset, FULL_HEX);
4105               putchar (' ');
4106               print_vma (segment->p_vaddr, FULL_HEX);
4107               putchar (' ');
4108               print_vma (segment->p_paddr, FULL_HEX);
4109               printf ("\n                 ");
4110               print_vma (segment->p_filesz, FULL_HEX);
4111               putchar (' ');
4112               print_vma (segment->p_memsz, FULL_HEX);
4113               printf ("  %c%c%c    ",
4114                       (segment->p_flags & PF_R ? 'R' : ' '),
4115                       (segment->p_flags & PF_W ? 'W' : ' '),
4116                       (segment->p_flags & PF_X ? 'E' : ' '));
4117               print_vma (segment->p_align, HEX);
4118             }
4119         }
4120
4121       switch (segment->p_type)
4122         {
4123         case PT_DYNAMIC:
4124           if (dynamic_addr)
4125             error (_("more than one dynamic segment\n"));
4126
4127           /* By default, assume that the .dynamic section is the first
4128              section in the DYNAMIC segment.  */
4129           dynamic_addr = segment->p_offset;
4130           dynamic_size = segment->p_filesz;
4131
4132           /* Try to locate the .dynamic section. If there is
4133              a section header table, we can easily locate it.  */
4134           if (section_headers != NULL)
4135             {
4136               Elf_Internal_Shdr * sec;
4137
4138               sec = find_section (".dynamic");
4139               if (sec == NULL || sec->sh_size == 0)
4140                 {
4141                   /* A corresponding .dynamic section is expected, but on
4142                      IA-64/OpenVMS it is OK for it to be missing.  */
4143                   if (!is_ia64_vms ())
4144                     error (_("no .dynamic section in the dynamic segment\n"));
4145                   break;
4146                 }
4147
4148               if (sec->sh_type == SHT_NOBITS)
4149                 {
4150                   dynamic_size = 0;
4151                   break;
4152                 }
4153
4154               dynamic_addr = sec->sh_offset;
4155               dynamic_size = sec->sh_size;
4156
4157               if (dynamic_addr < segment->p_offset
4158                   || dynamic_addr > segment->p_offset + segment->p_filesz)
4159                 warn (_("the .dynamic section is not contained"
4160                         " within the dynamic segment\n"));
4161               else if (dynamic_addr > segment->p_offset)
4162                 warn (_("the .dynamic section is not the first section"
4163                         " in the dynamic segment.\n"));
4164             }
4165           break;
4166
4167         case PT_INTERP:
4168           if (fseek (file, archive_file_offset + (long) segment->p_offset,
4169                      SEEK_SET))
4170             error (_("Unable to find program interpreter name\n"));
4171           else
4172             {
4173               char fmt [32];
4174               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
4175
4176               if (ret >= (int) sizeof (fmt) || ret < 0)
4177                 error (_("Internal error: failed to create format string to display program interpreter\n"));
4178
4179               program_interpreter[0] = 0;
4180               if (fscanf (file, fmt, program_interpreter) <= 0)
4181                 error (_("Unable to read program interpreter name\n"));
4182
4183               if (do_segments)
4184                 printf (_("\n      [Requesting program interpreter: %s]"),
4185                     program_interpreter);
4186             }
4187           break;
4188         }
4189
4190       if (do_segments)
4191         putc ('\n', stdout);
4192     }
4193
4194   if (do_segments && section_headers != NULL && string_table != NULL)
4195     {
4196       printf (_("\n Section to Segment mapping:\n"));
4197       printf (_("  Segment Sections...\n"));
4198
4199       for (i = 0; i < elf_header.e_phnum; i++)
4200         {
4201           unsigned int j;
4202           Elf_Internal_Shdr * section;
4203
4204           segment = program_headers + i;
4205           section = section_headers + 1;
4206
4207           printf ("   %2.2d     ", i);
4208
4209           for (j = 1; j < elf_header.e_shnum; j++, section++)
4210             {
4211               if (!ELF_TBSS_SPECIAL (section, segment)
4212                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4213                 printf ("%s ", SECTION_NAME (section));
4214             }
4215
4216           putc ('\n',stdout);
4217         }
4218     }
4219
4220   return 1;
4221 }
4222
4223
4224 /* Find the file offset corresponding to VMA by using the program headers.  */
4225
4226 static long
4227 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4228 {
4229   Elf_Internal_Phdr * seg;
4230
4231   if (! get_program_headers (file))
4232     {
4233       warn (_("Cannot interpret virtual addresses without program headers.\n"));
4234       return (long) vma;
4235     }
4236
4237   for (seg = program_headers;
4238        seg < program_headers + elf_header.e_phnum;
4239        ++seg)
4240     {
4241       if (seg->p_type != PT_LOAD)
4242         continue;
4243
4244       if (vma >= (seg->p_vaddr & -seg->p_align)
4245           && vma + size <= seg->p_vaddr + seg->p_filesz)
4246         return vma - seg->p_vaddr + seg->p_offset;
4247     }
4248
4249   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4250         (unsigned long) vma);
4251   return (long) vma;
4252 }
4253
4254
4255 static int
4256 get_32bit_section_headers (FILE * file, unsigned int num)
4257 {
4258   Elf32_External_Shdr * shdrs;
4259   Elf_Internal_Shdr *   internal;
4260   unsigned int i;
4261
4262   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4263                                             elf_header.e_shentsize, num,
4264                                             _("section headers"));
4265   if (!shdrs)
4266     return 0;
4267
4268   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4269                                                    sizeof (Elf_Internal_Shdr));
4270
4271   if (section_headers == NULL)
4272     {
4273       error (_("Out of memory\n"));
4274       return 0;
4275     }
4276
4277   for (i = 0, internal = section_headers;
4278        i < num;
4279        i++, internal++)
4280     {
4281       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4282       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4283       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4284       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4285       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4286       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4287       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4288       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4289       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4290       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4291     }
4292
4293   free (shdrs);
4294
4295   return 1;
4296 }
4297
4298 static int
4299 get_64bit_section_headers (FILE * file, unsigned int num)
4300 {
4301   Elf64_External_Shdr * shdrs;
4302   Elf_Internal_Shdr *   internal;
4303   unsigned int i;
4304
4305   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4306                                             elf_header.e_shentsize, num,
4307                                             _("section headers"));
4308   if (!shdrs)
4309     return 0;
4310
4311   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4312                                                    sizeof (Elf_Internal_Shdr));
4313
4314   if (section_headers == NULL)
4315     {
4316       error (_("Out of memory\n"));
4317       return 0;
4318     }
4319
4320   for (i = 0, internal = section_headers;
4321        i < num;
4322        i++, internal++)
4323     {
4324       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4325       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4326       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4327       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4328       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4329       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4330       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4331       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4332       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4333       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4334     }
4335
4336   free (shdrs);
4337
4338   return 1;
4339 }
4340
4341 static Elf_Internal_Sym *
4342 get_32bit_elf_symbols (FILE * file,
4343                        Elf_Internal_Shdr * section,
4344                        unsigned long * num_syms_return)
4345 {
4346   unsigned long number = 0;
4347   Elf32_External_Sym * esyms = NULL;
4348   Elf_External_Sym_Shndx * shndx = NULL;
4349   Elf_Internal_Sym * isyms = NULL;
4350   Elf_Internal_Sym * psym;
4351   unsigned int j;
4352
4353   /* Run some sanity checks first.  */
4354   if (section->sh_entsize == 0)
4355     {
4356       error (_("sh_entsize is zero\n"));
4357       goto exit_point;
4358     }
4359
4360   number = section->sh_size / section->sh_entsize;
4361
4362   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4363     {
4364       error (_("Invalid sh_entsize\n"));
4365       goto exit_point;
4366     }
4367
4368   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4369                                            section->sh_size, _("symbols"));
4370   if (esyms == NULL)
4371     goto exit_point;
4372
4373   shndx = NULL;
4374   if (symtab_shndx_hdr != NULL
4375       && (symtab_shndx_hdr->sh_link
4376           == (unsigned long) (section - section_headers)))
4377     {
4378       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4379                                                    symtab_shndx_hdr->sh_offset,
4380                                                    1, symtab_shndx_hdr->sh_size,
4381                                                    _("symbol table section indicies"));
4382       if (shndx == NULL)
4383         goto exit_point;
4384     }
4385
4386   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4387
4388   if (isyms == NULL)
4389     {
4390       error (_("Out of memory\n"));
4391       goto exit_point;
4392     }
4393
4394   for (j = 0, psym = isyms; j < number; j++, psym++)
4395     {
4396       psym->st_name  = BYTE_GET (esyms[j].st_name);
4397       psym->st_value = BYTE_GET (esyms[j].st_value);
4398       psym->st_size  = BYTE_GET (esyms[j].st_size);
4399       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4400       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4401         psym->st_shndx
4402           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4403       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4404         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4405       psym->st_info  = BYTE_GET (esyms[j].st_info);
4406       psym->st_other = BYTE_GET (esyms[j].st_other);
4407     }
4408
4409  exit_point:
4410   if (shndx != NULL)
4411     free (shndx);
4412   if (esyms != NULL)
4413     free (esyms);
4414
4415   if (num_syms_return != NULL)
4416     * num_syms_return = isyms == NULL ? 0 : number;
4417
4418   return isyms;
4419 }
4420
4421 static Elf_Internal_Sym *
4422 get_64bit_elf_symbols (FILE * file,
4423                        Elf_Internal_Shdr * section,
4424                        unsigned long * num_syms_return)
4425 {
4426   unsigned long number = 0;
4427   Elf64_External_Sym * esyms = NULL;
4428   Elf_External_Sym_Shndx * shndx = NULL;
4429   Elf_Internal_Sym * isyms = NULL;
4430   Elf_Internal_Sym * psym;
4431   unsigned int j;
4432
4433   /* Run some sanity checks first.  */
4434   if (section->sh_entsize == 0)
4435     {
4436       error (_("sh_entsize is zero\n"));
4437       goto exit_point;
4438     }
4439
4440   number = section->sh_size / section->sh_entsize;
4441
4442   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4443     {
4444       error (_("Invalid sh_entsize\n"));
4445       goto exit_point;
4446     }
4447
4448   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4449                                            section->sh_size, _("symbols"));
4450   if (!esyms)
4451     goto exit_point;
4452
4453   if (symtab_shndx_hdr != NULL
4454       && (symtab_shndx_hdr->sh_link
4455           == (unsigned long) (section - section_headers)))
4456     {
4457       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4458                                                    symtab_shndx_hdr->sh_offset,
4459                                                    1, symtab_shndx_hdr->sh_size,
4460                                                    _("symbol table section indicies"));
4461       if (shndx == NULL)
4462         goto exit_point;
4463     }
4464
4465   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4466
4467   if (isyms == NULL)
4468     {
4469       error (_("Out of memory\n"));
4470       goto exit_point;
4471     }
4472
4473   for (j = 0, psym = isyms; j < number; j++, psym++)
4474     {
4475       psym->st_name  = BYTE_GET (esyms[j].st_name);
4476       psym->st_info  = BYTE_GET (esyms[j].st_info);
4477       psym->st_other = BYTE_GET (esyms[j].st_other);
4478       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4479
4480       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4481         psym->st_shndx
4482           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4483       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4484         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4485
4486       psym->st_value = BYTE_GET (esyms[j].st_value);
4487       psym->st_size  = BYTE_GET (esyms[j].st_size);
4488     }
4489
4490  exit_point:
4491   if (shndx != NULL)
4492     free (shndx);
4493   if (esyms != NULL)
4494     free (esyms);
4495
4496   if (num_syms_return != NULL)
4497     * num_syms_return = isyms == NULL ? 0 : number;
4498
4499   return isyms;
4500 }
4501
4502 static const char *
4503 get_elf_section_flags (bfd_vma sh_flags)
4504 {
4505   static char buff[1024];
4506   char * p = buff;
4507   int field_size = is_32bit_elf ? 8 : 16;
4508   int sindex;
4509   int size = sizeof (buff) - (field_size + 4 + 1);
4510   bfd_vma os_flags = 0;
4511   bfd_vma proc_flags = 0;
4512   bfd_vma unknown_flags = 0;
4513   static const struct
4514     {
4515       const char * str;
4516       int len;
4517     }
4518   flags [] =
4519     {
4520       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
4521       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
4522       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
4523       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
4524       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
4525       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
4526       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4527       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4528       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
4529       /*  9 */ { STRING_COMMA_LEN ("TLS") },
4530       /* IA-64 specific.  */
4531       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4532       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4533       /* IA-64 OpenVMS specific.  */
4534       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4535       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4536       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4537       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4538       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4539       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4540       /* Generic.  */
4541       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4542       /* SPARC specific.  */
4543       /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4544     };
4545
4546   if (do_section_details)
4547     {
4548       sprintf (buff, "[%*.*lx]: ",
4549                field_size, field_size, (unsigned long) sh_flags);
4550       p += field_size + 4;
4551     }
4552
4553   while (sh_flags)
4554     {
4555       bfd_vma flag;
4556
4557       flag = sh_flags & - sh_flags;
4558       sh_flags &= ~ flag;
4559
4560       if (do_section_details)
4561         {
4562           switch (flag)
4563             {
4564             case SHF_WRITE:             sindex = 0; break;
4565             case SHF_ALLOC:             sindex = 1; break;
4566             case SHF_EXECINSTR:         sindex = 2; break;
4567             case SHF_MERGE:             sindex = 3; break;
4568             case SHF_STRINGS:           sindex = 4; break;
4569             case SHF_INFO_LINK:         sindex = 5; break;
4570             case SHF_LINK_ORDER:        sindex = 6; break;
4571             case SHF_OS_NONCONFORMING:  sindex = 7; break;
4572             case SHF_GROUP:             sindex = 8; break;
4573             case SHF_TLS:               sindex = 9; break;
4574             case SHF_EXCLUDE:           sindex = 18; break;
4575
4576             default:
4577               sindex = -1;
4578               switch (elf_header.e_machine)
4579                 {
4580                 case EM_IA_64:
4581                   if (flag == SHF_IA_64_SHORT)
4582                     sindex = 10;
4583                   else if (flag == SHF_IA_64_NORECOV)
4584                     sindex = 11;
4585 #ifdef BFD64
4586                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4587                     switch (flag)
4588                       {
4589                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
4590                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
4591                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
4592                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
4593                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4594                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
4595                       default:                        break;
4596                       }
4597 #endif
4598                   break;
4599
4600                 case EM_386:
4601                 case EM_486:
4602                 case EM_X86_64:
4603                 case EM_L1OM:
4604                 case EM_K1OM:
4605                 case EM_OLD_SPARCV9:
4606                 case EM_SPARC32PLUS:
4607                 case EM_SPARCV9:
4608                 case EM_SPARC:
4609                   if (flag == SHF_ORDERED)
4610                     sindex = 19;
4611                   break;
4612                 default:
4613                   break;
4614                 }
4615             }
4616
4617           if (sindex != -1)
4618             {
4619               if (p != buff + field_size + 4)
4620                 {
4621                   if (size < (10 + 2))
4622                     abort ();
4623                   size -= 2;
4624                   *p++ = ',';
4625                   *p++ = ' ';
4626                 }
4627
4628               size -= flags [sindex].len;
4629               p = stpcpy (p, flags [sindex].str);
4630             }
4631           else if (flag & SHF_MASKOS)
4632             os_flags |= flag;
4633           else if (flag & SHF_MASKPROC)
4634             proc_flags |= flag;
4635           else
4636             unknown_flags |= flag;
4637         }
4638       else
4639         {
4640           switch (flag)
4641             {
4642             case SHF_WRITE:             *p = 'W'; break;
4643             case SHF_ALLOC:             *p = 'A'; break;
4644             case SHF_EXECINSTR:         *p = 'X'; break;
4645             case SHF_MERGE:             *p = 'M'; break;
4646             case SHF_STRINGS:           *p = 'S'; break;
4647             case SHF_INFO_LINK:         *p = 'I'; break;
4648             case SHF_LINK_ORDER:        *p = 'L'; break;
4649             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
4650             case SHF_GROUP:             *p = 'G'; break;
4651             case SHF_TLS:               *p = 'T'; break;
4652             case SHF_EXCLUDE:           *p = 'E'; break;
4653
4654             default:
4655               if ((elf_header.e_machine == EM_X86_64
4656                    || elf_header.e_machine == EM_L1OM
4657                    || elf_header.e_machine == EM_K1OM)
4658                   && flag == SHF_X86_64_LARGE)
4659                 *p = 'l';
4660               else if (flag & SHF_MASKOS)
4661                 {
4662                   *p = 'o';
4663                   sh_flags &= ~ SHF_MASKOS;
4664                 }
4665               else if (flag & SHF_MASKPROC)
4666                 {
4667                   *p = 'p';
4668                   sh_flags &= ~ SHF_MASKPROC;
4669                 }
4670               else
4671                 *p = 'x';
4672               break;
4673             }
4674           p++;
4675         }
4676     }
4677
4678   if (do_section_details)
4679     {
4680       if (os_flags)
4681         {
4682           size -= 5 + field_size;
4683           if (p != buff + field_size + 4)
4684             {
4685               if (size < (2 + 1))
4686                 abort ();
4687               size -= 2;
4688               *p++ = ',';
4689               *p++ = ' ';
4690             }
4691           sprintf (p, "OS (%*.*lx)", field_size, field_size,
4692                    (unsigned long) os_flags);
4693           p += 5 + field_size;
4694         }
4695       if (proc_flags)
4696         {
4697           size -= 7 + field_size;
4698           if (p != buff + field_size + 4)
4699             {
4700               if (size < (2 + 1))
4701                 abort ();
4702               size -= 2;
4703               *p++ = ',';
4704               *p++ = ' ';
4705             }
4706           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4707                    (unsigned long) proc_flags);
4708           p += 7 + field_size;
4709         }
4710       if (unknown_flags)
4711         {
4712           size -= 10 + field_size;
4713           if (p != buff + field_size + 4)
4714             {
4715               if (size < (2 + 1))
4716                 abort ();
4717               size -= 2;
4718               *p++ = ',';
4719               *p++ = ' ';
4720             }
4721           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
4722                    (unsigned long) unknown_flags);
4723           p += 10 + field_size;
4724         }
4725     }
4726
4727   *p = '\0';
4728   return buff;
4729 }
4730
4731 static int
4732 process_section_headers (FILE * file)
4733 {
4734   Elf_Internal_Shdr * section;
4735   unsigned int i;
4736
4737   section_headers = NULL;
4738
4739   if (elf_header.e_shnum == 0)
4740     {
4741       /* PR binutils/12467.  */
4742       if (elf_header.e_shoff != 0)
4743         warn (_("possibly corrupt ELF file header - it has a non-zero"
4744                 " section header offset, but no section headers\n"));
4745       else if (do_sections)
4746         printf (_("\nThere are no sections in this file.\n"));
4747
4748       return 1;
4749     }
4750
4751   if (do_sections && !do_header)
4752     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4753             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4754
4755   if (is_32bit_elf)
4756     {
4757       if (! get_32bit_section_headers (file, elf_header.e_shnum))
4758         return 0;
4759     }
4760   else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4761     return 0;
4762
4763   /* Read in the string table, so that we have names to display.  */
4764   if (elf_header.e_shstrndx != SHN_UNDEF
4765        && elf_header.e_shstrndx < elf_header.e_shnum)
4766     {
4767       section = section_headers + elf_header.e_shstrndx;
4768
4769       if (section->sh_size != 0)
4770         {
4771           string_table = (char *) get_data (NULL, file, section->sh_offset,
4772                                             1, section->sh_size,
4773                                             _("string table"));
4774
4775           string_table_length = string_table != NULL ? section->sh_size : 0;
4776         }
4777     }
4778
4779   /* Scan the sections for the dynamic symbol table
4780      and dynamic string table and debug sections.  */
4781   dynamic_symbols = NULL;
4782   dynamic_strings = NULL;
4783   dynamic_syminfo = NULL;
4784   symtab_shndx_hdr = NULL;
4785
4786   eh_addr_size = is_32bit_elf ? 4 : 8;
4787   switch (elf_header.e_machine)
4788     {
4789     case EM_MIPS:
4790     case EM_MIPS_RS3_LE:
4791       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4792          FDE addresses.  However, the ABI also has a semi-official ILP32
4793          variant for which the normal FDE address size rules apply.
4794
4795          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4796          section, where XX is the size of longs in bits.  Unfortunately,
4797          earlier compilers provided no way of distinguishing ILP32 objects
4798          from LP64 objects, so if there's any doubt, we should assume that
4799          the official LP64 form is being used.  */
4800       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4801           && find_section (".gcc_compiled_long32") == NULL)
4802         eh_addr_size = 8;
4803       break;
4804
4805     case EM_H8_300:
4806     case EM_H8_300H:
4807       switch (elf_header.e_flags & EF_H8_MACH)
4808         {
4809         case E_H8_MACH_H8300:
4810         case E_H8_MACH_H8300HN:
4811         case E_H8_MACH_H8300SN:
4812         case E_H8_MACH_H8300SXN:
4813           eh_addr_size = 2;
4814           break;
4815         case E_H8_MACH_H8300H:
4816         case E_H8_MACH_H8300S:
4817         case E_H8_MACH_H8300SX:
4818           eh_addr_size = 4;
4819           break;
4820         }
4821       break;
4822
4823     case EM_M32C_OLD:
4824     case EM_M32C:
4825       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4826         {
4827         case EF_M32C_CPU_M16C:
4828           eh_addr_size = 2;
4829           break;
4830         }
4831       break;
4832     }
4833
4834 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4835   do                                                                        \
4836     {                                                                       \
4837       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;      \
4838       if (section->sh_entsize != expected_entsize)                          \
4839         {                                                               \
4840           error (_("Section %d has invalid sh_entsize of %" BFD_VMA_FMT "x\n"), \
4841                  i, section->sh_entsize);       \
4842           error (_("(Using the expected size of %d for the rest of this dump)\n"), \
4843                    (int) expected_entsize); \
4844           section->sh_entsize = expected_entsize;                       \
4845         } \
4846     }                                                                       \
4847   while (0)
4848
4849 #define CHECK_ENTSIZE(section, i, type)                                 \
4850   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
4851                         sizeof (Elf64_External_##type))
4852
4853   for (i = 0, section = section_headers;
4854        i < elf_header.e_shnum;
4855        i++, section++)
4856     {
4857       char * name = SECTION_NAME (section);
4858
4859       if (section->sh_type == SHT_DYNSYM)
4860         {
4861           if (dynamic_symbols != NULL)
4862             {
4863               error (_("File contains multiple dynamic symbol tables\n"));
4864               continue;
4865             }
4866
4867           CHECK_ENTSIZE (section, i, Sym);
4868           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
4869         }
4870       else if (section->sh_type == SHT_STRTAB
4871                && streq (name, ".dynstr"))
4872         {
4873           if (dynamic_strings != NULL)
4874             {
4875               error (_("File contains multiple dynamic string tables\n"));
4876               continue;
4877             }
4878
4879           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4880                                                1, section->sh_size,
4881                                                _("dynamic strings"));
4882           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
4883         }
4884       else if (section->sh_type == SHT_SYMTAB_SHNDX)
4885         {
4886           if (symtab_shndx_hdr != NULL)
4887             {
4888               error (_("File contains multiple symtab shndx tables\n"));
4889               continue;
4890             }
4891           symtab_shndx_hdr = section;
4892         }
4893       else if (section->sh_type == SHT_SYMTAB)
4894         CHECK_ENTSIZE (section, i, Sym);
4895       else if (section->sh_type == SHT_GROUP)
4896         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4897       else if (section->sh_type == SHT_REL)
4898         CHECK_ENTSIZE (section, i, Rel);
4899       else if (section->sh_type == SHT_RELA)
4900         CHECK_ENTSIZE (section, i, Rela);
4901       else if ((do_debugging || do_debug_info || do_debug_abbrevs
4902                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
4903                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
4904                 || do_debug_str || do_debug_loc || do_debug_ranges
4905                 || do_debug_addr || do_debug_cu_index)
4906                && (const_strneq (name, ".debug_")
4907                    || const_strneq (name, ".zdebug_")))
4908         {
4909           if (name[1] == 'z')
4910             name += sizeof (".zdebug_") - 1;
4911           else
4912             name += sizeof (".debug_") - 1;
4913
4914           if (do_debugging
4915               || (do_debug_info     && const_strneq (name, "info"))
4916               || (do_debug_info     && const_strneq (name, "types"))
4917               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
4918               || (do_debug_lines    && strcmp (name, "line") == 0)
4919               || (do_debug_lines    && const_strneq (name, "line."))
4920               || (do_debug_pubnames && const_strneq (name, "pubnames"))
4921               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
4922               || (do_debug_aranges  && const_strneq (name, "aranges"))
4923               || (do_debug_ranges   && const_strneq (name, "ranges"))
4924               || (do_debug_frames   && const_strneq (name, "frame"))
4925               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
4926               || (do_debug_macinfo  && const_strneq (name, "macro"))
4927               || (do_debug_str      && const_strneq (name, "str"))
4928               || (do_debug_loc      && const_strneq (name, "loc"))
4929               || (do_debug_addr     && const_strneq (name, "addr"))
4930               || (do_debug_cu_index && const_strneq (name, "cu_index"))
4931               || (do_debug_cu_index && const_strneq (name, "tu_index"))
4932               )
4933             request_dump_bynumber (i, DEBUG_DUMP);
4934         }
4935       /* Linkonce section to be combined with .debug_info at link time.  */
4936       else if ((do_debugging || do_debug_info)
4937                && const_strneq (name, ".gnu.linkonce.wi."))
4938         request_dump_bynumber (i, DEBUG_DUMP);
4939       else if (do_debug_frames && streq (name, ".eh_frame"))
4940         request_dump_bynumber (i, DEBUG_DUMP);
4941       else if (do_gdb_index && streq (name, ".gdb_index"))
4942         request_dump_bynumber (i, DEBUG_DUMP);
4943       /* Trace sections for Itanium VMS.  */
4944       else if ((do_debugging || do_trace_info || do_trace_abbrevs
4945                 || do_trace_aranges)
4946                && const_strneq (name, ".trace_"))
4947         {
4948           name += sizeof (".trace_") - 1;
4949
4950           if (do_debugging
4951               || (do_trace_info     && streq (name, "info"))
4952               || (do_trace_abbrevs  && streq (name, "abbrev"))
4953               || (do_trace_aranges  && streq (name, "aranges"))
4954               )
4955             request_dump_bynumber (i, DEBUG_DUMP);
4956         }
4957
4958     }
4959
4960   if (! do_sections)
4961     return 1;
4962
4963   if (elf_header.e_shnum > 1)
4964     printf (_("\nSection Headers:\n"));
4965   else
4966     printf (_("\nSection Header:\n"));
4967
4968   if (is_32bit_elf)
4969     {
4970       if (do_section_details)
4971         {
4972           printf (_("  [Nr] Name\n"));
4973           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
4974         }
4975       else
4976         printf
4977           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
4978     }
4979   else if (do_wide)
4980     {
4981       if (do_section_details)
4982         {
4983           printf (_("  [Nr] Name\n"));
4984           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
4985         }
4986       else
4987         printf
4988           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
4989     }
4990   else
4991     {
4992       if (do_section_details)
4993         {
4994           printf (_("  [Nr] Name\n"));
4995           printf (_("       Type              Address          Offset            Link\n"));
4996           printf (_("       Size              EntSize          Info              Align\n"));
4997         }
4998       else
4999         {
5000           printf (_("  [Nr] Name              Type             Address           Offset\n"));
5001           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
5002         }
5003     }
5004
5005   if (do_section_details)
5006     printf (_("       Flags\n"));
5007
5008   for (i = 0, section = section_headers;
5009        i < elf_header.e_shnum;
5010        i++, section++)
5011     {
5012       printf ("  [%2u] ", i);
5013       if (do_section_details)
5014         {
5015           print_symbol (INT_MAX, SECTION_NAME (section));
5016           printf ("\n      ");
5017         }
5018       else
5019         {
5020           print_symbol (-17, SECTION_NAME (section));
5021         }
5022
5023       printf (do_wide ? " %-15s " : " %-15.15s ",
5024               get_section_type_name (section->sh_type));
5025
5026       if (is_32bit_elf)
5027         {
5028           const char * link_too_big = NULL;
5029
5030           print_vma (section->sh_addr, LONG_HEX);
5031
5032           printf ( " %6.6lx %6.6lx %2.2lx",
5033                    (unsigned long) section->sh_offset,
5034                    (unsigned long) section->sh_size,
5035                    (unsigned long) section->sh_entsize);
5036
5037           if (do_section_details)
5038             fputs ("  ", stdout);
5039           else
5040             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5041
5042           if (section->sh_link >= elf_header.e_shnum)
5043             {
5044               link_too_big = "";
5045               /* The sh_link value is out of range.  Normally this indicates
5046                  an error but it can have special values in Solaris binaries.  */
5047               switch (elf_header.e_machine)
5048                 {
5049                 case EM_386:
5050                 case EM_486:
5051                 case EM_X86_64:
5052                 case EM_L1OM:
5053                 case EM_K1OM:
5054                 case EM_OLD_SPARCV9:
5055                 case EM_SPARC32PLUS:
5056                 case EM_SPARCV9:
5057                 case EM_SPARC:
5058                   if (section->sh_link == (SHN_BEFORE & 0xffff))
5059                     link_too_big = "BEFORE";
5060                   else if (section->sh_link == (SHN_AFTER & 0xffff))
5061                     link_too_big = "AFTER";
5062                   break;
5063                 default:
5064                   break;
5065                 }
5066             }
5067
5068           if (do_section_details)
5069             {
5070               if (link_too_big != NULL && * link_too_big)
5071                 printf ("<%s> ", link_too_big);
5072               else
5073                 printf ("%2u ", section->sh_link);
5074               printf ("%3u %2lu\n", section->sh_info,
5075                       (unsigned long) section->sh_addralign);
5076             }
5077           else
5078             printf ("%2u %3u %2lu\n",
5079                     section->sh_link,
5080                     section->sh_info,
5081                     (unsigned long) section->sh_addralign);
5082
5083           if (link_too_big && ! * link_too_big)
5084             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5085                   i, section->sh_link);
5086         }
5087       else if (do_wide)
5088         {
5089           print_vma (section->sh_addr, LONG_HEX);
5090
5091           if ((long) section->sh_offset == section->sh_offset)
5092             printf (" %6.6lx", (unsigned long) section->sh_offset);
5093           else
5094             {
5095               putchar (' ');
5096               print_vma (section->sh_offset, LONG_HEX);
5097             }
5098
5099           if ((unsigned long) section->sh_size == section->sh_size)
5100             printf (" %6.6lx", (unsigned long) section->sh_size);
5101           else
5102             {
5103               putchar (' ');
5104               print_vma (section->sh_size, LONG_HEX);
5105             }
5106
5107           if ((unsigned long) section->sh_entsize == section->sh_entsize)
5108             printf (" %2.2lx", (unsigned long) section->sh_entsize);
5109           else
5110             {
5111               putchar (' ');
5112               print_vma (section->sh_entsize, LONG_HEX);
5113             }
5114
5115           if (do_section_details)
5116             fputs ("  ", stdout);
5117           else
5118             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5119
5120           printf ("%2u %3u ", section->sh_link, section->sh_info);
5121
5122           if ((unsigned long) section->sh_addralign == section->sh_addralign)
5123             printf ("%2lu\n", (unsigned long) section->sh_addralign);
5124           else
5125             {
5126               print_vma (section->sh_addralign, DEC);
5127               putchar ('\n');
5128             }
5129         }
5130       else if (do_section_details)
5131         {
5132           printf ("       %-15.15s  ",
5133                   get_section_type_name (section->sh_type));
5134           print_vma (section->sh_addr, LONG_HEX);
5135           if ((long) section->sh_offset == section->sh_offset)
5136             printf ("  %16.16lx", (unsigned long) section->sh_offset);
5137           else
5138             {
5139               printf ("  ");
5140               print_vma (section->sh_offset, LONG_HEX);
5141             }
5142           printf ("  %u\n       ", section->sh_link);
5143           print_vma (section->sh_size, LONG_HEX);
5144           putchar (' ');
5145           print_vma (section->sh_entsize, LONG_HEX);
5146
5147           printf ("  %-16u  %lu\n",
5148                   section->sh_info,
5149                   (unsigned long) section->sh_addralign);
5150         }
5151       else
5152         {
5153           putchar (' ');
5154           print_vma (section->sh_addr, LONG_HEX);
5155           if ((long) section->sh_offset == section->sh_offset)
5156             printf ("  %8.8lx", (unsigned long) section->sh_offset);
5157           else
5158             {
5159               printf ("  ");
5160               print_vma (section->sh_offset, LONG_HEX);
5161             }
5162           printf ("\n       ");
5163           print_vma (section->sh_size, LONG_HEX);
5164           printf ("  ");
5165           print_vma (section->sh_entsize, LONG_HEX);
5166
5167           printf (" %3s ", get_elf_section_flags (section->sh_flags));
5168
5169           printf ("     %2u   %3u     %lu\n",
5170                   section->sh_link,
5171                   section->sh_info,
5172                   (unsigned long) section->sh_addralign);
5173         }
5174
5175       if (do_section_details)
5176         printf ("       %s\n", get_elf_section_flags (section->sh_flags));
5177     }
5178
5179   if (!do_section_details)
5180     {
5181       if (elf_header.e_machine == EM_X86_64
5182           || elf_header.e_machine == EM_L1OM
5183           || elf_header.e_machine == EM_K1OM)
5184         printf (_("Key to Flags:\n\
5185   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5186   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5187   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5188       else
5189         printf (_("Key to Flags:\n\
5190   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5191   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5192   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5193     }
5194
5195   return 1;
5196 }
5197
5198 static const char *
5199 get_group_flags (unsigned int flags)
5200 {
5201   static char buff[32];
5202   switch (flags)
5203     {
5204     case 0:
5205       return "";
5206
5207     case GRP_COMDAT:
5208       return "COMDAT ";
5209
5210    default:
5211       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5212       break;
5213     }
5214   return buff;
5215 }
5216
5217 static int
5218 process_section_groups (FILE * file)
5219 {
5220   Elf_Internal_Shdr * section;
5221   unsigned int i;
5222   struct group * group;
5223   Elf_Internal_Shdr * symtab_sec;
5224   Elf_Internal_Shdr * strtab_sec;
5225   Elf_Internal_Sym * symtab;
5226   unsigned long num_syms;
5227   char * strtab;
5228   size_t strtab_size;
5229
5230   /* Don't process section groups unless needed.  */
5231   if (!do_unwind && !do_section_groups)
5232     return 1;
5233
5234   if (elf_header.e_shnum == 0)
5235     {
5236       if (do_section_groups)
5237         printf (_("\nThere are no sections to group in this file.\n"));
5238
5239       return 1;
5240     }
5241
5242   if (section_headers == NULL)
5243     {
5244       error (_("Section headers are not available!\n"));
5245       /* PR 13622: This can happen with a corrupt ELF header.  */
5246       return 0;
5247     }
5248
5249   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5250                                                      sizeof (struct group *));
5251
5252   if (section_headers_groups == NULL)
5253     {
5254       error (_("Out of memory\n"));
5255       return 0;
5256     }
5257
5258   /* Scan the sections for the group section.  */
5259   group_count = 0;
5260   for (i = 0, section = section_headers;
5261        i < elf_header.e_shnum;
5262        i++, section++)
5263     if (section->sh_type == SHT_GROUP)
5264       group_count++;
5265
5266   if (group_count == 0)
5267     {
5268       if (do_section_groups)
5269         printf (_("\nThere are no section groups in this file.\n"));
5270
5271       return 1;
5272     }
5273
5274   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5275
5276   if (section_groups == NULL)
5277     {
5278       error (_("Out of memory\n"));
5279       return 0;
5280     }
5281
5282   symtab_sec = NULL;
5283   strtab_sec = NULL;
5284   symtab = NULL;
5285   num_syms = 0;
5286   strtab = NULL;
5287   strtab_size = 0;
5288   for (i = 0, section = section_headers, group = section_groups;
5289        i < elf_header.e_shnum;
5290        i++, section++)
5291     {
5292       if (section->sh_type == SHT_GROUP)
5293         {
5294           char * name = SECTION_NAME (section);
5295           char * group_name;
5296           unsigned char * start;
5297           unsigned char * indices;
5298           unsigned int entry, j, size;
5299           Elf_Internal_Shdr * sec;
5300           Elf_Internal_Sym * sym;
5301
5302           /* Get the symbol table.  */
5303           if (section->sh_link >= elf_header.e_shnum
5304               || ((sec = section_headers + section->sh_link)->sh_type
5305                   != SHT_SYMTAB))
5306             {
5307               error (_("Bad sh_link in group section `%s'\n"), name);
5308               continue;
5309             }
5310
5311           if (symtab_sec != sec)
5312             {
5313               symtab_sec = sec;
5314               if (symtab)
5315                 free (symtab);
5316               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5317             }
5318
5319           if (symtab == NULL)
5320             {
5321               error (_("Corrupt header in group section `%s'\n"), name);
5322               continue;
5323             }
5324
5325           if (section->sh_info >= num_syms)
5326             {
5327               error (_("Bad sh_info in group section `%s'\n"), name);
5328               continue;
5329             }
5330
5331           sym = symtab + section->sh_info;
5332
5333           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5334             {
5335               if (sym->st_shndx == 0
5336                   || sym->st_shndx >= elf_header.e_shnum)
5337                 {
5338                   error (_("Bad sh_info in group section `%s'\n"), name);
5339                   continue;
5340                 }
5341
5342               group_name = SECTION_NAME (section_headers + sym->st_shndx);
5343               strtab_sec = NULL;
5344               if (strtab)
5345                 free (strtab);
5346               strtab = NULL;
5347               strtab_size = 0;
5348             }
5349           else
5350             {
5351               /* Get the string table.  */
5352               if (symtab_sec->sh_link >= elf_header.e_shnum)
5353                 {
5354                   strtab_sec = NULL;
5355                   if (strtab)
5356                     free (strtab);
5357                   strtab = NULL;
5358                   strtab_size = 0;
5359                 }
5360               else if (strtab_sec
5361                        != (sec = section_headers + symtab_sec->sh_link))
5362                 {
5363                   strtab_sec = sec;
5364                   if (strtab)
5365                     free (strtab);
5366                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5367                                               1, strtab_sec->sh_size,
5368                                               _("string table"));
5369                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5370                 }
5371               group_name = sym->st_name < strtab_size
5372                 ? strtab + sym->st_name : _("<corrupt>");
5373             }
5374
5375           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5376                                               1, section->sh_size,
5377                                               _("section data"));
5378           if (start == NULL)
5379             continue;
5380
5381           indices = start;
5382           size = (section->sh_size / section->sh_entsize) - 1;
5383           entry = byte_get (indices, 4);
5384           indices += 4;
5385
5386           if (do_section_groups)
5387             {
5388               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5389                       get_group_flags (entry), i, name, group_name, size);
5390
5391               printf (_("   [Index]    Name\n"));
5392             }
5393
5394           group->group_index = i;
5395
5396           for (j = 0; j < size; j++)
5397             {
5398               struct group_list * g;
5399
5400               entry = byte_get (indices, 4);
5401               indices += 4;
5402
5403               if (entry >= elf_header.e_shnum)
5404                 {
5405                   error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5406                          entry, i, elf_header.e_shnum - 1);
5407                   continue;
5408                 }
5409
5410               if (section_headers_groups [entry] != NULL)
5411                 {
5412                   if (entry)
5413                     {
5414                       error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5415                              entry, i,
5416                              section_headers_groups [entry]->group_index);
5417                       continue;
5418                     }
5419                   else
5420                     {
5421                       /* Intel C/C++ compiler may put section 0 in a
5422                          section group. We just warn it the first time
5423                          and ignore it afterwards.  */
5424                       static int warned = 0;
5425                       if (!warned)
5426                         {
5427                           error (_("section 0 in group section [%5u]\n"),
5428                                  section_headers_groups [entry]->group_index);
5429                           warned++;
5430                         }
5431                     }
5432                 }
5433
5434               section_headers_groups [entry] = group;
5435
5436               if (do_section_groups)
5437                 {
5438                   sec = section_headers + entry;
5439                   printf ("   [%5u]   %s\n", entry, SECTION_NAME (sec));
5440                 }
5441
5442               g = (struct group_list *) xmalloc (sizeof (struct group_list));
5443               g->section_index = entry;
5444               g->next = group->root;
5445               group->root = g;
5446             }
5447
5448           if (start)
5449             free (start);
5450
5451           group++;
5452         }
5453     }
5454
5455   if (symtab)
5456     free (symtab);
5457   if (strtab)
5458     free (strtab);
5459   return 1;
5460 }
5461
5462 /* Data used to display dynamic fixups.  */
5463
5464 struct ia64_vms_dynfixup
5465 {
5466   bfd_vma needed_ident;         /* Library ident number.  */
5467   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
5468   bfd_vma fixup_needed;         /* Index of the library.  */
5469   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
5470   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
5471 };
5472
5473 /* Data used to display dynamic relocations.  */
5474
5475 struct ia64_vms_dynimgrela
5476 {
5477   bfd_vma img_rela_cnt;         /* Number of relocations.  */
5478   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
5479 };
5480
5481 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5482    library).  */
5483
5484 static void
5485 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5486                               const char *strtab, unsigned int strtab_sz)
5487 {
5488   Elf64_External_VMS_IMAGE_FIXUP *imfs;
5489   long i;
5490   const char *lib_name;
5491
5492   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5493                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
5494                    _("dynamic section image fixups"));
5495   if (!imfs)
5496     return;
5497
5498   if (fixup->needed < strtab_sz)
5499     lib_name = strtab + fixup->needed;
5500   else
5501     {
5502       warn ("corrupt library name index of 0x%lx found in dynamic entry",
5503             (unsigned long) fixup->needed);
5504       lib_name = "???";
5505     }
5506   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5507           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5508   printf
5509     (_("Seg Offset           Type                             SymVec DataType\n"));
5510
5511   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5512     {
5513       unsigned int type;
5514       const char *rtype;
5515
5516       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5517       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5518       type = BYTE_GET (imfs [i].type);
5519       rtype = elf_ia64_reloc_type (type);
5520       if (rtype == NULL)
5521         printf (" 0x%08x                       ", type);
5522       else
5523         printf (" %-32s ", rtype);
5524       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5525       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5526     }
5527
5528   free (imfs);
5529 }
5530
5531 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
5532
5533 static void
5534 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5535 {
5536   Elf64_External_VMS_IMAGE_RELA *imrs;
5537   long i;
5538
5539   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5540                    1, imgrela->img_rela_cnt * sizeof (*imrs),
5541                    _("dynamic section image relocations"));
5542   if (!imrs)
5543     return;
5544
5545   printf (_("\nImage relocs\n"));
5546   printf
5547     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
5548
5549   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5550     {
5551       unsigned int type;
5552       const char *rtype;
5553
5554       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5555       printf ("%08" BFD_VMA_FMT "x ",
5556               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5557       type = BYTE_GET (imrs [i].type);
5558       rtype = elf_ia64_reloc_type (type);
5559       if (rtype == NULL)
5560         printf ("0x%08x                      ", type);
5561       else
5562         printf ("%-31s ", rtype);
5563       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5564       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5565       printf ("%08" BFD_VMA_FMT "x\n",
5566               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5567     }
5568
5569   free (imrs);
5570 }
5571
5572 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
5573
5574 static int
5575 process_ia64_vms_dynamic_relocs (FILE *file)
5576 {
5577   struct ia64_vms_dynfixup fixup;
5578   struct ia64_vms_dynimgrela imgrela;
5579   Elf_Internal_Dyn *entry;
5580   int res = 0;
5581   bfd_vma strtab_off = 0;
5582   bfd_vma strtab_sz = 0;
5583   char *strtab = NULL;
5584
5585   memset (&fixup, 0, sizeof (fixup));
5586   memset (&imgrela, 0, sizeof (imgrela));
5587
5588   /* Note: the order of the entries is specified by the OpenVMS specs.  */
5589   for (entry = dynamic_section;
5590        entry < dynamic_section + dynamic_nent;
5591        entry++)
5592     {
5593       switch (entry->d_tag)
5594         {
5595         case DT_IA_64_VMS_STRTAB_OFFSET:
5596           strtab_off = entry->d_un.d_val;
5597           break;
5598         case DT_STRSZ:
5599           strtab_sz = entry->d_un.d_val;
5600           if (strtab == NULL)
5601             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5602                                1, strtab_sz, _("dynamic string section"));
5603           break;
5604
5605         case DT_IA_64_VMS_NEEDED_IDENT:
5606           fixup.needed_ident = entry->d_un.d_val;
5607           break;
5608         case DT_NEEDED:
5609           fixup.needed = entry->d_un.d_val;
5610           break;
5611         case DT_IA_64_VMS_FIXUP_NEEDED:
5612           fixup.fixup_needed = entry->d_un.d_val;
5613           break;
5614         case DT_IA_64_VMS_FIXUP_RELA_CNT:
5615           fixup.fixup_rela_cnt = entry->d_un.d_val;
5616           break;
5617         case DT_IA_64_VMS_FIXUP_RELA_OFF:
5618           fixup.fixup_rela_off = entry->d_un.d_val;
5619           res++;
5620           dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5621           break;
5622
5623         case DT_IA_64_VMS_IMG_RELA_CNT:
5624           imgrela.img_rela_cnt = entry->d_un.d_val;
5625           break;
5626         case DT_IA_64_VMS_IMG_RELA_OFF:
5627           imgrela.img_rela_off = entry->d_un.d_val;
5628           res++;
5629           dump_ia64_vms_dynamic_relocs (file, &imgrela);
5630           break;
5631
5632         default:
5633           break;
5634         }
5635     }
5636
5637   if (strtab != NULL)
5638     free (strtab);
5639
5640   return res;
5641 }
5642
5643 static struct
5644 {
5645   const char * name;
5646   int reloc;
5647   int size;
5648   int rela;
5649 } dynamic_relocations [] =
5650 {
5651     { "REL", DT_REL, DT_RELSZ, FALSE },
5652     { "RELA", DT_RELA, DT_RELASZ, TRUE },
5653     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5654 };
5655
5656 /* Process the reloc section.  */
5657
5658 static int
5659 process_relocs (FILE * file)
5660 {
5661   unsigned long rel_size;
5662   unsigned long rel_offset;
5663
5664
5665   if (!do_reloc)
5666     return 1;
5667
5668   if (do_using_dynamic)
5669     {
5670       int is_rela;
5671       const char * name;
5672       int has_dynamic_reloc;
5673       unsigned int i;
5674
5675       has_dynamic_reloc = 0;
5676
5677       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5678         {
5679           is_rela = dynamic_relocations [i].rela;
5680           name = dynamic_relocations [i].name;
5681           rel_size = dynamic_info [dynamic_relocations [i].size];
5682           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5683
5684           has_dynamic_reloc |= rel_size;
5685
5686           if (is_rela == UNKNOWN)
5687             {
5688               if (dynamic_relocations [i].reloc == DT_JMPREL)
5689                 switch (dynamic_info[DT_PLTREL])
5690                   {
5691                   case DT_REL:
5692                     is_rela = FALSE;
5693                     break;
5694                   case DT_RELA:
5695                     is_rela = TRUE;
5696                     break;
5697                   }
5698             }
5699
5700           if (rel_size)
5701             {
5702               printf
5703                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5704                  name, rel_offset, rel_size);
5705
5706               dump_relocations (file,
5707                                 offset_from_vma (file, rel_offset, rel_size),
5708                                 rel_size,
5709                                 dynamic_symbols, num_dynamic_syms,
5710                                 dynamic_strings, dynamic_strings_length, is_rela);
5711             }
5712         }
5713
5714       if (is_ia64_vms ())
5715         has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5716
5717       if (! has_dynamic_reloc)
5718         printf (_("\nThere are no dynamic relocations in this file.\n"));
5719     }
5720   else
5721     {
5722       Elf_Internal_Shdr * section;
5723       unsigned long i;
5724       int found = 0;
5725
5726       for (i = 0, section = section_headers;
5727            i < elf_header.e_shnum;
5728            i++, section++)
5729         {
5730           if (   section->sh_type != SHT_RELA
5731               && section->sh_type != SHT_REL)
5732             continue;
5733
5734           rel_offset = section->sh_offset;
5735           rel_size   = section->sh_size;
5736
5737           if (rel_size)
5738             {
5739               Elf_Internal_Shdr * strsec;
5740               int is_rela;
5741
5742               printf (_("\nRelocation section "));
5743
5744               if (string_table == NULL)
5745                 printf ("%d", section->sh_name);
5746               else
5747                 printf ("'%s'", SECTION_NAME (section));
5748
5749               printf (_(" at offset 0x%lx contains %lu entries:\n"),
5750                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5751
5752               is_rela = section->sh_type == SHT_RELA;
5753
5754               if (section->sh_link != 0
5755                   && section->sh_link < elf_header.e_shnum)
5756                 {
5757                   Elf_Internal_Shdr * symsec;
5758                   Elf_Internal_Sym *  symtab;
5759                   unsigned long nsyms;
5760                   unsigned long strtablen = 0;
5761                   char * strtab = NULL;
5762
5763                   symsec = section_headers + section->sh_link;
5764                   if (symsec->sh_type != SHT_SYMTAB
5765                       && symsec->sh_type != SHT_DYNSYM)
5766                     continue;
5767
5768                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
5769
5770                   if (symtab == NULL)
5771                     continue;
5772
5773                   if (symsec->sh_link != 0
5774                       && symsec->sh_link < elf_header.e_shnum)
5775                     {
5776                       strsec = section_headers + symsec->sh_link;
5777
5778                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5779                                                   1, strsec->sh_size,
5780                                                   _("string table"));
5781                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
5782                     }
5783
5784                   dump_relocations (file, rel_offset, rel_size,
5785                                     symtab, nsyms, strtab, strtablen, is_rela);
5786                   if (strtab)
5787                     free (strtab);
5788                   free (symtab);
5789                 }
5790               else
5791                 dump_relocations (file, rel_offset, rel_size,
5792                                   NULL, 0, NULL, 0, is_rela);
5793
5794               found = 1;
5795             }
5796         }
5797
5798       if (! found)
5799         printf (_("\nThere are no relocations in this file.\n"));
5800     }
5801
5802   return 1;
5803 }
5804
5805 /* Process the unwind section.  */
5806
5807 #include "unwind-ia64.h"
5808
5809 /* An absolute address consists of a section and an offset.  If the
5810    section is NULL, the offset itself is the address, otherwise, the
5811    address equals to LOAD_ADDRESS(section) + offset.  */
5812
5813 struct absaddr
5814   {
5815     unsigned short section;
5816     bfd_vma offset;
5817   };
5818
5819 #define ABSADDR(a) \
5820   ((a).section \
5821    ? section_headers [(a).section].sh_addr + (a).offset \
5822    : (a).offset)
5823
5824 struct ia64_unw_table_entry
5825   {
5826     struct absaddr start;
5827     struct absaddr end;
5828     struct absaddr info;
5829   };
5830
5831 struct ia64_unw_aux_info
5832   {
5833
5834     struct ia64_unw_table_entry *table; /* Unwind table.  */
5835     unsigned long table_len;    /* Length of unwind table.  */
5836     unsigned char * info;       /* Unwind info.  */
5837     unsigned long info_size;    /* Size of unwind info.  */
5838     bfd_vma info_addr;          /* starting address of unwind info.  */
5839     bfd_vma seg_base;           /* Starting address of segment.  */
5840     Elf_Internal_Sym * symtab;  /* The symbol table.  */
5841     unsigned long nsyms;        /* Number of symbols.  */
5842     char * strtab;              /* The string table.  */
5843     unsigned long strtab_size;  /* Size of string table.  */
5844   };
5845
5846 static void
5847 find_symbol_for_address (Elf_Internal_Sym * symtab,
5848                          unsigned long nsyms,
5849                          const char * strtab,
5850                          unsigned long strtab_size,
5851                          struct absaddr addr,
5852                          const char ** symname,
5853                          bfd_vma * offset)
5854 {
5855   bfd_vma dist = 0x100000;
5856   Elf_Internal_Sym * sym;
5857   Elf_Internal_Sym * best = NULL;
5858   unsigned long i;
5859
5860   REMOVE_ARCH_BITS (addr.offset);
5861
5862   for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
5863     {
5864       bfd_vma value = sym->st_value;
5865
5866       REMOVE_ARCH_BITS (value);
5867
5868       if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5869           && sym->st_name != 0
5870           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
5871           && addr.offset >= value
5872           && addr.offset - value < dist)
5873         {
5874           best = sym;
5875           dist = addr.offset - value;
5876           if (!dist)
5877             break;
5878         }
5879     }
5880
5881   if (best)
5882     {
5883       *symname = (best->st_name >= strtab_size
5884                   ? _("<corrupt>") : strtab + best->st_name);
5885       *offset = dist;
5886       return;
5887     }
5888
5889   *symname = NULL;
5890   *offset = addr.offset;
5891 }
5892
5893 static void
5894 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
5895 {
5896   struct ia64_unw_table_entry * tp;
5897   int in_body;
5898
5899   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5900     {
5901       bfd_vma stamp;
5902       bfd_vma offset;
5903       const unsigned char * dp;
5904       const unsigned char * head;
5905       const char * procname;
5906
5907       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5908                                aux->strtab_size, tp->start, &procname, &offset);
5909
5910       fputs ("\n<", stdout);
5911
5912       if (procname)
5913         {
5914           fputs (procname, stdout);
5915
5916           if (offset)
5917             printf ("+%lx", (unsigned long) offset);
5918         }
5919
5920       fputs (">: [", stdout);
5921       print_vma (tp->start.offset, PREFIX_HEX);
5922       fputc ('-', stdout);
5923       print_vma (tp->end.offset, PREFIX_HEX);
5924       printf ("], info at +0x%lx\n",
5925               (unsigned long) (tp->info.offset - aux->seg_base));
5926
5927       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5928       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5929
5930       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5931               (unsigned) UNW_VER (stamp),
5932               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5933               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5934               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5935               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5936
5937       if (UNW_VER (stamp) != 1)
5938         {
5939           printf (_("\tUnknown version.\n"));
5940           continue;
5941         }
5942
5943       in_body = 0;
5944       for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5945         dp = unw_decode (dp, in_body, & in_body);
5946     }
5947 }
5948
5949 static int
5950 slurp_ia64_unwind_table (FILE * file,
5951                          struct ia64_unw_aux_info * aux,
5952                          Elf_Internal_Shdr * sec)
5953 {
5954   unsigned long size, nrelas, i;
5955   Elf_Internal_Phdr * seg;
5956   struct ia64_unw_table_entry * tep;
5957   Elf_Internal_Shdr * relsec;
5958   Elf_Internal_Rela * rela;
5959   Elf_Internal_Rela * rp;
5960   unsigned char * table;
5961   unsigned char * tp;
5962   Elf_Internal_Sym * sym;
5963   const char * relname;
5964
5965   /* First, find the starting address of the segment that includes
5966      this section: */
5967
5968   if (elf_header.e_phnum)
5969     {
5970       if (! get_program_headers (file))
5971           return 0;
5972
5973       for (seg = program_headers;
5974            seg < program_headers + elf_header.e_phnum;
5975            ++seg)
5976         {
5977           if (seg->p_type != PT_LOAD)
5978             continue;
5979
5980           if (sec->sh_addr >= seg->p_vaddr
5981               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5982             {
5983               aux->seg_base = seg->p_vaddr;
5984               break;
5985             }
5986         }
5987     }
5988
5989   /* Second, build the unwind table from the contents of the unwind section:  */
5990   size = sec->sh_size;
5991   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5992                                       _("unwind table"));
5993   if (!table)
5994     return 0;
5995
5996   aux->table = (struct ia64_unw_table_entry *)
5997       xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5998   tep = aux->table;
5999   for (tp = table; tp < table + size; ++tep)
6000     {
6001       tep->start.section = SHN_UNDEF;
6002       tep->end.section   = SHN_UNDEF;
6003       tep->info.section  = SHN_UNDEF;
6004       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6005       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6006       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6007       tep->start.offset += aux->seg_base;
6008       tep->end.offset   += aux->seg_base;
6009       tep->info.offset  += aux->seg_base;
6010     }
6011   free (table);
6012
6013   /* Third, apply any relocations to the unwind table:  */
6014   for (relsec = section_headers;
6015        relsec < section_headers + elf_header.e_shnum;
6016        ++relsec)
6017     {
6018       if (relsec->sh_type != SHT_RELA
6019           || relsec->sh_info >= elf_header.e_shnum
6020           || section_headers + relsec->sh_info != sec)
6021         continue;
6022
6023       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6024                               & rela, & nrelas))
6025         return 0;
6026
6027       for (rp = rela; rp < rela + nrelas; ++rp)
6028         {
6029           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6030           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6031
6032           if (! const_strneq (relname, "R_IA64_SEGREL"))
6033             {
6034               warn (_("Skipping unexpected relocation type %s\n"), relname);
6035               continue;
6036             }
6037
6038           i = rp->r_offset / (3 * eh_addr_size);
6039
6040           switch (rp->r_offset/eh_addr_size % 3)
6041             {
6042             case 0:
6043               aux->table[i].start.section = sym->st_shndx;
6044               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
6045               break;
6046             case 1:
6047               aux->table[i].end.section   = sym->st_shndx;
6048               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
6049               break;
6050             case 2:
6051               aux->table[i].info.section  = sym->st_shndx;
6052               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
6053               break;
6054             default:
6055               break;
6056             }
6057         }
6058
6059       free (rela);
6060     }
6061
6062   aux->table_len = size / (3 * eh_addr_size);
6063   return 1;
6064 }
6065
6066 static void
6067 ia64_process_unwind (FILE * file)
6068 {
6069   Elf_Internal_Shdr * sec;
6070   Elf_Internal_Shdr * unwsec = NULL;
6071   Elf_Internal_Shdr * strsec;
6072   unsigned long i, unwcount = 0, unwstart = 0;
6073   struct ia64_unw_aux_info aux;
6074
6075   memset (& aux, 0, sizeof (aux));
6076
6077   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6078     {
6079       if (sec->sh_type == SHT_SYMTAB
6080           && sec->sh_link < elf_header.e_shnum)
6081         {
6082           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6083
6084           strsec = section_headers + sec->sh_link;
6085           assert (aux.strtab == NULL);
6086           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6087                                           1, strsec->sh_size,
6088                                           _("string table"));
6089           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6090         }
6091       else if (sec->sh_type == SHT_IA_64_UNWIND)
6092         unwcount++;
6093     }
6094
6095   if (!unwcount)
6096     printf (_("\nThere are no unwind sections in this file.\n"));
6097
6098   while (unwcount-- > 0)
6099     {
6100       char * suffix;
6101       size_t len, len2;
6102
6103       for (i = unwstart, sec = section_headers + unwstart;
6104            i < elf_header.e_shnum; ++i, ++sec)
6105         if (sec->sh_type == SHT_IA_64_UNWIND)
6106           {
6107             unwsec = sec;
6108             break;
6109           }
6110
6111       unwstart = i + 1;
6112       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6113
6114       if ((unwsec->sh_flags & SHF_GROUP) != 0)
6115         {
6116           /* We need to find which section group it is in.  */
6117           struct group_list * g = section_headers_groups [i]->root;
6118
6119           for (; g != NULL; g = g->next)
6120             {
6121               sec = section_headers + g->section_index;
6122
6123               if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6124                 break;
6125             }
6126
6127           if (g == NULL)
6128             i = elf_header.e_shnum;
6129         }
6130       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6131         {
6132           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
6133           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6134           suffix = SECTION_NAME (unwsec) + len;
6135           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6136                ++i, ++sec)
6137             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6138                 && streq (SECTION_NAME (sec) + len2, suffix))
6139               break;
6140         }
6141       else
6142         {
6143           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6144              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
6145           len = sizeof (ELF_STRING_ia64_unwind) - 1;
6146           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6147           suffix = "";
6148           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6149             suffix = SECTION_NAME (unwsec) + len;
6150           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6151                ++i, ++sec)
6152             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6153                 && streq (SECTION_NAME (sec) + len2, suffix))
6154               break;
6155         }
6156
6157       if (i == elf_header.e_shnum)
6158         {
6159           printf (_("\nCould not find unwind info section for "));
6160
6161           if (string_table == NULL)
6162             printf ("%d", unwsec->sh_name);
6163           else
6164             printf (_("'%s'"), SECTION_NAME (unwsec));
6165         }
6166       else
6167         {
6168           aux.info_addr = sec->sh_addr;
6169           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6170                                                  sec->sh_size,
6171                                                  _("unwind info"));
6172           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6173
6174           printf (_("\nUnwind section "));
6175
6176           if (string_table == NULL)
6177             printf ("%d", unwsec->sh_name);
6178           else
6179             printf (_("'%s'"), SECTION_NAME (unwsec));
6180
6181           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6182                   (unsigned long) unwsec->sh_offset,
6183                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6184
6185           (void) slurp_ia64_unwind_table (file, & aux, unwsec);
6186
6187           if (aux.table_len > 0)
6188             dump_ia64_unwind (& aux);
6189
6190           if (aux.table)
6191             free ((char *) aux.table);
6192           if (aux.info)
6193             free ((char *) aux.info);
6194           aux.table = NULL;
6195           aux.info = NULL;
6196         }
6197     }
6198
6199   if (aux.symtab)
6200     free (aux.symtab);
6201   if (aux.strtab)
6202     free ((char *) aux.strtab);
6203 }
6204
6205 struct hppa_unw_table_entry
6206   {
6207     struct absaddr start;
6208     struct absaddr end;
6209     unsigned int Cannot_unwind:1;                       /* 0 */
6210     unsigned int Millicode:1;                   /* 1 */
6211     unsigned int Millicode_save_sr0:1;          /* 2 */
6212     unsigned int Region_description:2;          /* 3..4 */
6213     unsigned int reserved1:1;                   /* 5 */
6214     unsigned int Entry_SR:1;                    /* 6 */
6215     unsigned int Entry_FR:4;     /* number saved */     /* 7..10 */
6216     unsigned int Entry_GR:5;     /* number saved */     /* 11..15 */
6217     unsigned int Args_stored:1;                 /* 16 */
6218     unsigned int Variable_Frame:1;                      /* 17 */
6219     unsigned int Separate_Package_Body:1;               /* 18 */
6220     unsigned int Frame_Extension_Millicode:1;   /* 19 */
6221     unsigned int Stack_Overflow_Check:1;                /* 20 */
6222     unsigned int Two_Instruction_SP_Increment:1;        /* 21 */
6223     unsigned int Ada_Region:1;                  /* 22 */
6224     unsigned int cxx_info:1;                    /* 23 */
6225     unsigned int cxx_try_catch:1;                       /* 24 */
6226     unsigned int sched_entry_seq:1;                     /* 25 */
6227     unsigned int reserved2:1;                   /* 26 */
6228     unsigned int Save_SP:1;                             /* 27 */
6229     unsigned int Save_RP:1;                             /* 28 */
6230     unsigned int Save_MRP_in_frame:1;           /* 29 */
6231     unsigned int extn_ptr_defined:1;            /* 30 */
6232     unsigned int Cleanup_defined:1;                     /* 31 */
6233
6234     unsigned int MPE_XL_interrupt_marker:1;             /* 0 */
6235     unsigned int HP_UX_interrupt_marker:1;              /* 1 */
6236     unsigned int Large_frame:1;                 /* 2 */
6237     unsigned int Pseudo_SP_Set:1;                       /* 3 */
6238     unsigned int reserved4:1;                   /* 4 */
6239     unsigned int Total_frame_size:27;           /* 5..31 */
6240   };
6241
6242 struct hppa_unw_aux_info
6243   {
6244     struct hppa_unw_table_entry *table; /* Unwind table.  */
6245     unsigned long table_len;    /* Length of unwind table.  */
6246     bfd_vma seg_base;           /* Starting address of segment.  */
6247     Elf_Internal_Sym * symtab;  /* The symbol table.  */
6248     unsigned long nsyms;        /* Number of symbols.  */
6249     char * strtab;              /* The string table.  */
6250     unsigned long strtab_size;  /* Size of string table.  */
6251   };
6252
6253 static void
6254 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
6255 {
6256   struct hppa_unw_table_entry * tp;
6257
6258   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6259     {
6260       bfd_vma offset;
6261       const char * procname;
6262
6263       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6264                                aux->strtab_size, tp->start, &procname,
6265                                &offset);
6266
6267       fputs ("\n<", stdout);
6268
6269       if (procname)
6270         {
6271           fputs (procname, stdout);
6272
6273           if (offset)
6274             printf ("+%lx", (unsigned long) offset);
6275         }
6276
6277       fputs (">: [", stdout);
6278       print_vma (tp->start.offset, PREFIX_HEX);
6279       fputc ('-', stdout);
6280       print_vma (tp->end.offset, PREFIX_HEX);
6281       printf ("]\n\t");
6282
6283 #define PF(_m) if (tp->_m) printf (#_m " ");
6284 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6285       PF(Cannot_unwind);
6286       PF(Millicode);
6287       PF(Millicode_save_sr0);
6288       /* PV(Region_description);  */
6289       PF(Entry_SR);
6290       PV(Entry_FR);
6291       PV(Entry_GR);
6292       PF(Args_stored);
6293       PF(Variable_Frame);
6294       PF(Separate_Package_Body);
6295       PF(Frame_Extension_Millicode);
6296       PF(Stack_Overflow_Check);
6297       PF(Two_Instruction_SP_Increment);
6298       PF(Ada_Region);
6299       PF(cxx_info);
6300       PF(cxx_try_catch);
6301       PF(sched_entry_seq);
6302       PF(Save_SP);
6303       PF(Save_RP);
6304       PF(Save_MRP_in_frame);
6305       PF(extn_ptr_defined);
6306       PF(Cleanup_defined);
6307       PF(MPE_XL_interrupt_marker);
6308       PF(HP_UX_interrupt_marker);
6309       PF(Large_frame);
6310       PF(Pseudo_SP_Set);
6311       PV(Total_frame_size);
6312 #undef PF
6313 #undef PV
6314     }
6315
6316   printf ("\n");
6317 }
6318
6319 static int
6320 slurp_hppa_unwind_table (FILE * file,
6321                          struct hppa_unw_aux_info * aux,
6322                          Elf_Internal_Shdr * sec)
6323 {
6324   unsigned long size, unw_ent_size, nentries, nrelas, i;
6325   Elf_Internal_Phdr * seg;
6326   struct hppa_unw_table_entry * tep;
6327   Elf_Internal_Shdr * relsec;
6328   Elf_Internal_Rela * rela;
6329   Elf_Internal_Rela * rp;
6330   unsigned char * table;
6331   unsigned char * tp;
6332   Elf_Internal_Sym * sym;
6333   const char * relname;
6334
6335   /* First, find the starting address of the segment that includes
6336      this section.  */
6337
6338   if (elf_header.e_phnum)
6339     {
6340       if (! get_program_headers (file))
6341         return 0;
6342
6343       for (seg = program_headers;
6344            seg < program_headers + elf_header.e_phnum;
6345            ++seg)
6346         {
6347           if (seg->p_type != PT_LOAD)
6348             continue;
6349
6350           if (sec->sh_addr >= seg->p_vaddr
6351               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6352             {
6353               aux->seg_base = seg->p_vaddr;
6354               break;
6355             }
6356         }
6357     }
6358
6359   /* Second, build the unwind table from the contents of the unwind
6360      section.  */
6361   size = sec->sh_size;
6362   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6363                                       _("unwind table"));
6364   if (!table)
6365     return 0;
6366
6367   unw_ent_size = 16;
6368   nentries = size / unw_ent_size;
6369   size = unw_ent_size * nentries;
6370
6371   tep = aux->table = (struct hppa_unw_table_entry *)
6372       xcmalloc (nentries, sizeof (aux->table[0]));
6373
6374   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6375     {
6376       unsigned int tmp1, tmp2;
6377
6378       tep->start.section = SHN_UNDEF;
6379       tep->end.section   = SHN_UNDEF;
6380
6381       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6382       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6383       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6384       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6385
6386       tep->start.offset += aux->seg_base;
6387       tep->end.offset   += aux->seg_base;
6388
6389       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6390       tep->Millicode = (tmp1 >> 30) & 0x1;
6391       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6392       tep->Region_description = (tmp1 >> 27) & 0x3;
6393       tep->reserved1 = (tmp1 >> 26) & 0x1;
6394       tep->Entry_SR = (tmp1 >> 25) & 0x1;
6395       tep->Entry_FR = (tmp1 >> 21) & 0xf;
6396       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6397       tep->Args_stored = (tmp1 >> 15) & 0x1;
6398       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6399       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6400       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6401       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6402       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6403       tep->Ada_Region = (tmp1 >> 9) & 0x1;
6404       tep->cxx_info = (tmp1 >> 8) & 0x1;
6405       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6406       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6407       tep->reserved2 = (tmp1 >> 5) & 0x1;
6408       tep->Save_SP = (tmp1 >> 4) & 0x1;
6409       tep->Save_RP = (tmp1 >> 3) & 0x1;
6410       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6411       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6412       tep->Cleanup_defined = tmp1 & 0x1;
6413
6414       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6415       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6416       tep->Large_frame = (tmp2 >> 29) & 0x1;
6417       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6418       tep->reserved4 = (tmp2 >> 27) & 0x1;
6419       tep->Total_frame_size = tmp2 & 0x7ffffff;
6420     }
6421   free (table);
6422
6423   /* Third, apply any relocations to the unwind table.  */
6424   for (relsec = section_headers;
6425        relsec < section_headers + elf_header.e_shnum;
6426        ++relsec)
6427     {
6428       if (relsec->sh_type != SHT_RELA
6429           || relsec->sh_info >= elf_header.e_shnum
6430           || section_headers + relsec->sh_info != sec)
6431         continue;
6432
6433       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6434                               & rela, & nrelas))
6435         return 0;
6436
6437       for (rp = rela; rp < rela + nrelas; ++rp)
6438         {
6439           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6440           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6441
6442           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
6443           if (! const_strneq (relname, "R_PARISC_SEGREL"))
6444             {
6445               warn (_("Skipping unexpected relocation type %s\n"), relname);
6446               continue;
6447             }
6448
6449           i = rp->r_offset / unw_ent_size;
6450
6451           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6452             {
6453             case 0:
6454               aux->table[i].start.section = sym->st_shndx;
6455               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
6456               break;
6457             case 1:
6458               aux->table[i].end.section   = sym->st_shndx;
6459               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
6460               break;
6461             default:
6462               break;
6463             }
6464         }
6465
6466       free (rela);
6467     }
6468
6469   aux->table_len = nentries;
6470
6471   return 1;
6472 }
6473
6474 static void
6475 hppa_process_unwind (FILE * file)
6476 {
6477   struct hppa_unw_aux_info aux;
6478   Elf_Internal_Shdr * unwsec = NULL;
6479   Elf_Internal_Shdr * strsec;
6480   Elf_Internal_Shdr * sec;
6481   unsigned long i;
6482
6483   if (string_table == NULL)
6484     return;
6485
6486   memset (& aux, 0, sizeof (aux));
6487
6488   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6489     {
6490       if (sec->sh_type == SHT_SYMTAB
6491           && sec->sh_link < elf_header.e_shnum)
6492         {
6493           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6494
6495           strsec = section_headers + sec->sh_link;
6496           assert (aux.strtab == NULL);
6497           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6498                                           1, strsec->sh_size,
6499                                           _("string table"));
6500           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6501         }
6502       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6503         unwsec = sec;
6504     }
6505
6506   if (!unwsec)
6507     printf (_("\nThere are no unwind sections in this file.\n"));
6508
6509   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6510     {
6511       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6512         {
6513           printf (_("\nUnwind section "));
6514           printf (_("'%s'"), SECTION_NAME (sec));
6515
6516           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6517                   (unsigned long) sec->sh_offset,
6518                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6519
6520           slurp_hppa_unwind_table (file, &aux, sec);
6521           if (aux.table_len > 0)
6522             dump_hppa_unwind (&aux);
6523
6524           if (aux.table)
6525             free ((char *) aux.table);
6526           aux.table = NULL;
6527         }
6528     }
6529
6530   if (aux.symtab)
6531     free (aux.symtab);
6532   if (aux.strtab)
6533     free ((char *) aux.strtab);
6534 }
6535
6536 struct arm_section
6537 {
6538   unsigned char *      data;            /* The unwind data.  */
6539   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
6540   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
6541   unsigned long        nrelas;          /* The number of relocations.  */
6542   unsigned int         rel_type;        /* REL or RELA ?  */
6543   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
6544 };
6545
6546 struct arm_unw_aux_info
6547 {
6548   FILE *              file;             /* The file containing the unwind sections.  */
6549   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
6550   unsigned long       nsyms;            /* Number of symbols.  */
6551   char *              strtab;           /* The file's string table.  */
6552   unsigned long       strtab_size;      /* Size of string table.  */
6553 };
6554
6555 static const char *
6556 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6557                         bfd_vma fn, struct absaddr addr)
6558 {
6559   const char *procname;
6560   bfd_vma sym_offset;
6561
6562   if (addr.section == SHN_UNDEF)
6563     addr.offset = fn;
6564
6565   find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6566                            aux->strtab_size, addr, &procname,
6567                            &sym_offset);
6568
6569   print_vma (fn, PREFIX_HEX);
6570
6571   if (procname)
6572     {
6573       fputs (" <", stdout);
6574       fputs (procname, stdout);
6575
6576       if (sym_offset)
6577         printf ("+0x%lx", (unsigned long) sym_offset);
6578       fputc ('>', stdout);
6579     }
6580
6581   return procname;
6582 }
6583
6584 static void
6585 arm_free_section (struct arm_section *arm_sec)
6586 {
6587   if (arm_sec->data != NULL)
6588     free (arm_sec->data);
6589
6590   if (arm_sec->rela != NULL)
6591     free (arm_sec->rela);
6592 }
6593
6594 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6595       cached section and install SEC instead.
6596    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6597       and return its valued in * WORDP, relocating if necessary.
6598    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6599       relocation's offset in ADDR.
6600    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6601       into the string table of the symbol associated with the reloc.  If no
6602       reloc was applied store -1 there.
6603    5) Return TRUE upon success, FALSE otherwise.  */
6604
6605 static bfd_boolean
6606 get_unwind_section_word (struct arm_unw_aux_info *  aux,
6607                          struct arm_section *       arm_sec,
6608                          Elf_Internal_Shdr *        sec,
6609                          bfd_vma                    word_offset,
6610                          unsigned int *             wordp,
6611                          struct absaddr *           addr,
6612                          bfd_vma *                  sym_name)
6613 {
6614   Elf_Internal_Rela *rp;
6615   Elf_Internal_Sym *sym;
6616   const char * relname;
6617   unsigned int word;
6618   bfd_boolean wrapped;
6619
6620   addr->section = SHN_UNDEF;
6621   addr->offset = 0;
6622
6623   if (sym_name != NULL)
6624     *sym_name = (bfd_vma) -1;
6625
6626   /* If necessary, update the section cache.  */
6627   if (sec != arm_sec->sec)
6628     {
6629       Elf_Internal_Shdr *relsec;
6630
6631       arm_free_section (arm_sec);
6632
6633       arm_sec->sec = sec;
6634       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6635                                 sec->sh_size, _("unwind data"));
6636       arm_sec->rela = NULL;
6637       arm_sec->nrelas = 0;
6638
6639       for (relsec = section_headers;
6640            relsec < section_headers + elf_header.e_shnum;
6641            ++relsec)
6642         {
6643           if (relsec->sh_info >= elf_header.e_shnum
6644               || section_headers + relsec->sh_info != sec
6645               /* PR 15745: Check the section type as well.  */
6646               || (relsec->sh_type != SHT_REL
6647                   && relsec->sh_type != SHT_RELA))
6648             continue;
6649
6650           arm_sec->rel_type = relsec->sh_type;
6651           if (relsec->sh_type == SHT_REL)
6652             {
6653               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6654                                      relsec->sh_size,
6655                                      & arm_sec->rela, & arm_sec->nrelas))
6656                 return FALSE;
6657             }
6658           else /* relsec->sh_type == SHT_RELA */
6659             {
6660               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6661                                       relsec->sh_size,
6662                                       & arm_sec->rela, & arm_sec->nrelas))
6663                 return FALSE;
6664             }
6665           break;
6666         }
6667
6668       arm_sec->next_rela = arm_sec->rela;
6669     }
6670
6671   /* If there is no unwind data we can do nothing.  */
6672   if (arm_sec->data == NULL)
6673     return FALSE;
6674
6675   /* Get the word at the required offset.  */
6676   word = byte_get (arm_sec->data + word_offset, 4);
6677
6678   /* Look through the relocs to find the one that applies to the provided offset.  */
6679   wrapped = FALSE;
6680   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6681     {
6682       bfd_vma prelval, offset;
6683
6684       if (rp->r_offset > word_offset && !wrapped)
6685         {
6686           rp = arm_sec->rela;
6687           wrapped = TRUE;
6688         }
6689       if (rp->r_offset > word_offset)
6690         break;
6691
6692       if (rp->r_offset & 3)
6693         {
6694           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6695                 (unsigned long) rp->r_offset);
6696           continue;
6697         }
6698
6699       if (rp->r_offset < word_offset)
6700         continue;
6701
6702       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6703
6704       if (arm_sec->rel_type == SHT_REL)
6705         {
6706           offset = word & 0x7fffffff;
6707           if (offset & 0x40000000)
6708             offset |= ~ (bfd_vma) 0x7fffffff;
6709         }
6710       else if (arm_sec->rel_type == SHT_RELA)
6711         offset = rp->r_addend;
6712       else
6713         abort ();
6714
6715       offset += sym->st_value;
6716       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6717
6718       /* Check that we are processing the expected reloc type.  */
6719       if (elf_header.e_machine == EM_ARM)
6720         {
6721           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6722
6723           if (streq (relname, "R_ARM_NONE"))
6724               continue;
6725
6726           if (! streq (relname, "R_ARM_PREL31"))
6727             {
6728               warn (_("Skipping unexpected relocation type %s\n"), relname);
6729               continue;
6730             }
6731         }
6732       else if (elf_header.e_machine == EM_TI_C6000)
6733         {
6734           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6735
6736           if (streq (relname, "R_C6000_NONE"))
6737             continue;
6738
6739           if (! streq (relname, "R_C6000_PREL31"))
6740             {
6741               warn (_("Skipping unexpected relocation type %s\n"), relname);
6742               continue;
6743             }
6744
6745           prelval >>= 1;
6746         }
6747       else
6748         /* This function currently only supports ARM and TI unwinders.  */
6749         abort ();
6750
6751       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6752       addr->section = sym->st_shndx;
6753       addr->offset = offset;
6754       if (sym_name)
6755         * sym_name = sym->st_name;
6756       break;
6757     }
6758
6759   *wordp = word;
6760   arm_sec->next_rela = rp;
6761
6762   return TRUE;
6763 }
6764
6765 static const char *tic6x_unwind_regnames[16] =
6766 {
6767   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6768   "A14", "A13", "A12", "A11", "A10",
6769   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6770 };
6771
6772 static void
6773 decode_tic6x_unwind_regmask (unsigned int mask)
6774 {
6775   int i;
6776
6777   for (i = 12; mask; mask >>= 1, i--)
6778     {
6779       if (mask & 1)
6780         {
6781           fputs (tic6x_unwind_regnames[i], stdout);
6782           if (mask > 1)
6783             fputs (", ", stdout);
6784         }
6785     }
6786 }
6787
6788 #define ADVANCE                                                 \
6789   if (remaining == 0 && more_words)                             \
6790     {                                                           \
6791       data_offset += 4;                                         \
6792       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
6793                                      data_offset, & word, & addr, NULL))        \
6794         return;                                                 \
6795       remaining = 4;                                            \
6796       more_words--;                                             \
6797     }                                                           \
6798
6799 #define GET_OP(OP)                      \
6800   ADVANCE;                              \
6801   if (remaining)                        \
6802     {                                   \
6803       remaining--;                      \
6804       (OP) = word >> 24;                \
6805       word <<= 8;                       \
6806     }                                   \
6807   else                                  \
6808     {                                   \
6809       printf (_("[Truncated opcode]\n"));       \
6810       return;                           \
6811     }                                   \
6812   printf ("0x%02x ", OP)
6813
6814 static void
6815 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6816                             unsigned int word, unsigned int remaining,
6817                             unsigned int more_words,
6818                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6819                             struct arm_section *data_arm_sec)
6820 {
6821   struct absaddr addr;
6822
6823   /* Decode the unwinding instructions.  */
6824   while (1)
6825     {
6826       unsigned int op, op2;
6827
6828       ADVANCE;
6829       if (remaining == 0)
6830         break;
6831       remaining--;
6832       op = word >> 24;
6833       word <<= 8;
6834
6835       printf ("  0x%02x ", op);
6836
6837       if ((op & 0xc0) == 0x00)
6838         {
6839           int offset = ((op & 0x3f) << 2) + 4;
6840
6841           printf ("     vsp = vsp + %d", offset);
6842         }
6843       else if ((op & 0xc0) == 0x40)
6844         {
6845           int offset = ((op & 0x3f) << 2) + 4;
6846
6847           printf ("     vsp = vsp - %d", offset);
6848         }
6849       else if ((op & 0xf0) == 0x80)
6850         {
6851           GET_OP (op2);
6852           if (op == 0x80 && op2 == 0)
6853             printf (_("Refuse to unwind"));
6854           else
6855             {
6856               unsigned int mask = ((op & 0x0f) << 8) | op2;
6857               int first = 1;
6858               int i;
6859
6860               printf ("pop {");
6861               for (i = 0; i < 12; i++)
6862                 if (mask & (1 << i))
6863                   {
6864                     if (first)
6865                       first = 0;
6866                     else
6867                       printf (", ");
6868                     printf ("r%d", 4 + i);
6869                   }
6870               printf ("}");
6871             }
6872         }
6873       else if ((op & 0xf0) == 0x90)
6874         {
6875           if (op == 0x9d || op == 0x9f)
6876             printf (_("     [Reserved]"));
6877           else
6878             printf ("     vsp = r%d", op & 0x0f);
6879         }
6880       else if ((op & 0xf0) == 0xa0)
6881         {
6882           int end = 4 + (op & 0x07);
6883           int first = 1;
6884           int i;
6885
6886           printf ("     pop {");
6887           for (i = 4; i <= end; i++)
6888             {
6889               if (first)
6890                 first = 0;
6891               else
6892                 printf (", ");
6893               printf ("r%d", i);
6894             }
6895           if (op & 0x08)
6896             {
6897               if (!first)
6898                 printf (", ");
6899               printf ("r14");
6900             }
6901           printf ("}");
6902         }
6903       else if (op == 0xb0)
6904         printf (_("     finish"));
6905       else if (op == 0xb1)
6906         {
6907           GET_OP (op2);
6908           if (op2 == 0 || (op2 & 0xf0) != 0)
6909             printf (_("[Spare]"));
6910           else
6911             {
6912               unsigned int mask = op2 & 0x0f;
6913               int first = 1;
6914               int i;
6915
6916               printf ("pop {");
6917               for (i = 0; i < 12; i++)
6918                 if (mask & (1 << i))
6919                   {
6920                     if (first)
6921                       first = 0;
6922                     else
6923                       printf (", ");
6924                     printf ("r%d", i);
6925                   }
6926               printf ("}");
6927             }
6928         }
6929       else if (op == 0xb2)
6930         {
6931           unsigned char buf[9];
6932           unsigned int i, len;
6933           unsigned long offset;
6934
6935           for (i = 0; i < sizeof (buf); i++)
6936             {
6937               GET_OP (buf[i]);
6938               if ((buf[i] & 0x80) == 0)
6939                 break;
6940             }
6941           assert (i < sizeof (buf));
6942           offset = read_uleb128 (buf, &len, buf + i + 1);
6943           assert (len == i + 1);
6944           offset = offset * 4 + 0x204;
6945           printf ("vsp = vsp + %ld", offset);
6946         }
6947       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
6948         {
6949           unsigned int first, last;
6950
6951           GET_OP (op2);
6952           first = op2 >> 4;
6953           last = op2 & 0x0f;
6954           if (op == 0xc8)
6955             first = first + 16;
6956           printf ("pop {D%d", first);
6957           if (last)
6958             printf ("-D%d", first + last);
6959           printf ("}");
6960         }
6961       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6962         {
6963           unsigned int count = op & 0x07;
6964
6965           printf ("pop {D8");
6966           if (count)
6967             printf ("-D%d", 8 + count);
6968           printf ("}");
6969         }
6970       else if (op >= 0xc0 && op <= 0xc5)
6971         {
6972           unsigned int count = op & 0x07;
6973
6974           printf ("     pop {wR10");
6975           if (count)
6976             printf ("-wR%d", 10 + count);
6977           printf ("}");
6978         }
6979       else if (op == 0xc6)
6980         {
6981           unsigned int first, last;
6982
6983           GET_OP (op2);
6984           first = op2 >> 4;
6985           last = op2 & 0x0f;
6986           printf ("pop {wR%d", first);
6987           if (last)
6988             printf ("-wR%d", first + last);
6989           printf ("}");
6990         }
6991       else if (op == 0xc7)
6992         {
6993           GET_OP (op2);
6994           if (op2 == 0 || (op2 & 0xf0) != 0)
6995             printf (_("[Spare]"));
6996           else
6997             {
6998               unsigned int mask = op2 & 0x0f;
6999               int first = 1;
7000               int i;
7001
7002               printf ("pop {");
7003               for (i = 0; i < 4; i++)
7004                 if (mask & (1 << i))
7005                   {
7006                     if (first)
7007                       first = 0;
7008                     else
7009                       printf (", ");
7010                     printf ("wCGR%d", i);
7011                   }
7012               printf ("}");
7013             }
7014         }
7015       else
7016         printf (_("     [unsupported opcode]"));
7017       printf ("\n");
7018     }
7019 }
7020
7021 static void
7022 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7023                             unsigned int word, unsigned int remaining,
7024                             unsigned int more_words,
7025                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7026                             struct arm_section *data_arm_sec)
7027 {
7028   struct absaddr addr;
7029
7030   /* Decode the unwinding instructions.  */
7031   while (1)
7032     {
7033       unsigned int op, op2;
7034
7035       ADVANCE;
7036       if (remaining == 0)
7037         break;
7038       remaining--;
7039       op = word >> 24;
7040       word <<= 8;
7041
7042       printf ("  0x%02x ", op);
7043
7044       if ((op & 0xc0) == 0x00)
7045         {
7046           int offset = ((op & 0x3f) << 3) + 8;
7047           printf ("     sp = sp + %d", offset);
7048         }
7049       else if ((op & 0xc0) == 0x80)
7050         {
7051           GET_OP (op2);
7052           if (op == 0x80 && op2 == 0)
7053             printf (_("Refuse to unwind"));
7054           else
7055             {
7056               unsigned int mask = ((op & 0x1f) << 8) | op2;
7057               if (op & 0x20)
7058                 printf ("pop compact {");
7059               else
7060                 printf ("pop {");
7061
7062               decode_tic6x_unwind_regmask (mask);
7063               printf("}");
7064             }
7065         }
7066       else if ((op & 0xf0) == 0xc0)
7067         {
7068           unsigned int reg;
7069           unsigned int nregs;
7070           unsigned int i;
7071           const char *name;
7072           struct
7073           {
7074               unsigned int offset;
7075               unsigned int reg;
7076           } regpos[16];
7077
7078           /* Scan entire instruction first so that GET_OP output is not
7079              interleaved with disassembly.  */
7080           nregs = 0;
7081           for (i = 0; nregs < (op & 0xf); i++)
7082             {
7083               GET_OP (op2);
7084               reg = op2 >> 4;
7085               if (reg != 0xf)
7086                 {
7087                   regpos[nregs].offset = i * 2;
7088                   regpos[nregs].reg = reg;
7089                   nregs++;
7090                 }
7091
7092               reg = op2 & 0xf;
7093               if (reg != 0xf)
7094                 {
7095                   regpos[nregs].offset = i * 2 + 1;
7096                   regpos[nregs].reg = reg;
7097                   nregs++;
7098                 }
7099             }
7100
7101           printf (_("pop frame {"));
7102           reg = nregs - 1;
7103           for (i = i * 2; i > 0; i--)
7104             {
7105               if (regpos[reg].offset == i - 1)
7106                 {
7107                   name = tic6x_unwind_regnames[regpos[reg].reg];
7108                   if (reg > 0)
7109                     reg--;
7110                 }
7111               else
7112                 name = _("[pad]");
7113
7114               fputs (name, stdout);
7115               if (i > 1)
7116                 printf (", ");
7117             }
7118
7119           printf ("}");
7120         }
7121       else if (op == 0xd0)
7122         printf ("     MOV FP, SP");
7123       else if (op == 0xd1)
7124         printf ("     __c6xabi_pop_rts");
7125       else if (op == 0xd2)
7126         {
7127           unsigned char buf[9];
7128           unsigned int i, len;
7129           unsigned long offset;
7130
7131           for (i = 0; i < sizeof (buf); i++)
7132             {
7133               GET_OP (buf[i]);
7134               if ((buf[i] & 0x80) == 0)
7135                 break;
7136             }
7137           assert (i < sizeof (buf));
7138           offset = read_uleb128 (buf, &len, buf + i + 1);
7139           assert (len == i + 1);
7140           offset = offset * 8 + 0x408;
7141           printf (_("sp = sp + %ld"), offset);
7142         }
7143       else if ((op & 0xf0) == 0xe0)
7144         {
7145           if ((op & 0x0f) == 7)
7146             printf ("     RETURN");
7147           else
7148             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7149         }
7150       else
7151         {
7152           printf (_("     [unsupported opcode]"));
7153         }
7154       putchar ('\n');
7155     }
7156 }
7157
7158 static bfd_vma
7159 arm_expand_prel31 (bfd_vma word, bfd_vma where)
7160 {
7161   bfd_vma offset;
7162
7163   offset = word & 0x7fffffff;
7164   if (offset & 0x40000000)
7165     offset |= ~ (bfd_vma) 0x7fffffff;
7166
7167   if (elf_header.e_machine == EM_TI_C6000)
7168     offset <<= 1;
7169
7170   return offset + where;
7171 }
7172
7173 static void
7174 decode_arm_unwind (struct arm_unw_aux_info *  aux,
7175                    unsigned int               word,
7176                    unsigned int               remaining,
7177                    bfd_vma                    data_offset,
7178                    Elf_Internal_Shdr *        data_sec,
7179                    struct arm_section *       data_arm_sec)
7180 {
7181   int per_index;
7182   unsigned int more_words = 0;
7183   struct absaddr addr;
7184   bfd_vma sym_name = (bfd_vma) -1;
7185
7186   if (remaining == 0)
7187     {
7188       /* Fetch the first word.
7189          Note - when decoding an object file the address extracted
7190          here will always be 0.  So we also pass in the sym_name
7191          parameter so that we can find the symbol associated with
7192          the personality routine.  */
7193       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7194                                      & word, & addr, & sym_name))
7195         return;
7196
7197       remaining = 4;
7198     }
7199
7200   if ((word & 0x80000000) == 0)
7201     {
7202       /* Expand prel31 for personality routine.  */
7203       bfd_vma fn;
7204       const char *procname;
7205
7206       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
7207       printf (_("  Personality routine: "));
7208       if (fn == 0
7209           && addr.section == SHN_UNDEF && addr.offset == 0
7210           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7211         {
7212           procname = aux->strtab + sym_name;
7213           print_vma (fn, PREFIX_HEX);
7214           if (procname)
7215             {
7216               fputs (" <", stdout);
7217               fputs (procname, stdout);
7218               fputc ('>', stdout);
7219             }
7220         }
7221       else
7222         procname = arm_print_vma_and_name (aux, fn, addr);
7223       fputc ('\n', stdout);
7224
7225       /* The GCC personality routines use the standard compact
7226          encoding, starting with one byte giving the number of
7227          words.  */
7228       if (procname != NULL
7229           && (const_strneq (procname, "__gcc_personality_v0")
7230               || const_strneq (procname, "__gxx_personality_v0")
7231               || const_strneq (procname, "__gcj_personality_v0")
7232               || const_strneq (procname, "__gnu_objc_personality_v0")))
7233         {
7234           remaining = 0;
7235           more_words = 1;
7236           ADVANCE;
7237           if (!remaining)
7238             {
7239               printf (_("  [Truncated data]\n"));
7240               return;
7241             }
7242           more_words = word >> 24;
7243           word <<= 8;
7244           remaining--;
7245           per_index = -1;
7246         }
7247       else
7248         return;
7249     }
7250   else
7251     {
7252       /* ARM EHABI Section 6.3:
7253
7254          An exception-handling table entry for the compact model looks like:
7255
7256            31 30-28 27-24 23-0
7257            -- ----- ----- ----
7258             1   0   index Data for personalityRoutine[index]    */
7259
7260       if (elf_header.e_machine == EM_ARM
7261           && (word & 0x70000000))
7262         warn (_("Corrupt ARM compact model table entry: %x \n"), word);
7263
7264       per_index = (word >> 24) & 0x7f;
7265       printf (_("  Compact model index: %d\n"), per_index);
7266       if (per_index == 0)
7267         {
7268           more_words = 0;
7269           word <<= 8;
7270           remaining--;
7271         }
7272       else if (per_index < 3)
7273         {
7274           more_words = (word >> 16) & 0xff;
7275           word <<= 16;
7276           remaining -= 2;
7277         }
7278     }
7279
7280   switch (elf_header.e_machine)
7281     {
7282     case EM_ARM:
7283       if (per_index < 3)
7284         {
7285           decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7286                                       data_offset, data_sec, data_arm_sec);
7287         }
7288       else
7289         {
7290           warn (_("Unknown ARM compact model index encountered\n"));
7291           printf (_("  [reserved]\n"));
7292         }
7293       break;
7294
7295     case EM_TI_C6000:
7296       if (per_index < 3)
7297         {
7298           decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
7299                                         data_offset, data_sec, data_arm_sec);
7300         }
7301       else if (per_index < 5)
7302         {
7303           if (((word >> 17) & 0x7f) == 0x7f)
7304             printf (_("  Restore stack from frame pointer\n"));
7305           else
7306             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
7307           printf (_("  Registers restored: "));
7308           if (per_index == 4)
7309             printf (" (compact) ");
7310           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7311           putchar ('\n');
7312           printf (_("  Return register: %s\n"),
7313                   tic6x_unwind_regnames[word & 0xf]);
7314         }
7315       else
7316         printf (_("  [reserved (%d)]\n"), per_index);
7317       break;
7318
7319     default:
7320       error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7321              elf_header.e_machine);
7322     }
7323
7324   /* Decode the descriptors.  Not implemented.  */
7325 }
7326
7327 static void
7328 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7329 {
7330   struct arm_section exidx_arm_sec, extab_arm_sec;
7331   unsigned int i, exidx_len;
7332
7333   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7334   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7335   exidx_len = exidx_sec->sh_size / 8;
7336
7337   for (i = 0; i < exidx_len; i++)
7338     {
7339       unsigned int exidx_fn, exidx_entry;
7340       struct absaddr fn_addr, entry_addr;
7341       bfd_vma fn;
7342
7343       fputc ('\n', stdout);
7344
7345       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7346                                      8 * i, & exidx_fn, & fn_addr, NULL)
7347           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7348                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
7349         {
7350           arm_free_section (& exidx_arm_sec);
7351           arm_free_section (& extab_arm_sec);
7352           return;
7353         }
7354
7355       /* ARM EHABI, Section 5:
7356          An index table entry consists of 2 words.
7357          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
7358       if (exidx_fn & 0x80000000)
7359         warn (_("corrupt index table entry: %x\n"), exidx_fn);
7360
7361       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
7362
7363       arm_print_vma_and_name (aux, fn, fn_addr);
7364       fputs (": ", stdout);
7365
7366       if (exidx_entry == 1)
7367         {
7368           print_vma (exidx_entry, PREFIX_HEX);
7369           fputs (" [cantunwind]\n", stdout);
7370         }
7371       else if (exidx_entry & 0x80000000)
7372         {
7373           print_vma (exidx_entry, PREFIX_HEX);
7374           fputc ('\n', stdout);
7375           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7376         }
7377       else
7378         {
7379           bfd_vma table, table_offset = 0;
7380           Elf_Internal_Shdr *table_sec;
7381
7382           fputs ("@", stdout);
7383           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
7384           print_vma (table, PREFIX_HEX);
7385           printf ("\n");
7386
7387           /* Locate the matching .ARM.extab.  */
7388           if (entry_addr.section != SHN_UNDEF
7389               && entry_addr.section < elf_header.e_shnum)
7390             {
7391               table_sec = section_headers + entry_addr.section;
7392               table_offset = entry_addr.offset;
7393             }
7394           else
7395             {
7396               table_sec = find_section_by_address (table);
7397               if (table_sec != NULL)
7398                 table_offset = table - table_sec->sh_addr;
7399             }
7400           if (table_sec == NULL)
7401             {
7402               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7403                     (unsigned long) table);
7404               continue;
7405             }
7406           decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7407                              &extab_arm_sec);
7408         }
7409     }
7410
7411   printf ("\n");
7412
7413   arm_free_section (&exidx_arm_sec);
7414   arm_free_section (&extab_arm_sec);
7415 }
7416
7417 /* Used for both ARM and C6X unwinding tables.  */
7418
7419 static void
7420 arm_process_unwind (FILE *file)
7421 {
7422   struct arm_unw_aux_info aux;
7423   Elf_Internal_Shdr *unwsec = NULL;
7424   Elf_Internal_Shdr *strsec;
7425   Elf_Internal_Shdr *sec;
7426   unsigned long i;
7427   unsigned int sec_type;
7428
7429   switch (elf_header.e_machine)
7430     {
7431     case EM_ARM:
7432       sec_type = SHT_ARM_EXIDX;
7433       break;
7434
7435     case EM_TI_C6000:
7436       sec_type = SHT_C6000_UNWIND;
7437       break;
7438
7439     default:
7440       error (_("Unsupported architecture type %d encountered when processing unwind table"),
7441              elf_header.e_machine);
7442       return;
7443     }
7444
7445   if (string_table == NULL)
7446     return;
7447
7448   memset (& aux, 0, sizeof (aux));
7449   aux.file = file;
7450
7451   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7452     {
7453       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7454         {
7455           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7456
7457           strsec = section_headers + sec->sh_link;
7458           assert (aux.strtab == NULL);
7459           aux.strtab = get_data (NULL, file, strsec->sh_offset,
7460                                  1, strsec->sh_size, _("string table"));
7461           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7462         }
7463       else if (sec->sh_type == sec_type)
7464         unwsec = sec;
7465     }
7466
7467   if (unwsec == NULL)
7468     printf (_("\nThere are no unwind sections in this file.\n"));
7469   else
7470     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7471       {
7472         if (sec->sh_type == sec_type)
7473           {
7474             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7475                     SECTION_NAME (sec),
7476                     (unsigned long) sec->sh_offset,
7477                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7478
7479             dump_arm_unwind (&aux, sec);
7480           }
7481       }
7482
7483   if (aux.symtab)
7484     free (aux.symtab);
7485   if (aux.strtab)
7486     free ((char *) aux.strtab);
7487 }
7488
7489 static void
7490 process_unwind (FILE * file)
7491 {
7492   struct unwind_handler
7493   {
7494     int machtype;
7495     void (* handler)(FILE *);
7496   } handlers[] =
7497   {
7498     { EM_ARM, arm_process_unwind },
7499     { EM_IA_64, ia64_process_unwind },
7500     { EM_PARISC, hppa_process_unwind },
7501     { EM_TI_C6000, arm_process_unwind },
7502     { 0, 0 }
7503   };
7504   int i;
7505
7506   if (!do_unwind)
7507     return;
7508
7509   for (i = 0; handlers[i].handler != NULL; i++)
7510     if (elf_header.e_machine == handlers[i].machtype)
7511       {
7512         handlers[i].handler (file);
7513         return;
7514       }
7515
7516   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7517           get_machine_name (elf_header.e_machine));
7518 }
7519
7520 static void
7521 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
7522 {
7523   switch (entry->d_tag)
7524     {
7525     case DT_MIPS_FLAGS:
7526       if (entry->d_un.d_val == 0)
7527         printf (_("NONE"));
7528       else
7529         {
7530           static const char * opts[] =
7531           {
7532             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7533             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7534             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7535             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7536             "RLD_ORDER_SAFE"
7537           };
7538           unsigned int cnt;
7539           int first = 1;
7540
7541           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
7542             if (entry->d_un.d_val & (1 << cnt))
7543               {
7544                 printf ("%s%s", first ? "" : " ", opts[cnt]);
7545                 first = 0;
7546               }
7547         }
7548       break;
7549
7550     case DT_MIPS_IVERSION:
7551       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7552         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
7553       else
7554         printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
7555       break;
7556
7557     case DT_MIPS_TIME_STAMP:
7558       {
7559         char timebuf[20];
7560         struct tm * tmp;
7561
7562         time_t atime = entry->d_un.d_val;
7563         tmp = gmtime (&atime);
7564         snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7565                   tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7566                   tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7567         printf (_("Time Stamp: %s"), timebuf);
7568       }
7569       break;
7570
7571     case DT_MIPS_RLD_VERSION:
7572     case DT_MIPS_LOCAL_GOTNO:
7573     case DT_MIPS_CONFLICTNO:
7574     case DT_MIPS_LIBLISTNO:
7575     case DT_MIPS_SYMTABNO:
7576     case DT_MIPS_UNREFEXTNO:
7577     case DT_MIPS_HIPAGENO:
7578     case DT_MIPS_DELTA_CLASS_NO:
7579     case DT_MIPS_DELTA_INSTANCE_NO:
7580     case DT_MIPS_DELTA_RELOC_NO:
7581     case DT_MIPS_DELTA_SYM_NO:
7582     case DT_MIPS_DELTA_CLASSSYM_NO:
7583     case DT_MIPS_COMPACT_SIZE:
7584       print_vma (entry->d_un.d_ptr, DEC);
7585       break;
7586
7587     default:
7588       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7589     }
7590     putchar ('\n');
7591 }
7592
7593 static void
7594 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
7595 {
7596   switch (entry->d_tag)
7597     {
7598     case DT_HP_DLD_FLAGS:
7599       {
7600         static struct
7601         {
7602           long int bit;
7603           const char * str;
7604         }
7605         flags[] =
7606         {
7607           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7608           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7609           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7610           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7611           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7612           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7613           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7614           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7615           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7616           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
7617           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7618           { DT_HP_GST, "HP_GST" },
7619           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7620           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7621           { DT_HP_NODELETE, "HP_NODELETE" },
7622           { DT_HP_GROUP, "HP_GROUP" },
7623           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
7624         };
7625         int first = 1;
7626         size_t cnt;
7627         bfd_vma val = entry->d_un.d_val;
7628
7629         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
7630           if (val & flags[cnt].bit)
7631             {
7632               if (! first)
7633                 putchar (' ');
7634               fputs (flags[cnt].str, stdout);
7635               first = 0;
7636               val ^= flags[cnt].bit;
7637             }
7638
7639         if (val != 0 || first)
7640           {
7641             if (! first)
7642               putchar (' ');
7643             print_vma (val, HEX);
7644           }
7645       }
7646       break;
7647
7648     default:
7649       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7650       break;
7651     }
7652   putchar ('\n');
7653 }
7654
7655 #ifdef BFD64
7656
7657 /* VMS vs Unix time offset and factor.  */
7658
7659 #define VMS_EPOCH_OFFSET 35067168000000000LL
7660 #define VMS_GRANULARITY_FACTOR 10000000
7661
7662 /* Display a VMS time in a human readable format.  */
7663
7664 static void
7665 print_vms_time (bfd_int64_t vmstime)
7666 {
7667   struct tm *tm;
7668   time_t unxtime;
7669
7670   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7671   tm = gmtime (&unxtime);
7672   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7673           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7674           tm->tm_hour, tm->tm_min, tm->tm_sec);
7675 }
7676 #endif /* BFD64 */
7677
7678 static void
7679 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
7680 {
7681   switch (entry->d_tag)
7682     {
7683     case DT_IA_64_PLT_RESERVE:
7684       /* First 3 slots reserved.  */
7685       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7686       printf (" -- ");
7687       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
7688       break;
7689
7690     case DT_IA_64_VMS_LINKTIME:
7691 #ifdef BFD64
7692       print_vms_time (entry->d_un.d_val);
7693 #endif
7694       break;
7695
7696     case DT_IA_64_VMS_LNKFLAGS:
7697       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7698       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7699         printf (" CALL_DEBUG");
7700       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7701         printf (" NOP0BUFS");
7702       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7703         printf (" P0IMAGE");
7704       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7705         printf (" MKTHREADS");
7706       if (entry->d_un.d_val & VMS_LF_UPCALLS)
7707         printf (" UPCALLS");
7708       if (entry->d_un.d_val & VMS_LF_IMGSTA)
7709         printf (" IMGSTA");
7710       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7711         printf (" INITIALIZE");
7712       if (entry->d_un.d_val & VMS_LF_MAIN)
7713         printf (" MAIN");
7714       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7715         printf (" EXE_INIT");
7716       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7717         printf (" TBK_IN_IMG");
7718       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7719         printf (" DBG_IN_IMG");
7720       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7721         printf (" TBK_IN_DSF");
7722       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7723         printf (" DBG_IN_DSF");
7724       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7725         printf (" SIGNATURES");
7726       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7727         printf (" REL_SEG_OFF");
7728       break;
7729
7730     default:
7731       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7732       break;
7733     }
7734   putchar ('\n');
7735 }
7736
7737 static int
7738 get_32bit_dynamic_section (FILE * file)
7739 {
7740   Elf32_External_Dyn * edyn;
7741   Elf32_External_Dyn * ext;
7742   Elf_Internal_Dyn * entry;
7743
7744   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7745                                           dynamic_size, _("dynamic section"));
7746   if (!edyn)
7747     return 0;
7748
7749 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7750    might not have the luxury of section headers.  Look for the DT_NULL
7751    terminator to determine the number of entries.  */
7752   for (ext = edyn, dynamic_nent = 0;
7753        (char *) ext < (char *) edyn + dynamic_size;
7754        ext++)
7755     {
7756       dynamic_nent++;
7757       if (BYTE_GET (ext->d_tag) == DT_NULL)
7758         break;
7759     }
7760
7761   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7762                                                   sizeof (* entry));
7763   if (dynamic_section == NULL)
7764     {
7765       error (_("Out of memory\n"));
7766       free (edyn);
7767       return 0;
7768     }
7769
7770   for (ext = edyn, entry = dynamic_section;
7771        entry < dynamic_section + dynamic_nent;
7772        ext++, entry++)
7773     {
7774       entry->d_tag      = BYTE_GET (ext->d_tag);
7775       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7776     }
7777
7778   free (edyn);
7779
7780   return 1;
7781 }
7782
7783 static int
7784 get_64bit_dynamic_section (FILE * file)
7785 {
7786   Elf64_External_Dyn * edyn;
7787   Elf64_External_Dyn * ext;
7788   Elf_Internal_Dyn * entry;
7789
7790   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7791                                           dynamic_size, _("dynamic section"));
7792   if (!edyn)
7793     return 0;
7794
7795 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7796    might not have the luxury of section headers.  Look for the DT_NULL
7797    terminator to determine the number of entries.  */
7798   for (ext = edyn, dynamic_nent = 0;
7799        (char *) ext < (char *) edyn + dynamic_size;
7800        ext++)
7801     {
7802       dynamic_nent++;
7803       if (BYTE_GET (ext->d_tag) == DT_NULL)
7804         break;
7805     }
7806
7807   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7808                                                   sizeof (* entry));
7809   if (dynamic_section == NULL)
7810     {
7811       error (_("Out of memory\n"));
7812       free (edyn);
7813       return 0;
7814     }
7815
7816   for (ext = edyn, entry = dynamic_section;
7817        entry < dynamic_section + dynamic_nent;
7818        ext++, entry++)
7819     {
7820       entry->d_tag      = BYTE_GET (ext->d_tag);
7821       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7822     }
7823
7824   free (edyn);
7825
7826   return 1;
7827 }
7828
7829 static void
7830 print_dynamic_flags (bfd_vma flags)
7831 {
7832   int first = 1;
7833
7834   while (flags)
7835     {
7836       bfd_vma flag;
7837
7838       flag = flags & - flags;
7839       flags &= ~ flag;
7840
7841       if (first)
7842         first = 0;
7843       else
7844         putc (' ', stdout);
7845
7846       switch (flag)
7847         {
7848         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
7849         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
7850         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
7851         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
7852         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
7853         default:                fputs (_("unknown"), stdout); break;
7854         }
7855     }
7856   puts ("");
7857 }
7858
7859 /* Parse and display the contents of the dynamic section.  */
7860
7861 static int
7862 process_dynamic_section (FILE * file)
7863 {
7864   Elf_Internal_Dyn * entry;
7865
7866   if (dynamic_size == 0)
7867     {
7868       if (do_dynamic)
7869         printf (_("\nThere is no dynamic section in this file.\n"));
7870
7871       return 1;
7872     }
7873
7874   if (is_32bit_elf)
7875     {
7876       if (! get_32bit_dynamic_section (file))
7877         return 0;
7878     }
7879   else if (! get_64bit_dynamic_section (file))
7880     return 0;
7881
7882   /* Find the appropriate symbol table.  */
7883   if (dynamic_symbols == NULL)
7884     {
7885       for (entry = dynamic_section;
7886            entry < dynamic_section + dynamic_nent;
7887            ++entry)
7888         {
7889           Elf_Internal_Shdr section;
7890
7891           if (entry->d_tag != DT_SYMTAB)
7892             continue;
7893
7894           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7895
7896           /* Since we do not know how big the symbol table is,
7897              we default to reading in the entire file (!) and
7898              processing that.  This is overkill, I know, but it
7899              should work.  */
7900           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
7901
7902           if (archive_file_offset != 0)
7903             section.sh_size = archive_file_size - section.sh_offset;
7904           else
7905             {
7906               if (fseek (file, 0, SEEK_END))
7907                 error (_("Unable to seek to end of file!\n"));
7908
7909               section.sh_size = ftell (file) - section.sh_offset;
7910             }
7911
7912           if (is_32bit_elf)
7913             section.sh_entsize = sizeof (Elf32_External_Sym);
7914           else
7915             section.sh_entsize = sizeof (Elf64_External_Sym);
7916
7917           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
7918           if (num_dynamic_syms < 1)
7919             {
7920               error (_("Unable to determine the number of symbols to load\n"));
7921               continue;
7922             }
7923         }
7924     }
7925
7926   /* Similarly find a string table.  */
7927   if (dynamic_strings == NULL)
7928     {
7929       for (entry = dynamic_section;
7930            entry < dynamic_section + dynamic_nent;
7931            ++entry)
7932         {
7933           unsigned long offset;
7934           long str_tab_len;
7935
7936           if (entry->d_tag != DT_STRTAB)
7937             continue;
7938
7939           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7940
7941           /* Since we do not know how big the string table is,
7942              we default to reading in the entire file (!) and
7943              processing that.  This is overkill, I know, but it
7944              should work.  */
7945
7946           offset = offset_from_vma (file, entry->d_un.d_val, 0);
7947
7948           if (archive_file_offset != 0)
7949             str_tab_len = archive_file_size - offset;
7950           else
7951             {
7952               if (fseek (file, 0, SEEK_END))
7953                 error (_("Unable to seek to end of file\n"));
7954               str_tab_len = ftell (file) - offset;
7955             }
7956
7957           if (str_tab_len < 1)
7958             {
7959               error
7960                 (_("Unable to determine the length of the dynamic string table\n"));
7961               continue;
7962             }
7963
7964           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7965                                                str_tab_len,
7966                                                _("dynamic string table"));
7967           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
7968           break;
7969         }
7970     }
7971
7972   /* And find the syminfo section if available.  */
7973   if (dynamic_syminfo == NULL)
7974     {
7975       unsigned long syminsz = 0;
7976
7977       for (entry = dynamic_section;
7978            entry < dynamic_section + dynamic_nent;
7979            ++entry)
7980         {
7981           if (entry->d_tag == DT_SYMINENT)
7982             {
7983               /* Note: these braces are necessary to avoid a syntax
7984                  error from the SunOS4 C compiler.  */
7985               assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7986             }
7987           else if (entry->d_tag == DT_SYMINSZ)
7988             syminsz = entry->d_un.d_val;
7989           else if (entry->d_tag == DT_SYMINFO)
7990             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7991                                                       syminsz);
7992         }
7993
7994       if (dynamic_syminfo_offset != 0 && syminsz != 0)
7995         {
7996           Elf_External_Syminfo * extsyminfo;
7997           Elf_External_Syminfo * extsym;
7998           Elf_Internal_Syminfo * syminfo;
7999
8000           /* There is a syminfo section.  Read the data.  */
8001           extsyminfo = (Elf_External_Syminfo *)
8002               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8003                         _("symbol information"));
8004           if (!extsyminfo)
8005             return 0;
8006
8007           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
8008           if (dynamic_syminfo == NULL)
8009             {
8010               error (_("Out of memory\n"));
8011               return 0;
8012             }
8013
8014           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
8015           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8016                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8017                ++syminfo, ++extsym)
8018             {
8019               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8020               syminfo->si_flags = BYTE_GET (extsym->si_flags);
8021             }
8022
8023           free (extsyminfo);
8024         }
8025     }
8026
8027   if (do_dynamic && dynamic_addr)
8028     printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
8029             dynamic_addr, dynamic_nent);
8030   if (do_dynamic)
8031     printf (_("  Tag        Type                         Name/Value\n"));
8032
8033   for (entry = dynamic_section;
8034        entry < dynamic_section + dynamic_nent;
8035        entry++)
8036     {
8037       if (do_dynamic)
8038         {
8039           const char * dtype;
8040
8041           putchar (' ');
8042           print_vma (entry->d_tag, FULL_HEX);
8043           dtype = get_dynamic_type (entry->d_tag);
8044           printf (" (%s)%*s", dtype,
8045                   ((is_32bit_elf ? 27 : 19)
8046                    - (int) strlen (dtype)),
8047                   " ");
8048         }
8049
8050       switch (entry->d_tag)
8051         {
8052         case DT_FLAGS:
8053           if (do_dynamic)
8054             print_dynamic_flags (entry->d_un.d_val);
8055           break;
8056
8057         case DT_AUXILIARY:
8058         case DT_FILTER:
8059         case DT_CONFIG:
8060         case DT_DEPAUDIT:
8061         case DT_AUDIT:
8062           if (do_dynamic)
8063             {
8064               switch (entry->d_tag)
8065                 {
8066                 case DT_AUXILIARY:
8067                   printf (_("Auxiliary library"));
8068                   break;
8069
8070                 case DT_FILTER:
8071                   printf (_("Filter library"));
8072                   break;
8073
8074                 case DT_CONFIG:
8075                   printf (_("Configuration file"));
8076                   break;
8077
8078                 case DT_DEPAUDIT:
8079                   printf (_("Dependency audit library"));
8080                   break;
8081
8082                 case DT_AUDIT:
8083                   printf (_("Audit library"));
8084                   break;
8085                 }
8086
8087               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8088                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
8089               else
8090                 {
8091                   printf (": ");
8092                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8093                   putchar ('\n');
8094                 }
8095             }
8096           break;
8097
8098         case DT_FEATURE:
8099           if (do_dynamic)
8100             {
8101               printf (_("Flags:"));
8102
8103               if (entry->d_un.d_val == 0)
8104                 printf (_(" None\n"));
8105               else
8106                 {
8107                   unsigned long int val = entry->d_un.d_val;
8108
8109                   if (val & DTF_1_PARINIT)
8110                     {
8111                       printf (" PARINIT");
8112                       val ^= DTF_1_PARINIT;
8113                     }
8114                   if (val & DTF_1_CONFEXP)
8115                     {
8116                       printf (" CONFEXP");
8117                       val ^= DTF_1_CONFEXP;
8118                     }
8119                   if (val != 0)
8120                     printf (" %lx", val);
8121                   puts ("");
8122                 }
8123             }
8124           break;
8125
8126         case DT_POSFLAG_1:
8127           if (do_dynamic)
8128             {
8129               printf (_("Flags:"));
8130
8131               if (entry->d_un.d_val == 0)
8132                 printf (_(" None\n"));
8133               else
8134                 {
8135                   unsigned long int val = entry->d_un.d_val;
8136
8137                   if (val & DF_P1_LAZYLOAD)
8138                     {
8139                       printf (" LAZYLOAD");
8140                       val ^= DF_P1_LAZYLOAD;
8141                     }
8142                   if (val & DF_P1_GROUPPERM)
8143                     {
8144                       printf (" GROUPPERM");
8145                       val ^= DF_P1_GROUPPERM;
8146                     }
8147                   if (val != 0)
8148                     printf (" %lx", val);
8149                   puts ("");
8150                 }
8151             }
8152           break;
8153
8154         case DT_FLAGS_1:
8155           if (do_dynamic)
8156             {
8157               printf (_("Flags:"));
8158               if (entry->d_un.d_val == 0)
8159                 printf (_(" None\n"));
8160               else
8161                 {
8162                   unsigned long int val = entry->d_un.d_val;
8163
8164                   if (val & DF_1_NOW)
8165                     {
8166                       printf (" NOW");
8167                       val ^= DF_1_NOW;
8168                     }
8169                   if (val & DF_1_GLOBAL)
8170                     {
8171                       printf (" GLOBAL");
8172                       val ^= DF_1_GLOBAL;
8173                     }
8174                   if (val & DF_1_GROUP)
8175                     {
8176                       printf (" GROUP");
8177                       val ^= DF_1_GROUP;
8178                     }
8179                   if (val & DF_1_NODELETE)
8180                     {
8181                       printf (" NODELETE");
8182                       val ^= DF_1_NODELETE;
8183                     }
8184                   if (val & DF_1_LOADFLTR)
8185                     {
8186                       printf (" LOADFLTR");
8187                       val ^= DF_1_LOADFLTR;
8188                     }
8189                   if (val & DF_1_INITFIRST)
8190                     {
8191                       printf (" INITFIRST");
8192                       val ^= DF_1_INITFIRST;
8193                     }
8194                   if (val & DF_1_NOOPEN)
8195                     {
8196                       printf (" NOOPEN");
8197                       val ^= DF_1_NOOPEN;
8198                     }
8199                   if (val & DF_1_ORIGIN)
8200                     {
8201                       printf (" ORIGIN");
8202                       val ^= DF_1_ORIGIN;
8203                     }
8204                   if (val & DF_1_DIRECT)
8205                     {
8206                       printf (" DIRECT");
8207                       val ^= DF_1_DIRECT;
8208                     }
8209                   if (val & DF_1_TRANS)
8210                     {
8211                       printf (" TRANS");
8212                       val ^= DF_1_TRANS;
8213                     }
8214                   if (val & DF_1_INTERPOSE)
8215                     {
8216                       printf (" INTERPOSE");
8217                       val ^= DF_1_INTERPOSE;
8218                     }
8219                   if (val & DF_1_NODEFLIB)
8220                     {
8221                       printf (" NODEFLIB");
8222                       val ^= DF_1_NODEFLIB;
8223                     }
8224                   if (val & DF_1_NODUMP)
8225                     {
8226                       printf (" NODUMP");
8227                       val ^= DF_1_NODUMP;
8228                     }
8229                   if (val & DF_1_CONFALT)
8230                     {
8231                       printf (" CONFALT");
8232                       val ^= DF_1_CONFALT;
8233                     }
8234                   if (val & DF_1_ENDFILTEE)
8235                     {
8236                       printf (" ENDFILTEE");
8237                       val ^= DF_1_ENDFILTEE;
8238                     }
8239                   if (val & DF_1_DISPRELDNE)
8240                     {
8241                       printf (" DISPRELDNE");
8242                       val ^= DF_1_DISPRELDNE;
8243                     }
8244                   if (val & DF_1_DISPRELPND)
8245                     {
8246                       printf (" DISPRELPND");
8247                       val ^= DF_1_DISPRELPND;
8248                     }
8249                   if (val & DF_1_NODIRECT)
8250                     {
8251                       printf (" NODIRECT");
8252                       val ^= DF_1_NODIRECT;
8253                     }
8254                   if (val & DF_1_IGNMULDEF)
8255                     {
8256                       printf (" IGNMULDEF");
8257                       val ^= DF_1_IGNMULDEF;
8258                     }
8259                   if (val & DF_1_NOKSYMS)
8260                     {
8261                       printf (" NOKSYMS");
8262                       val ^= DF_1_NOKSYMS;
8263                     }
8264                   if (val & DF_1_NOHDR)
8265                     {
8266                       printf (" NOHDR");
8267                       val ^= DF_1_NOHDR;
8268                     }
8269                   if (val & DF_1_EDITED)
8270                     {
8271                       printf (" EDITED");
8272                       val ^= DF_1_EDITED;
8273                     }
8274                   if (val & DF_1_NORELOC)
8275                     {
8276                       printf (" NORELOC");
8277                       val ^= DF_1_NORELOC;
8278                     }
8279                   if (val & DF_1_SYMINTPOSE)
8280                     {
8281                       printf (" SYMINTPOSE");
8282                       val ^= DF_1_SYMINTPOSE;
8283                     }
8284                   if (val & DF_1_GLOBAUDIT)
8285                     {
8286                       printf (" GLOBAUDIT");
8287                       val ^= DF_1_GLOBAUDIT;
8288                     }
8289                   if (val & DF_1_SINGLETON)
8290                     {
8291                       printf (" SINGLETON");
8292                       val ^= DF_1_SINGLETON;
8293                     }
8294                   if (val != 0)
8295                     printf (" %lx", val);
8296                   puts ("");
8297                 }
8298             }
8299           break;
8300
8301         case DT_PLTREL:
8302           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8303           if (do_dynamic)
8304             puts (get_dynamic_type (entry->d_un.d_val));
8305           break;
8306
8307         case DT_NULL    :
8308         case DT_NEEDED  :
8309         case DT_PLTGOT  :
8310         case DT_HASH    :
8311         case DT_STRTAB  :
8312         case DT_SYMTAB  :
8313         case DT_RELA    :
8314         case DT_INIT    :
8315         case DT_FINI    :
8316         case DT_SONAME  :
8317         case DT_RPATH   :
8318         case DT_SYMBOLIC:
8319         case DT_REL     :
8320         case DT_DEBUG   :
8321         case DT_TEXTREL :
8322         case DT_JMPREL  :
8323         case DT_RUNPATH :
8324           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8325
8326           if (do_dynamic)
8327             {
8328               char * name;
8329
8330               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8331                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8332               else
8333                 name = NULL;
8334
8335               if (name)
8336                 {
8337                   switch (entry->d_tag)
8338                     {
8339                     case DT_NEEDED:
8340                       printf (_("Shared library: [%s]"), name);
8341
8342                       if (streq (name, program_interpreter))
8343                         printf (_(" program interpreter"));
8344                       break;
8345
8346                     case DT_SONAME:
8347                       printf (_("Library soname: [%s]"), name);
8348                       break;
8349
8350                     case DT_RPATH:
8351                       printf (_("Library rpath: [%s]"), name);
8352                       break;
8353
8354                     case DT_RUNPATH:
8355                       printf (_("Library runpath: [%s]"), name);
8356                       break;
8357
8358                     default:
8359                       print_vma (entry->d_un.d_val, PREFIX_HEX);
8360                       break;
8361                     }
8362                 }
8363               else
8364                 print_vma (entry->d_un.d_val, PREFIX_HEX);
8365
8366               putchar ('\n');
8367             }
8368           break;
8369
8370         case DT_PLTRELSZ:
8371         case DT_RELASZ  :
8372         case DT_STRSZ   :
8373         case DT_RELSZ   :
8374         case DT_RELAENT :
8375         case DT_SYMENT  :
8376         case DT_RELENT  :
8377           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8378         case DT_PLTPADSZ:
8379         case DT_MOVEENT :
8380         case DT_MOVESZ  :
8381         case DT_INIT_ARRAYSZ:
8382         case DT_FINI_ARRAYSZ:
8383         case DT_GNU_CONFLICTSZ:
8384         case DT_GNU_LIBLISTSZ:
8385           if (do_dynamic)
8386             {
8387               print_vma (entry->d_un.d_val, UNSIGNED);
8388               printf (_(" (bytes)\n"));
8389             }
8390           break;
8391
8392         case DT_VERDEFNUM:
8393         case DT_VERNEEDNUM:
8394         case DT_RELACOUNT:
8395         case DT_RELCOUNT:
8396           if (do_dynamic)
8397             {
8398               print_vma (entry->d_un.d_val, UNSIGNED);
8399               putchar ('\n');
8400             }
8401           break;
8402
8403         case DT_SYMINSZ:
8404         case DT_SYMINENT:
8405         case DT_SYMINFO:
8406         case DT_USED:
8407         case DT_INIT_ARRAY:
8408         case DT_FINI_ARRAY:
8409           if (do_dynamic)
8410             {
8411               if (entry->d_tag == DT_USED
8412                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
8413                 {
8414                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8415
8416                   if (*name)
8417                     {
8418                       printf (_("Not needed object: [%s]\n"), name);
8419                       break;
8420                     }
8421                 }
8422
8423               print_vma (entry->d_un.d_val, PREFIX_HEX);
8424               putchar ('\n');
8425             }
8426           break;
8427
8428         case DT_BIND_NOW:
8429           /* The value of this entry is ignored.  */
8430           if (do_dynamic)
8431             putchar ('\n');
8432           break;
8433
8434         case DT_GNU_PRELINKED:
8435           if (do_dynamic)
8436             {
8437               struct tm * tmp;
8438               time_t atime = entry->d_un.d_val;
8439
8440               tmp = gmtime (&atime);
8441               printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8442                       tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8443                       tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8444
8445             }
8446           break;
8447
8448         case DT_GNU_HASH:
8449           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8450           if (do_dynamic)
8451             {
8452               print_vma (entry->d_un.d_val, PREFIX_HEX);
8453               putchar ('\n');
8454             }
8455           break;
8456
8457         default:
8458           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
8459             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
8460               entry->d_un.d_val;
8461
8462           if (do_dynamic)
8463             {
8464               switch (elf_header.e_machine)
8465                 {
8466                 case EM_MIPS:
8467                 case EM_MIPS_RS3_LE:
8468                   dynamic_section_mips_val (entry);
8469                   break;
8470                 case EM_PARISC:
8471                   dynamic_section_parisc_val (entry);
8472                   break;
8473                 case EM_IA_64:
8474                   dynamic_section_ia64_val (entry);
8475                   break;
8476                 default:
8477                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8478                   putchar ('\n');
8479                 }
8480             }
8481           break;
8482         }
8483     }
8484
8485   return 1;
8486 }
8487
8488 static char *
8489 get_ver_flags (unsigned int flags)
8490 {
8491   static char buff[32];
8492
8493   buff[0] = 0;
8494
8495   if (flags == 0)
8496     return _("none");
8497
8498   if (flags & VER_FLG_BASE)
8499     strcat (buff, "BASE ");
8500
8501   if (flags & VER_FLG_WEAK)
8502     {
8503       if (flags & VER_FLG_BASE)
8504         strcat (buff, "| ");
8505
8506       strcat (buff, "WEAK ");
8507     }
8508
8509   if (flags & VER_FLG_INFO)
8510     {
8511       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8512         strcat (buff, "| ");
8513
8514       strcat (buff, "INFO ");
8515     }
8516
8517   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
8518     strcat (buff, _("| <unknown>"));
8519
8520   return buff;
8521 }
8522
8523 /* Display the contents of the version sections.  */
8524
8525 static int
8526 process_version_sections (FILE * file)
8527 {
8528   Elf_Internal_Shdr * section;
8529   unsigned i;
8530   int found = 0;
8531
8532   if (! do_version)
8533     return 1;
8534
8535   for (i = 0, section = section_headers;
8536        i < elf_header.e_shnum;
8537        i++, section++)
8538     {
8539       switch (section->sh_type)
8540         {
8541         case SHT_GNU_verdef:
8542           {
8543             Elf_External_Verdef * edefs;
8544             unsigned int idx;
8545             unsigned int cnt;
8546             char * endbuf;
8547
8548             found = 1;
8549
8550             printf
8551               (_("\nVersion definition section '%s' contains %u entries:\n"),
8552                SECTION_NAME (section), section->sh_info);
8553
8554             printf (_("  Addr: 0x"));
8555             printf_vma (section->sh_addr);
8556             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8557                     (unsigned long) section->sh_offset, section->sh_link,
8558                     section->sh_link < elf_header.e_shnum
8559                     ? SECTION_NAME (section_headers + section->sh_link)
8560                     : _("<corrupt>"));
8561
8562             edefs = (Elf_External_Verdef *)
8563                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8564                           _("version definition section"));
8565             if (!edefs)
8566               break;
8567             endbuf = (char *) edefs + section->sh_size;
8568
8569             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8570               {
8571                 char * vstart;
8572                 Elf_External_Verdef * edef;
8573                 Elf_Internal_Verdef ent;
8574                 Elf_External_Verdaux * eaux;
8575                 Elf_Internal_Verdaux aux;
8576                 int j;
8577                 int isum;
8578
8579                 /* Check for very large indicies.  */
8580                 if (idx > (size_t) (endbuf - (char *) edefs))
8581                   break;
8582
8583                 vstart = ((char *) edefs) + idx;
8584                 if (vstart + sizeof (*edef) > endbuf)
8585                   break;
8586
8587                 edef = (Elf_External_Verdef *) vstart;
8588
8589                 ent.vd_version = BYTE_GET (edef->vd_version);
8590                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
8591                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
8592                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
8593                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
8594                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
8595                 ent.vd_next    = BYTE_GET (edef->vd_next);
8596
8597                 printf (_("  %#06x: Rev: %d  Flags: %s"),
8598                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8599
8600                 printf (_("  Index: %d  Cnt: %d  "),
8601                         ent.vd_ndx, ent.vd_cnt);
8602
8603                 /* Check for overflow.  */
8604                 if (ent.vd_aux > (size_t) (endbuf - vstart))
8605                   break;
8606
8607                 vstart += ent.vd_aux;
8608
8609                 eaux = (Elf_External_Verdaux *) vstart;
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 (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
8616                 else
8617                   printf (_("Name index: %ld\n"), aux.vda_name);
8618
8619                 isum = idx + ent.vd_aux;
8620
8621                 for (j = 1; j < ent.vd_cnt; j++)
8622                   {
8623                     /* Check for overflow.  */
8624                     if (aux.vda_next > (size_t) (endbuf - vstart))
8625                       break;
8626
8627                     isum   += aux.vda_next;
8628                     vstart += aux.vda_next;
8629
8630                     eaux = (Elf_External_Verdaux *) vstart;
8631                     if (vstart + sizeof (*eaux) > endbuf)
8632                       break;
8633
8634                     aux.vda_name = BYTE_GET (eaux->vda_name);
8635                     aux.vda_next = BYTE_GET (eaux->vda_next);
8636
8637                     if (VALID_DYNAMIC_NAME (aux.vda_name))
8638                       printf (_("  %#06x: Parent %d: %s\n"),
8639                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
8640                     else
8641                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
8642                               isum, j, aux.vda_name);
8643                   }
8644
8645                 if (j < ent.vd_cnt)
8646                   printf (_("  Version def aux past end of section\n"));
8647
8648                 idx += ent.vd_next;
8649               }
8650
8651             if (cnt < section->sh_info)
8652               printf (_("  Version definition past end of section\n"));
8653
8654             free (edefs);
8655           }
8656           break;
8657
8658         case SHT_GNU_verneed:
8659           {
8660             Elf_External_Verneed * eneed;
8661             unsigned int idx;
8662             unsigned int cnt;
8663             char * endbuf;
8664
8665             found = 1;
8666
8667             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8668                     SECTION_NAME (section), section->sh_info);
8669
8670             printf (_(" Addr: 0x"));
8671             printf_vma (section->sh_addr);
8672             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8673                     (unsigned long) section->sh_offset, section->sh_link,
8674                     section->sh_link < elf_header.e_shnum
8675                     ? SECTION_NAME (section_headers + section->sh_link)
8676                     : _("<corrupt>"));
8677
8678             eneed = (Elf_External_Verneed *) get_data (NULL, file,
8679                                                        section->sh_offset, 1,
8680                                                        section->sh_size,
8681                                                        _("Version Needs section"));
8682             if (!eneed)
8683               break;
8684             endbuf = (char *) eneed + section->sh_size;
8685
8686             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8687               {
8688                 Elf_External_Verneed * entry;
8689                 Elf_Internal_Verneed ent;
8690                 int j;
8691                 int isum;
8692                 char * vstart;
8693
8694                 if (idx > (size_t) (endbuf - (char *) eneed))
8695                   break;
8696
8697                 vstart = ((char *) eneed) + idx;
8698                 if (vstart + sizeof (*entry) > endbuf)
8699                   break;
8700
8701                 entry = (Elf_External_Verneed *) vstart;
8702
8703                 ent.vn_version = BYTE_GET (entry->vn_version);
8704                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
8705                 ent.vn_file    = BYTE_GET (entry->vn_file);
8706                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
8707                 ent.vn_next    = BYTE_GET (entry->vn_next);
8708
8709                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
8710
8711                 if (VALID_DYNAMIC_NAME (ent.vn_file))
8712                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
8713                 else
8714                   printf (_("  File: %lx"), ent.vn_file);
8715
8716                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
8717
8718                 /* Check for overflow.  */
8719                 if (ent.vn_aux > (size_t) (endbuf - vstart))
8720                   break;
8721
8722                 vstart += ent.vn_aux;
8723
8724                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8725                   {
8726                     Elf_External_Vernaux * eaux;
8727                     Elf_Internal_Vernaux aux;
8728
8729                     if (vstart + sizeof (*eaux) > endbuf)
8730                       break;
8731                     eaux = (Elf_External_Vernaux *) vstart;
8732
8733                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
8734                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
8735                     aux.vna_other = BYTE_GET (eaux->vna_other);
8736                     aux.vna_name  = BYTE_GET (eaux->vna_name);
8737                     aux.vna_next  = BYTE_GET (eaux->vna_next);
8738
8739                     if (VALID_DYNAMIC_NAME (aux.vna_name))
8740                       printf (_("  %#06x:   Name: %s"),
8741                               isum, GET_DYNAMIC_NAME (aux.vna_name));
8742                     else
8743                       printf (_("  %#06x:   Name index: %lx"),
8744                               isum, aux.vna_name);
8745
8746                     printf (_("  Flags: %s  Version: %d\n"),
8747                             get_ver_flags (aux.vna_flags), aux.vna_other);
8748
8749                     /* Check for overflow.  */
8750                     if (aux.vna_next > (size_t) (endbuf - vstart))
8751                       break;
8752
8753                     isum   += aux.vna_next;
8754                     vstart += aux.vna_next;
8755                   }
8756
8757                 if (j < ent.vn_cnt)
8758                   warn (_("Missing Version Needs auxillary information\n"));
8759
8760                 idx += ent.vn_next;
8761               }
8762
8763             if (cnt < section->sh_info)
8764               warn (_("Missing Version Needs information\n"));
8765
8766             free (eneed);
8767           }
8768           break;
8769
8770         case SHT_GNU_versym:
8771           {
8772             Elf_Internal_Shdr * link_section;
8773             int total;
8774             int cnt;
8775             unsigned char * edata;
8776             unsigned short * data;
8777             char * strtab;
8778             Elf_Internal_Sym * symbols;
8779             Elf_Internal_Shdr * string_sec;
8780             unsigned long num_syms;
8781             long off;
8782
8783             if (section->sh_link >= elf_header.e_shnum)
8784               break;
8785
8786             link_section = section_headers + section->sh_link;
8787             total = section->sh_size / sizeof (Elf_External_Versym);
8788
8789             if (link_section->sh_link >= elf_header.e_shnum)
8790               break;
8791
8792             found = 1;
8793
8794             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
8795             if (symbols == NULL)
8796               break;
8797
8798             string_sec = section_headers + link_section->sh_link;
8799
8800             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8801                                         string_sec->sh_size,
8802                                         _("version string table"));
8803             if (!strtab)
8804               {
8805                 free (symbols);
8806                 break;
8807               }
8808
8809             printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8810                     SECTION_NAME (section), total);
8811
8812             printf (_(" Addr: "));
8813             printf_vma (section->sh_addr);
8814             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8815                     (unsigned long) section->sh_offset, section->sh_link,
8816                     SECTION_NAME (link_section));
8817
8818             off = offset_from_vma (file,
8819                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8820                                    total * sizeof (short));
8821             edata = (unsigned char *) get_data (NULL, file, off, total,
8822                                                 sizeof (short),
8823                                                 _("version symbol data"));
8824             if (!edata)
8825               {
8826                 free (strtab);
8827                 free (symbols);
8828                 break;
8829               }
8830
8831             data = (short unsigned int *) cmalloc (total, sizeof (short));
8832
8833             for (cnt = total; cnt --;)
8834               data[cnt] = byte_get (edata + cnt * sizeof (short),
8835                                     sizeof (short));
8836
8837             free (edata);
8838
8839             for (cnt = 0; cnt < total; cnt += 4)
8840               {
8841                 int j, nn;
8842                 int check_def, check_need;
8843                 char * name;
8844
8845                 printf ("  %03x:", cnt);
8846
8847                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
8848                   switch (data[cnt + j])
8849                     {
8850                     case 0:
8851                       fputs (_("   0 (*local*)    "), stdout);
8852                       break;
8853
8854                     case 1:
8855                       fputs (_("   1 (*global*)   "), stdout);
8856                       break;
8857
8858                     default:
8859                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8860                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
8861
8862                       /* If this index value is greater than the size of the symbols
8863                          array, break to avoid an out-of-bounds read.  */
8864                       if ((unsigned long)(cnt + j) >= num_syms)
8865                         {
8866                           warn (_("invalid index into symbol array\n"));
8867                           break;
8868                         }
8869
8870                       check_def = 1;
8871                       check_need = 1;
8872                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8873                           || section_headers[symbols[cnt + j].st_shndx].sh_type
8874                              != SHT_NOBITS)
8875                         {
8876                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
8877                             check_def = 0;
8878                           else
8879                             check_need = 0;
8880                         }
8881
8882                       if (check_need
8883                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
8884                         {
8885                           Elf_Internal_Verneed ivn;
8886                           unsigned long offset;
8887
8888                           offset = offset_from_vma
8889                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8890                              sizeof (Elf_External_Verneed));
8891
8892                           do
8893                             {
8894                               Elf_Internal_Vernaux ivna;
8895                               Elf_External_Verneed evn;
8896                               Elf_External_Vernaux evna;
8897                               unsigned long a_off;
8898
8899                               if (get_data (&evn, file, offset, sizeof (evn), 1,
8900                                             _("version need")) == NULL)
8901                                 break;
8902
8903                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
8904                               ivn.vn_next = BYTE_GET (evn.vn_next);
8905
8906                               a_off = offset + ivn.vn_aux;
8907
8908                               do
8909                                 {
8910                                   if (get_data (&evna, file, a_off, sizeof (evna),
8911                                                 1, _("version need aux (2)")) == NULL)
8912                                     {
8913                                       ivna.vna_next  = 0;
8914                                       ivna.vna_other = 0;
8915                                     }
8916                                   else
8917                                     {
8918                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
8919                                       ivna.vna_other = BYTE_GET (evna.vna_other);
8920                                     }
8921
8922                                   a_off += ivna.vna_next;
8923                                 }
8924                               while (ivna.vna_other != data[cnt + j]
8925                                      && ivna.vna_next != 0);
8926
8927                               if (ivna.vna_other == data[cnt + j])
8928                                 {
8929                                   ivna.vna_name = BYTE_GET (evna.vna_name);
8930
8931                                   if (ivna.vna_name >= string_sec->sh_size)
8932                                     name = _("*invalid*");
8933                                   else
8934                                     name = strtab + ivna.vna_name;
8935                                   nn += printf ("(%s%-*s",
8936                                                 name,
8937                                                 12 - (int) strlen (name),
8938                                                 ")");
8939                                   check_def = 0;
8940                                   break;
8941                                 }
8942
8943                               offset += ivn.vn_next;
8944                             }
8945                           while (ivn.vn_next);
8946                         }
8947
8948                       if (check_def && data[cnt + j] != 0x8001
8949                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8950                         {
8951                           Elf_Internal_Verdef ivd;
8952                           Elf_External_Verdef evd;
8953                           unsigned long offset;
8954
8955                           offset = offset_from_vma
8956                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8957                              sizeof evd);
8958
8959                           do
8960                             {
8961                               if (get_data (&evd, file, offset, sizeof (evd), 1,
8962                                             _("version def")) == NULL)
8963                                 {
8964                                   ivd.vd_next = 0;
8965                                   ivd.vd_ndx  = 0;
8966                                 }
8967                               else
8968                                 {
8969                                   ivd.vd_next = BYTE_GET (evd.vd_next);
8970                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
8971                                 }
8972
8973                               offset += ivd.vd_next;
8974                             }
8975                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
8976                                  && ivd.vd_next != 0);
8977
8978                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
8979                             {
8980                               Elf_External_Verdaux evda;
8981                               Elf_Internal_Verdaux ivda;
8982
8983                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
8984
8985                               if (get_data (&evda, file,
8986                                             offset - ivd.vd_next + ivd.vd_aux,
8987                                             sizeof (evda), 1,
8988                                             _("version def aux")) == NULL)
8989                                 break;
8990
8991                               ivda.vda_name = BYTE_GET (evda.vda_name);
8992
8993                               if (ivda.vda_name >= string_sec->sh_size)
8994                                 name = _("*invalid*");
8995                               else
8996                                 name = strtab + ivda.vda_name;
8997                               nn += printf ("(%s%-*s",
8998                                             name,
8999                                             12 - (int) strlen (name),
9000                                             ")");
9001                             }
9002                         }
9003
9004                       if (nn < 18)
9005                         printf ("%*c", 18 - nn, ' ');
9006                     }
9007
9008                 putchar ('\n');
9009               }
9010
9011             free (data);
9012             free (strtab);
9013             free (symbols);
9014           }
9015           break;
9016
9017         default:
9018           break;
9019         }
9020     }
9021
9022   if (! found)
9023     printf (_("\nNo version information found in this file.\n"));
9024
9025   return 1;
9026 }
9027
9028 static const char *
9029 get_symbol_binding (unsigned int binding)
9030 {
9031   static char buff[32];
9032
9033   switch (binding)
9034     {
9035     case STB_LOCAL:     return "LOCAL";
9036     case STB_GLOBAL:    return "GLOBAL";
9037     case STB_WEAK:      return "WEAK";
9038     default:
9039       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
9040         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9041                   binding);
9042       else if (binding >= STB_LOOS && binding <= STB_HIOS)
9043         {
9044           if (binding == STB_GNU_UNIQUE
9045               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9046                   /* GNU is still using the default value 0.  */
9047                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9048             return "UNIQUE";
9049           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9050         }
9051       else
9052         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
9053       return buff;
9054     }
9055 }
9056
9057 static const char *
9058 get_symbol_type (unsigned int type)
9059 {
9060   static char buff[32];
9061
9062   switch (type)
9063     {
9064     case STT_NOTYPE:    return "NOTYPE";
9065     case STT_OBJECT:    return "OBJECT";
9066     case STT_FUNC:      return "FUNC";
9067     case STT_SECTION:   return "SECTION";
9068     case STT_FILE:      return "FILE";
9069     case STT_COMMON:    return "COMMON";
9070     case STT_TLS:       return "TLS";
9071     case STT_RELC:      return "RELC";
9072     case STT_SRELC:     return "SRELC";
9073     default:
9074       if (type >= STT_LOPROC && type <= STT_HIPROC)
9075         {
9076           if (elf_header.e_machine == EM_ARM)
9077             {
9078               if (type == STT_ARM_TFUNC)
9079                 return "THUMB_FUNC";
9080               if (type == STT_ARM_16BIT)
9081                 return "THUMB_LABEL";
9082             }
9083
9084           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
9085             return "REGISTER";
9086
9087           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9088             return "PARISC_MILLI";
9089
9090           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
9091         }
9092       else if (type >= STT_LOOS && type <= STT_HIOS)
9093         {
9094           if (elf_header.e_machine == EM_PARISC)
9095             {
9096               if (type == STT_HP_OPAQUE)
9097                 return "HP_OPAQUE";
9098               if (type == STT_HP_STUB)
9099                 return "HP_STUB";
9100             }
9101
9102           if (type == STT_GNU_IFUNC
9103               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9104                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9105                   /* GNU is still using the default value 0.  */
9106                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9107             return "IFUNC";
9108
9109           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
9110         }
9111       else
9112         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
9113       return buff;
9114     }
9115 }
9116
9117 static const char *
9118 get_symbol_visibility (unsigned int visibility)
9119 {
9120   switch (visibility)
9121     {
9122     case STV_DEFAULT:   return "DEFAULT";
9123     case STV_INTERNAL:  return "INTERNAL";
9124     case STV_HIDDEN:    return "HIDDEN";
9125     case STV_PROTECTED: return "PROTECTED";
9126     default: abort ();
9127     }
9128 }
9129
9130 static const char *
9131 get_mips_symbol_other (unsigned int other)
9132 {
9133   switch (other)
9134     {
9135     case STO_OPTIONAL:
9136       return "OPTIONAL";
9137     case STO_MIPS_PLT:
9138       return "MIPS PLT";
9139     case STO_MIPS_PIC:
9140       return "MIPS PIC";
9141     case STO_MICROMIPS:
9142       return "MICROMIPS";
9143     case STO_MICROMIPS | STO_MIPS_PIC:
9144       return "MICROMIPS, MIPS PIC";
9145     case STO_MIPS16:
9146       return "MIPS16";
9147     default:
9148       return NULL;
9149     }
9150 }
9151
9152 static const char *
9153 get_ia64_symbol_other (unsigned int other)
9154 {
9155   if (is_ia64_vms ())
9156     {
9157       static char res[32];
9158
9159       res[0] = 0;
9160
9161       /* Function types is for images and .STB files only.  */
9162       switch (elf_header.e_type)
9163         {
9164         case ET_DYN:
9165         case ET_EXEC:
9166           switch (VMS_ST_FUNC_TYPE (other))
9167             {
9168             case VMS_SFT_CODE_ADDR:
9169               strcat (res, " CA");
9170               break;
9171             case VMS_SFT_SYMV_IDX:
9172               strcat (res, " VEC");
9173               break;
9174             case VMS_SFT_FD:
9175               strcat (res, " FD");
9176               break;
9177             case VMS_SFT_RESERVE:
9178               strcat (res, " RSV");
9179               break;
9180             default:
9181               abort ();
9182             }
9183           break;
9184         default:
9185           break;
9186         }
9187       switch (VMS_ST_LINKAGE (other))
9188         {
9189         case VMS_STL_IGNORE:
9190           strcat (res, " IGN");
9191           break;
9192         case VMS_STL_RESERVE:
9193           strcat (res, " RSV");
9194           break;
9195         case VMS_STL_STD:
9196           strcat (res, " STD");
9197           break;
9198         case VMS_STL_LNK:
9199           strcat (res, " LNK");
9200           break;
9201         default:
9202           abort ();
9203         }
9204
9205       if (res[0] != 0)
9206         return res + 1;
9207       else
9208         return res;
9209     }
9210   return NULL;
9211 }
9212
9213 static const char *
9214 get_ppc64_symbol_other (unsigned int other)
9215 {
9216   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
9217     {
9218       static char buf[32];
9219       snprintf (buf, sizeof buf, _("<localentry>: %d"),
9220                 PPC64_LOCAL_ENTRY_OFFSET (other));
9221       return buf;
9222     }
9223   return NULL;
9224 }
9225
9226 static const char *
9227 get_symbol_other (unsigned int other)
9228 {
9229   const char * result = NULL;
9230   static char buff [32];
9231
9232   if (other == 0)
9233     return "";
9234
9235   switch (elf_header.e_machine)
9236     {
9237     case EM_MIPS:
9238       result = get_mips_symbol_other (other);
9239       break;
9240     case EM_IA_64:
9241       result = get_ia64_symbol_other (other);
9242       break;
9243     case EM_PPC64:
9244       result = get_ppc64_symbol_other (other);
9245       break;
9246     default:
9247       break;
9248     }
9249
9250   if (result)
9251     return result;
9252
9253   snprintf (buff, sizeof buff, _("<other>: %x"), other);
9254   return buff;
9255 }
9256
9257 static const char *
9258 get_symbol_index_type (unsigned int type)
9259 {
9260   static char buff[32];
9261
9262   switch (type)
9263     {
9264     case SHN_UNDEF:     return "UND";
9265     case SHN_ABS:       return "ABS";
9266     case SHN_COMMON:    return "COM";
9267     default:
9268       if (type == SHN_IA_64_ANSI_COMMON
9269           && elf_header.e_machine == EM_IA_64
9270           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9271         return "ANSI_COM";
9272       else if ((elf_header.e_machine == EM_X86_64
9273                 || elf_header.e_machine == EM_L1OM
9274                 || elf_header.e_machine == EM_K1OM)
9275                && type == SHN_X86_64_LCOMMON)
9276         return "LARGE_COM";
9277       else if ((type == SHN_MIPS_SCOMMON
9278                 && elf_header.e_machine == EM_MIPS)
9279                || (type == SHN_TIC6X_SCOMMON
9280                    && elf_header.e_machine == EM_TI_C6000))
9281         return "SCOM";
9282       else if (type == SHN_MIPS_SUNDEFINED
9283                && elf_header.e_machine == EM_MIPS)
9284         return "SUND";
9285       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
9286         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
9287       else if (type >= SHN_LOOS && type <= SHN_HIOS)
9288         sprintf (buff, "OS [0x%04x]", type & 0xffff);
9289       else if (type >= SHN_LORESERVE)
9290         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
9291       else if (type >= elf_header.e_shnum)
9292         sprintf (buff, "bad section index[%3d]", type);
9293       else
9294         sprintf (buff, "%3d", type);
9295       break;
9296     }
9297
9298   return buff;
9299 }
9300
9301 static bfd_vma *
9302 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
9303 {
9304   unsigned char * e_data;
9305   bfd_vma * i_data;
9306
9307   e_data = (unsigned char *) cmalloc (number, ent_size);
9308
9309   if (e_data == NULL)
9310     {
9311       error (_("Out of memory\n"));
9312       return NULL;
9313     }
9314
9315   if (fread (e_data, ent_size, number, file) != number)
9316     {
9317       error (_("Unable to read in dynamic data\n"));
9318       return NULL;
9319     }
9320
9321   i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
9322
9323   if (i_data == NULL)
9324     {
9325       error (_("Out of memory\n"));
9326       free (e_data);
9327       return NULL;
9328     }
9329
9330   while (number--)
9331     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
9332
9333   free (e_data);
9334
9335   return i_data;
9336 }
9337
9338 static void
9339 print_dynamic_symbol (bfd_vma si, unsigned long hn)
9340 {
9341   Elf_Internal_Sym * psym;
9342   int n;
9343
9344   psym = dynamic_symbols + si;
9345
9346   n = print_vma (si, DEC_5);
9347   if (n < 5)
9348     fputs (&"     "[n], stdout);
9349   printf (" %3lu: ", hn);
9350   print_vma (psym->st_value, LONG_HEX);
9351   putchar (' ');
9352   print_vma (psym->st_size, DEC_5);
9353
9354   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9355   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9356   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9357   /* Check to see if any other bits in the st_other field are set.
9358      Note - displaying this information disrupts the layout of the
9359      table being generated, but for the moment this case is very
9360      rare.  */
9361   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9362     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9363   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9364   if (VALID_DYNAMIC_NAME (psym->st_name))
9365     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9366   else
9367     printf (_(" <corrupt: %14ld>"), psym->st_name);
9368   putchar ('\n');
9369 }
9370
9371 /* Dump the symbol table.  */
9372 static int
9373 process_symbol_table (FILE * file)
9374 {
9375   Elf_Internal_Shdr * section;
9376   bfd_vma nbuckets = 0;
9377   bfd_vma nchains = 0;
9378   bfd_vma * buckets = NULL;
9379   bfd_vma * chains = NULL;
9380   bfd_vma ngnubuckets = 0;
9381   bfd_vma * gnubuckets = NULL;
9382   bfd_vma * gnuchains = NULL;
9383   bfd_vma gnusymidx = 0;
9384
9385   if (!do_syms && !do_dyn_syms && !do_histogram)
9386     return 1;
9387
9388   if (dynamic_info[DT_HASH]
9389       && (do_histogram
9390           || (do_using_dynamic
9391               && !do_dyn_syms
9392               && dynamic_strings != NULL)))
9393     {
9394       unsigned char nb[8];
9395       unsigned char nc[8];
9396       int hash_ent_size = 4;
9397
9398       if ((elf_header.e_machine == EM_ALPHA
9399            || elf_header.e_machine == EM_S390
9400            || elf_header.e_machine == EM_S390_OLD)
9401           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9402         hash_ent_size = 8;
9403
9404       if (fseek (file,
9405                  (archive_file_offset
9406                   + offset_from_vma (file, dynamic_info[DT_HASH],
9407                                      sizeof nb + sizeof nc)),
9408                  SEEK_SET))
9409         {
9410           error (_("Unable to seek to start of dynamic information\n"));
9411           goto no_hash;
9412         }
9413
9414       if (fread (nb, hash_ent_size, 1, file) != 1)
9415         {
9416           error (_("Failed to read in number of buckets\n"));
9417           goto no_hash;
9418         }
9419
9420       if (fread (nc, hash_ent_size, 1, file) != 1)
9421         {
9422           error (_("Failed to read in number of chains\n"));
9423           goto no_hash;
9424         }
9425
9426       nbuckets = byte_get (nb, hash_ent_size);
9427       nchains  = byte_get (nc, hash_ent_size);
9428
9429       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9430       chains  = get_dynamic_data (file, nchains, hash_ent_size);
9431
9432     no_hash:
9433       if (buckets == NULL || chains == NULL)
9434         {
9435           if (do_using_dynamic)
9436             return 0;
9437           free (buckets);
9438           free (chains);
9439           buckets = NULL;
9440           chains = NULL;
9441           nbuckets = 0;
9442           nchains = 0;
9443         }
9444     }
9445
9446   if (dynamic_info_DT_GNU_HASH
9447       && (do_histogram
9448           || (do_using_dynamic
9449               && !do_dyn_syms
9450               && dynamic_strings != NULL)))
9451     {
9452       unsigned char nb[16];
9453       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9454       bfd_vma buckets_vma;
9455
9456       if (fseek (file,
9457                  (archive_file_offset
9458                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9459                                      sizeof nb)),
9460                  SEEK_SET))
9461         {
9462           error (_("Unable to seek to start of dynamic information\n"));
9463           goto no_gnu_hash;
9464         }
9465
9466       if (fread (nb, 16, 1, file) != 1)
9467         {
9468           error (_("Failed to read in number of buckets\n"));
9469           goto no_gnu_hash;
9470         }
9471
9472       ngnubuckets = byte_get (nb, 4);
9473       gnusymidx = byte_get (nb + 4, 4);
9474       bitmaskwords = byte_get (nb + 8, 4);
9475       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
9476       if (is_32bit_elf)
9477         buckets_vma += bitmaskwords * 4;
9478       else
9479         buckets_vma += bitmaskwords * 8;
9480
9481       if (fseek (file,
9482                  (archive_file_offset
9483                   + offset_from_vma (file, buckets_vma, 4)),
9484                  SEEK_SET))
9485         {
9486           error (_("Unable to seek to start of dynamic information\n"));
9487           goto no_gnu_hash;
9488         }
9489
9490       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
9491
9492       if (gnubuckets == NULL)
9493         goto no_gnu_hash;
9494
9495       for (i = 0; i < ngnubuckets; i++)
9496         if (gnubuckets[i] != 0)
9497           {
9498             if (gnubuckets[i] < gnusymidx)
9499               return 0;
9500
9501             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9502               maxchain = gnubuckets[i];
9503           }
9504
9505       if (maxchain == 0xffffffff)
9506         goto no_gnu_hash;
9507
9508       maxchain -= gnusymidx;
9509
9510       if (fseek (file,
9511                  (archive_file_offset
9512                   + offset_from_vma (file, buckets_vma
9513                                            + 4 * (ngnubuckets + maxchain), 4)),
9514                  SEEK_SET))
9515         {
9516           error (_("Unable to seek to start of dynamic information\n"));
9517           goto no_gnu_hash;
9518         }
9519
9520       do
9521         {
9522           if (fread (nb, 4, 1, file) != 1)
9523             {
9524               error (_("Failed to determine last chain length\n"));
9525               goto no_gnu_hash;
9526             }
9527
9528           if (maxchain + 1 == 0)
9529             goto no_gnu_hash;
9530
9531           ++maxchain;
9532         }
9533       while ((byte_get (nb, 4) & 1) == 0);
9534
9535       if (fseek (file,
9536                  (archive_file_offset
9537                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9538                  SEEK_SET))
9539         {
9540           error (_("Unable to seek to start of dynamic information\n"));
9541           goto no_gnu_hash;
9542         }
9543
9544       gnuchains = get_dynamic_data (file, maxchain, 4);
9545
9546     no_gnu_hash:
9547       if (gnuchains == NULL)
9548         {
9549           free (gnubuckets);
9550           gnubuckets = NULL;
9551           ngnubuckets = 0;
9552           if (do_using_dynamic)
9553             return 0;
9554         }
9555     }
9556
9557   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9558       && do_syms
9559       && do_using_dynamic
9560       && dynamic_strings != NULL)
9561     {
9562       unsigned long hn;
9563
9564       if (dynamic_info[DT_HASH])
9565         {
9566           bfd_vma si;
9567
9568           printf (_("\nSymbol table for image:\n"));
9569           if (is_32bit_elf)
9570             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9571           else
9572             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9573
9574           for (hn = 0; hn < nbuckets; hn++)
9575             {
9576               if (! buckets[hn])
9577                 continue;
9578
9579               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9580                 print_dynamic_symbol (si, hn);
9581             }
9582         }
9583
9584       if (dynamic_info_DT_GNU_HASH)
9585         {
9586           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9587           if (is_32bit_elf)
9588             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9589           else
9590             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9591
9592           for (hn = 0; hn < ngnubuckets; ++hn)
9593             if (gnubuckets[hn] != 0)
9594               {
9595                 bfd_vma si = gnubuckets[hn];
9596                 bfd_vma off = si - gnusymidx;
9597
9598                 do
9599                   {
9600                     print_dynamic_symbol (si, hn);
9601                     si++;
9602                   }
9603                 while ((gnuchains[off++] & 1) == 0);
9604               }
9605         }
9606     }
9607   else if (do_dyn_syms || (do_syms && !do_using_dynamic))
9608     {
9609       unsigned int i;
9610
9611       for (i = 0, section = section_headers;
9612            i < elf_header.e_shnum;
9613            i++, section++)
9614         {
9615           unsigned int si;
9616           char * strtab = NULL;
9617           unsigned long int strtab_size = 0;
9618           Elf_Internal_Sym * symtab;
9619           Elf_Internal_Sym * psym;
9620           unsigned long num_syms;
9621
9622           if ((section->sh_type != SHT_SYMTAB
9623                && section->sh_type != SHT_DYNSYM)
9624               || (!do_syms
9625                   && section->sh_type == SHT_SYMTAB))
9626             continue;
9627
9628           if (section->sh_entsize == 0)
9629             {
9630               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9631                       SECTION_NAME (section));
9632               continue;
9633             }
9634
9635           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9636                   SECTION_NAME (section),
9637                   (unsigned long) (section->sh_size / section->sh_entsize));
9638
9639           if (is_32bit_elf)
9640             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
9641           else
9642             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
9643
9644           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
9645           if (symtab == NULL)
9646             continue;
9647
9648           if (section->sh_link == elf_header.e_shstrndx)
9649             {
9650               strtab = string_table;
9651               strtab_size = string_table_length;
9652             }
9653           else if (section->sh_link < elf_header.e_shnum)
9654             {
9655               Elf_Internal_Shdr * string_sec;
9656
9657               string_sec = section_headers + section->sh_link;
9658
9659               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9660                                           1, string_sec->sh_size,
9661                                           _("string table"));
9662               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
9663             }
9664
9665           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
9666             {
9667               printf ("%6d: ", si);
9668               print_vma (psym->st_value, LONG_HEX);
9669               putchar (' ');
9670               print_vma (psym->st_size, DEC_5);
9671               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9672               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9673               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9674               /* Check to see if any other bits in the st_other field are set.
9675                  Note - displaying this information disrupts the layout of the
9676                  table being generated, but for the moment this case is very rare.  */
9677               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9678                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9679               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
9680               print_symbol (25, psym->st_name < strtab_size
9681                             ? strtab + psym->st_name : _("<corrupt>"));
9682
9683               if (section->sh_type == SHT_DYNSYM
9684                   && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9685                 {
9686                   unsigned char data[2];
9687                   unsigned short vers_data;
9688                   unsigned long offset;
9689                   int is_nobits;
9690                   int check_def;
9691
9692                   offset = offset_from_vma
9693                     (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9694                      sizeof data + si * sizeof (vers_data));
9695
9696                   if (get_data (&data, file, offset + si * sizeof (vers_data),
9697                                 sizeof (data), 1, _("version data")) == NULL)
9698                     break;
9699
9700                   vers_data = byte_get (data, 2);
9701
9702                   is_nobits = (psym->st_shndx < elf_header.e_shnum
9703                                && section_headers[psym->st_shndx].sh_type
9704                                   == SHT_NOBITS);
9705
9706                   check_def = (psym->st_shndx != SHN_UNDEF);
9707
9708                   if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
9709                     {
9710                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
9711                           && (is_nobits || ! check_def))
9712                         {
9713                           Elf_External_Verneed evn;
9714                           Elf_Internal_Verneed ivn;
9715                           Elf_Internal_Vernaux ivna;
9716
9717                           /* We must test both.  */
9718                           offset = offset_from_vma
9719                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9720                              sizeof evn);
9721
9722                           do
9723                             {
9724                               unsigned long vna_off;
9725
9726                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9727                                             _("version need")) == NULL)
9728                                 {
9729                                   ivna.vna_next = 0;
9730                                   ivna.vna_other = 0;
9731                                   ivna.vna_name = 0;
9732                                   break;
9733                                 }
9734
9735                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9736                               ivn.vn_next = BYTE_GET (evn.vn_next);
9737
9738                               vna_off = offset + ivn.vn_aux;
9739
9740                               do
9741                                 {
9742                                   Elf_External_Vernaux evna;
9743
9744                                   if (get_data (&evna, file, vna_off,
9745                                                 sizeof (evna), 1,
9746                                                 _("version need aux (3)")) == NULL)
9747                                     {
9748                                       ivna.vna_next = 0;
9749                                       ivna.vna_other = 0;
9750                                       ivna.vna_name = 0;
9751                                     }
9752                                   else
9753                                     {
9754                                       ivna.vna_other = BYTE_GET (evna.vna_other);
9755                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
9756                                       ivna.vna_name  = BYTE_GET (evna.vna_name);
9757                                     }
9758
9759                                   vna_off += ivna.vna_next;
9760                                 }
9761                               while (ivna.vna_other != vers_data
9762                                      && ivna.vna_next != 0);
9763
9764                               if (ivna.vna_other == vers_data)
9765                                 break;
9766
9767                               offset += ivn.vn_next;
9768                             }
9769                           while (ivn.vn_next != 0);
9770
9771                           if (ivna.vna_other == vers_data)
9772                             {
9773                               printf ("@%s (%d)",
9774                                       ivna.vna_name < strtab_size
9775                                       ? strtab + ivna.vna_name : _("<corrupt>"),
9776                                       ivna.vna_other);
9777                               check_def = 0;
9778                             }
9779                           else if (! is_nobits)
9780                             error (_("bad dynamic symbol\n"));
9781                           else
9782                             check_def = 1;
9783                         }
9784
9785                       if (check_def)
9786                         {
9787                           if (vers_data != 0x8001
9788                               && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9789                             {
9790                               Elf_Internal_Verdef ivd;
9791                               Elf_Internal_Verdaux ivda;
9792                               Elf_External_Verdaux evda;
9793                               unsigned long off;
9794
9795                               off = offset_from_vma
9796                                 (file,
9797                                  version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9798                                  sizeof (Elf_External_Verdef));
9799
9800                               do
9801                                 {
9802                                   Elf_External_Verdef evd;
9803
9804                                   if (get_data (&evd, file, off, sizeof (evd),
9805                                                 1, _("version def")) == NULL)
9806                                     {
9807                                       ivd.vd_ndx = 0;
9808                                       ivd.vd_aux = 0;
9809                                       ivd.vd_next = 0;
9810                                     }
9811                                   else
9812                                     {
9813                                       ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9814                                       ivd.vd_aux = BYTE_GET (evd.vd_aux);
9815                                       ivd.vd_next = BYTE_GET (evd.vd_next);
9816                                     }
9817
9818                                   off += ivd.vd_next;
9819                                 }
9820                               while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
9821                                      && ivd.vd_next != 0);
9822
9823                               off -= ivd.vd_next;
9824                               off += ivd.vd_aux;
9825
9826                               if (get_data (&evda, file, off, sizeof (evda),
9827                                             1, _("version def aux")) == NULL)
9828                                 break;
9829
9830                               ivda.vda_name = BYTE_GET (evda.vda_name);
9831
9832                               if (psym->st_name != ivda.vda_name)
9833                                 printf ((vers_data & VERSYM_HIDDEN)
9834                                         ? "@%s" : "@@%s",
9835                                         ivda.vda_name < strtab_size
9836                                         ? strtab + ivda.vda_name : _("<corrupt>"));
9837                             }
9838                         }
9839                     }
9840                 }
9841
9842               putchar ('\n');
9843             }
9844
9845           free (symtab);
9846           if (strtab != string_table)
9847             free (strtab);
9848         }
9849     }
9850   else if (do_syms)
9851     printf
9852       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9853
9854   if (do_histogram && buckets != NULL)
9855     {
9856       unsigned long * lengths;
9857       unsigned long * counts;
9858       unsigned long hn;
9859       bfd_vma si;
9860       unsigned long maxlength = 0;
9861       unsigned long nzero_counts = 0;
9862       unsigned long nsyms = 0;
9863
9864       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9865               (unsigned long) nbuckets);
9866       printf (_(" Length  Number     %% of total  Coverage\n"));
9867
9868       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
9869       if (lengths == NULL)
9870         {
9871           error (_("Out of memory\n"));
9872           return 0;
9873         }
9874       for (hn = 0; hn < nbuckets; ++hn)
9875         {
9876           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
9877             {
9878               ++nsyms;
9879               if (maxlength < ++lengths[hn])
9880                 ++maxlength;
9881             }
9882         }
9883
9884       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9885       if (counts == NULL)
9886         {
9887           error (_("Out of memory\n"));
9888           return 0;
9889         }
9890
9891       for (hn = 0; hn < nbuckets; ++hn)
9892         ++counts[lengths[hn]];
9893
9894       if (nbuckets > 0)
9895         {
9896           unsigned long i;
9897           printf ("      0  %-10lu (%5.1f%%)\n",
9898                   counts[0], (counts[0] * 100.0) / nbuckets);
9899           for (i = 1; i <= maxlength; ++i)
9900             {
9901               nzero_counts += counts[i] * i;
9902               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
9903                       i, counts[i], (counts[i] * 100.0) / nbuckets,
9904                       (nzero_counts * 100.0) / nsyms);
9905             }
9906         }
9907
9908       free (counts);
9909       free (lengths);
9910     }
9911
9912   if (buckets != NULL)
9913     {
9914       free (buckets);
9915       free (chains);
9916     }
9917
9918   if (do_histogram && gnubuckets != NULL)
9919     {
9920       unsigned long * lengths;
9921       unsigned long * counts;
9922       unsigned long hn;
9923       unsigned long maxlength = 0;
9924       unsigned long nzero_counts = 0;
9925       unsigned long nsyms = 0;
9926
9927       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
9928       if (lengths == NULL)
9929         {
9930           error (_("Out of memory\n"));
9931           return 0;
9932         }
9933
9934       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9935               (unsigned long) ngnubuckets);
9936       printf (_(" Length  Number     %% of total  Coverage\n"));
9937
9938       for (hn = 0; hn < ngnubuckets; ++hn)
9939         if (gnubuckets[hn] != 0)
9940           {
9941             bfd_vma off, length = 1;
9942
9943             for (off = gnubuckets[hn] - gnusymidx;
9944                  (gnuchains[off] & 1) == 0; ++off)
9945               ++length;
9946             lengths[hn] = length;
9947             if (length > maxlength)
9948               maxlength = length;
9949             nsyms += length;
9950           }
9951
9952       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9953       if (counts == NULL)
9954         {
9955           error (_("Out of memory\n"));
9956           return 0;
9957         }
9958
9959       for (hn = 0; hn < ngnubuckets; ++hn)
9960         ++counts[lengths[hn]];
9961
9962       if (ngnubuckets > 0)
9963         {
9964           unsigned long j;
9965           printf ("      0  %-10lu (%5.1f%%)\n",
9966                   counts[0], (counts[0] * 100.0) / ngnubuckets);
9967           for (j = 1; j <= maxlength; ++j)
9968             {
9969               nzero_counts += counts[j] * j;
9970               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
9971                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9972                       (nzero_counts * 100.0) / nsyms);
9973             }
9974         }
9975
9976       free (counts);
9977       free (lengths);
9978       free (gnubuckets);
9979       free (gnuchains);
9980     }
9981
9982   return 1;
9983 }
9984
9985 static int
9986 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
9987 {
9988   unsigned int i;
9989
9990   if (dynamic_syminfo == NULL
9991       || !do_dynamic)
9992     /* No syminfo, this is ok.  */
9993     return 1;
9994
9995   /* There better should be a dynamic symbol section.  */
9996   if (dynamic_symbols == NULL || dynamic_strings == NULL)
9997     return 0;
9998
9999   if (dynamic_addr)
10000     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10001             dynamic_syminfo_offset, dynamic_syminfo_nent);
10002
10003   printf (_(" Num: Name                           BoundTo     Flags\n"));
10004   for (i = 0; i < dynamic_syminfo_nent; ++i)
10005     {
10006       unsigned short int flags = dynamic_syminfo[i].si_flags;
10007
10008       printf ("%4d: ", i);
10009       if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
10010         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10011       else
10012         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
10013       putchar (' ');
10014
10015       switch (dynamic_syminfo[i].si_boundto)
10016         {
10017         case SYMINFO_BT_SELF:
10018           fputs ("SELF       ", stdout);
10019           break;
10020         case SYMINFO_BT_PARENT:
10021           fputs ("PARENT     ", stdout);
10022           break;
10023         default:
10024           if (dynamic_syminfo[i].si_boundto > 0
10025               && dynamic_syminfo[i].si_boundto < dynamic_nent
10026               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
10027             {
10028               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
10029               putchar (' ' );
10030             }
10031           else
10032             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10033           break;
10034         }
10035
10036       if (flags & SYMINFO_FLG_DIRECT)
10037         printf (" DIRECT");
10038       if (flags & SYMINFO_FLG_PASSTHRU)
10039         printf (" PASSTHRU");
10040       if (flags & SYMINFO_FLG_COPY)
10041         printf (" COPY");
10042       if (flags & SYMINFO_FLG_LAZYLOAD)
10043         printf (" LAZYLOAD");
10044
10045       puts ("");
10046     }
10047
10048   return 1;
10049 }
10050
10051 /* Check to see if the given reloc needs to be handled in a target specific
10052    manner.  If so then process the reloc and return TRUE otherwise return
10053    FALSE.  */
10054
10055 static bfd_boolean
10056 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10057                                 unsigned char *     start,
10058                                 Elf_Internal_Sym *  symtab)
10059 {
10060   unsigned int reloc_type = get_reloc_type (reloc->r_info);
10061
10062   switch (elf_header.e_machine)
10063     {
10064     case EM_MSP430:
10065     case EM_MSP430_OLD:
10066       {
10067         static Elf_Internal_Sym * saved_sym = NULL;
10068
10069         switch (reloc_type)
10070           {
10071           case 10: /* R_MSP430_SYM_DIFF */
10072             if (uses_msp430x_relocs ())
10073               break;
10074           case 21: /* R_MSP430X_SYM_DIFF */
10075             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10076             return TRUE;
10077
10078           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10079           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10080             goto handle_sym_diff;
10081
10082           case 5: /* R_MSP430_16_BYTE */
10083           case 9: /* R_MSP430_8 */
10084             if (uses_msp430x_relocs ())
10085               break;
10086             goto handle_sym_diff;
10087
10088           case 2: /* R_MSP430_ABS16 */
10089           case 15: /* R_MSP430X_ABS16 */
10090             if (! uses_msp430x_relocs ())
10091               break;
10092             goto handle_sym_diff;
10093
10094           handle_sym_diff:
10095             if (saved_sym != NULL)
10096               {
10097                 bfd_vma value;
10098
10099                 value = reloc->r_addend
10100                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10101                      - saved_sym->st_value);
10102
10103                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10104
10105                 saved_sym = NULL;
10106                 return TRUE;
10107               }
10108             break;
10109
10110           default:
10111             if (saved_sym != NULL)
10112               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc"));
10113             break;
10114           }
10115         break;
10116       }
10117
10118     case EM_MN10300:
10119     case EM_CYGNUS_MN10300:
10120       {
10121         static Elf_Internal_Sym * saved_sym = NULL;
10122
10123         switch (reloc_type)
10124           {
10125           case 34: /* R_MN10300_ALIGN */
10126             return TRUE;
10127           case 33: /* R_MN10300_SYM_DIFF */
10128             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10129             return TRUE;
10130           case 1: /* R_MN10300_32 */
10131           case 2: /* R_MN10300_16 */
10132             if (saved_sym != NULL)
10133               {
10134                 bfd_vma value;
10135
10136                 value = reloc->r_addend
10137                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10138                      - saved_sym->st_value);
10139
10140                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10141
10142                 saved_sym = NULL;
10143                 return TRUE;
10144               }
10145             break;
10146           default:
10147             if (saved_sym != NULL)
10148               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10149             break;
10150           }
10151         break;
10152       }
10153     }
10154
10155   return FALSE;
10156 }
10157
10158 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10159    DWARF debug sections.  This is a target specific test.  Note - we do not
10160    go through the whole including-target-headers-multiple-times route, (as
10161    we have already done with <elf/h8.h>) because this would become very
10162    messy and even then this function would have to contain target specific
10163    information (the names of the relocs instead of their numeric values).
10164    FIXME: This is not the correct way to solve this problem.  The proper way
10165    is to have target specific reloc sizing and typing functions created by
10166    the reloc-macros.h header, in the same way that it already creates the
10167    reloc naming functions.  */
10168
10169 static bfd_boolean
10170 is_32bit_abs_reloc (unsigned int reloc_type)
10171 {
10172   switch (elf_header.e_machine)
10173     {
10174     case EM_386:
10175     case EM_486:
10176       return reloc_type == 1; /* R_386_32.  */
10177     case EM_68K:
10178       return reloc_type == 1; /* R_68K_32.  */
10179     case EM_860:
10180       return reloc_type == 1; /* R_860_32.  */
10181     case EM_960:
10182       return reloc_type == 2; /* R_960_32.  */
10183     case EM_AARCH64:
10184       return reloc_type == 258; /* R_AARCH64_ABS32 */
10185     case EM_ALPHA:
10186       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
10187     case EM_ARC:
10188       return reloc_type == 1; /* R_ARC_32.  */
10189     case EM_ARM:
10190       return reloc_type == 2; /* R_ARM_ABS32 */
10191     case EM_AVR_OLD:
10192     case EM_AVR:
10193       return reloc_type == 1;
10194     case EM_ADAPTEVA_EPIPHANY:
10195       return reloc_type == 3;
10196     case EM_BLACKFIN:
10197       return reloc_type == 0x12; /* R_byte4_data.  */
10198     case EM_CRIS:
10199       return reloc_type == 3; /* R_CRIS_32.  */
10200     case EM_CR16:
10201       return reloc_type == 3; /* R_CR16_NUM32.  */
10202     case EM_CRX:
10203       return reloc_type == 15; /* R_CRX_NUM32.  */
10204     case EM_CYGNUS_FRV:
10205       return reloc_type == 1;
10206     case EM_CYGNUS_D10V:
10207     case EM_D10V:
10208       return reloc_type == 6; /* R_D10V_32.  */
10209     case EM_CYGNUS_D30V:
10210     case EM_D30V:
10211       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
10212     case EM_DLX:
10213       return reloc_type == 3; /* R_DLX_RELOC_32.  */
10214     case EM_CYGNUS_FR30:
10215     case EM_FR30:
10216       return reloc_type == 3; /* R_FR30_32.  */
10217     case EM_H8S:
10218     case EM_H8_300:
10219     case EM_H8_300H:
10220       return reloc_type == 1; /* R_H8_DIR32.  */
10221     case EM_IA_64:
10222       return reloc_type == 0x65; /* R_IA64_SECREL32LSB.  */
10223     case EM_IP2K_OLD:
10224     case EM_IP2K:
10225       return reloc_type == 2; /* R_IP2K_32.  */
10226     case EM_IQ2000:
10227       return reloc_type == 2; /* R_IQ2000_32.  */
10228     case EM_LATTICEMICO32:
10229       return reloc_type == 3; /* R_LM32_32.  */
10230     case EM_M32C_OLD:
10231     case EM_M32C:
10232       return reloc_type == 3; /* R_M32C_32.  */
10233     case EM_M32R:
10234       return reloc_type == 34; /* R_M32R_32_RELA.  */
10235     case EM_MCORE:
10236       return reloc_type == 1; /* R_MCORE_ADDR32.  */
10237     case EM_CYGNUS_MEP:
10238       return reloc_type == 4; /* R_MEP_32.  */
10239     case EM_METAG:
10240       return reloc_type == 2; /* R_METAG_ADDR32.  */
10241     case EM_MICROBLAZE:
10242       return reloc_type == 1; /* R_MICROBLAZE_32.  */
10243     case EM_MIPS:
10244       return reloc_type == 2; /* R_MIPS_32.  */
10245     case EM_MMIX:
10246       return reloc_type == 4; /* R_MMIX_32.  */
10247     case EM_CYGNUS_MN10200:
10248     case EM_MN10200:
10249       return reloc_type == 1; /* R_MN10200_32.  */
10250     case EM_CYGNUS_MN10300:
10251     case EM_MN10300:
10252       return reloc_type == 1; /* R_MN10300_32.  */
10253     case EM_MOXIE:
10254       return reloc_type == 1; /* R_MOXIE_32.  */
10255     case EM_MSP430_OLD:
10256     case EM_MSP430:
10257       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
10258     case EM_MT:
10259       return reloc_type == 2; /* R_MT_32.  */
10260     case EM_ALTERA_NIOS2:
10261       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
10262     case EM_NIOS32:
10263       return reloc_type == 1; /* R_NIOS_32.  */
10264     case EM_OPENRISC:
10265     case EM_OR32:
10266       return reloc_type == 1; /* R_OR32_32.  */
10267     case EM_PARISC:
10268       return (reloc_type == 1 /* R_PARISC_DIR32.  */
10269               || reloc_type == 41); /* R_PARISC_SECREL32.  */
10270     case EM_PJ:
10271     case EM_PJ_OLD:
10272       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
10273     case EM_PPC64:
10274       return reloc_type == 1; /* R_PPC64_ADDR32.  */
10275     case EM_PPC:
10276       return reloc_type == 1; /* R_PPC_ADDR32.  */
10277     case EM_RL78:
10278       return reloc_type == 1; /* R_RL78_DIR32.  */
10279     case EM_RX:
10280       return reloc_type == 1; /* R_RX_DIR32.  */
10281     case EM_S370:
10282       return reloc_type == 1; /* R_I370_ADDR31.  */
10283     case EM_S390_OLD:
10284     case EM_S390:
10285       return reloc_type == 4; /* R_S390_32.  */
10286     case EM_SCORE:
10287       return reloc_type == 8; /* R_SCORE_ABS32.  */
10288     case EM_SH:
10289       return reloc_type == 1; /* R_SH_DIR32.  */
10290     case EM_SPARC32PLUS:
10291     case EM_SPARCV9:
10292     case EM_SPARC:
10293       return reloc_type == 3 /* R_SPARC_32.  */
10294         || reloc_type == 23; /* R_SPARC_UA32.  */
10295     case EM_SPU:
10296       return reloc_type == 6; /* R_SPU_ADDR32 */
10297     case EM_TI_C6000:
10298       return reloc_type == 1; /* R_C6000_ABS32.  */
10299     case EM_TILEGX:
10300       return reloc_type == 2; /* R_TILEGX_32.  */
10301     case EM_TILEPRO:
10302       return reloc_type == 1; /* R_TILEPRO_32.  */
10303     case EM_CYGNUS_V850:
10304     case EM_V850:
10305       return reloc_type == 6; /* R_V850_ABS32.  */
10306     case EM_V800:
10307       return reloc_type == 0x33; /* R_V810_WORD.  */
10308     case EM_VAX:
10309       return reloc_type == 1; /* R_VAX_32.  */
10310     case EM_X86_64:
10311     case EM_L1OM:
10312     case EM_K1OM:
10313       return reloc_type == 10; /* R_X86_64_32.  */
10314     case EM_XC16X:
10315     case EM_C166:
10316       return reloc_type == 3; /* R_XC16C_ABS_32.  */
10317     case EM_XGATE:
10318       return reloc_type == 4; /* R_XGATE_32.  */
10319     case EM_XSTORMY16:
10320       return reloc_type == 1; /* R_XSTROMY16_32.  */
10321     case EM_XTENSA_OLD:
10322     case EM_XTENSA:
10323       return reloc_type == 1; /* R_XTENSA_32.  */
10324     default:
10325       error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10326              elf_header.e_machine);
10327       abort ();
10328     }
10329 }
10330
10331 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10332    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
10333
10334 static bfd_boolean
10335 is_32bit_pcrel_reloc (unsigned int reloc_type)
10336 {
10337   switch (elf_header.e_machine)
10338     {
10339     case EM_386:
10340     case EM_486:
10341       return reloc_type == 2;  /* R_386_PC32.  */
10342     case EM_68K:
10343       return reloc_type == 4;  /* R_68K_PC32.  */
10344     case EM_AARCH64:
10345       return reloc_type == 261; /* R_AARCH64_PREL32 */
10346     case EM_ADAPTEVA_EPIPHANY:
10347       return reloc_type == 6;
10348     case EM_ALPHA:
10349       return reloc_type == 10; /* R_ALPHA_SREL32.  */
10350     case EM_ARM:
10351       return reloc_type == 3;  /* R_ARM_REL32 */
10352     case EM_MICROBLAZE:
10353       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
10354     case EM_PARISC:
10355       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
10356     case EM_PPC:
10357       return reloc_type == 26; /* R_PPC_REL32.  */
10358     case EM_PPC64:
10359       return reloc_type == 26; /* R_PPC64_REL32.  */
10360     case EM_S390_OLD:
10361     case EM_S390:
10362       return reloc_type == 5;  /* R_390_PC32.  */
10363     case EM_SH:
10364       return reloc_type == 2;  /* R_SH_REL32.  */
10365     case EM_SPARC32PLUS:
10366     case EM_SPARCV9:
10367     case EM_SPARC:
10368       return reloc_type == 6;  /* R_SPARC_DISP32.  */
10369     case EM_SPU:
10370       return reloc_type == 13; /* R_SPU_REL32.  */
10371     case EM_TILEGX:
10372       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
10373     case EM_TILEPRO:
10374       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
10375     case EM_X86_64:
10376     case EM_L1OM:
10377     case EM_K1OM:
10378       return reloc_type == 2;  /* R_X86_64_PC32.  */
10379     case EM_XTENSA_OLD:
10380     case EM_XTENSA:
10381       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
10382     default:
10383       /* Do not abort or issue an error message here.  Not all targets use
10384          pc-relative 32-bit relocs in their DWARF debug information and we
10385          have already tested for target coverage in is_32bit_abs_reloc.  A
10386          more helpful warning message will be generated by apply_relocations
10387          anyway, so just return.  */
10388       return FALSE;
10389     }
10390 }
10391
10392 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10393    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
10394
10395 static bfd_boolean
10396 is_64bit_abs_reloc (unsigned int reloc_type)
10397 {
10398   switch (elf_header.e_machine)
10399     {
10400     case EM_AARCH64:
10401       return reloc_type == 257; /* R_AARCH64_ABS64.  */
10402     case EM_ALPHA:
10403       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
10404     case EM_IA_64:
10405       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
10406     case EM_PARISC:
10407       return reloc_type == 80; /* R_PARISC_DIR64.  */
10408     case EM_PPC64:
10409       return reloc_type == 38; /* R_PPC64_ADDR64.  */
10410     case EM_SPARC32PLUS:
10411     case EM_SPARCV9:
10412     case EM_SPARC:
10413       return reloc_type == 54; /* R_SPARC_UA64.  */
10414     case EM_X86_64:
10415     case EM_L1OM:
10416     case EM_K1OM:
10417       return reloc_type == 1; /* R_X86_64_64.  */
10418     case EM_S390_OLD:
10419     case EM_S390:
10420       return reloc_type == 22;  /* R_S390_64.  */
10421     case EM_TILEGX:
10422       return reloc_type == 1; /* R_TILEGX_64.  */
10423     case EM_MIPS:
10424       return reloc_type == 18;  /* R_MIPS_64.  */
10425     default:
10426       return FALSE;
10427     }
10428 }
10429
10430 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10431    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
10432
10433 static bfd_boolean
10434 is_64bit_pcrel_reloc (unsigned int reloc_type)
10435 {
10436   switch (elf_header.e_machine)
10437     {
10438     case EM_AARCH64:
10439       return reloc_type == 260; /* R_AARCH64_PREL64.  */
10440     case EM_ALPHA:
10441       return reloc_type == 11; /* R_ALPHA_SREL64.  */
10442     case EM_IA_64:
10443       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
10444     case EM_PARISC:
10445       return reloc_type == 72; /* R_PARISC_PCREL64.  */
10446     case EM_PPC64:
10447       return reloc_type == 44; /* R_PPC64_REL64.  */
10448     case EM_SPARC32PLUS:
10449     case EM_SPARCV9:
10450     case EM_SPARC:
10451       return reloc_type == 46; /* R_SPARC_DISP64.  */
10452     case EM_X86_64:
10453     case EM_L1OM:
10454     case EM_K1OM:
10455       return reloc_type == 24; /* R_X86_64_PC64.  */
10456     case EM_S390_OLD:
10457     case EM_S390:
10458       return reloc_type == 23;  /* R_S390_PC64.  */
10459     case EM_TILEGX:
10460       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
10461     default:
10462       return FALSE;
10463     }
10464 }
10465
10466 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10467    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
10468
10469 static bfd_boolean
10470 is_24bit_abs_reloc (unsigned int reloc_type)
10471 {
10472   switch (elf_header.e_machine)
10473     {
10474     case EM_CYGNUS_MN10200:
10475     case EM_MN10200:
10476       return reloc_type == 4; /* R_MN10200_24.  */
10477     default:
10478       return FALSE;
10479     }
10480 }
10481
10482 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10483    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
10484
10485 static bfd_boolean
10486 is_16bit_abs_reloc (unsigned int reloc_type)
10487 {
10488   switch (elf_header.e_machine)
10489     {
10490     case EM_AVR_OLD:
10491     case EM_AVR:
10492       return reloc_type == 4; /* R_AVR_16.  */
10493     case EM_ADAPTEVA_EPIPHANY:
10494       return reloc_type == 5;
10495     case EM_CYGNUS_D10V:
10496     case EM_D10V:
10497       return reloc_type == 3; /* R_D10V_16.  */
10498     case EM_H8S:
10499     case EM_H8_300:
10500     case EM_H8_300H:
10501       return reloc_type == R_H8_DIR16;
10502     case EM_IP2K_OLD:
10503     case EM_IP2K:
10504       return reloc_type == 1; /* R_IP2K_16.  */
10505     case EM_M32C_OLD:
10506     case EM_M32C:
10507       return reloc_type == 1; /* R_M32C_16 */
10508     case EM_MSP430:
10509       if (uses_msp430x_relocs ())
10510         return reloc_type == 2; /* R_MSP430_ABS16.  */
10511     case EM_MSP430_OLD:
10512       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
10513     case EM_ALTERA_NIOS2:
10514       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
10515     case EM_NIOS32:
10516       return reloc_type == 9; /* R_NIOS_16.  */
10517     case EM_TI_C6000:
10518       return reloc_type == 2; /* R_C6000_ABS16.  */
10519     case EM_XC16X:
10520     case EM_C166:
10521       return reloc_type == 2; /* R_XC16C_ABS_16.  */
10522     case EM_CYGNUS_MN10200:
10523     case EM_MN10200:
10524       return reloc_type == 2; /* R_MN10200_16.  */
10525     case EM_CYGNUS_MN10300:
10526     case EM_MN10300:
10527       return reloc_type == 2; /* R_MN10300_16.  */
10528     case EM_XGATE:
10529       return reloc_type == 3; /* R_XGATE_16.  */
10530     default:
10531       return FALSE;
10532     }
10533 }
10534
10535 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10536    relocation entries (possibly formerly used for SHT_GROUP sections).  */
10537
10538 static bfd_boolean
10539 is_none_reloc (unsigned int reloc_type)
10540 {
10541   switch (elf_header.e_machine)
10542     {
10543     case EM_68K:     /* R_68K_NONE.  */
10544     case EM_386:     /* R_386_NONE.  */
10545     case EM_SPARC32PLUS:
10546     case EM_SPARCV9:
10547     case EM_SPARC:   /* R_SPARC_NONE.  */
10548     case EM_MIPS:    /* R_MIPS_NONE.  */
10549     case EM_PARISC:  /* R_PARISC_NONE.  */
10550     case EM_ALPHA:   /* R_ALPHA_NONE.  */
10551     case EM_ADAPTEVA_EPIPHANY:
10552     case EM_PPC:     /* R_PPC_NONE.  */
10553     case EM_PPC64:   /* R_PPC64_NONE.  */
10554     case EM_ARM:     /* R_ARM_NONE.  */
10555     case EM_IA_64:   /* R_IA64_NONE.  */
10556     case EM_SH:      /* R_SH_NONE.  */
10557     case EM_S390_OLD:
10558     case EM_S390:    /* R_390_NONE.  */
10559     case EM_CRIS:    /* R_CRIS_NONE.  */
10560     case EM_X86_64:  /* R_X86_64_NONE.  */
10561     case EM_L1OM:    /* R_X86_64_NONE.  */
10562     case EM_K1OM:    /* R_X86_64_NONE.  */
10563     case EM_MN10300: /* R_MN10300_NONE.  */
10564     case EM_MOXIE:   /* R_MOXIE_NONE.  */
10565     case EM_M32R:    /* R_M32R_NONE.  */
10566     case EM_TI_C6000:/* R_C6000_NONE.  */
10567     case EM_TILEGX:  /* R_TILEGX_NONE.  */
10568     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
10569     case EM_XC16X:
10570     case EM_C166:    /* R_XC16X_NONE.  */
10571     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
10572     case EM_NIOS32:  /* R_NIOS_NONE.  */
10573       return reloc_type == 0;
10574     case EM_AARCH64:
10575       return reloc_type == 0 || reloc_type == 256;
10576     case EM_XTENSA_OLD:
10577     case EM_XTENSA:
10578       return (reloc_type == 0      /* R_XTENSA_NONE.  */
10579               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
10580               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
10581               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
10582     case EM_METAG:
10583       return reloc_type == 3; /* R_METAG_NONE.  */
10584     }
10585   return FALSE;
10586 }
10587
10588 /* Apply relocations to a section.
10589    Note: So far support has been added only for those relocations
10590    which can be found in debug sections.
10591    FIXME: Add support for more relocations ?  */
10592
10593 static void
10594 apply_relocations (void * file,
10595                    Elf_Internal_Shdr * section,
10596                    unsigned char * start)
10597 {
10598   Elf_Internal_Shdr * relsec;
10599   unsigned char * end = start + section->sh_size;
10600
10601   if (elf_header.e_type != ET_REL)
10602     return;
10603
10604   /* Find the reloc section associated with the section.  */
10605   for (relsec = section_headers;
10606        relsec < section_headers + elf_header.e_shnum;
10607        ++relsec)
10608     {
10609       bfd_boolean is_rela;
10610       unsigned long num_relocs;
10611       Elf_Internal_Rela * relocs;
10612       Elf_Internal_Rela * rp;
10613       Elf_Internal_Shdr * symsec;
10614       Elf_Internal_Sym * symtab;
10615       unsigned long num_syms;
10616       Elf_Internal_Sym * sym;
10617
10618       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10619           || relsec->sh_info >= elf_header.e_shnum
10620           || section_headers + relsec->sh_info != section
10621           || relsec->sh_size == 0
10622           || relsec->sh_link >= elf_header.e_shnum)
10623         continue;
10624
10625       is_rela = relsec->sh_type == SHT_RELA;
10626
10627       if (is_rela)
10628         {
10629           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10630                                   relsec->sh_size, & relocs, & num_relocs))
10631             return;
10632         }
10633       else
10634         {
10635           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10636                                  relsec->sh_size, & relocs, & num_relocs))
10637             return;
10638         }
10639
10640       /* SH uses RELA but uses in place value instead of the addend field.  */
10641       if (elf_header.e_machine == EM_SH)
10642         is_rela = FALSE;
10643
10644       symsec = section_headers + relsec->sh_link;
10645       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
10646
10647       for (rp = relocs; rp < relocs + num_relocs; ++rp)
10648         {
10649           bfd_vma         addend;
10650           unsigned int    reloc_type;
10651           unsigned int    reloc_size;
10652           unsigned char * rloc;
10653           unsigned long   sym_index;
10654
10655           reloc_type = get_reloc_type (rp->r_info);
10656
10657           if (target_specific_reloc_handling (rp, start, symtab))
10658             continue;
10659           else if (is_none_reloc (reloc_type))
10660             continue;
10661           else if (is_32bit_abs_reloc (reloc_type)
10662                    || is_32bit_pcrel_reloc (reloc_type))
10663             reloc_size = 4;
10664           else if (is_64bit_abs_reloc (reloc_type)
10665                    || is_64bit_pcrel_reloc (reloc_type))
10666             reloc_size = 8;
10667           else if (is_24bit_abs_reloc (reloc_type))
10668             reloc_size = 3;
10669           else if (is_16bit_abs_reloc (reloc_type))
10670             reloc_size = 2;
10671           else
10672             {
10673               warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10674                     reloc_type, SECTION_NAME (section));
10675               continue;
10676             }
10677
10678           rloc = start + rp->r_offset;
10679           if ((rloc + reloc_size) > end || (rloc < start))
10680             {
10681               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10682                     (unsigned long) rp->r_offset,
10683                     SECTION_NAME (section));
10684               continue;
10685             }
10686
10687           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10688           if (sym_index >= num_syms)
10689             {
10690               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10691                     sym_index, SECTION_NAME (section));
10692               continue;
10693             }
10694           sym = symtab + sym_index;
10695
10696           /* If the reloc has a symbol associated with it,
10697              make sure that it is of an appropriate type.
10698
10699              Relocations against symbols without type can happen.
10700              Gcc -feliminate-dwarf2-dups may generate symbols
10701              without type for debug info.
10702
10703              Icc generates relocations against function symbols
10704              instead of local labels.
10705
10706              Relocations against object symbols can happen, eg when
10707              referencing a global array.  For an example of this see
10708              the _clz.o binary in libgcc.a.  */
10709           if (sym != symtab
10710               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
10711             {
10712               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10713                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
10714                     (long int)(rp - relocs),
10715                     SECTION_NAME (relsec));
10716               continue;
10717             }
10718
10719           addend = 0;
10720           if (is_rela)
10721             addend += rp->r_addend;
10722           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10723              partial_inplace.  */
10724           if (!is_rela
10725               || (elf_header.e_machine == EM_XTENSA
10726                   && reloc_type == 1)
10727               || ((elf_header.e_machine == EM_PJ
10728                    || elf_header.e_machine == EM_PJ_OLD)
10729                   && reloc_type == 1)
10730               || ((elf_header.e_machine == EM_D30V
10731                    || elf_header.e_machine == EM_CYGNUS_D30V)
10732                   && reloc_type == 12))
10733             addend += byte_get (rloc, reloc_size);
10734
10735           if (is_32bit_pcrel_reloc (reloc_type)
10736               || is_64bit_pcrel_reloc (reloc_type))
10737             {
10738               /* On HPPA, all pc-relative relocations are biased by 8.  */
10739               if (elf_header.e_machine == EM_PARISC)
10740                 addend -= 8;
10741               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
10742                         reloc_size);
10743             }
10744           else
10745             byte_put (rloc, addend + sym->st_value, reloc_size);
10746         }
10747
10748       free (symtab);
10749       free (relocs);
10750       break;
10751     }
10752 }
10753
10754 #ifdef SUPPORT_DISASSEMBLY
10755 static int
10756 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10757 {
10758   printf (_("\nAssembly dump of section %s\n"),
10759           SECTION_NAME (section));
10760
10761   /* XXX -- to be done --- XXX */
10762
10763   return 1;
10764 }
10765 #endif
10766
10767 /* Reads in the contents of SECTION from FILE, returning a pointer
10768    to a malloc'ed buffer or NULL if something went wrong.  */
10769
10770 static char *
10771 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10772 {
10773   bfd_size_type num_bytes;
10774
10775   num_bytes = section->sh_size;
10776
10777   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10778     {
10779       printf (_("\nSection '%s' has no data to dump.\n"),
10780               SECTION_NAME (section));
10781       return NULL;
10782     }
10783
10784   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10785                              _("section contents"));
10786 }
10787
10788
10789 static void
10790 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10791 {
10792   Elf_Internal_Shdr * relsec;
10793   bfd_size_type num_bytes;
10794   char * data;
10795   char * end;
10796   char * start;
10797   char * name = SECTION_NAME (section);
10798   bfd_boolean some_strings_shown;
10799
10800   start = get_section_contents (section, file);
10801   if (start == NULL)
10802     return;
10803
10804   printf (_("\nString dump of section '%s':\n"), name);
10805
10806   /* If the section being dumped has relocations against it the user might
10807      be expecting these relocations to have been applied.  Check for this
10808      case and issue a warning message in order to avoid confusion.
10809      FIXME: Maybe we ought to have an option that dumps a section with
10810      relocs applied ?  */
10811   for (relsec = section_headers;
10812        relsec < section_headers + elf_header.e_shnum;
10813        ++relsec)
10814     {
10815       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10816           || relsec->sh_info >= elf_header.e_shnum
10817           || section_headers + relsec->sh_info != section
10818           || relsec->sh_size == 0
10819           || relsec->sh_link >= elf_header.e_shnum)
10820         continue;
10821
10822       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10823       break;
10824     }
10825
10826   num_bytes = section->sh_size;
10827   data = start;
10828   end  = start + num_bytes;
10829   some_strings_shown = FALSE;
10830
10831   while (data < end)
10832     {
10833       while (!ISPRINT (* data))
10834         if (++ data >= end)
10835           break;
10836
10837       if (data < end)
10838         {
10839 #ifndef __MSVCRT__
10840           /* PR 11128: Use two separate invocations in order to work
10841              around bugs in the Solaris 8 implementation of printf.  */
10842           printf ("  [%6tx]  ", data - start);
10843           printf ("%s\n", data);
10844 #else
10845           printf ("  [%6Ix]  %s\n", (size_t) (data - start), data);
10846 #endif
10847           data += strlen (data);
10848           some_strings_shown = TRUE;
10849         }
10850     }
10851
10852   if (! some_strings_shown)
10853     printf (_("  No strings found in this section."));
10854
10855   free (start);
10856
10857   putchar ('\n');
10858 }
10859
10860 static void
10861 dump_section_as_bytes (Elf_Internal_Shdr * section,
10862                        FILE * file,
10863                        bfd_boolean relocate)
10864 {
10865   Elf_Internal_Shdr * relsec;
10866   bfd_size_type bytes;
10867   bfd_vma addr;
10868   unsigned char * data;
10869   unsigned char * start;
10870
10871   start = (unsigned char *) get_section_contents (section, file);
10872   if (start == NULL)
10873     return;
10874
10875   printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10876
10877   if (relocate)
10878     {
10879       apply_relocations (file, section, start);
10880     }
10881   else
10882     {
10883       /* If the section being dumped has relocations against it the user might
10884          be expecting these relocations to have been applied.  Check for this
10885          case and issue a warning message in order to avoid confusion.
10886          FIXME: Maybe we ought to have an option that dumps a section with
10887          relocs applied ?  */
10888       for (relsec = section_headers;
10889            relsec < section_headers + elf_header.e_shnum;
10890            ++relsec)
10891         {
10892           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10893               || relsec->sh_info >= elf_header.e_shnum
10894               || section_headers + relsec->sh_info != section
10895               || relsec->sh_size == 0
10896               || relsec->sh_link >= elf_header.e_shnum)
10897             continue;
10898
10899           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10900           break;
10901         }
10902     }
10903
10904   addr = section->sh_addr;
10905   bytes = section->sh_size;
10906   data = start;
10907
10908   while (bytes)
10909     {
10910       int j;
10911       int k;
10912       int lbytes;
10913
10914       lbytes = (bytes > 16 ? 16 : bytes);
10915
10916       printf ("  0x%8.8lx ", (unsigned long) addr);
10917
10918       for (j = 0; j < 16; j++)
10919         {
10920           if (j < lbytes)
10921             printf ("%2.2x", data[j]);
10922           else
10923             printf ("  ");
10924
10925           if ((j & 3) == 3)
10926             printf (" ");
10927         }
10928
10929       for (j = 0; j < lbytes; j++)
10930         {
10931           k = data[j];
10932           if (k >= ' ' && k < 0x7f)
10933             printf ("%c", k);
10934           else
10935             printf (".");
10936         }
10937
10938       putchar ('\n');
10939
10940       data  += lbytes;
10941       addr  += lbytes;
10942       bytes -= lbytes;
10943     }
10944
10945   free (start);
10946
10947   putchar ('\n');
10948 }
10949
10950 /* Uncompresses a section that was compressed using zlib, in place.  */
10951
10952 static int
10953 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10954                              dwarf_size_type *size ATTRIBUTE_UNUSED)
10955 {
10956 #ifndef HAVE_ZLIB_H
10957   return FALSE;
10958 #else
10959   dwarf_size_type compressed_size = *size;
10960   unsigned char * compressed_buffer = *buffer;
10961   dwarf_size_type uncompressed_size;
10962   unsigned char * uncompressed_buffer;
10963   z_stream strm;
10964   int rc;
10965   dwarf_size_type header_size = 12;
10966
10967   /* Read the zlib header.  In this case, it should be "ZLIB" followed
10968      by the uncompressed section size, 8 bytes in big-endian order.  */
10969   if (compressed_size < header_size
10970       || ! streq ((char *) compressed_buffer, "ZLIB"))
10971     return 0;
10972
10973   uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10974   uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10975   uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10976   uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10977   uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10978   uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10979   uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10980   uncompressed_size += compressed_buffer[11];
10981
10982   /* It is possible the section consists of several compressed
10983      buffers concatenated together, so we uncompress in a loop.  */
10984   strm.zalloc = NULL;
10985   strm.zfree = NULL;
10986   strm.opaque = NULL;
10987   strm.avail_in = compressed_size - header_size;
10988   strm.next_in = (Bytef *) compressed_buffer + header_size;
10989   strm.avail_out = uncompressed_size;
10990   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
10991
10992   rc = inflateInit (& strm);
10993   while (strm.avail_in > 0)
10994     {
10995       if (rc != Z_OK)
10996         goto fail;
10997       strm.next_out = ((Bytef *) uncompressed_buffer
10998                        + (uncompressed_size - strm.avail_out));
10999       rc = inflate (&strm, Z_FINISH);
11000       if (rc != Z_STREAM_END)
11001         goto fail;
11002       rc = inflateReset (& strm);
11003     }
11004   rc = inflateEnd (& strm);
11005   if (rc != Z_OK
11006       || strm.avail_out != 0)
11007     goto fail;
11008
11009   free (compressed_buffer);
11010   *buffer = uncompressed_buffer;
11011   *size = uncompressed_size;
11012   return 1;
11013
11014  fail:
11015   free (uncompressed_buffer);
11016   /* Indicate decompression failure.  */
11017   *buffer = NULL;
11018   return 0;
11019 #endif  /* HAVE_ZLIB_H */
11020 }
11021
11022 static int
11023 load_specific_debug_section (enum dwarf_section_display_enum debug,
11024                              Elf_Internal_Shdr * sec, void * file)
11025 {
11026   struct dwarf_section * section = &debug_displays [debug].section;
11027   char buf [64];
11028
11029   /* If it is already loaded, do nothing.  */
11030   if (section->start != NULL)
11031     return 1;
11032
11033   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11034   section->address = sec->sh_addr;
11035   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11036                                                sec->sh_offset, 1,
11037                                                sec->sh_size, buf);
11038   if (section->start == NULL)
11039     section->size = 0;
11040   else
11041     {
11042       section->size = sec->sh_size;
11043       if (uncompress_section_contents (&section->start, &section->size))
11044         sec->sh_size = section->size;
11045     }
11046
11047   if (section->start == NULL)
11048     return 0;
11049
11050   if (debug_displays [debug].relocate)
11051     apply_relocations ((FILE *) file, sec, section->start);
11052
11053   return 1;
11054 }
11055
11056 /* If this is not NULL, load_debug_section will only look for sections
11057    within the list of sections given here.  */
11058 unsigned int *section_subset = NULL;
11059
11060 int
11061 load_debug_section (enum dwarf_section_display_enum debug, void * file)
11062 {
11063   struct dwarf_section * section = &debug_displays [debug].section;
11064   Elf_Internal_Shdr * sec;
11065
11066   /* Locate the debug section.  */
11067   sec = find_section_in_set (section->uncompressed_name, section_subset);
11068   if (sec != NULL)
11069     section->name = section->uncompressed_name;
11070   else
11071     {
11072       sec = find_section_in_set (section->compressed_name, section_subset);
11073       if (sec != NULL)
11074         section->name = section->compressed_name;
11075     }
11076   if (sec == NULL)
11077     return 0;
11078
11079   /* If we're loading from a subset of sections, and we've loaded
11080      a section matching this name before, it's likely that it's a
11081      different one.  */
11082   if (section_subset != NULL)
11083     free_debug_section (debug);
11084
11085   return load_specific_debug_section (debug, sec, (FILE *) file);
11086 }
11087
11088 void
11089 free_debug_section (enum dwarf_section_display_enum debug)
11090 {
11091   struct dwarf_section * section = &debug_displays [debug].section;
11092
11093   if (section->start == NULL)
11094     return;
11095
11096   free ((char *) section->start);
11097   section->start = NULL;
11098   section->address = 0;
11099   section->size = 0;
11100 }
11101
11102 static int
11103 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
11104 {
11105   char * name = SECTION_NAME (section);
11106   bfd_size_type length;
11107   int result = 1;
11108   int i;
11109
11110   length = section->sh_size;
11111   if (length == 0)
11112     {
11113       printf (_("\nSection '%s' has no debugging data.\n"), name);
11114       return 0;
11115     }
11116   if (section->sh_type == SHT_NOBITS)
11117     {
11118       /* There is no point in dumping the contents of a debugging section
11119          which has the NOBITS type - the bits in the file will be random.
11120          This can happen when a file containing a .eh_frame section is
11121          stripped with the --only-keep-debug command line option.  */
11122       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
11123       return 0;
11124     }
11125
11126   if (const_strneq (name, ".gnu.linkonce.wi."))
11127     name = ".debug_info";
11128
11129   /* See if we know how to display the contents of this section.  */
11130   for (i = 0; i < max; i++)
11131     if (streq (debug_displays[i].section.uncompressed_name, name)
11132         || (i == line && const_strneq (name, ".debug_line."))
11133         || streq (debug_displays[i].section.compressed_name, name))
11134       {
11135         struct dwarf_section * sec = &debug_displays [i].section;
11136         int secondary = (section != find_section (name));
11137
11138         if (secondary)
11139           free_debug_section ((enum dwarf_section_display_enum) i);
11140
11141         if (i == line && const_strneq (name, ".debug_line."))
11142           sec->name = name;
11143         else if (streq (sec->uncompressed_name, name))
11144           sec->name = sec->uncompressed_name;
11145         else
11146           sec->name = sec->compressed_name;
11147         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
11148                                          section, file))
11149           {
11150             /* If this debug section is part of a CU/TU set in a .dwp file,
11151                restrict load_debug_section to the sections in that set.  */
11152             section_subset = find_cu_tu_set (file, shndx);
11153
11154             result &= debug_displays[i].display (sec, file);
11155
11156             section_subset = NULL;
11157
11158             if (secondary || (i != info && i != abbrev))
11159               free_debug_section ((enum dwarf_section_display_enum) i);
11160           }
11161
11162         break;
11163       }
11164
11165   if (i == max)
11166     {
11167       printf (_("Unrecognized debug section: %s\n"), name);
11168       result = 0;
11169     }
11170
11171   return result;
11172 }
11173
11174 /* Set DUMP_SECTS for all sections where dumps were requested
11175    based on section name.  */
11176
11177 static void
11178 initialise_dumps_byname (void)
11179 {
11180   struct dump_list_entry * cur;
11181
11182   for (cur = dump_sects_byname; cur; cur = cur->next)
11183     {
11184       unsigned int i;
11185       int any;
11186
11187       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11188         if (streq (SECTION_NAME (section_headers + i), cur->name))
11189           {
11190             request_dump_bynumber (i, cur->type);
11191             any = 1;
11192           }
11193
11194       if (!any)
11195         warn (_("Section '%s' was not dumped because it does not exist!\n"),
11196               cur->name);
11197     }
11198 }
11199
11200 static void
11201 process_section_contents (FILE * file)
11202 {
11203   Elf_Internal_Shdr * section;
11204   unsigned int i;
11205
11206   if (! do_dump)
11207     return;
11208
11209   initialise_dumps_byname ();
11210
11211   for (i = 0, section = section_headers;
11212        i < elf_header.e_shnum && i < num_dump_sects;
11213        i++, section++)
11214     {
11215 #ifdef SUPPORT_DISASSEMBLY
11216       if (dump_sects[i] & DISASS_DUMP)
11217         disassemble_section (section, file);
11218 #endif
11219       if (dump_sects[i] & HEX_DUMP)
11220         dump_section_as_bytes (section, file, FALSE);
11221
11222       if (dump_sects[i] & RELOC_DUMP)
11223         dump_section_as_bytes (section, file, TRUE);
11224
11225       if (dump_sects[i] & STRING_DUMP)
11226         dump_section_as_strings (section, file);
11227
11228       if (dump_sects[i] & DEBUG_DUMP)
11229         display_debug_section (i, section, file);
11230     }
11231
11232   /* Check to see if the user requested a
11233      dump of a section that does not exist.  */
11234   while (i++ < num_dump_sects)
11235     if (dump_sects[i])
11236       warn (_("Section %d was not dumped because it does not exist!\n"), i);
11237 }
11238
11239 static void
11240 process_mips_fpe_exception (int mask)
11241 {
11242   if (mask)
11243     {
11244       int first = 1;
11245       if (mask & OEX_FPU_INEX)
11246         fputs ("INEX", stdout), first = 0;
11247       if (mask & OEX_FPU_UFLO)
11248         printf ("%sUFLO", first ? "" : "|"), first = 0;
11249       if (mask & OEX_FPU_OFLO)
11250         printf ("%sOFLO", first ? "" : "|"), first = 0;
11251       if (mask & OEX_FPU_DIV0)
11252         printf ("%sDIV0", first ? "" : "|"), first = 0;
11253       if (mask & OEX_FPU_INVAL)
11254         printf ("%sINVAL", first ? "" : "|");
11255     }
11256   else
11257     fputs ("0", stdout);
11258 }
11259
11260 /* Display's the value of TAG at location P.  If TAG is
11261    greater than 0 it is assumed to be an unknown tag, and
11262    a message is printed to this effect.  Otherwise it is
11263    assumed that a message has already been printed.
11264
11265    If the bottom bit of TAG is set it assumed to have a
11266    string value, otherwise it is assumed to have an integer
11267    value.
11268
11269    Returns an updated P pointing to the first unread byte
11270    beyond the end of TAG's value.
11271
11272    Reads at or beyond END will not be made.  */
11273
11274 static unsigned char *
11275 display_tag_value (int tag,
11276                    unsigned char * p,
11277                    const unsigned char * const end)
11278 {
11279   unsigned long val;
11280
11281   if (tag > 0)
11282     printf ("  Tag_unknown_%d: ", tag);
11283
11284   if (p >= end)
11285     {
11286       warn (_("corrupt tag\n"));
11287     }
11288   else if (tag & 1)
11289     {
11290       /* FIXME: we could read beyond END here.  */
11291       printf ("\"%s\"\n", p);
11292       p += strlen ((char *) p) + 1;
11293     }
11294   else
11295     {
11296       unsigned int len;
11297
11298       val = read_uleb128 (p, &len, end);
11299       p += len;
11300       printf ("%ld (0x%lx)\n", val, val);
11301     }
11302
11303   return p;
11304 }
11305
11306 /* ARM EABI attributes section.  */
11307 typedef struct
11308 {
11309   int tag;
11310   const char * name;
11311   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
11312   int type;
11313   const char ** table;
11314 } arm_attr_public_tag;
11315
11316 static const char * arm_attr_tag_CPU_arch[] =
11317   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11318    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11319 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11320 static const char * arm_attr_tag_THUMB_ISA_use[] =
11321   {"No", "Thumb-1", "Thumb-2"};
11322 static const char * arm_attr_tag_FP_arch[] =
11323   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11324    "FP for ARMv8"};
11325 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
11326 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
11327   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11328 static const char * arm_attr_tag_PCS_config[] =
11329   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11330    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11331 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11332   {"V6", "SB", "TLS", "Unused"};
11333 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11334   {"Absolute", "PC-relative", "SB-relative", "None"};
11335 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11336   {"Absolute", "PC-relative", "None"};
11337 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11338   {"None", "direct", "GOT-indirect"};
11339 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11340   {"None", "??? 1", "2", "??? 3", "4"};
11341 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11342 static const char * arm_attr_tag_ABI_FP_denormal[] =
11343   {"Unused", "Needed", "Sign only"};
11344 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11345 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11346 static const char * arm_attr_tag_ABI_FP_number_model[] =
11347   {"Unused", "Finite", "RTABI", "IEEE 754"};
11348 static const char * arm_attr_tag_ABI_enum_size[] =
11349   {"Unused", "small", "int", "forced to int"};
11350 static const char * arm_attr_tag_ABI_HardFP_use[] =
11351   {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11352 static const char * arm_attr_tag_ABI_VFP_args[] =
11353   {"AAPCS", "VFP registers", "custom"};
11354 static const char * arm_attr_tag_ABI_WMMX_args[] =
11355   {"AAPCS", "WMMX registers", "custom"};
11356 static const char * arm_attr_tag_ABI_optimization_goals[] =
11357   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11358     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11359 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11360   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11361     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11362 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
11363 static const char * arm_attr_tag_FP_HP_extension[] =
11364   {"Not Allowed", "Allowed"};
11365 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
11366   {"None", "IEEE 754", "Alternative Format"};
11367 static const char * arm_attr_tag_MPextension_use[] =
11368   {"Not Allowed", "Allowed"};
11369 static const char * arm_attr_tag_DIV_use[] =
11370   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11371     "Allowed in v7-A with integer division extension"};
11372 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11373 static const char * arm_attr_tag_Virtualization_use[] =
11374   {"Not Allowed", "TrustZone", "Virtualization Extensions",
11375     "TrustZone and Virtualization Extensions"};
11376 static const char * arm_attr_tag_MPextension_use_legacy[] =
11377   {"Not Allowed", "Allowed"};
11378
11379 #define LOOKUP(id, name) \
11380   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11381 static arm_attr_public_tag arm_attr_public_tags[] =
11382 {
11383   {4, "CPU_raw_name", 1, NULL},
11384   {5, "CPU_name", 1, NULL},
11385   LOOKUP(6, CPU_arch),
11386   {7, "CPU_arch_profile", 0, NULL},
11387   LOOKUP(8, ARM_ISA_use),
11388   LOOKUP(9, THUMB_ISA_use),
11389   LOOKUP(10, FP_arch),
11390   LOOKUP(11, WMMX_arch),
11391   LOOKUP(12, Advanced_SIMD_arch),
11392   LOOKUP(13, PCS_config),
11393   LOOKUP(14, ABI_PCS_R9_use),
11394   LOOKUP(15, ABI_PCS_RW_data),
11395   LOOKUP(16, ABI_PCS_RO_data),
11396   LOOKUP(17, ABI_PCS_GOT_use),
11397   LOOKUP(18, ABI_PCS_wchar_t),
11398   LOOKUP(19, ABI_FP_rounding),
11399   LOOKUP(20, ABI_FP_denormal),
11400   LOOKUP(21, ABI_FP_exceptions),
11401   LOOKUP(22, ABI_FP_user_exceptions),
11402   LOOKUP(23, ABI_FP_number_model),
11403   {24, "ABI_align_needed", 0, NULL},
11404   {25, "ABI_align_preserved", 0, NULL},
11405   LOOKUP(26, ABI_enum_size),
11406   LOOKUP(27, ABI_HardFP_use),
11407   LOOKUP(28, ABI_VFP_args),
11408   LOOKUP(29, ABI_WMMX_args),
11409   LOOKUP(30, ABI_optimization_goals),
11410   LOOKUP(31, ABI_FP_optimization_goals),
11411   {32, "compatibility", 0, NULL},
11412   LOOKUP(34, CPU_unaligned_access),
11413   LOOKUP(36, FP_HP_extension),
11414   LOOKUP(38, ABI_FP_16bit_format),
11415   LOOKUP(42, MPextension_use),
11416   LOOKUP(44, DIV_use),
11417   {64, "nodefaults", 0, NULL},
11418   {65, "also_compatible_with", 0, NULL},
11419   LOOKUP(66, T2EE_use),
11420   {67, "conformance", 1, NULL},
11421   LOOKUP(68, Virtualization_use),
11422   LOOKUP(70, MPextension_use_legacy)
11423 };
11424 #undef LOOKUP
11425
11426 static unsigned char *
11427 display_arm_attribute (unsigned char * p,
11428                        const unsigned char * const end)
11429 {
11430   int tag;
11431   unsigned int len;
11432   int val;
11433   arm_attr_public_tag * attr;
11434   unsigned i;
11435   int type;
11436
11437   tag = read_uleb128 (p, &len, end);
11438   p += len;
11439   attr = NULL;
11440   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11441     {
11442       if (arm_attr_public_tags[i].tag == tag)
11443         {
11444           attr = &arm_attr_public_tags[i];
11445           break;
11446         }
11447     }
11448
11449   if (attr)
11450     {
11451       printf ("  Tag_%s: ", attr->name);
11452       switch (attr->type)
11453         {
11454         case 0:
11455           switch (tag)
11456             {
11457             case 7: /* Tag_CPU_arch_profile.  */
11458               val = read_uleb128 (p, &len, end);
11459               p += len;
11460               switch (val)
11461                 {
11462                 case 0: printf (_("None\n")); break;
11463                 case 'A': printf (_("Application\n")); break;
11464                 case 'R': printf (_("Realtime\n")); break;
11465                 case 'M': printf (_("Microcontroller\n")); break;
11466                 case 'S': printf (_("Application or Realtime\n")); break;
11467                 default: printf ("??? (%d)\n", val); break;
11468                 }
11469               break;
11470
11471             case 24: /* Tag_align_needed.  */
11472               val = read_uleb128 (p, &len, end);
11473               p += len;
11474               switch (val)
11475                 {
11476                 case 0: printf (_("None\n")); break;
11477                 case 1: printf (_("8-byte\n")); break;
11478                 case 2: printf (_("4-byte\n")); break;
11479                 case 3: printf ("??? 3\n"); break;
11480                 default:
11481                   if (val <= 12)
11482                     printf (_("8-byte and up to %d-byte extended\n"),
11483                             1 << val);
11484                   else
11485                     printf ("??? (%d)\n", val);
11486                   break;
11487                 }
11488               break;
11489
11490             case 25: /* Tag_align_preserved.  */
11491               val = read_uleb128 (p, &len, end);
11492               p += len;
11493               switch (val)
11494                 {
11495                 case 0: printf (_("None\n")); break;
11496                 case 1: printf (_("8-byte, except leaf SP\n")); break;
11497                 case 2: printf (_("8-byte\n")); break;
11498                 case 3: printf ("??? 3\n"); break;
11499                 default:
11500                   if (val <= 12)
11501                     printf (_("8-byte and up to %d-byte extended\n"),
11502                             1 << val);
11503                   else
11504                     printf ("??? (%d)\n", val);
11505                   break;
11506                 }
11507               break;
11508
11509             case 32: /* Tag_compatibility.  */
11510               val = read_uleb128 (p, &len, end);
11511               p += len;
11512               printf (_("flag = %d, vendor = %s\n"), val, p);
11513               p += strlen ((char *) p) + 1;
11514               break;
11515
11516             case 64: /* Tag_nodefaults.  */
11517               p++;
11518               printf (_("True\n"));
11519               break;
11520
11521             case 65: /* Tag_also_compatible_with.  */
11522               val = read_uleb128 (p, &len, end);
11523               p += len;
11524               if (val == 6 /* Tag_CPU_arch.  */)
11525                 {
11526                   val = read_uleb128 (p, &len, end);
11527                   p += len;
11528                   if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
11529                     printf ("??? (%d)\n", val);
11530                   else
11531                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11532                 }
11533               else
11534                 printf ("???\n");
11535               while (*(p++) != '\0' /* NUL terminator.  */);
11536               break;
11537
11538             default:
11539               abort ();
11540             }
11541           return p;
11542
11543         case 1:
11544           return display_tag_value (-1, p, end);
11545         case 2:
11546           return display_tag_value (0, p, end);
11547
11548         default:
11549           assert (attr->type & 0x80);
11550           val = read_uleb128 (p, &len, end);
11551           p += len;
11552           type = attr->type & 0x7f;
11553           if (val >= type)
11554             printf ("??? (%d)\n", val);
11555           else
11556             printf ("%s\n", attr->table[val]);
11557           return p;
11558         }
11559     }
11560
11561   return display_tag_value (tag, p, end);
11562 }
11563
11564 static unsigned char *
11565 display_gnu_attribute (unsigned char * p,
11566                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
11567                        const unsigned char * const end)
11568 {
11569   int tag;
11570   unsigned int len;
11571   int val;
11572
11573   tag = read_uleb128 (p, &len, end);
11574   p += len;
11575
11576   /* Tag_compatibility is the only generic GNU attribute defined at
11577      present.  */
11578   if (tag == 32)
11579     {
11580       val = read_uleb128 (p, &len, end);
11581       p += len;
11582       if (p == end)
11583         {
11584           printf (_("flag = %d, vendor = <corrupt>\n"), val);
11585           warn (_("corrupt vendor attribute\n"));
11586         }
11587       else
11588         {
11589           printf (_("flag = %d, vendor = %s\n"), val, p);
11590           p += strlen ((char *) p) + 1;
11591         }
11592       return p;
11593     }
11594
11595   if ((tag & 2) == 0 && display_proc_gnu_attribute)
11596     return display_proc_gnu_attribute (p, tag, end);
11597
11598   return display_tag_value (tag, p, end);
11599 }
11600
11601 static unsigned char *
11602 display_power_gnu_attribute (unsigned char * p,
11603                              int tag,
11604                              const unsigned char * const end)
11605 {
11606   unsigned int len;
11607   int val;
11608
11609   if (tag == Tag_GNU_Power_ABI_FP)
11610     {
11611       val = read_uleb128 (p, &len, end);
11612       p += len;
11613       printf ("  Tag_GNU_Power_ABI_FP: ");
11614
11615       switch (val)
11616         {
11617         case 0:
11618           printf (_("Hard or soft float\n"));
11619           break;
11620         case 1:
11621           printf (_("Hard float\n"));
11622           break;
11623         case 2:
11624           printf (_("Soft float\n"));
11625           break;
11626         case 3:
11627           printf (_("Single-precision hard float\n"));
11628           break;
11629         default:
11630           printf ("??? (%d)\n", val);
11631           break;
11632         }
11633       return p;
11634    }
11635
11636   if (tag == Tag_GNU_Power_ABI_Vector)
11637     {
11638       val = read_uleb128 (p, &len, end);
11639       p += len;
11640       printf ("  Tag_GNU_Power_ABI_Vector: ");
11641       switch (val)
11642         {
11643         case 0:
11644           printf (_("Any\n"));
11645           break;
11646         case 1:
11647           printf (_("Generic\n"));
11648           break;
11649         case 2:
11650           printf ("AltiVec\n");
11651           break;
11652         case 3:
11653           printf ("SPE\n");
11654           break;
11655         default:
11656           printf ("??? (%d)\n", val);
11657           break;
11658         }
11659       return p;
11660    }
11661
11662   if (tag == Tag_GNU_Power_ABI_Struct_Return)
11663     {
11664       if (p == end)
11665         {
11666           warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
11667           return p;
11668         }
11669
11670       val = read_uleb128 (p, &len, end);
11671       p += len;
11672       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
11673       switch (val)
11674        {
11675        case 0:
11676          printf (_("Any\n"));
11677          break;
11678        case 1:
11679          printf ("r3/r4\n");
11680          break;
11681        case 2:
11682          printf (_("Memory\n"));
11683          break;
11684        default:
11685          printf ("??? (%d)\n", val);
11686          break;
11687        }
11688       return p;
11689     }
11690
11691   return display_tag_value (tag & 1, p, end);
11692 }
11693
11694 static void
11695 display_sparc_hwcaps (int mask)
11696 {
11697   if (mask)
11698     {
11699       int first = 1;
11700       if (mask & ELF_SPARC_HWCAP_MUL32)
11701         fputs ("mul32", stdout), first = 0;
11702       if (mask & ELF_SPARC_HWCAP_DIV32)
11703         printf ("%sdiv32", first ? "" : "|"), first = 0;
11704       if (mask & ELF_SPARC_HWCAP_FSMULD)
11705         printf ("%sfsmuld", first ? "" : "|"), first = 0;
11706       if (mask & ELF_SPARC_HWCAP_V8PLUS)
11707         printf ("%sv8plus", first ? "" : "|"), first = 0;
11708       if (mask & ELF_SPARC_HWCAP_POPC)
11709         printf ("%spopc", first ? "" : "|"), first = 0;
11710       if (mask & ELF_SPARC_HWCAP_VIS)
11711         printf ("%svis", first ? "" : "|"), first = 0;
11712       if (mask & ELF_SPARC_HWCAP_VIS2)
11713         printf ("%svis2", first ? "" : "|"), first = 0;
11714       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11715         printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11716       if (mask & ELF_SPARC_HWCAP_FMAF)
11717         printf ("%sfmaf", first ? "" : "|"), first = 0;
11718       if (mask & ELF_SPARC_HWCAP_VIS3)
11719         printf ("%svis3", first ? "" : "|"), first = 0;
11720       if (mask & ELF_SPARC_HWCAP_HPC)
11721         printf ("%shpc", first ? "" : "|"), first = 0;
11722       if (mask & ELF_SPARC_HWCAP_RANDOM)
11723         printf ("%srandom", first ? "" : "|"), first = 0;
11724       if (mask & ELF_SPARC_HWCAP_TRANS)
11725         printf ("%strans", first ? "" : "|"), first = 0;
11726       if (mask & ELF_SPARC_HWCAP_FJFMAU)
11727         printf ("%sfjfmau", first ? "" : "|"), first = 0;
11728       if (mask & ELF_SPARC_HWCAP_IMA)
11729         printf ("%sima", first ? "" : "|"), first = 0;
11730       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11731         printf ("%scspare", first ? "" : "|"), first = 0;
11732     }
11733   else
11734     fputc('0', stdout);
11735   fputc('\n', stdout);
11736 }
11737
11738 static unsigned char *
11739 display_sparc_gnu_attribute (unsigned char * p,
11740                              int tag,
11741                              const unsigned char * const end)
11742 {
11743   if (tag == Tag_GNU_Sparc_HWCAPS)
11744     {
11745       unsigned int len;
11746       int val;
11747
11748       val = read_uleb128 (p, &len, end);
11749       p += len;
11750       printf ("  Tag_GNU_Sparc_HWCAPS: ");
11751       display_sparc_hwcaps (val);
11752       return p;
11753    }
11754
11755   return display_tag_value (tag, p, end);
11756 }
11757
11758 static unsigned char *
11759 display_mips_gnu_attribute (unsigned char * p,
11760                             int tag,
11761                             const unsigned char * const end)
11762 {
11763   if (tag == Tag_GNU_MIPS_ABI_FP)
11764     {
11765       unsigned int len;
11766       int val;
11767
11768       val = read_uleb128 (p, &len, end);
11769       p += len;
11770       printf ("  Tag_GNU_MIPS_ABI_FP: ");
11771
11772       switch (val)
11773         {
11774         case Val_GNU_MIPS_ABI_FP_ANY:
11775           printf (_("Hard or soft float\n"));
11776           break;
11777         case Val_GNU_MIPS_ABI_FP_DOUBLE:
11778           printf (_("Hard float (double precision)\n"));
11779           break;
11780         case Val_GNU_MIPS_ABI_FP_SINGLE:
11781           printf (_("Hard float (single precision)\n"));
11782           break;
11783         case Val_GNU_MIPS_ABI_FP_SOFT:
11784           printf (_("Soft float\n"));
11785           break;
11786         case Val_GNU_MIPS_ABI_FP_64:
11787           printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
11788           break;
11789         default:
11790           printf ("??? (%d)\n", val);
11791           break;
11792         }
11793       return p;
11794    }
11795
11796   return display_tag_value (tag & 1, p, end);
11797 }
11798
11799 static unsigned char *
11800 display_tic6x_attribute (unsigned char * p,
11801                          const unsigned char * const end)
11802 {
11803   int tag;
11804   unsigned int len;
11805   int val;
11806
11807   tag = read_uleb128 (p, &len, end);
11808   p += len;
11809
11810   switch (tag)
11811     {
11812     case Tag_ISA:
11813       val = read_uleb128 (p, &len, end);
11814       p += len;
11815       printf ("  Tag_ISA: ");
11816
11817       switch (val)
11818         {
11819         case C6XABI_Tag_ISA_none:
11820           printf (_("None\n"));
11821           break;
11822         case C6XABI_Tag_ISA_C62X:
11823           printf ("C62x\n");
11824           break;
11825         case C6XABI_Tag_ISA_C67X:
11826           printf ("C67x\n");
11827           break;
11828         case C6XABI_Tag_ISA_C67XP:
11829           printf ("C67x+\n");
11830           break;
11831         case C6XABI_Tag_ISA_C64X:
11832           printf ("C64x\n");
11833           break;
11834         case C6XABI_Tag_ISA_C64XP:
11835           printf ("C64x+\n");
11836           break;
11837         case C6XABI_Tag_ISA_C674X:
11838           printf ("C674x\n");
11839           break;
11840         default:
11841           printf ("??? (%d)\n", val);
11842           break;
11843         }
11844       return p;
11845
11846     case Tag_ABI_wchar_t:
11847       val = read_uleb128 (p, &len, end);
11848       p += len;
11849       printf ("  Tag_ABI_wchar_t: ");
11850       switch (val)
11851         {
11852         case 0:
11853           printf (_("Not used\n"));
11854           break;
11855         case 1:
11856           printf (_("2 bytes\n"));
11857           break;
11858         case 2:
11859           printf (_("4 bytes\n"));
11860           break;
11861         default:
11862           printf ("??? (%d)\n", val);
11863           break;
11864         }
11865       return p;
11866
11867     case Tag_ABI_stack_align_needed:
11868       val = read_uleb128 (p, &len, end);
11869       p += len;
11870       printf ("  Tag_ABI_stack_align_needed: ");
11871       switch (val)
11872         {
11873         case 0:
11874           printf (_("8-byte\n"));
11875           break;
11876         case 1:
11877           printf (_("16-byte\n"));
11878           break;
11879         default:
11880           printf ("??? (%d)\n", val);
11881           break;
11882         }
11883       return p;
11884
11885     case Tag_ABI_stack_align_preserved:
11886       val = read_uleb128 (p, &len, end);
11887       p += len;
11888       printf ("  Tag_ABI_stack_align_preserved: ");
11889       switch (val)
11890         {
11891         case 0:
11892           printf (_("8-byte\n"));
11893           break;
11894         case 1:
11895           printf (_("16-byte\n"));
11896           break;
11897         default:
11898           printf ("??? (%d)\n", val);
11899           break;
11900         }
11901       return p;
11902
11903     case Tag_ABI_DSBT:
11904       val = read_uleb128 (p, &len, end);
11905       p += len;
11906       printf ("  Tag_ABI_DSBT: ");
11907       switch (val)
11908         {
11909         case 0:
11910           printf (_("DSBT addressing not used\n"));
11911           break;
11912         case 1:
11913           printf (_("DSBT addressing used\n"));
11914           break;
11915         default:
11916           printf ("??? (%d)\n", val);
11917           break;
11918         }
11919       return p;
11920
11921     case Tag_ABI_PID:
11922       val = read_uleb128 (p, &len, end);
11923       p += len;
11924       printf ("  Tag_ABI_PID: ");
11925       switch (val)
11926         {
11927         case 0:
11928           printf (_("Data addressing position-dependent\n"));
11929           break;
11930         case 1:
11931           printf (_("Data addressing position-independent, GOT near DP\n"));
11932           break;
11933         case 2:
11934           printf (_("Data addressing position-independent, GOT far from DP\n"));
11935           break;
11936         default:
11937           printf ("??? (%d)\n", val);
11938           break;
11939         }
11940       return p;
11941
11942     case Tag_ABI_PIC:
11943       val = read_uleb128 (p, &len, end);
11944       p += len;
11945       printf ("  Tag_ABI_PIC: ");
11946       switch (val)
11947         {
11948         case 0:
11949           printf (_("Code addressing position-dependent\n"));
11950           break;
11951         case 1:
11952           printf (_("Code addressing position-independent\n"));
11953           break;
11954         default:
11955           printf ("??? (%d)\n", val);
11956           break;
11957         }
11958       return p;
11959
11960     case Tag_ABI_array_object_alignment:
11961       val = read_uleb128 (p, &len, end);
11962       p += len;
11963       printf ("  Tag_ABI_array_object_alignment: ");
11964       switch (val)
11965         {
11966         case 0:
11967           printf (_("8-byte\n"));
11968           break;
11969         case 1:
11970           printf (_("4-byte\n"));
11971           break;
11972         case 2:
11973           printf (_("16-byte\n"));
11974           break;
11975         default:
11976           printf ("??? (%d)\n", val);
11977           break;
11978         }
11979       return p;
11980
11981     case Tag_ABI_array_object_align_expected:
11982       val = read_uleb128 (p, &len, end);
11983       p += len;
11984       printf ("  Tag_ABI_array_object_align_expected: ");
11985       switch (val)
11986         {
11987         case 0:
11988           printf (_("8-byte\n"));
11989           break;
11990         case 1:
11991           printf (_("4-byte\n"));
11992           break;
11993         case 2:
11994           printf (_("16-byte\n"));
11995           break;
11996         default:
11997           printf ("??? (%d)\n", val);
11998           break;
11999         }
12000       return p;
12001
12002     case Tag_ABI_compatibility:
12003       val = read_uleb128 (p, &len, end);
12004       p += len;
12005       printf ("  Tag_ABI_compatibility: ");
12006       printf (_("flag = %d, vendor = %s\n"), val, p);
12007       p += strlen ((char *) p) + 1;
12008       return p;
12009
12010     case Tag_ABI_conformance:
12011       printf ("  Tag_ABI_conformance: ");
12012       printf ("\"%s\"\n", p);
12013       p += strlen ((char *) p) + 1;
12014       return p;
12015     }
12016
12017   return display_tag_value (tag, p, end);
12018 }
12019
12020 static void
12021 display_raw_attribute (unsigned char * p, unsigned char * end)
12022 {
12023   unsigned long addr = 0;
12024   size_t bytes = end - p;
12025
12026   while (bytes)
12027     {
12028       int j;
12029       int k;
12030       int lbytes = (bytes > 16 ? 16 : bytes);
12031
12032       printf ("  0x%8.8lx ", addr);
12033
12034       for (j = 0; j < 16; j++)
12035         {
12036           if (j < lbytes)
12037             printf ("%2.2x", p[j]);
12038           else
12039             printf ("  ");
12040
12041           if ((j & 3) == 3)
12042             printf (" ");
12043         }
12044
12045       for (j = 0; j < lbytes; j++)
12046         {
12047           k = p[j];
12048           if (k >= ' ' && k < 0x7f)
12049             printf ("%c", k);
12050           else
12051             printf (".");
12052         }
12053
12054       putchar ('\n');
12055
12056       p  += lbytes;
12057       bytes -= lbytes;
12058       addr += lbytes;
12059     }
12060
12061   putchar ('\n');
12062 }
12063
12064 static unsigned char *
12065 display_msp430x_attribute (unsigned char * p,
12066                            const unsigned char * const end)
12067 {
12068   unsigned int len;
12069   int val;
12070   int tag;
12071
12072   tag = read_uleb128 (p, & len, end);
12073   p += len;
12074
12075   switch (tag)
12076     {
12077     case OFBA_MSPABI_Tag_ISA:
12078       val = read_uleb128 (p, &len, end);
12079       p += len;
12080       printf ("  Tag_ISA: ");
12081       switch (val)
12082         {
12083         case 0: printf (_("None\n")); break;
12084         case 1: printf (_("MSP430\n")); break;
12085         case 2: printf (_("MSP430X\n")); break;
12086         default: printf ("??? (%d)\n", val); break;
12087         }
12088       break;
12089
12090     case OFBA_MSPABI_Tag_Code_Model:
12091       val = read_uleb128 (p, &len, end);
12092       p += len;
12093       printf ("  Tag_Code_Model: ");
12094       switch (val)
12095         {
12096         case 0: printf (_("None\n")); break;
12097         case 1: printf (_("Small\n")); break;
12098         case 2: printf (_("Large\n")); break;
12099         default: printf ("??? (%d)\n", val); break;
12100         }
12101       break;
12102
12103     case OFBA_MSPABI_Tag_Data_Model:
12104       val = read_uleb128 (p, &len, end);
12105       p += len;
12106       printf ("  Tag_Data_Model: ");
12107       switch (val)
12108         {
12109         case 0: printf (_("None\n")); break;
12110         case 1: printf (_("Small\n")); break;
12111         case 2: printf (_("Large\n")); break;
12112         case 3: printf (_("Restricted Large\n")); break;
12113         default: printf ("??? (%d)\n", val); break;
12114         }
12115       break;
12116
12117     default:
12118       printf (_("  <unknown tag %d>: "), tag);
12119
12120       if (tag & 1)
12121         {
12122           printf ("\"%s\"\n", p);
12123           p += strlen ((char *) p) + 1;
12124         }
12125       else
12126         {
12127           val = read_uleb128 (p, &len, end);
12128           p += len;
12129           printf ("%d (0x%x)\n", val, val);
12130         }
12131       break;
12132    }
12133
12134   return p;
12135 }
12136
12137 static int
12138 process_attributes (FILE * file,
12139                     const char * public_name,
12140                     unsigned int proc_type,
12141                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
12142                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
12143 {
12144   Elf_Internal_Shdr * sect;
12145   unsigned char * contents;
12146   unsigned char * p;
12147   unsigned char * end;
12148   bfd_vma section_len;
12149   bfd_vma len;
12150   unsigned i;
12151
12152   /* Find the section header so that we get the size.  */
12153   for (i = 0, sect = section_headers;
12154        i < elf_header.e_shnum;
12155        i++, sect++)
12156     {
12157       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
12158         continue;
12159
12160       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
12161                                              sect->sh_size, _("attributes"));
12162       if (contents == NULL)
12163         continue;
12164
12165       p = contents;
12166       if (*p == 'A')
12167         {
12168           len = sect->sh_size - 1;
12169           p++;
12170
12171           while (len > 0)
12172             {
12173               int namelen;
12174               bfd_boolean public_section;
12175               bfd_boolean gnu_section;
12176
12177               section_len = byte_get (p, 4);
12178               p += 4;
12179
12180               if (section_len > len)
12181                 {
12182                   printf (_("ERROR: Bad section length (%d > %d)\n"),
12183                           (int) section_len, (int) len);
12184                   section_len = len;
12185                 }
12186
12187               len -= section_len;
12188               printf (_("Attribute Section: %s\n"), p);
12189
12190               if (public_name && streq ((char *) p, public_name))
12191                 public_section = TRUE;
12192               else
12193                 public_section = FALSE;
12194
12195               if (streq ((char *) p, "gnu"))
12196                 gnu_section = TRUE;
12197               else
12198                 gnu_section = FALSE;
12199
12200               namelen = strlen ((char *) p) + 1;
12201               p += namelen;
12202               section_len -= namelen + 4;
12203
12204               while (section_len > 0)
12205                 {
12206                   int tag = *(p++);
12207                   int val;
12208                   bfd_vma size;
12209
12210                   size = byte_get (p, 4);
12211                   if (size > section_len)
12212                     {
12213                       printf (_("ERROR: Bad subsection length (%d > %d)\n"),
12214                               (int) size, (int) section_len);
12215                       size = section_len;
12216                     }
12217
12218                   section_len -= size;
12219                   end = p + size - 1;
12220                   p += 4;
12221
12222                   switch (tag)
12223                     {
12224                     case 1:
12225                       printf (_("File Attributes\n"));
12226                       break;
12227                     case 2:
12228                       printf (_("Section Attributes:"));
12229                       goto do_numlist;
12230                     case 3:
12231                       printf (_("Symbol Attributes:"));
12232                     do_numlist:
12233                       for (;;)
12234                         {
12235                           unsigned int j;
12236
12237                           val = read_uleb128 (p, &j, end);
12238                           p += j;
12239                           if (val == 0)
12240                             break;
12241                           printf (" %d", val);
12242                         }
12243                       printf ("\n");
12244                       break;
12245                     default:
12246                       printf (_("Unknown tag: %d\n"), tag);
12247                       public_section = FALSE;
12248                       break;
12249                     }
12250
12251                   if (public_section)
12252                     {
12253                       while (p < end)
12254                         p = display_pub_attribute (p, end);
12255                     }
12256                   else if (gnu_section)
12257                     {
12258                       while (p < end)
12259                         p = display_gnu_attribute (p,
12260                                                    display_proc_gnu_attribute,
12261                                                    end);
12262                     }
12263                   else
12264                     {
12265                       printf (_("  Unknown section contexts\n"));
12266                       display_raw_attribute (p, end);
12267                       p = end;
12268                     }
12269                 }
12270             }
12271         }
12272       else
12273         printf (_("Unknown format '%c'\n"), *p);
12274
12275       free (contents);
12276     }
12277   return 1;
12278 }
12279
12280 static int
12281 process_arm_specific (FILE * file)
12282 {
12283   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
12284                              display_arm_attribute, NULL);
12285 }
12286
12287 static int
12288 process_power_specific (FILE * file)
12289 {
12290   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12291                              display_power_gnu_attribute);
12292 }
12293
12294 static int
12295 process_sparc_specific (FILE * file)
12296 {
12297   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12298                              display_sparc_gnu_attribute);
12299 }
12300
12301 static int
12302 process_tic6x_specific (FILE * file)
12303 {
12304   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
12305                              display_tic6x_attribute, NULL);
12306 }
12307
12308 static int
12309 process_msp430x_specific (FILE * file)
12310 {
12311   return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
12312                              display_msp430x_attribute, NULL);
12313 }
12314
12315 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12316    Print the Address, Access and Initial fields of an entry at VMA ADDR
12317    and return the VMA of the next entry.  */
12318
12319 static bfd_vma
12320 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12321 {
12322   printf ("  ");
12323   print_vma (addr, LONG_HEX);
12324   printf (" ");
12325   if (addr < pltgot + 0xfff0)
12326     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
12327   else
12328     printf ("%10s", "");
12329   printf (" ");
12330   if (data == NULL)
12331     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12332   else
12333     {
12334       bfd_vma entry;
12335
12336       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12337       print_vma (entry, LONG_HEX);
12338     }
12339   return addr + (is_32bit_elf ? 4 : 8);
12340 }
12341
12342 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12343    PLTGOT.  Print the Address and Initial fields of an entry at VMA
12344    ADDR and return the VMA of the next entry.  */
12345
12346 static bfd_vma
12347 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12348 {
12349   printf ("  ");
12350   print_vma (addr, LONG_HEX);
12351   printf (" ");
12352   if (data == NULL)
12353     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12354   else
12355     {
12356       bfd_vma entry;
12357
12358       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12359       print_vma (entry, LONG_HEX);
12360     }
12361   return addr + (is_32bit_elf ? 4 : 8);
12362 }
12363
12364 static int
12365 process_mips_specific (FILE * file)
12366 {
12367   Elf_Internal_Dyn * entry;
12368   size_t liblist_offset = 0;
12369   size_t liblistno = 0;
12370   size_t conflictsno = 0;
12371   size_t options_offset = 0;
12372   size_t conflicts_offset = 0;
12373   size_t pltrelsz = 0;
12374   size_t pltrel = 0;
12375   bfd_vma pltgot = 0;
12376   bfd_vma mips_pltgot = 0;
12377   bfd_vma jmprel = 0;
12378   bfd_vma local_gotno = 0;
12379   bfd_vma gotsym = 0;
12380   bfd_vma symtabno = 0;
12381
12382   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12383                       display_mips_gnu_attribute);
12384
12385   /* We have a lot of special sections.  Thanks SGI!  */
12386   if (dynamic_section == NULL)
12387     /* No information available.  */
12388     return 0;
12389
12390   for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
12391     switch (entry->d_tag)
12392       {
12393       case DT_MIPS_LIBLIST:
12394         liblist_offset
12395           = offset_from_vma (file, entry->d_un.d_val,
12396                              liblistno * sizeof (Elf32_External_Lib));
12397         break;
12398       case DT_MIPS_LIBLISTNO:
12399         liblistno = entry->d_un.d_val;
12400         break;
12401       case DT_MIPS_OPTIONS:
12402         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
12403         break;
12404       case DT_MIPS_CONFLICT:
12405         conflicts_offset
12406           = offset_from_vma (file, entry->d_un.d_val,
12407                              conflictsno * sizeof (Elf32_External_Conflict));
12408         break;
12409       case DT_MIPS_CONFLICTNO:
12410         conflictsno = entry->d_un.d_val;
12411         break;
12412       case DT_PLTGOT:
12413         pltgot = entry->d_un.d_ptr;
12414         break;
12415       case DT_MIPS_LOCAL_GOTNO:
12416         local_gotno = entry->d_un.d_val;
12417         break;
12418       case DT_MIPS_GOTSYM:
12419         gotsym = entry->d_un.d_val;
12420         break;
12421       case DT_MIPS_SYMTABNO:
12422         symtabno = entry->d_un.d_val;
12423         break;
12424       case DT_MIPS_PLTGOT:
12425         mips_pltgot = entry->d_un.d_ptr;
12426         break;
12427       case DT_PLTREL:
12428         pltrel = entry->d_un.d_val;
12429         break;
12430       case DT_PLTRELSZ:
12431         pltrelsz = entry->d_un.d_val;
12432         break;
12433       case DT_JMPREL:
12434         jmprel = entry->d_un.d_ptr;
12435         break;
12436       default:
12437         break;
12438       }
12439
12440   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
12441     {
12442       Elf32_External_Lib * elib;
12443       size_t cnt;
12444
12445       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
12446                                               liblistno,
12447                                               sizeof (Elf32_External_Lib),
12448                                               _("liblist section data"));
12449       if (elib)
12450         {
12451           printf (_("\nSection '.liblist' contains %lu entries:\n"),
12452                   (unsigned long) liblistno);
12453           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
12454                  stdout);
12455
12456           for (cnt = 0; cnt < liblistno; ++cnt)
12457             {
12458               Elf32_Lib liblist;
12459               time_t atime;
12460               char timebuf[20];
12461               struct tm * tmp;
12462
12463               liblist.l_name = BYTE_GET (elib[cnt].l_name);
12464               atime = BYTE_GET (elib[cnt].l_time_stamp);
12465               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12466               liblist.l_version = BYTE_GET (elib[cnt].l_version);
12467               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12468
12469               tmp = gmtime (&atime);
12470               snprintf (timebuf, sizeof (timebuf),
12471                         "%04u-%02u-%02uT%02u:%02u:%02u",
12472                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12473                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12474
12475               printf ("%3lu: ", (unsigned long) cnt);
12476               if (VALID_DYNAMIC_NAME (liblist.l_name))
12477                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
12478               else
12479                 printf (_("<corrupt: %9ld>"), liblist.l_name);
12480               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
12481                       liblist.l_version);
12482
12483               if (liblist.l_flags == 0)
12484                 puts (_(" NONE"));
12485               else
12486                 {
12487                   static const struct
12488                   {
12489                     const char * name;
12490                     int bit;
12491                   }
12492                   l_flags_vals[] =
12493                   {
12494                     { " EXACT_MATCH", LL_EXACT_MATCH },
12495                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
12496                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
12497                     { " EXPORTS", LL_EXPORTS },
12498                     { " DELAY_LOAD", LL_DELAY_LOAD },
12499                     { " DELTA", LL_DELTA }
12500                   };
12501                   int flags = liblist.l_flags;
12502                   size_t fcnt;
12503
12504                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
12505                     if ((flags & l_flags_vals[fcnt].bit) != 0)
12506                       {
12507                         fputs (l_flags_vals[fcnt].name, stdout);
12508                         flags ^= l_flags_vals[fcnt].bit;
12509                       }
12510                   if (flags != 0)
12511                     printf (" %#x", (unsigned int) flags);
12512
12513                   puts ("");
12514                 }
12515             }
12516
12517           free (elib);
12518         }
12519     }
12520
12521   if (options_offset != 0)
12522     {
12523       Elf_External_Options * eopt;
12524       Elf_Internal_Shdr * sect = section_headers;
12525       Elf_Internal_Options * iopt;
12526       Elf_Internal_Options * option;
12527       size_t offset;
12528       int cnt;
12529
12530       /* Find the section header so that we get the size.  */
12531       while (sect->sh_type != SHT_MIPS_OPTIONS)
12532         ++sect;
12533
12534       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
12535                                                 sect->sh_size, _("options"));
12536       if (eopt)
12537         {
12538           iopt = (Elf_Internal_Options *)
12539               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
12540           if (iopt == NULL)
12541             {
12542               error (_("Out of memory\n"));
12543               return 0;
12544             }
12545
12546           offset = cnt = 0;
12547           option = iopt;
12548
12549           while (offset < sect->sh_size)
12550             {
12551               Elf_External_Options * eoption;
12552
12553               eoption = (Elf_External_Options *) ((char *) eopt + offset);
12554
12555               option->kind = BYTE_GET (eoption->kind);
12556               option->size = BYTE_GET (eoption->size);
12557               option->section = BYTE_GET (eoption->section);
12558               option->info = BYTE_GET (eoption->info);
12559
12560               offset += option->size;
12561
12562               ++option;
12563               ++cnt;
12564             }
12565
12566           printf (_("\nSection '%s' contains %d entries:\n"),
12567                   SECTION_NAME (sect), cnt);
12568
12569           option = iopt;
12570
12571           while (cnt-- > 0)
12572             {
12573               size_t len;
12574
12575               switch (option->kind)
12576                 {
12577                 case ODK_NULL:
12578                   /* This shouldn't happen.  */
12579                   printf (" NULL       %d %lx", option->section, option->info);
12580                   break;
12581                 case ODK_REGINFO:
12582                   printf (" REGINFO    ");
12583                   if (elf_header.e_machine == EM_MIPS)
12584                     {
12585                       /* 32bit form.  */
12586                       Elf32_External_RegInfo * ereg;
12587                       Elf32_RegInfo reginfo;
12588
12589                       ereg = (Elf32_External_RegInfo *) (option + 1);
12590                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12591                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12592                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12593                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12594                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12595                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12596
12597                       printf ("GPR %08lx  GP 0x%lx\n",
12598                               reginfo.ri_gprmask,
12599                               (unsigned long) reginfo.ri_gp_value);
12600                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
12601                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12602                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12603                     }
12604                   else
12605                     {
12606                       /* 64 bit form.  */
12607                       Elf64_External_RegInfo * ereg;
12608                       Elf64_Internal_RegInfo reginfo;
12609
12610                       ereg = (Elf64_External_RegInfo *) (option + 1);
12611                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
12612                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12613                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12614                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12615                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12616                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
12617
12618                       printf ("GPR %08lx  GP 0x",
12619                               reginfo.ri_gprmask);
12620                       printf_vma (reginfo.ri_gp_value);
12621                       printf ("\n");
12622
12623                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
12624                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12625                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12626                     }
12627                   ++option;
12628                   continue;
12629                 case ODK_EXCEPTIONS:
12630                   fputs (" EXCEPTIONS fpe_min(", stdout);
12631                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12632                   fputs (") fpe_max(", stdout);
12633                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12634                   fputs (")", stdout);
12635
12636                   if (option->info & OEX_PAGE0)
12637                     fputs (" PAGE0", stdout);
12638                   if (option->info & OEX_SMM)
12639                     fputs (" SMM", stdout);
12640                   if (option->info & OEX_FPDBUG)
12641                     fputs (" FPDBUG", stdout);
12642                   if (option->info & OEX_DISMISS)
12643                     fputs (" DISMISS", stdout);
12644                   break;
12645                 case ODK_PAD:
12646                   fputs (" PAD       ", stdout);
12647                   if (option->info & OPAD_PREFIX)
12648                     fputs (" PREFIX", stdout);
12649                   if (option->info & OPAD_POSTFIX)
12650                     fputs (" POSTFIX", stdout);
12651                   if (option->info & OPAD_SYMBOL)
12652                     fputs (" SYMBOL", stdout);
12653                   break;
12654                 case ODK_HWPATCH:
12655                   fputs (" HWPATCH   ", stdout);
12656                   if (option->info & OHW_R4KEOP)
12657                     fputs (" R4KEOP", stdout);
12658                   if (option->info & OHW_R8KPFETCH)
12659                     fputs (" R8KPFETCH", stdout);
12660                   if (option->info & OHW_R5KEOP)
12661                     fputs (" R5KEOP", stdout);
12662                   if (option->info & OHW_R5KCVTL)
12663                     fputs (" R5KCVTL", stdout);
12664                   break;
12665                 case ODK_FILL:
12666                   fputs (" FILL       ", stdout);
12667                   /* XXX Print content of info word?  */
12668                   break;
12669                 case ODK_TAGS:
12670                   fputs (" TAGS       ", stdout);
12671                   /* XXX Print content of info word?  */
12672                   break;
12673                 case ODK_HWAND:
12674                   fputs (" HWAND     ", stdout);
12675                   if (option->info & OHWA0_R4KEOP_CHECKED)
12676                     fputs (" R4KEOP_CHECKED", stdout);
12677                   if (option->info & OHWA0_R4KEOP_CLEAN)
12678                     fputs (" R4KEOP_CLEAN", stdout);
12679                   break;
12680                 case ODK_HWOR:
12681                   fputs (" HWOR      ", stdout);
12682                   if (option->info & OHWA0_R4KEOP_CHECKED)
12683                     fputs (" R4KEOP_CHECKED", stdout);
12684                   if (option->info & OHWA0_R4KEOP_CLEAN)
12685                     fputs (" R4KEOP_CLEAN", stdout);
12686                   break;
12687                 case ODK_GP_GROUP:
12688                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
12689                           option->info & OGP_GROUP,
12690                           (option->info & OGP_SELF) >> 16);
12691                   break;
12692                 case ODK_IDENT:
12693                   printf (" IDENT     %#06lx  self-contained %#06lx",
12694                           option->info & OGP_GROUP,
12695                           (option->info & OGP_SELF) >> 16);
12696                   break;
12697                 default:
12698                   /* This shouldn't happen.  */
12699                   printf (" %3d ???     %d %lx",
12700                           option->kind, option->section, option->info);
12701                   break;
12702                 }
12703
12704               len = sizeof (* eopt);
12705               while (len < option->size)
12706                 if (((char *) option)[len] >= ' '
12707                     && ((char *) option)[len] < 0x7f)
12708                   printf ("%c", ((char *) option)[len++]);
12709                 else
12710                   printf ("\\%03o", ((char *) option)[len++]);
12711
12712               fputs ("\n", stdout);
12713               ++option;
12714             }
12715
12716           free (eopt);
12717         }
12718     }
12719
12720   if (conflicts_offset != 0 && conflictsno != 0)
12721     {
12722       Elf32_Conflict * iconf;
12723       size_t cnt;
12724
12725       if (dynamic_symbols == NULL)
12726         {
12727           error (_("conflict list found without a dynamic symbol table\n"));
12728           return 0;
12729         }
12730
12731       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
12732       if (iconf == NULL)
12733         {
12734           error (_("Out of memory\n"));
12735           return 0;
12736         }
12737
12738       if (is_32bit_elf)
12739         {
12740           Elf32_External_Conflict * econf32;
12741
12742           econf32 = (Elf32_External_Conflict *)
12743               get_data (NULL, file, conflicts_offset, conflictsno,
12744                         sizeof (* econf32), _("conflict"));
12745           if (!econf32)
12746             return 0;
12747
12748           for (cnt = 0; cnt < conflictsno; ++cnt)
12749             iconf[cnt] = BYTE_GET (econf32[cnt]);
12750
12751           free (econf32);
12752         }
12753       else
12754         {
12755           Elf64_External_Conflict * econf64;
12756
12757           econf64 = (Elf64_External_Conflict *)
12758               get_data (NULL, file, conflicts_offset, conflictsno,
12759                         sizeof (* econf64), _("conflict"));
12760           if (!econf64)
12761             return 0;
12762
12763           for (cnt = 0; cnt < conflictsno; ++cnt)
12764             iconf[cnt] = BYTE_GET (econf64[cnt]);
12765
12766           free (econf64);
12767         }
12768
12769       printf (_("\nSection '.conflict' contains %lu entries:\n"),
12770               (unsigned long) conflictsno);
12771       puts (_("  Num:    Index       Value  Name"));
12772
12773       for (cnt = 0; cnt < conflictsno; ++cnt)
12774         {
12775           Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
12776
12777           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
12778           print_vma (psym->st_value, FULL_HEX);
12779           putchar (' ');
12780           if (VALID_DYNAMIC_NAME (psym->st_name))
12781             print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
12782           else
12783             printf (_("<corrupt: %14ld>"), psym->st_name);
12784           putchar ('\n');
12785         }
12786
12787       free (iconf);
12788     }
12789
12790   if (pltgot != 0 && local_gotno != 0)
12791     {
12792       bfd_vma ent, local_end, global_end;
12793       size_t i, offset;
12794       unsigned char * data;
12795       int addr_size;
12796
12797       ent = pltgot;
12798       addr_size = (is_32bit_elf ? 4 : 8);
12799       local_end = pltgot + local_gotno * addr_size;
12800       global_end = local_end + (symtabno - gotsym) * addr_size;
12801
12802       offset = offset_from_vma (file, pltgot, global_end - pltgot);
12803       data = (unsigned char *) get_data (NULL, file, offset,
12804                                          global_end - pltgot, 1,
12805                                          _("Global Offset Table data"));
12806       if (data == NULL)
12807         return 0;
12808
12809       printf (_("\nPrimary GOT:\n"));
12810       printf (_(" Canonical gp value: "));
12811       print_vma (pltgot + 0x7ff0, LONG_HEX);
12812       printf ("\n\n");
12813
12814       printf (_(" Reserved entries:\n"));
12815       printf (_("  %*s %10s %*s Purpose\n"),
12816               addr_size * 2, _("Address"), _("Access"),
12817               addr_size * 2, _("Initial"));
12818       ent = print_mips_got_entry (data, pltgot, ent);
12819       printf (_(" Lazy resolver\n"));
12820       if (data
12821           && (byte_get (data + ent - pltgot, addr_size)
12822               >> (addr_size * 8 - 1)) != 0)
12823         {
12824           ent = print_mips_got_entry (data, pltgot, ent);
12825           printf (_(" Module pointer (GNU extension)\n"));
12826         }
12827       printf ("\n");
12828
12829       if (ent < local_end)
12830         {
12831           printf (_(" Local entries:\n"));
12832           printf ("  %*s %10s %*s\n",
12833                   addr_size * 2, _("Address"), _("Access"),
12834                   addr_size * 2, _("Initial"));
12835           while (ent < local_end)
12836             {
12837               ent = print_mips_got_entry (data, pltgot, ent);
12838               printf ("\n");
12839             }
12840           printf ("\n");
12841         }
12842
12843       if (gotsym < symtabno)
12844         {
12845           int sym_width;
12846
12847           printf (_(" Global entries:\n"));
12848           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
12849                   addr_size * 2, _("Address"),
12850                   _("Access"),
12851                   addr_size * 2, _("Initial"),
12852                   addr_size * 2, _("Sym.Val."),
12853                   _("Type"),
12854                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
12855                   _("Ndx"), _("Name"));
12856
12857           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12858           for (i = gotsym; i < symtabno; i++)
12859             {
12860               Elf_Internal_Sym * psym;
12861
12862               psym = dynamic_symbols + i;
12863               ent = print_mips_got_entry (data, pltgot, ent);
12864               printf (" ");
12865               print_vma (psym->st_value, LONG_HEX);
12866               printf (" %-7s %3s ",
12867                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12868                       get_symbol_index_type (psym->st_shndx));
12869               if (VALID_DYNAMIC_NAME (psym->st_name))
12870                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12871               else
12872                 printf (_("<corrupt: %14ld>"), psym->st_name);
12873               printf ("\n");
12874             }
12875           printf ("\n");
12876         }
12877
12878       if (data)
12879         free (data);
12880     }
12881
12882   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12883     {
12884       bfd_vma ent, end;
12885       size_t offset, rel_offset;
12886       unsigned long count, i;
12887       unsigned char * data;
12888       int addr_size, sym_width;
12889       Elf_Internal_Rela * rels;
12890
12891       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12892       if (pltrel == DT_RELA)
12893         {
12894           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12895             return 0;
12896         }
12897       else
12898         {
12899           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12900             return 0;
12901         }
12902
12903       ent = mips_pltgot;
12904       addr_size = (is_32bit_elf ? 4 : 8);
12905       end = mips_pltgot + (2 + count) * addr_size;
12906
12907       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
12908       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
12909                                          1, _("Procedure Linkage Table data"));
12910       if (data == NULL)
12911         return 0;
12912
12913       printf ("\nPLT GOT:\n\n");
12914       printf (_(" Reserved entries:\n"));
12915       printf (_("  %*s %*s Purpose\n"),
12916               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
12917       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12918       printf (_(" PLT lazy resolver\n"));
12919       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12920       printf (_(" Module pointer\n"));
12921       printf ("\n");
12922
12923       printf (_(" Entries:\n"));
12924       printf ("  %*s %*s %*s %-7s %3s %s\n",
12925               addr_size * 2, _("Address"),
12926               addr_size * 2, _("Initial"),
12927               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12928       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12929       for (i = 0; i < count; i++)
12930         {
12931           Elf_Internal_Sym * psym;
12932
12933           psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
12934           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12935           printf (" ");
12936           print_vma (psym->st_value, LONG_HEX);
12937           printf (" %-7s %3s ",
12938                   get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12939                   get_symbol_index_type (psym->st_shndx));
12940           if (VALID_DYNAMIC_NAME (psym->st_name))
12941             print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12942           else
12943             printf (_("<corrupt: %14ld>"), psym->st_name);
12944           printf ("\n");
12945         }
12946       printf ("\n");
12947
12948       if (data)
12949         free (data);
12950       free (rels);
12951     }
12952
12953   return 1;
12954 }
12955
12956 static int
12957 process_gnu_liblist (FILE * file)
12958 {
12959   Elf_Internal_Shdr * section;
12960   Elf_Internal_Shdr * string_sec;
12961   Elf32_External_Lib * elib;
12962   char * strtab;
12963   size_t strtab_size;
12964   size_t cnt;
12965   unsigned i;
12966
12967   if (! do_arch)
12968     return 0;
12969
12970   for (i = 0, section = section_headers;
12971        i < elf_header.e_shnum;
12972        i++, section++)
12973     {
12974       switch (section->sh_type)
12975         {
12976         case SHT_GNU_LIBLIST:
12977           if (section->sh_link >= elf_header.e_shnum)
12978             break;
12979
12980           elib = (Elf32_External_Lib *)
12981               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
12982                         _("liblist section data"));
12983
12984           if (elib == NULL)
12985             break;
12986           string_sec = section_headers + section->sh_link;
12987
12988           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12989                                       string_sec->sh_size,
12990                                       _("liblist string table"));
12991           if (strtab == NULL
12992               || section->sh_entsize != sizeof (Elf32_External_Lib))
12993             {
12994               free (elib);
12995               free (strtab);
12996               break;
12997             }
12998           strtab_size = string_sec->sh_size;
12999
13000           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
13001                   SECTION_NAME (section),
13002                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
13003
13004           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
13005
13006           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
13007                ++cnt)
13008             {
13009               Elf32_Lib liblist;
13010               time_t atime;
13011               char timebuf[20];
13012               struct tm * tmp;
13013
13014               liblist.l_name = BYTE_GET (elib[cnt].l_name);
13015               atime = BYTE_GET (elib[cnt].l_time_stamp);
13016               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13017               liblist.l_version = BYTE_GET (elib[cnt].l_version);
13018               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13019
13020               tmp = gmtime (&atime);
13021               snprintf (timebuf, sizeof (timebuf),
13022                         "%04u-%02u-%02uT%02u:%02u:%02u",
13023                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13024                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
13025
13026               printf ("%3lu: ", (unsigned long) cnt);
13027               if (do_wide)
13028                 printf ("%-20s", liblist.l_name < strtab_size
13029                         ? strtab + liblist.l_name : _("<corrupt>"));
13030               else
13031                 printf ("%-20.20s", liblist.l_name < strtab_size
13032                         ? strtab + liblist.l_name : _("<corrupt>"));
13033               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
13034                       liblist.l_version, liblist.l_flags);
13035             }
13036
13037           free (elib);
13038           free (strtab);
13039         }
13040     }
13041
13042   return 1;
13043 }
13044
13045 static const char *
13046 get_note_type (unsigned e_type)
13047 {
13048   static char buff[64];
13049
13050   if (elf_header.e_type == ET_CORE)
13051     switch (e_type)
13052       {
13053       case NT_AUXV:
13054         return _("NT_AUXV (auxiliary vector)");
13055       case NT_PRSTATUS:
13056         return _("NT_PRSTATUS (prstatus structure)");
13057       case NT_FPREGSET:
13058         return _("NT_FPREGSET (floating point registers)");
13059       case NT_PRPSINFO:
13060         return _("NT_PRPSINFO (prpsinfo structure)");
13061       case NT_TASKSTRUCT:
13062         return _("NT_TASKSTRUCT (task structure)");
13063       case NT_PRXFPREG:
13064         return _("NT_PRXFPREG (user_xfpregs structure)");
13065       case NT_PPC_VMX:
13066         return _("NT_PPC_VMX (ppc Altivec registers)");
13067       case NT_PPC_VSX:
13068         return _("NT_PPC_VSX (ppc VSX registers)");
13069       case NT_386_TLS:
13070         return _("NT_386_TLS (x86 TLS information)");
13071       case NT_386_IOPERM:
13072         return _("NT_386_IOPERM (x86 I/O permissions)");
13073       case NT_X86_XSTATE:
13074         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
13075       case NT_S390_HIGH_GPRS:
13076         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
13077       case NT_S390_TIMER:
13078         return _("NT_S390_TIMER (s390 timer register)");
13079       case NT_S390_TODCMP:
13080         return _("NT_S390_TODCMP (s390 TOD comparator register)");
13081       case NT_S390_TODPREG:
13082         return _("NT_S390_TODPREG (s390 TOD programmable register)");
13083       case NT_S390_CTRS:
13084         return _("NT_S390_CTRS (s390 control registers)");
13085       case NT_S390_PREFIX:
13086         return _("NT_S390_PREFIX (s390 prefix register)");
13087       case NT_S390_LAST_BREAK:
13088         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
13089       case NT_S390_SYSTEM_CALL:
13090         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
13091       case NT_S390_TDB:
13092         return _("NT_S390_TDB (s390 transaction diagnostic block)");
13093       case NT_ARM_VFP:
13094         return _("NT_ARM_VFP (arm VFP registers)");
13095       case NT_ARM_TLS:
13096         return _("NT_ARM_TLS (AArch TLS registers)");
13097       case NT_ARM_HW_BREAK:
13098         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
13099       case NT_ARM_HW_WATCH:
13100         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
13101       case NT_PSTATUS:
13102         return _("NT_PSTATUS (pstatus structure)");
13103       case NT_FPREGS:
13104         return _("NT_FPREGS (floating point registers)");
13105       case NT_PSINFO:
13106         return _("NT_PSINFO (psinfo structure)");
13107       case NT_LWPSTATUS:
13108         return _("NT_LWPSTATUS (lwpstatus_t structure)");
13109       case NT_LWPSINFO:
13110         return _("NT_LWPSINFO (lwpsinfo_t structure)");
13111       case NT_WIN32PSTATUS:
13112         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
13113       case NT_SIGINFO:
13114         return _("NT_SIGINFO (siginfo_t data)");
13115       case NT_FILE:
13116         return _("NT_FILE (mapped files)");
13117       default:
13118         break;
13119       }
13120   else
13121     switch (e_type)
13122       {
13123       case NT_VERSION:
13124         return _("NT_VERSION (version)");
13125       case NT_ARCH:
13126         return _("NT_ARCH (architecture)");
13127       default:
13128         break;
13129       }
13130
13131   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13132   return buff;
13133 }
13134
13135 static int
13136 print_core_note (Elf_Internal_Note *pnote)
13137 {
13138   unsigned int addr_size = is_32bit_elf ? 4 : 8;
13139   bfd_vma count, page_size;
13140   unsigned char *descdata, *filenames, *descend;
13141
13142   if (pnote->type != NT_FILE)
13143     return 1;
13144
13145 #ifndef BFD64
13146   if (!is_32bit_elf)
13147     {
13148       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
13149       /* Still "successful".  */
13150       return 1;
13151     }
13152 #endif
13153
13154   if (pnote->descsz < 2 * addr_size)
13155     {
13156       printf (_("    Malformed note - too short for header\n"));
13157       return 0;
13158     }
13159
13160   descdata = (unsigned char *) pnote->descdata;
13161   descend = descdata + pnote->descsz;
13162
13163   if (descdata[pnote->descsz - 1] != '\0')
13164     {
13165       printf (_("    Malformed note - does not end with \\0\n"));
13166       return 0;
13167     }
13168
13169   count = byte_get (descdata, addr_size);
13170   descdata += addr_size;
13171
13172   page_size = byte_get (descdata, addr_size);
13173   descdata += addr_size;
13174
13175   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
13176     {
13177       printf (_("    Malformed note - too short for supplied file count\n"));
13178       return 0;
13179     }
13180
13181   printf (_("    Page size: "));
13182   print_vma (page_size, DEC);
13183   printf ("\n");
13184
13185   printf (_("    %*s%*s%*s\n"),
13186           (int) (2 + 2 * addr_size), _("Start"),
13187           (int) (4 + 2 * addr_size), _("End"),
13188           (int) (4 + 2 * addr_size), _("Page Offset"));
13189   filenames = descdata + count * 3 * addr_size;
13190   while (--count > 0)
13191     {
13192       bfd_vma start, end, file_ofs;
13193
13194       if (filenames == descend)
13195         {
13196           printf (_("    Malformed note - filenames end too early\n"));
13197           return 0;
13198         }
13199
13200       start = byte_get (descdata, addr_size);
13201       descdata += addr_size;
13202       end = byte_get (descdata, addr_size);
13203       descdata += addr_size;
13204       file_ofs = byte_get (descdata, addr_size);
13205       descdata += addr_size;
13206
13207       printf ("    ");
13208       print_vma (start, FULL_HEX);
13209       printf ("  ");
13210       print_vma (end, FULL_HEX);
13211       printf ("  ");
13212       print_vma (file_ofs, FULL_HEX);
13213       printf ("\n        %s\n", filenames);
13214
13215       filenames += 1 + strlen ((char *) filenames);
13216     }
13217
13218   return 1;
13219 }
13220
13221 static const char *
13222 get_gnu_elf_note_type (unsigned e_type)
13223 {
13224   static char buff[64];
13225
13226   switch (e_type)
13227     {
13228     case NT_GNU_ABI_TAG:
13229       return _("NT_GNU_ABI_TAG (ABI version tag)");
13230     case NT_GNU_HWCAP:
13231       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
13232     case NT_GNU_BUILD_ID:
13233       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
13234     case NT_GNU_GOLD_VERSION:
13235       return _("NT_GNU_GOLD_VERSION (gold version)");
13236     default:
13237       break;
13238     }
13239
13240   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13241   return buff;
13242 }
13243
13244 static int
13245 print_gnu_note (Elf_Internal_Note *pnote)
13246 {
13247   switch (pnote->type)
13248     {
13249     case NT_GNU_BUILD_ID:
13250       {
13251         unsigned long i;
13252
13253         printf (_("    Build ID: "));
13254         for (i = 0; i < pnote->descsz; ++i)
13255           printf ("%02x", pnote->descdata[i] & 0xff);
13256         printf ("\n");
13257       }
13258       break;
13259
13260     case NT_GNU_ABI_TAG:
13261       {
13262         unsigned long os, major, minor, subminor;
13263         const char *osname;
13264
13265         os = byte_get ((unsigned char *) pnote->descdata, 4);
13266         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
13267         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
13268         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
13269
13270         switch (os)
13271           {
13272           case GNU_ABI_TAG_LINUX:
13273             osname = "Linux";
13274             break;
13275           case GNU_ABI_TAG_HURD:
13276             osname = "Hurd";
13277             break;
13278           case GNU_ABI_TAG_SOLARIS:
13279             osname = "Solaris";
13280             break;
13281           case GNU_ABI_TAG_FREEBSD:
13282             osname = "FreeBSD";
13283             break;
13284           case GNU_ABI_TAG_NETBSD:
13285             osname = "NetBSD";
13286             break;
13287           default:
13288             osname = "Unknown";
13289             break;
13290           }
13291
13292         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
13293                 major, minor, subminor);
13294       }
13295       break;
13296     }
13297
13298   return 1;
13299 }
13300
13301 static const char *
13302 get_netbsd_elfcore_note_type (unsigned e_type)
13303 {
13304   static char buff[64];
13305
13306   if (e_type == NT_NETBSDCORE_PROCINFO)
13307     {
13308       /* NetBSD core "procinfo" structure.  */
13309       return _("NetBSD procinfo structure");
13310     }
13311
13312   /* As of Jan 2002 there are no other machine-independent notes
13313      defined for NetBSD core files.  If the note type is less
13314      than the start of the machine-dependent note types, we don't
13315      understand it.  */
13316
13317   if (e_type < NT_NETBSDCORE_FIRSTMACH)
13318     {
13319       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13320       return buff;
13321     }
13322
13323   switch (elf_header.e_machine)
13324     {
13325     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13326        and PT_GETFPREGS == mach+2.  */
13327
13328     case EM_OLD_ALPHA:
13329     case EM_ALPHA:
13330     case EM_SPARC:
13331     case EM_SPARC32PLUS:
13332     case EM_SPARCV9:
13333       switch (e_type)
13334         {
13335         case NT_NETBSDCORE_FIRSTMACH + 0:
13336           return _("PT_GETREGS (reg structure)");
13337         case NT_NETBSDCORE_FIRSTMACH + 2:
13338           return _("PT_GETFPREGS (fpreg structure)");
13339         default:
13340           break;
13341         }
13342       break;
13343
13344     /* On all other arch's, PT_GETREGS == mach+1 and
13345        PT_GETFPREGS == mach+3.  */
13346     default:
13347       switch (e_type)
13348         {
13349         case NT_NETBSDCORE_FIRSTMACH + 1:
13350           return _("PT_GETREGS (reg structure)");
13351         case NT_NETBSDCORE_FIRSTMACH + 3:
13352           return _("PT_GETFPREGS (fpreg structure)");
13353         default:
13354           break;
13355         }
13356     }
13357
13358   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
13359             e_type - NT_NETBSDCORE_FIRSTMACH);
13360   return buff;
13361 }
13362
13363 static const char *
13364 get_stapsdt_note_type (unsigned e_type)
13365 {
13366   static char buff[64];
13367
13368   switch (e_type)
13369     {
13370     case NT_STAPSDT:
13371       return _("NT_STAPSDT (SystemTap probe descriptors)");
13372
13373     default:
13374       break;
13375     }
13376
13377   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13378   return buff;
13379 }
13380
13381 static int
13382 print_stapsdt_note (Elf_Internal_Note *pnote)
13383 {
13384   int addr_size = is_32bit_elf ? 4 : 8;
13385   char *data = pnote->descdata;
13386   char *data_end = pnote->descdata + pnote->descsz;
13387   bfd_vma pc, base_addr, semaphore;
13388   char *provider, *probe, *arg_fmt;
13389
13390   pc = byte_get ((unsigned char *) data, addr_size);
13391   data += addr_size;
13392   base_addr = byte_get ((unsigned char *) data, addr_size);
13393   data += addr_size;
13394   semaphore = byte_get ((unsigned char *) data, addr_size);
13395   data += addr_size;
13396
13397   provider = data;
13398   data += strlen (data) + 1;
13399   probe = data;
13400   data += strlen (data) + 1;
13401   arg_fmt = data;
13402   data += strlen (data) + 1;
13403
13404   printf (_("    Provider: %s\n"), provider);
13405   printf (_("    Name: %s\n"), probe);
13406   printf (_("    Location: "));
13407   print_vma (pc, FULL_HEX);
13408   printf (_(", Base: "));
13409   print_vma (base_addr, FULL_HEX);
13410   printf (_(", Semaphore: "));
13411   print_vma (semaphore, FULL_HEX);
13412   printf ("\n");
13413   printf (_("    Arguments: %s\n"), arg_fmt);
13414
13415   return data == data_end;
13416 }
13417
13418 static const char *
13419 get_ia64_vms_note_type (unsigned e_type)
13420 {
13421   static char buff[64];
13422
13423   switch (e_type)
13424     {
13425     case NT_VMS_MHD:
13426       return _("NT_VMS_MHD (module header)");
13427     case NT_VMS_LNM:
13428       return _("NT_VMS_LNM (language name)");
13429     case NT_VMS_SRC:
13430       return _("NT_VMS_SRC (source files)");
13431     case NT_VMS_TITLE:
13432       return "NT_VMS_TITLE";
13433     case NT_VMS_EIDC:
13434       return _("NT_VMS_EIDC (consistency check)");
13435     case NT_VMS_FPMODE:
13436       return _("NT_VMS_FPMODE (FP mode)");
13437     case NT_VMS_LINKTIME:
13438       return "NT_VMS_LINKTIME";
13439     case NT_VMS_IMGNAM:
13440       return _("NT_VMS_IMGNAM (image name)");
13441     case NT_VMS_IMGID:
13442       return _("NT_VMS_IMGID (image id)");
13443     case NT_VMS_LINKID:
13444       return _("NT_VMS_LINKID (link id)");
13445     case NT_VMS_IMGBID:
13446       return _("NT_VMS_IMGBID (build id)");
13447     case NT_VMS_GSTNAM:
13448       return _("NT_VMS_GSTNAM (sym table name)");
13449     case NT_VMS_ORIG_DYN:
13450       return "NT_VMS_ORIG_DYN";
13451     case NT_VMS_PATCHTIME:
13452       return "NT_VMS_PATCHTIME";
13453     default:
13454       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13455       return buff;
13456     }
13457 }
13458
13459 static int
13460 print_ia64_vms_note (Elf_Internal_Note * pnote)
13461 {
13462   switch (pnote->type)
13463     {
13464     case NT_VMS_MHD:
13465       if (pnote->descsz > 36)
13466         {
13467           size_t l = strlen (pnote->descdata + 34);
13468           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
13469           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
13470           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
13471           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
13472         }
13473       else
13474         printf (_("    Invalid size\n"));
13475       break;
13476     case NT_VMS_LNM:
13477       printf (_("   Language: %s\n"), pnote->descdata);
13478       break;
13479 #ifdef BFD64
13480     case NT_VMS_FPMODE:
13481       printf (_("   Floating Point mode: "));
13482       printf ("0x%016" BFD_VMA_FMT "x\n",
13483               (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
13484       break;
13485     case NT_VMS_LINKTIME:
13486       printf (_("   Link time: "));
13487       print_vms_time
13488         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13489       printf ("\n");
13490       break;
13491     case NT_VMS_PATCHTIME:
13492       printf (_("   Patch time: "));
13493       print_vms_time
13494         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13495       printf ("\n");
13496       break;
13497     case NT_VMS_ORIG_DYN:
13498       printf (_("   Major id: %u,  minor id: %u\n"),
13499               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
13500               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
13501       printf (_("   Last modified  : "));
13502       print_vms_time
13503         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
13504       printf (_("\n   Link flags  : "));
13505       printf ("0x%016" BFD_VMA_FMT "x\n",
13506               (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
13507       printf (_("   Header flags: 0x%08x\n"),
13508               (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
13509       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
13510       break;
13511 #endif
13512     case NT_VMS_IMGNAM:
13513       printf (_("    Image name: %s\n"), pnote->descdata);
13514       break;
13515     case NT_VMS_GSTNAM:
13516       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
13517       break;
13518     case NT_VMS_IMGID:
13519       printf (_("    Image id: %s\n"), pnote->descdata);
13520       break;
13521     case NT_VMS_LINKID:
13522       printf (_("    Linker id: %s\n"), pnote->descdata);
13523       break;
13524     default:
13525       break;
13526     }
13527   return 1;
13528 }
13529
13530 /* Note that by the ELF standard, the name field is already null byte
13531    terminated, and namesz includes the terminating null byte.
13532    I.E. the value of namesz for the name "FSF" is 4.
13533
13534    If the value of namesz is zero, there is no name present.  */
13535 static int
13536 process_note (Elf_Internal_Note * pnote)
13537 {
13538   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
13539   const char * nt;
13540
13541   if (pnote->namesz == 0)
13542     /* If there is no note name, then use the default set of
13543        note type strings.  */
13544     nt = get_note_type (pnote->type);
13545
13546   else if (const_strneq (pnote->namedata, "GNU"))
13547     /* GNU-specific object file notes.  */
13548     nt = get_gnu_elf_note_type (pnote->type);
13549
13550   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
13551     /* NetBSD-specific core file notes.  */
13552     nt = get_netbsd_elfcore_note_type (pnote->type);
13553
13554   else if (strneq (pnote->namedata, "SPU/", 4))
13555     {
13556       /* SPU-specific core file notes.  */
13557       nt = pnote->namedata + 4;
13558       name = "SPU";
13559     }
13560
13561   else if (const_strneq (pnote->namedata, "IPF/VMS"))
13562     /* VMS/ia64-specific file notes.  */
13563     nt = get_ia64_vms_note_type (pnote->type);
13564
13565   else if (const_strneq (pnote->namedata, "stapsdt"))
13566     nt = get_stapsdt_note_type (pnote->type);
13567
13568   else
13569     /* Don't recognize this note name; just use the default set of
13570        note type strings.  */
13571     nt = get_note_type (pnote->type);
13572
13573   printf ("  %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
13574
13575   if (const_strneq (pnote->namedata, "IPF/VMS"))
13576     return print_ia64_vms_note (pnote);
13577   else if (const_strneq (pnote->namedata, "GNU"))
13578     return print_gnu_note (pnote);
13579   else if (const_strneq (pnote->namedata, "stapsdt"))
13580     return print_stapsdt_note (pnote);
13581   else if (const_strneq (pnote->namedata, "CORE"))
13582     return print_core_note (pnote);
13583   else
13584     return 1;
13585 }
13586
13587
13588 static int
13589 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
13590 {
13591   Elf_External_Note * pnotes;
13592   Elf_External_Note * external;
13593   int res = 1;
13594
13595   if (length <= 0)
13596     return 0;
13597
13598   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
13599                                            _("notes"));
13600   if (pnotes == NULL)
13601     return 0;
13602
13603   external = pnotes;
13604
13605   printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
13606           (unsigned long) offset, (unsigned long) length);
13607   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
13608
13609   while ((char *) external < (char *) pnotes + length)
13610     {
13611       Elf_Internal_Note inote;
13612       size_t min_notesz;
13613       char *next;
13614       char * temp = NULL;
13615       size_t data_remaining = ((char *) pnotes + length) - (char *) external;
13616
13617       if (!is_ia64_vms ())
13618         {
13619           /* PR binutils/15191
13620              Make sure that there is enough data to read.  */
13621           min_notesz = offsetof (Elf_External_Note, name);
13622           if (data_remaining < min_notesz)
13623             {
13624               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13625                     (int) data_remaining);
13626               break;
13627             }
13628           inote.type     = BYTE_GET (external->type);
13629           inote.namesz   = BYTE_GET (external->namesz);
13630           inote.namedata = external->name;
13631           inote.descsz   = BYTE_GET (external->descsz);
13632           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
13633           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
13634           next = inote.descdata + align_power (inote.descsz, 2);
13635         }
13636       else
13637         {
13638           Elf64_External_VMS_Note *vms_external;
13639
13640           /* PR binutils/15191
13641              Make sure that there is enough data to read.  */
13642           min_notesz = offsetof (Elf64_External_VMS_Note, name);
13643           if (data_remaining < min_notesz)
13644             {
13645               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13646                     (int) data_remaining);
13647               break;
13648             }
13649
13650           vms_external = (Elf64_External_VMS_Note *) external;
13651           inote.type     = BYTE_GET (vms_external->type);
13652           inote.namesz   = BYTE_GET (vms_external->namesz);
13653           inote.namedata = vms_external->name;
13654           inote.descsz   = BYTE_GET (vms_external->descsz);
13655           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
13656           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
13657           next = inote.descdata + align_power (inote.descsz, 3);
13658         }
13659
13660       if (inote.descdata < (char *) external + min_notesz
13661           || next < (char *) external + min_notesz
13662           || data_remaining < (size_t)(next - (char *) external))
13663         {
13664           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
13665                 (unsigned long) ((char *) external - (char *) pnotes));
13666           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
13667                 inote.type, inote.namesz, inote.descsz);
13668           break;
13669         }
13670
13671       external = (Elf_External_Note *) next;
13672
13673       /* Verify that name is null terminated.  It appears that at least
13674          one version of Linux (RedHat 6.0) generates corefiles that don't
13675          comply with the ELF spec by failing to include the null byte in
13676          namesz.  */
13677       if (inote.namedata[inote.namesz - 1] != '\0')
13678         {
13679           temp = (char *) malloc (inote.namesz + 1);
13680
13681           if (temp == NULL)
13682             {
13683               error (_("Out of memory\n"));
13684               res = 0;
13685               break;
13686             }
13687
13688           strncpy (temp, inote.namedata, inote.namesz);
13689           temp[inote.namesz] = 0;
13690
13691           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
13692           inote.namedata = temp;
13693         }
13694
13695       res &= process_note (& inote);
13696
13697       if (temp != NULL)
13698         {
13699           free (temp);
13700           temp = NULL;
13701         }
13702     }
13703
13704   free (pnotes);
13705
13706   return res;
13707 }
13708
13709 static int
13710 process_corefile_note_segments (FILE * file)
13711 {
13712   Elf_Internal_Phdr * segment;
13713   unsigned int i;
13714   int res = 1;
13715
13716   if (! get_program_headers (file))
13717       return 0;
13718
13719   for (i = 0, segment = program_headers;
13720        i < elf_header.e_phnum;
13721        i++, segment++)
13722     {
13723       if (segment->p_type == PT_NOTE)
13724         res &= process_corefile_note_segment (file,
13725                                               (bfd_vma) segment->p_offset,
13726                                               (bfd_vma) segment->p_filesz);
13727     }
13728
13729   return res;
13730 }
13731
13732 static int
13733 process_note_sections (FILE * file)
13734 {
13735   Elf_Internal_Shdr * section;
13736   unsigned long i;
13737   int res = 1;
13738
13739   for (i = 0, section = section_headers;
13740        i < elf_header.e_shnum && section != NULL;
13741        i++, section++)
13742     if (section->sh_type == SHT_NOTE)
13743       res &= process_corefile_note_segment (file,
13744                                             (bfd_vma) section->sh_offset,
13745                                             (bfd_vma) section->sh_size);
13746
13747   return res;
13748 }
13749
13750 static int
13751 process_notes (FILE * file)
13752 {
13753   /* If we have not been asked to display the notes then do nothing.  */
13754   if (! do_notes)
13755     return 1;
13756
13757   if (elf_header.e_type != ET_CORE)
13758     return process_note_sections (file);
13759
13760   /* No program headers means no NOTE segment.  */
13761   if (elf_header.e_phnum > 0)
13762     return process_corefile_note_segments (file);
13763
13764   printf (_("No note segments present in the core file.\n"));
13765   return 1;
13766 }
13767
13768 static int
13769 process_arch_specific (FILE * file)
13770 {
13771   if (! do_arch)
13772     return 1;
13773
13774   switch (elf_header.e_machine)
13775     {
13776     case EM_ARM:
13777       return process_arm_specific (file);
13778     case EM_MIPS:
13779     case EM_MIPS_RS3_LE:
13780       return process_mips_specific (file);
13781       break;
13782     case EM_PPC:
13783       return process_power_specific (file);
13784       break;
13785     case EM_SPARC:
13786     case EM_SPARC32PLUS:
13787     case EM_SPARCV9:
13788       return process_sparc_specific (file);
13789       break;
13790     case EM_TI_C6000:
13791       return process_tic6x_specific (file);
13792       break;
13793     case EM_MSP430:
13794       return process_msp430x_specific (file);
13795     default:
13796       break;
13797     }
13798   return 1;
13799 }
13800
13801 static int
13802 get_file_header (FILE * file)
13803 {
13804   /* Read in the identity array.  */
13805   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
13806     return 0;
13807
13808   /* Determine how to read the rest of the header.  */
13809   switch (elf_header.e_ident[EI_DATA])
13810     {
13811     default: /* fall through */
13812     case ELFDATANONE: /* fall through */
13813     case ELFDATA2LSB:
13814       byte_get = byte_get_little_endian;
13815       byte_put = byte_put_little_endian;
13816       break;
13817     case ELFDATA2MSB:
13818       byte_get = byte_get_big_endian;
13819       byte_put = byte_put_big_endian;
13820       break;
13821     }
13822
13823   /* For now we only support 32 bit and 64 bit ELF files.  */
13824   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
13825
13826   /* Read in the rest of the header.  */
13827   if (is_32bit_elf)
13828     {
13829       Elf32_External_Ehdr ehdr32;
13830
13831       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
13832         return 0;
13833
13834       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
13835       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
13836       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
13837       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
13838       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
13839       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
13840       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
13841       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
13842       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
13843       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
13844       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
13845       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
13846       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
13847     }
13848   else
13849     {
13850       Elf64_External_Ehdr ehdr64;
13851
13852       /* If we have been compiled with sizeof (bfd_vma) == 4, then
13853          we will not be able to cope with the 64bit data found in
13854          64 ELF files.  Detect this now and abort before we start
13855          overwriting things.  */
13856       if (sizeof (bfd_vma) < 8)
13857         {
13858           error (_("This instance of readelf has been built without support for a\n\
13859 64 bit data type and so it cannot read 64 bit ELF files.\n"));
13860           return 0;
13861         }
13862
13863       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
13864         return 0;
13865
13866       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
13867       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
13868       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
13869       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
13870       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
13871       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
13872       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
13873       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
13874       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
13875       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
13876       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
13877       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
13878       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
13879     }
13880
13881   if (elf_header.e_shoff)
13882     {
13883       /* There may be some extensions in the first section header.  Don't
13884          bomb if we can't read it.  */
13885       if (is_32bit_elf)
13886         get_32bit_section_headers (file, 1);
13887       else
13888         get_64bit_section_headers (file, 1);
13889     }
13890
13891   return 1;
13892 }
13893
13894 /* Process one ELF object file according to the command line options.
13895    This file may actually be stored in an archive.  The file is
13896    positioned at the start of the ELF object.  */
13897
13898 static int
13899 process_object (char * file_name, FILE * file)
13900 {
13901   unsigned int i;
13902
13903   if (! get_file_header (file))
13904     {
13905       error (_("%s: Failed to read file header\n"), file_name);
13906       return 1;
13907     }
13908
13909   /* Initialise per file variables.  */
13910   for (i = ARRAY_SIZE (version_info); i--;)
13911     version_info[i] = 0;
13912
13913   for (i = ARRAY_SIZE (dynamic_info); i--;)
13914     dynamic_info[i] = 0;
13915   dynamic_info_DT_GNU_HASH = 0;
13916
13917   /* Process the file.  */
13918   if (show_name)
13919     printf (_("\nFile: %s\n"), file_name);
13920
13921   /* Initialise the dump_sects array from the cmdline_dump_sects array.
13922      Note we do this even if cmdline_dump_sects is empty because we
13923      must make sure that the dump_sets array is zeroed out before each
13924      object file is processed.  */
13925   if (num_dump_sects > num_cmdline_dump_sects)
13926     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
13927
13928   if (num_cmdline_dump_sects > 0)
13929     {
13930       if (num_dump_sects == 0)
13931         /* A sneaky way of allocating the dump_sects array.  */
13932         request_dump_bynumber (num_cmdline_dump_sects, 0);
13933
13934       assert (num_dump_sects >= num_cmdline_dump_sects);
13935       memcpy (dump_sects, cmdline_dump_sects,
13936               num_cmdline_dump_sects * sizeof (* dump_sects));
13937     }
13938
13939   if (! process_file_header ())
13940     return 1;
13941
13942   if (! process_section_headers (file))
13943     {
13944       /* Without loaded section headers we cannot process lots of
13945          things.  */
13946       do_unwind = do_version = do_dump = do_arch = 0;
13947
13948       if (! do_using_dynamic)
13949         do_syms = do_dyn_syms = do_reloc = 0;
13950     }
13951
13952   if (! process_section_groups (file))
13953     {
13954       /* Without loaded section groups we cannot process unwind.  */
13955       do_unwind = 0;
13956     }
13957
13958   if (process_program_headers (file))
13959     process_dynamic_section (file);
13960
13961   process_relocs (file);
13962
13963   process_unwind (file);
13964
13965   process_symbol_table (file);
13966
13967   process_syminfo (file);
13968
13969   process_version_sections (file);
13970
13971   process_section_contents (file);
13972
13973   process_notes (file);
13974
13975   process_gnu_liblist (file);
13976
13977   process_arch_specific (file);
13978
13979   if (program_headers)
13980     {
13981       free (program_headers);
13982       program_headers = NULL;
13983     }
13984
13985   if (section_headers)
13986     {
13987       free (section_headers);
13988       section_headers = NULL;
13989     }
13990
13991   if (string_table)
13992     {
13993       free (string_table);
13994       string_table = NULL;
13995       string_table_length = 0;
13996     }
13997
13998   if (dynamic_strings)
13999     {
14000       free (dynamic_strings);
14001       dynamic_strings = NULL;
14002       dynamic_strings_length = 0;
14003     }
14004
14005   if (dynamic_symbols)
14006     {
14007       free (dynamic_symbols);
14008       dynamic_symbols = NULL;
14009       num_dynamic_syms = 0;
14010     }
14011
14012   if (dynamic_syminfo)
14013     {
14014       free (dynamic_syminfo);
14015       dynamic_syminfo = NULL;
14016     }
14017
14018   if (dynamic_section)
14019     {
14020       free (dynamic_section);
14021       dynamic_section = NULL;
14022     }
14023
14024   if (section_headers_groups)
14025     {
14026       free (section_headers_groups);
14027       section_headers_groups = NULL;
14028     }
14029
14030   if (section_groups)
14031     {
14032       struct group_list * g;
14033       struct group_list * next;
14034
14035       for (i = 0; i < group_count; i++)
14036         {
14037           for (g = section_groups [i].root; g != NULL; g = next)
14038             {
14039               next = g->next;
14040               free (g);
14041             }
14042         }
14043
14044       free (section_groups);
14045       section_groups = NULL;
14046     }
14047
14048   free_debug_memory ();
14049
14050   return 0;
14051 }
14052
14053 /* Process an ELF archive.
14054    On entry the file is positioned just after the ARMAG string.  */
14055
14056 static int
14057 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
14058 {
14059   struct archive_info arch;
14060   struct archive_info nested_arch;
14061   size_t got;
14062   int ret;
14063
14064   show_name = 1;
14065
14066   /* The ARCH structure is used to hold information about this archive.  */
14067   arch.file_name = NULL;
14068   arch.file = NULL;
14069   arch.index_array = NULL;
14070   arch.sym_table = NULL;
14071   arch.longnames = NULL;
14072
14073   /* The NESTED_ARCH structure is used as a single-item cache of information
14074      about a nested archive (when members of a thin archive reside within
14075      another regular archive file).  */
14076   nested_arch.file_name = NULL;
14077   nested_arch.file = NULL;
14078   nested_arch.index_array = NULL;
14079   nested_arch.sym_table = NULL;
14080   nested_arch.longnames = NULL;
14081
14082   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
14083     {
14084       ret = 1;
14085       goto out;
14086     }
14087
14088   if (do_archive_index)
14089     {
14090       if (arch.sym_table == NULL)
14091         error (_("%s: unable to dump the index as none was found\n"), file_name);
14092       else
14093         {
14094           unsigned int i, l;
14095           unsigned long current_pos;
14096
14097           printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
14098                   file_name, (long) arch.index_num, arch.sym_size);
14099           current_pos = ftell (file);
14100
14101           for (i = l = 0; i < arch.index_num; i++)
14102             {
14103               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
14104                 {
14105                   char * member_name;
14106
14107                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
14108
14109                   if (member_name != NULL)
14110                     {
14111                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
14112
14113                       if (qualified_name != NULL)
14114                         {
14115                           printf (_("Contents of binary %s at offset "), qualified_name);
14116                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
14117                           putchar ('\n');
14118                           free (qualified_name);
14119                         }
14120                     }
14121                 }
14122
14123               if (l >= arch.sym_size)
14124                 {
14125                   error (_("%s: end of the symbol table reached before the end of the index\n"),
14126                          file_name);
14127                   break;
14128                 }
14129               printf ("\t%s\n", arch.sym_table + l);
14130               l += strlen (arch.sym_table + l) + 1;
14131             }
14132
14133           if (arch.uses_64bit_indicies)
14134             l = (l + 7) & ~ 7;
14135           else
14136             l += l & 1;
14137
14138           if (l < arch.sym_size)
14139             error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
14140                    file_name, arch.sym_size - l);
14141
14142           if (fseek (file, current_pos, SEEK_SET) != 0)
14143             {
14144               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
14145               ret = 1;
14146               goto out;
14147             }
14148         }
14149
14150       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
14151           && !do_segments && !do_header && !do_dump && !do_version
14152           && !do_histogram && !do_debugging && !do_arch && !do_notes
14153           && !do_section_groups && !do_dyn_syms)
14154         {
14155           ret = 0; /* Archive index only.  */
14156           goto out;
14157         }
14158     }
14159
14160   ret = 0;
14161
14162   while (1)
14163     {
14164       char * name;
14165       size_t namelen;
14166       char * qualified_name;
14167
14168       /* Read the next archive header.  */
14169       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
14170         {
14171           error (_("%s: failed to seek to next archive header\n"), file_name);
14172           return 1;
14173         }
14174       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
14175       if (got != sizeof arch.arhdr)
14176         {
14177           if (got == 0)
14178             break;
14179           error (_("%s: failed to read archive header\n"), file_name);
14180           ret = 1;
14181           break;
14182         }
14183       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
14184         {
14185           error (_("%s: did not find a valid archive header\n"), arch.file_name);
14186           ret = 1;
14187           break;
14188         }
14189
14190       arch.next_arhdr_offset += sizeof arch.arhdr;
14191
14192       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
14193       if (archive_file_size & 01)
14194         ++archive_file_size;
14195
14196       name = get_archive_member_name (&arch, &nested_arch);
14197       if (name == NULL)
14198         {
14199           error (_("%s: bad archive file name\n"), file_name);
14200           ret = 1;
14201           break;
14202         }
14203       namelen = strlen (name);
14204
14205       qualified_name = make_qualified_name (&arch, &nested_arch, name);
14206       if (qualified_name == NULL)
14207         {
14208           error (_("%s: bad archive file name\n"), file_name);
14209           ret = 1;
14210           break;
14211         }
14212
14213       if (is_thin_archive && arch.nested_member_origin == 0)
14214         {
14215           /* This is a proxy for an external member of a thin archive.  */
14216           FILE * member_file;
14217           char * member_file_name = adjust_relative_path (file_name, name, namelen);
14218           if (member_file_name == NULL)
14219             {
14220               ret = 1;
14221               break;
14222             }
14223
14224           member_file = fopen (member_file_name, "rb");
14225           if (member_file == NULL)
14226             {
14227               error (_("Input file '%s' is not readable.\n"), member_file_name);
14228               free (member_file_name);
14229               ret = 1;
14230               break;
14231             }
14232
14233           archive_file_offset = arch.nested_member_origin;
14234
14235           ret |= process_object (qualified_name, member_file);
14236
14237           fclose (member_file);
14238           free (member_file_name);
14239         }
14240       else if (is_thin_archive)
14241         {
14242           /* PR 15140: Allow for corrupt thin archives.  */
14243           if (nested_arch.file == NULL)
14244             {
14245               error (_("%s: contains corrupt thin archive: %s\n"),
14246                      file_name, name);
14247               ret = 1;
14248               break;
14249             }
14250
14251           /* This is a proxy for a member of a nested archive.  */
14252           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
14253
14254           /* The nested archive file will have been opened and setup by
14255              get_archive_member_name.  */
14256           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
14257             {
14258               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
14259               ret = 1;
14260               break;
14261             }
14262
14263           ret |= process_object (qualified_name, nested_arch.file);
14264         }
14265       else
14266         {
14267           archive_file_offset = arch.next_arhdr_offset;
14268           arch.next_arhdr_offset += archive_file_size;
14269
14270           ret |= process_object (qualified_name, file);
14271         }
14272
14273       if (dump_sects != NULL)
14274         {
14275           free (dump_sects);
14276           dump_sects = NULL;
14277           num_dump_sects = 0;
14278         }
14279
14280       free (qualified_name);
14281     }
14282
14283  out:
14284   if (nested_arch.file != NULL)
14285     fclose (nested_arch.file);
14286   release_archive (&nested_arch);
14287   release_archive (&arch);
14288
14289   return ret;
14290 }
14291
14292 static int
14293 process_file (char * file_name)
14294 {
14295   FILE * file;
14296   struct stat statbuf;
14297   char armag[SARMAG];
14298   int ret;
14299
14300   if (stat (file_name, &statbuf) < 0)
14301     {
14302       if (errno == ENOENT)
14303         error (_("'%s': No such file\n"), file_name);
14304       else
14305         error (_("Could not locate '%s'.  System error message: %s\n"),
14306                file_name, strerror (errno));
14307       return 1;
14308     }
14309
14310   if (! S_ISREG (statbuf.st_mode))
14311     {
14312       error (_("'%s' is not an ordinary file\n"), file_name);
14313       return 1;
14314     }
14315
14316   file = fopen (file_name, "rb");
14317   if (file == NULL)
14318     {
14319       error (_("Input file '%s' is not readable.\n"), file_name);
14320       return 1;
14321     }
14322
14323   if (fread (armag, SARMAG, 1, file) != 1)
14324     {
14325       error (_("%s: Failed to read file's magic number\n"), file_name);
14326       fclose (file);
14327       return 1;
14328     }
14329
14330   if (memcmp (armag, ARMAG, SARMAG) == 0)
14331     ret = process_archive (file_name, file, FALSE);
14332   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
14333     ret = process_archive (file_name, file, TRUE);
14334   else
14335     {
14336       if (do_archive_index)
14337         error (_("File %s is not an archive so its index cannot be displayed.\n"),
14338                file_name);
14339
14340       rewind (file);
14341       archive_file_size = archive_file_offset = 0;
14342       ret = process_object (file_name, file);
14343     }
14344
14345   fclose (file);
14346
14347   return ret;
14348 }
14349
14350 #ifdef SUPPORT_DISASSEMBLY
14351 /* Needed by the i386 disassembler.  For extra credit, someone could
14352    fix this so that we insert symbolic addresses here, esp for GOT/PLT
14353    symbols.  */
14354
14355 void
14356 print_address (unsigned int addr, FILE * outfile)
14357 {
14358   fprintf (outfile,"0x%8.8x", addr);
14359 }
14360
14361 /* Needed by the i386 disassembler.  */
14362 void
14363 db_task_printsym (unsigned int addr)
14364 {
14365   print_address (addr, stderr);
14366 }
14367 #endif
14368
14369 int
14370 main (int argc, char ** argv)
14371 {
14372   int err;
14373
14374 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14375   setlocale (LC_MESSAGES, "");
14376 #endif
14377 #if defined (HAVE_SETLOCALE)
14378   setlocale (LC_CTYPE, "");
14379 #endif
14380   bindtextdomain (PACKAGE, LOCALEDIR);
14381   textdomain (PACKAGE);
14382
14383   expandargv (&argc, &argv);
14384
14385   parse_args (argc, argv);
14386
14387   if (num_dump_sects > 0)
14388     {
14389       /* Make a copy of the dump_sects array.  */
14390       cmdline_dump_sects = (dump_type *)
14391           malloc (num_dump_sects * sizeof (* dump_sects));
14392       if (cmdline_dump_sects == NULL)
14393         error (_("Out of memory allocating dump request table.\n"));
14394       else
14395         {
14396           memcpy (cmdline_dump_sects, dump_sects,
14397                   num_dump_sects * sizeof (* dump_sects));
14398           num_cmdline_dump_sects = num_dump_sects;
14399         }
14400     }
14401
14402   if (optind < (argc - 1))
14403     show_name = 1;
14404
14405   err = 0;
14406   while (optind < argc)
14407     err |= process_file (argv[optind++]);
14408
14409   if (dump_sects != NULL)
14410     free (dump_sects);
14411   if (cmdline_dump_sects != NULL)
14412     free (cmdline_dump_sects);
14413
14414   return err;
14415 }