binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright 1998-2013 Free Software Foundation, Inc.
   3
   4    Originally developed by Eric Youngdale <eric@andante.jic.com>
   5    Modifications by Nick Clifton <nickc@redhat.com>
   6
   7    This file is part of GNU Binutils.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  22    02110-1301, USA.  */
  23 \f
  24 /* The difference between readelf and objdump:
  25
  26   Both programs are capable of displaying the contents of ELF format files,
  27   so why does the binutils project have two file dumpers ?
  28
  29   The reason is that objdump sees an ELF file through a BFD filter of the
  30   world; if BFD has a bug where, say, it disagrees about a machine constant
  31   in e_flags, then the odds are good that it will remain internally
  32   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
  33   GAS sees it the BFD way.  There was need for a tool to go find out what
  34   the file actually says.
  35
  36   This is why the readelf program does not link against the BFD library - it
  37   exists as an independent program to help verify the correct working of BFD.
  38
  39   There is also the case that readelf can provide more information about an
  40   ELF file than is provided by objdump.  In particular it can display DWARF
  41   debugging information which (at the moment) objdump cannot.  */
  42 \f
  43 #include "sysdep.h"
  44 #include <assert.h>
  45 #include <time.h>
  46 #ifdef HAVE_ZLIB_H
  47 #include <zlib.h>
  48 #endif
  49 #ifdef HAVE_WCHAR_H
  50 #include <wchar.h>
  51 #endif
  52
  53 #if __GNUC__ >= 2
  54 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  55    as this will allow us to read in and parse 64bit and 32bit ELF files.
  56    Only do this if we believe that the compiler can support a 64 bit
  57    data type.  For now we only rely on GCC being able to do this.  */
  58 #define BFD64
  59 #endif
  60
  61 #include "bfd.h"
  62 #include "bucomm.h"
  63 #include "elfcomm.h"
  64 #include "dwarf.h"
  65
  66 #include "elf/common.h"
  67 #include "elf/external.h"
  68 #include "elf/internal.h"
  69
  70
  71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  72    we can obtain the H8 reloc numbers.  We need these for the
  73    get_reloc_size() function.  We include h8.h again after defining
  74    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  75
  76 #include "elf/h8.h"
  77 #undef _ELF_H8_H
  78
  79 /* Undo the effects of #including reloc-macros.h.  */
  80
  81 #undef START_RELOC_NUMBERS
  82 #undef RELOC_NUMBER
  83 #undef FAKE_RELOC
  84 #undef EMPTY_RELOC
  85 #undef END_RELOC_NUMBERS
  86 #undef _RELOC_MACROS_H
  87
  88 /* The following headers use the elf/reloc-macros.h file to
  89    automatically generate relocation recognition functions
  90    such as elf_mips_reloc_type()  */
  91
  92 #define RELOC_MACROS_GEN_FUNC
  93
  94 #include "elf/aarch64.h"
  95 #include "elf/alpha.h"
  96 #include "elf/arc.h"
  97 #include "elf/arm.h"
  98 #include "elf/avr.h"
  99 #include "elf/bfin.h"
 100 #include "elf/cr16.h"
 101 #include "elf/cris.h"
 102 #include "elf/crx.h"
 103 #include "elf/d10v.h"
 104 #include "elf/d30v.h"
 105 #include "elf/dlx.h"
 106 #include "elf/epiphany.h"
 107 #include "elf/fr30.h"
 108 #include "elf/frv.h"
 109 #include "elf/h8.h"
 110 #include "elf/hppa.h"
 111 #include "elf/i386.h"
 112 #include "elf/i370.h"
 113 #include "elf/i860.h"
 114 #include "elf/i960.h"
 115 #include "elf/ia64.h"
 116 #include "elf/ip2k.h"
 117 #include "elf/lm32.h"
 118 #include "elf/iq2000.h"
 119 #include "elf/m32c.h"
 120 #include "elf/m32r.h"
 121 #include "elf/m68k.h"
 122 #include "elf/m68hc11.h"
 123 #include "elf/mcore.h"
 124 #include "elf/mep.h"
 125 #include "elf/metag.h"
 126 #include "elf/microblaze.h"
 127 #include "elf/mips.h"
 128 #include "elf/mmix.h"
 129 #include "elf/mn10200.h"
 130 #include "elf/mn10300.h"
 131 #include "elf/moxie.h"
 132 #include "elf/mt.h"
 133 #include "elf/msp430.h"
 134 #include "elf/nios2.h"
 135 #include "elf/or32.h"
 136 #include "elf/pj.h"
 137 #include "elf/ppc.h"
 138 #include "elf/ppc64.h"
 139 #include "elf/rl78.h"
 140 #include "elf/rx.h"
 141 #include "elf/s390.h"
 142 #include "elf/score.h"
 143 #include "elf/sh.h"
 144 #include "elf/sparc.h"
 145 #include "elf/spu.h"
 146 #include "elf/tic6x.h"
 147 #include "elf/tilegx.h"
 148 #include "elf/tilepro.h"
 149 #include "elf/v850.h"
 150 #include "elf/vax.h"
 151 #include "elf/x86-64.h"
 152 #include "elf/xc16x.h"
 153 #include "elf/xgate.h"
 154 #include "elf/xstormy16.h"
 155 #include "elf/xtensa.h"
 156
 157 #include "getopt.h"
 158 #include "libiberty.h"
 159 #include "safe-ctype.h"
 160 #include "filenames.h"
 161
 162 #ifndef offsetof
 163 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 164 #endif
 165
 166 char * program_name = "readelf";
 167 static long archive_file_offset;
 168 static unsigned long archive_file_size;
 169 static unsigned long dynamic_addr;
 170 static bfd_size_type dynamic_size;
 171 static unsigned int dynamic_nent;
 172 static char * dynamic_strings;
 173 static unsigned long dynamic_strings_length;
 174 static char * string_table;
 175 static unsigned long string_table_length;
 176 static unsigned long num_dynamic_syms;
 177 static Elf_Internal_Sym * dynamic_symbols;
 178 static Elf_Internal_Syminfo * dynamic_syminfo;
 179 static unsigned long dynamic_syminfo_offset;
 180 static unsigned int dynamic_syminfo_nent;
 181 static char program_interpreter[PATH_MAX];
 182 static bfd_vma dynamic_info[DT_ENCODING];
 183 static bfd_vma dynamic_info_DT_GNU_HASH;
 184 static bfd_vma version_info[16];
 185 static Elf_Internal_Ehdr elf_header;
 186 static Elf_Internal_Shdr * section_headers;
 187 static Elf_Internal_Phdr * program_headers;
 188 static Elf_Internal_Dyn *  dynamic_section;
 189 static Elf_Internal_Shdr * symtab_shndx_hdr;
 190 static int show_name;
 191 static int do_dynamic;
 192 static int do_syms;
 193 static int do_dyn_syms;
 194 static int do_reloc;
 195 static int do_sections;
 196 static int do_section_groups;
 197 static int do_section_details;
 198 static int do_segments;
 199 static int do_unwind;
 200 static int do_using_dynamic;
 201 static int do_header;
 202 static int do_dump;
 203 static int do_version;
 204 static int do_histogram;
 205 static int do_debugging;
 206 static int do_arch;
 207 static int do_notes;
 208 static int do_archive_index;
 209 static int is_32bit_elf;
 210
 211 struct group_list
 212 {
 213   struct group_list * next;
 214   unsigned int section_index;
 215 };
 216
 217 struct group
 218 {
 219   struct group_list * root;
 220   unsigned int group_index;
 221 };
 222
 223 static size_t group_count;
 224 static struct group * section_groups;
 225 static struct group ** section_headers_groups;
 226
 227
 228 /* Flag bits indicating particular types of dump.  */
 229 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 230 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 231 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 232 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 233 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 234
 235 typedef unsigned char dump_type;
 236
 237 /* A linked list of the section names for which dumps were requested.  */
 238 struct dump_list_entry
 239 {
 240   char * name;
 241   dump_type type;
 242   struct dump_list_entry * next;
 243 };
 244 static struct dump_list_entry * dump_sects_byname;
 245
 246 /* A dynamic array of flags indicating for which sections a dump
 247    has been requested via command line switches.  */
 248 static dump_type *   cmdline_dump_sects = NULL;
 249 static unsigned int  num_cmdline_dump_sects = 0;
 250
 251 /* A dynamic array of flags indicating for which sections a dump of
 252    some kind has been requested.  It is reset on a per-object file
 253    basis and then initialised from the cmdline_dump_sects array,
 254    the results of interpreting the -w switch, and the
 255    dump_sects_byname list.  */
 256 static dump_type *   dump_sects = NULL;
 257 static unsigned int  num_dump_sects = 0;
 258
 259
 260 /* How to print a vma value.  */
 261 typedef enum print_mode
 262 {
 263   HEX,
 264   DEC,
 265   DEC_5,
 266   UNSIGNED,
 267   PREFIX_HEX,
 268   FULL_HEX,
 269   LONG_HEX
 270 }
 271 print_mode;
 272
 273 #define UNKNOWN -1
 274
 275 #define SECTION_NAME(X)                                         \
 276   ((X) == NULL ? _("<none>")                                    \
 277    : string_table == NULL ? _("<no-name>")                      \
 278    : ((X)->sh_name >= string_table_length ? _("<corrupt>")      \
 279   : string_table + (X)->sh_name))
 280
 281 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 282
 283 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 284   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 285    : get_64bit_elf_symbols (file, section, sym_count))
 286
 287 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 288 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 289    already been called and verified that the string exists.  */
 290 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 291
 292 #define REMOVE_ARCH_BITS(ADDR)                  \
 293   do                                            \
 294     {                                           \
 295       if (elf_header.e_machine == EM_ARM)       \
 296         (ADDR) &= ~1;                           \
 297     }                                           \
 298   while (0)
 299 \f
 300 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
 301    Put the retrieved data into VAR, if it is not NULL.  Otherwise allocate a buffer
 302    using malloc and fill that.  In either case return the pointer to the start of
 303    the retrieved data or NULL if something went wrong.  If something does go wrong
 304    emit an error message using REASON as part of the context.  */
 305
 306 static void *
 307 get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
 308           const char * reason)
 309 {
 310   void * mvar;
 311
 312   if (size == 0 || nmemb == 0)
 313     return NULL;
 314
 315   if (fseek (file, archive_file_offset + offset, SEEK_SET))
 316     {
 317       error (_("Unable to seek to 0x%lx for %s\n"),
 318              (unsigned long) archive_file_offset + offset, reason);
 319       return NULL;
 320     }
 321
 322   mvar = var;
 323   if (mvar == NULL)
 324     {
 325       /* Check for overflow.  */
 326       if (nmemb < (~(size_t) 0 - 1) / size)
 327         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 328         mvar = malloc (size * nmemb + 1);
 329
 330       if (mvar == NULL)
 331         {
 332           error (_("Out of memory allocating 0x%lx bytes for %s\n"),
 333                  (unsigned long)(size * nmemb), reason);
 334           return NULL;
 335         }
 336
 337       ((char *) mvar)[size * nmemb] = '\0';
 338     }
 339
 340   if (fread (mvar, size, nmemb, file) != nmemb)
 341     {
 342       error (_("Unable to read in 0x%lx bytes of %s\n"),
 343              (unsigned long)(size * nmemb), reason);
 344       if (mvar != var)
 345         free (mvar);
 346       return NULL;
 347     }
 348
 349   return mvar;
 350 }
 351
 352 /* Print a VMA value.  */
 353
 354 static int
 355 print_vma (bfd_vma vma, print_mode mode)
 356 {
 357   int nc = 0;
 358
 359   switch (mode)
 360     {
 361     case FULL_HEX:
 362       nc = printf ("0x");
 363       /* Drop through.  */
 364
 365     case LONG_HEX:
 366 #ifdef BFD64
 367       if (is_32bit_elf)
 368         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 369 #endif
 370       printf_vma (vma);
 371       return nc + 16;
 372
 373     case DEC_5:
 374       if (vma <= 99999)
 375         return printf ("%5" BFD_VMA_FMT "d", vma);
 376       /* Drop through.  */
 377
 378     case PREFIX_HEX:
 379       nc = printf ("0x");
 380       /* Drop through.  */
 381
 382     case HEX:
 383       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 384
 385     case DEC:
 386       return printf ("%" BFD_VMA_FMT "d", vma);
 387
 388     case UNSIGNED:
 389       return printf ("%" BFD_VMA_FMT "u", vma);
 390     }
 391   return 0;
 392 }
 393
 394 /* Display a symbol on stdout.  Handles the display of control characters and
 395    multibye characters (assuming the host environment supports them).
 396
 397    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 398
 399    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 400    padding as necessary.
 401
 402    Returns the number of emitted characters.  */
 403
 404 static unsigned int
 405 print_symbol (int width, const char *symbol)
 406 {
 407   bfd_boolean extra_padding = FALSE;
 408   int num_printed = 0;
 409 #ifdef HAVE_MBSTATE_T
 410   mbstate_t state;
 411 #endif
 412   int width_remaining;
 413
 414   if (width < 0)
 415     {
 416       /* Keep the width positive.  This also helps.  */
 417       width = - width;
 418       extra_padding = TRUE;
 419     }
 420
 421   if (do_wide)
 422     /* Set the remaining width to a very large value.
 423        This simplifies the code below.  */
 424     width_remaining = INT_MAX;
 425   else
 426     width_remaining = width;
 427
 428 #ifdef HAVE_MBSTATE_T
 429   /* Initialise the multibyte conversion state.  */
 430   memset (& state, 0, sizeof (state));
 431 #endif
 432
 433   while (width_remaining)
 434     {
 435       size_t  n;
 436       const char c = *symbol++;
 437
 438       if (c == 0)
 439         break;
 440
 441       /* Do not print control characters directly as they can affect terminal
 442          settings.  Such characters usually appear in the names generated
 443          by the assembler for local labels.  */
 444       if (ISCNTRL (c))
 445         {
 446           if (width_remaining < 2)
 447             break;
 448
 449           printf ("^%c", c + 0x40);
 450           width_remaining -= 2;
 451           num_printed += 2;
 452         }
 453       else if (ISPRINT (c))
 454         {
 455           putchar (c);
 456           width_remaining --;
 457           num_printed ++;
 458         }
 459       else
 460         {
 461 #ifdef HAVE_MBSTATE_T
 462           wchar_t w;
 463 #endif
 464           /* Let printf do the hard work of displaying multibyte characters.  */
 465           printf ("%.1s", symbol - 1);
 466           width_remaining --;
 467           num_printed ++;
 468
 469 #ifdef HAVE_MBSTATE_T
 470           /* Try to find out how many bytes made up the character that was
 471              just printed.  Advance the symbol pointer past the bytes that
 472              were displayed.  */
 473           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 474 #else
 475           n = 1;
 476 #endif
 477           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 478             symbol += (n - 1);
 479         }
 480     }
 481
 482   if (extra_padding && num_printed < width)
 483     {
 484       /* Fill in the remaining spaces.  */
 485       printf ("%-*s", width - num_printed, " ");
 486       num_printed = width;
 487     }
 488
 489   return num_printed;
 490 }
 491
 492 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 493
 494 static Elf_Internal_Shdr *
 495 find_section (const char * name)
 496 {
 497   unsigned int i;
 498
 499   for (i = 0; i < elf_header.e_shnum; i++)
 500     if (streq (SECTION_NAME (section_headers + i), name))
 501       return section_headers + i;
 502
 503   return NULL;
 504 }
 505
 506 /* Return a pointer to a section containing ADDR, or NULL if no such
 507    section exists.  */
 508
 509 static Elf_Internal_Shdr *
 510 find_section_by_address (bfd_vma addr)
 511 {
 512   unsigned int i;
 513
 514   for (i = 0; i < elf_header.e_shnum; i++)
 515     {
 516       Elf_Internal_Shdr *sec = section_headers + i;
 517       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 518         return sec;
 519     }
 520
 521   return NULL;
 522 }
 523
 524 /* Return a pointer to section NAME, or NULL if no such section exists,
 525    restricted to the list of sections given in SET.  */
 526
 527 static Elf_Internal_Shdr *
 528 find_section_in_set (const char * name, unsigned int * set)
 529 {
 530   unsigned int i;
 531
 532   if (set != NULL)
 533     {
 534       while ((i = *set++) > 0)
 535         if (streq (SECTION_NAME (section_headers + i), name))
 536           return section_headers + i;
 537     }
 538
 539   return find_section (name);
 540 }
 541
 542 /* Read an unsigned LEB128 encoded value from p.  Set *PLEN to the number of
 543    bytes read.  */
 544
 545 static inline unsigned long
 546 read_uleb128 (unsigned char *data,
 547               unsigned int *length_return,
 548               const unsigned char * const end)
 549 {
 550   return read_leb128 (data, length_return, FALSE, end);
 551 }
 552
 553 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
 554    This OS has so many departures from the ELF standard that we test it at
 555    many places.  */
 556
 557 static inline int
 558 is_ia64_vms (void)
 559 {
 560   return elf_header.e_machine == EM_IA_64
 561     && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 562 }
 563
 564 /* Guess the relocation size commonly used by the specific machines.  */
 565
 566 static int
 567 guess_is_rela (unsigned int e_machine)
 568 {
 569   switch (e_machine)
 570     {
 571       /* Targets that use REL relocations.  */
 572     case EM_386:
 573     case EM_486:
 574     case EM_960:
 575     case EM_ARM:
 576     case EM_D10V:
 577     case EM_CYGNUS_D10V:
 578     case EM_DLX:
 579     case EM_MIPS:
 580     case EM_MIPS_RS3_LE:
 581     case EM_CYGNUS_M32R:
 582     case EM_OPENRISC:
 583     case EM_OR32:
 584     case EM_SCORE:
 585     case EM_XGATE:
 586       return FALSE;
 587
 588       /* Targets that use RELA relocations.  */
 589     case EM_68K:
 590     case EM_860:
 591     case EM_AARCH64:
 592     case EM_ADAPTEVA_EPIPHANY:
 593     case EM_ALPHA:
 594     case EM_ALTERA_NIOS2:
 595     case EM_AVR:
 596     case EM_AVR_OLD:
 597     case EM_BLACKFIN:
 598     case EM_CR16:
 599     case EM_CRIS:
 600     case EM_CRX:
 601     case EM_D30V:
 602     case EM_CYGNUS_D30V:
 603     case EM_FR30:
 604     case EM_CYGNUS_FR30:
 605     case EM_CYGNUS_FRV:
 606     case EM_H8S:
 607     case EM_H8_300:
 608     case EM_H8_300H:
 609     case EM_IA_64:
 610     case EM_IP2K:
 611     case EM_IP2K_OLD:
 612     case EM_IQ2000:
 613     case EM_LATTICEMICO32:
 614     case EM_M32C_OLD:
 615     case EM_M32C:
 616     case EM_M32R:
 617     case EM_MCORE:
 618     case EM_CYGNUS_MEP:
 619     case EM_METAG:
 620     case EM_MMIX:
 621     case EM_MN10200:
 622     case EM_CYGNUS_MN10200:
 623     case EM_MN10300:
 624     case EM_CYGNUS_MN10300:
 625     case EM_MOXIE:
 626     case EM_MSP430:
 627     case EM_MSP430_OLD:
 628     case EM_MT:
 629     case EM_NIOS32:
 630     case EM_PPC64:
 631     case EM_PPC:
 632     case EM_RL78:
 633     case EM_RX:
 634     case EM_S390:
 635     case EM_S390_OLD:
 636     case EM_SH:
 637     case EM_SPARC:
 638     case EM_SPARC32PLUS:
 639     case EM_SPARCV9:
 640     case EM_SPU:
 641     case EM_TI_C6000:
 642     case EM_TILEGX:
 643     case EM_TILEPRO:
 644     case EM_V800:
 645     case EM_V850:
 646     case EM_CYGNUS_V850:
 647     case EM_VAX:
 648     case EM_X86_64:
 649     case EM_L1OM:
 650     case EM_K1OM:
 651     case EM_XSTORMY16:
 652     case EM_XTENSA:
 653     case EM_XTENSA_OLD:
 654     case EM_MICROBLAZE:
 655     case EM_MICROBLAZE_OLD:
 656       return TRUE;
 657
 658     case EM_68HC05:
 659     case EM_68HC08:
 660     case EM_68HC11:
 661     case EM_68HC16:
 662     case EM_FX66:
 663     case EM_ME16:
 664     case EM_MMA:
 665     case EM_NCPU:
 666     case EM_NDR1:
 667     case EM_PCP:
 668     case EM_ST100:
 669     case EM_ST19:
 670     case EM_ST7:
 671     case EM_ST9PLUS:
 672     case EM_STARCORE:
 673     case EM_SVX:
 674     case EM_TINYJ:
 675     default:
 676       warn (_("Don't know about relocations on this machine architecture\n"));
 677       return FALSE;
 678     }
 679 }
 680
 681 static int
 682 slurp_rela_relocs (FILE * file,
 683                    unsigned long rel_offset,
 684                    unsigned long rel_size,
 685                    Elf_Internal_Rela ** relasp,
 686                    unsigned long * nrelasp)
 687 {
 688   Elf_Internal_Rela * relas;
 689   unsigned long nrelas;
 690   unsigned int i;
 691
 692   if (is_32bit_elf)
 693     {
 694       Elf32_External_Rela * erelas;
 695
 696       erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
 697                                                  rel_size, _("32-bit relocation data"));
 698       if (!erelas)
 699         return 0;
 700
 701       nrelas = rel_size / sizeof (Elf32_External_Rela);
 702
 703       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 704                                              sizeof (Elf_Internal_Rela));
 705
 706       if (relas == NULL)
 707         {
 708           free (erelas);
 709           error (_("out of memory parsing relocs\n"));
 710           return 0;
 711         }
 712
 713       for (i = 0; i < nrelas; i++)
 714         {
 715           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 716           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 717           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 718         }
 719
 720       free (erelas);
 721     }
 722   else
 723     {
 724       Elf64_External_Rela * erelas;
 725
 726       erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
 727                                                  rel_size, _("64-bit relocation data"));
 728       if (!erelas)
 729         return 0;
 730
 731       nrelas = rel_size / sizeof (Elf64_External_Rela);
 732
 733       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 734                                              sizeof (Elf_Internal_Rela));
 735
 736       if (relas == NULL)
 737         {
 738           free (erelas);
 739           error (_("out of memory parsing relocs\n"));
 740           return 0;
 741         }
 742
 743       for (i = 0; i < nrelas; i++)
 744         {
 745           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 746           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 747           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 748
 749           /* The #ifdef BFD64 below is to prevent a compile time
 750              warning.  We know that if we do not have a 64 bit data
 751              type that we will never execute this code anyway.  */
 752 #ifdef BFD64
 753           if (elf_header.e_machine == EM_MIPS
 754               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 755             {
 756               /* In little-endian objects, r_info isn't really a
 757                  64-bit little-endian value: it has a 32-bit
 758                  little-endian symbol index followed by four
 759                  individual byte fields.  Reorder INFO
 760                  accordingly.  */
 761               bfd_vma inf = relas[i].r_info;
 762               inf = (((inf & 0xffffffff) << 32)
 763                       | ((inf >> 56) & 0xff)
 764                       | ((inf >> 40) & 0xff00)
 765                       | ((inf >> 24) & 0xff0000)
 766                       | ((inf >> 8) & 0xff000000));
 767               relas[i].r_info = inf;
 768             }
 769 #endif /* BFD64 */
 770         }
 771
 772       free (erelas);
 773     }
 774   *relasp = relas;
 775   *nrelasp = nrelas;
 776   return 1;
 777 }
 778
 779 static int
 780 slurp_rel_relocs (FILE * file,
 781                   unsigned long rel_offset,
 782                   unsigned long rel_size,
 783                   Elf_Internal_Rela ** relsp,
 784                   unsigned long * nrelsp)
 785 {
 786   Elf_Internal_Rela * rels;
 787   unsigned long nrels;
 788   unsigned int i;
 789
 790   if (is_32bit_elf)
 791     {
 792       Elf32_External_Rel * erels;
 793
 794       erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
 795                                                rel_size, _("32-bit relocation data"));
 796       if (!erels)
 797         return 0;
 798
 799       nrels = rel_size / sizeof (Elf32_External_Rel);
 800
 801       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 802
 803       if (rels == NULL)
 804         {
 805           free (erels);
 806           error (_("out of memory parsing relocs\n"));
 807           return 0;
 808         }
 809
 810       for (i = 0; i < nrels; i++)
 811         {
 812           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 813           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 814           rels[i].r_addend = 0;
 815         }
 816
 817       free (erels);
 818     }
 819   else
 820     {
 821       Elf64_External_Rel * erels;
 822
 823       erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
 824                                                rel_size, _("64-bit relocation data"));
 825       if (!erels)
 826         return 0;
 827
 828       nrels = rel_size / sizeof (Elf64_External_Rel);
 829
 830       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 831
 832       if (rels == NULL)
 833         {
 834           free (erels);
 835           error (_("out of memory parsing relocs\n"));
 836           return 0;
 837         }
 838
 839       for (i = 0; i < nrels; i++)
 840         {
 841           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 842           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 843           rels[i].r_addend = 0;
 844
 845           /* The #ifdef BFD64 below is to prevent a compile time
 846              warning.  We know that if we do not have a 64 bit data
 847              type that we will never execute this code anyway.  */
 848 #ifdef BFD64
 849           if (elf_header.e_machine == EM_MIPS
 850               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 851             {
 852               /* In little-endian objects, r_info isn't really a
 853                  64-bit little-endian value: it has a 32-bit
 854                  little-endian symbol index followed by four
 855                  individual byte fields.  Reorder INFO
 856                  accordingly.  */
 857               bfd_vma inf = rels[i].r_info;
 858               inf = (((inf & 0xffffffff) << 32)
 859                      | ((inf >> 56) & 0xff)
 860                      | ((inf >> 40) & 0xff00)
 861                      | ((inf >> 24) & 0xff0000)
 862                      | ((inf >> 8) & 0xff000000));
 863               rels[i].r_info = inf;
 864             }
 865 #endif /* BFD64 */
 866         }
 867
 868       free (erels);
 869     }
 870   *relsp = rels;
 871   *nrelsp = nrels;
 872   return 1;
 873 }
 874
 875 /* Returns the reloc type extracted from the reloc info field.  */
 876
 877 static unsigned int
 878 get_reloc_type (bfd_vma reloc_info)
 879 {
 880   if (is_32bit_elf)
 881     return ELF32_R_TYPE (reloc_info);
 882
 883   switch (elf_header.e_machine)
 884     {
 885     case EM_MIPS:
 886       /* Note: We assume that reloc_info has already been adjusted for us.  */
 887       return ELF64_MIPS_R_TYPE (reloc_info);
 888
 889     case EM_SPARCV9:
 890       return ELF64_R_TYPE_ID (reloc_info);
 891
 892     default:
 893       return ELF64_R_TYPE (reloc_info);
 894     }
 895 }
 896
 897 /* Return the symbol index extracted from the reloc info field.  */
 898
 899 static bfd_vma
 900 get_reloc_symindex (bfd_vma reloc_info)
 901 {
 902   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
 903 }
 904
 905 static inline bfd_boolean
 906 uses_msp430x_relocs (void)
 907 {
 908   return
 909     elf_header.e_machine == EM_MSP430 /* Paranoia.  */
 910     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
 911     && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
 912         /* TI compiler uses ELFOSABI_NONE.  */
 913         || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
 914 }
 915
 916 /* Display the contents of the relocation data found at the specified
 917    offset.  */
 918
 919 static void
 920 dump_relocations (FILE * file,
 921                   unsigned long rel_offset,
 922                   unsigned long rel_size,
 923                   Elf_Internal_Sym * symtab,
 924                   unsigned long nsyms,
 925                   char * strtab,
 926                   unsigned long strtablen,
 927                   int is_rela)
 928 {
 929   unsigned int i;
 930   Elf_Internal_Rela * rels;
 931
 932   if (is_rela == UNKNOWN)
 933     is_rela = guess_is_rela (elf_header.e_machine);
 934
 935   if (is_rela)
 936     {
 937       if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
 938         return;
 939     }
 940   else
 941     {
 942       if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
 943         return;
 944     }
 945
 946   if (is_32bit_elf)
 947     {
 948       if (is_rela)
 949         {
 950           if (do_wide)
 951             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
 952           else
 953             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
 954         }
 955       else
 956         {
 957           if (do_wide)
 958             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
 959           else
 960             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
 961         }
 962     }
 963   else
 964     {
 965       if (is_rela)
 966         {
 967           if (do_wide)
 968             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
 969           else
 970             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
 971         }
 972       else
 973         {
 974           if (do_wide)
 975             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
 976           else
 977             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
 978         }
 979     }
 980
 981   for (i = 0; i < rel_size; i++)
 982     {
 983       const char * rtype;
 984       bfd_vma offset;
 985       bfd_vma inf;
 986       bfd_vma symtab_index;
 987       bfd_vma type;
 988
 989       offset = rels[i].r_offset;
 990       inf    = rels[i].r_info;
 991
 992       type = get_reloc_type (inf);
 993       symtab_index = get_reloc_symindex  (inf);
 994
 995       if (is_32bit_elf)
 996         {
 997           printf ("%8.8lx  %8.8lx ",
 998                   (unsigned long) offset & 0xffffffff,
 999                   (unsigned long) inf & 0xffffffff);
1000         }
1001       else
1002         {
1003 #if BFD_HOST_64BIT_LONG
1004           printf (do_wide
1005                   ? "%16.16lx  %16.16lx "
1006                   : "%12.12lx  %12.12lx ",
1007                   offset, inf);
1008 #elif BFD_HOST_64BIT_LONG_LONG
1009 #ifndef __MSVCRT__
1010           printf (do_wide
1011                   ? "%16.16llx  %16.16llx "
1012                   : "%12.12llx  %12.12llx ",
1013                   offset, inf);
1014 #else
1015           printf (do_wide
1016                   ? "%16.16I64x  %16.16I64x "
1017                   : "%12.12I64x  %12.12I64x ",
1018                   offset, inf);
1019 #endif
1020 #else
1021           printf (do_wide
1022                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1023                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1024                   _bfd_int64_high (offset),
1025                   _bfd_int64_low (offset),
1026                   _bfd_int64_high (inf),
1027                   _bfd_int64_low (inf));
1028 #endif
1029         }
1030
1031       switch (elf_header.e_machine)
1032         {
1033         default:
1034           rtype = NULL;
1035           break;
1036
1037         case EM_AARCH64:
1038           rtype = elf_aarch64_reloc_type (type);
1039           break;
1040
1041         case EM_M32R:
1042         case EM_CYGNUS_M32R:
1043           rtype = elf_m32r_reloc_type (type);
1044           break;
1045
1046         case EM_386:
1047         case EM_486:
1048           rtype = elf_i386_reloc_type (type);
1049           break;
1050
1051         case EM_68HC11:
1052         case EM_68HC12:
1053           rtype = elf_m68hc11_reloc_type (type);
1054           break;
1055
1056         case EM_68K:
1057           rtype = elf_m68k_reloc_type (type);
1058           break;
1059
1060         case EM_960:
1061           rtype = elf_i960_reloc_type (type);
1062           break;
1063
1064         case EM_AVR:
1065         case EM_AVR_OLD:
1066           rtype = elf_avr_reloc_type (type);
1067           break;
1068
1069         case EM_OLD_SPARCV9:
1070         case EM_SPARC32PLUS:
1071         case EM_SPARCV9:
1072         case EM_SPARC:
1073           rtype = elf_sparc_reloc_type (type);
1074           break;
1075
1076         case EM_SPU:
1077           rtype = elf_spu_reloc_type (type);
1078           break;
1079
1080         case EM_V800:
1081           rtype = v800_reloc_type (type);
1082           break;
1083         case EM_V850:
1084         case EM_CYGNUS_V850:
1085           rtype = v850_reloc_type (type);
1086           break;
1087
1088         case EM_D10V:
1089         case EM_CYGNUS_D10V:
1090           rtype = elf_d10v_reloc_type (type);
1091           break;
1092
1093         case EM_D30V:
1094         case EM_CYGNUS_D30V:
1095           rtype = elf_d30v_reloc_type (type);
1096           break;
1097
1098         case EM_DLX:
1099           rtype = elf_dlx_reloc_type (type);
1100           break;
1101
1102         case EM_SH:
1103           rtype = elf_sh_reloc_type (type);
1104           break;
1105
1106         case EM_MN10300:
1107         case EM_CYGNUS_MN10300:
1108           rtype = elf_mn10300_reloc_type (type);
1109           break;
1110
1111         case EM_MN10200:
1112         case EM_CYGNUS_MN10200:
1113           rtype = elf_mn10200_reloc_type (type);
1114           break;
1115
1116         case EM_FR30:
1117         case EM_CYGNUS_FR30:
1118           rtype = elf_fr30_reloc_type (type);
1119           break;
1120
1121         case EM_CYGNUS_FRV:
1122           rtype = elf_frv_reloc_type (type);
1123           break;
1124
1125         case EM_MCORE:
1126           rtype = elf_mcore_reloc_type (type);
1127           break;
1128
1129         case EM_MMIX:
1130           rtype = elf_mmix_reloc_type (type);
1131           break;
1132
1133         case EM_MOXIE:
1134           rtype = elf_moxie_reloc_type (type);
1135           break;
1136
1137         case EM_MSP430:
1138           if (uses_msp430x_relocs ())
1139             {
1140               rtype = elf_msp430x_reloc_type (type);
1141               break;
1142             }
1143         case EM_MSP430_OLD:
1144           rtype = elf_msp430_reloc_type (type);
1145           break;
1146
1147         case EM_PPC:
1148           rtype = elf_ppc_reloc_type (type);
1149           break;
1150
1151         case EM_PPC64:
1152           rtype = elf_ppc64_reloc_type (type);
1153           break;
1154
1155         case EM_MIPS:
1156         case EM_MIPS_RS3_LE:
1157           rtype = elf_mips_reloc_type (type);
1158           break;
1159
1160         case EM_ALPHA:
1161           rtype = elf_alpha_reloc_type (type);
1162           break;
1163
1164         case EM_ARM:
1165           rtype = elf_arm_reloc_type (type);
1166           break;
1167
1168         case EM_ARC:
1169           rtype = elf_arc_reloc_type (type);
1170           break;
1171
1172         case EM_PARISC:
1173           rtype = elf_hppa_reloc_type (type);
1174           break;
1175
1176         case EM_H8_300:
1177         case EM_H8_300H:
1178         case EM_H8S:
1179           rtype = elf_h8_reloc_type (type);
1180           break;
1181
1182         case EM_OPENRISC:
1183         case EM_OR32:
1184           rtype = elf_or32_reloc_type (type);
1185           break;
1186
1187         case EM_PJ:
1188         case EM_PJ_OLD:
1189           rtype = elf_pj_reloc_type (type);
1190           break;
1191         case EM_IA_64:
1192           rtype = elf_ia64_reloc_type (type);
1193           break;
1194
1195         case EM_CRIS:
1196           rtype = elf_cris_reloc_type (type);
1197           break;
1198
1199         case EM_860:
1200           rtype = elf_i860_reloc_type (type);
1201           break;
1202
1203         case EM_X86_64:
1204         case EM_L1OM:
1205         case EM_K1OM:
1206           rtype = elf_x86_64_reloc_type (type);
1207           break;
1208
1209         case EM_S370:
1210           rtype = i370_reloc_type (type);
1211           break;
1212
1213         case EM_S390_OLD:
1214         case EM_S390:
1215           rtype = elf_s390_reloc_type (type);
1216           break;
1217
1218         case EM_SCORE:
1219           rtype = elf_score_reloc_type (type);
1220           break;
1221
1222         case EM_XSTORMY16:
1223           rtype = elf_xstormy16_reloc_type (type);
1224           break;
1225
1226         case EM_CRX:
1227           rtype = elf_crx_reloc_type (type);
1228           break;
1229
1230         case EM_VAX:
1231           rtype = elf_vax_reloc_type (type);
1232           break;
1233
1234         case EM_ADAPTEVA_EPIPHANY:
1235           rtype = elf_epiphany_reloc_type (type);
1236           break;
1237
1238         case EM_IP2K:
1239         case EM_IP2K_OLD:
1240           rtype = elf_ip2k_reloc_type (type);
1241           break;
1242
1243         case EM_IQ2000:
1244           rtype = elf_iq2000_reloc_type (type);
1245           break;
1246
1247         case EM_XTENSA_OLD:
1248         case EM_XTENSA:
1249           rtype = elf_xtensa_reloc_type (type);
1250           break;
1251
1252         case EM_LATTICEMICO32:
1253           rtype = elf_lm32_reloc_type (type);
1254           break;
1255
1256         case EM_M32C_OLD:
1257         case EM_M32C:
1258           rtype = elf_m32c_reloc_type (type);
1259           break;
1260
1261         case EM_MT:
1262           rtype = elf_mt_reloc_type (type);
1263           break;
1264
1265         case EM_BLACKFIN:
1266           rtype = elf_bfin_reloc_type (type);
1267           break;
1268
1269         case EM_CYGNUS_MEP:
1270           rtype = elf_mep_reloc_type (type);
1271           break;
1272
1273         case EM_CR16:
1274           rtype = elf_cr16_reloc_type (type);
1275           break;
1276
1277         case EM_MICROBLAZE:
1278         case EM_MICROBLAZE_OLD:
1279           rtype = elf_microblaze_reloc_type (type);
1280           break;
1281
1282         case EM_RL78:
1283           rtype = elf_rl78_reloc_type (type);
1284           break;
1285
1286         case EM_RX:
1287           rtype = elf_rx_reloc_type (type);
1288           break;
1289
1290         case EM_METAG:
1291           rtype = elf_metag_reloc_type (type);
1292           break;
1293
1294         case EM_XC16X:
1295         case EM_C166:
1296           rtype = elf_xc16x_reloc_type (type);
1297           break;
1298
1299         case EM_TI_C6000:
1300           rtype = elf_tic6x_reloc_type (type);
1301           break;
1302
1303         case EM_TILEGX:
1304           rtype = elf_tilegx_reloc_type (type);
1305           break;
1306
1307         case EM_TILEPRO:
1308           rtype = elf_tilepro_reloc_type (type);
1309           break;
1310
1311         case EM_XGATE:
1312           rtype = elf_xgate_reloc_type (type);
1313           break;
1314
1315         case EM_ALTERA_NIOS2:
1316           rtype = elf_nios2_reloc_type (type);
1317           break;
1318         }
1319
1320       if (rtype == NULL)
1321         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1322       else
1323         printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1324
1325       if (elf_header.e_machine == EM_ALPHA
1326           && rtype != NULL
1327           && streq (rtype, "R_ALPHA_LITUSE")
1328           && is_rela)
1329         {
1330           switch (rels[i].r_addend)
1331             {
1332             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1333             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1334             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1335             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1336             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1337             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1338             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1339             default: rtype = NULL;
1340             }
1341           if (rtype)
1342             printf (" (%s)", rtype);
1343           else
1344             {
1345               putchar (' ');
1346               printf (_("<unknown addend: %lx>"),
1347                       (unsigned long) rels[i].r_addend);
1348             }
1349         }
1350       else if (symtab_index)
1351         {
1352           if (symtab == NULL || symtab_index >= nsyms)
1353             printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1354           else
1355             {
1356               Elf_Internal_Sym * psym;
1357
1358               psym = symtab + symtab_index;
1359
1360               printf (" ");
1361
1362               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1363                 {
1364                   const char * name;
1365                   unsigned int len;
1366                   unsigned int width = is_32bit_elf ? 8 : 14;
1367
1368                   /* Relocations against GNU_IFUNC symbols do not use the value
1369                      of the symbol as the address to relocate against.  Instead
1370                      they invoke the function named by the symbol and use its
1371                      result as the address for relocation.
1372
1373                      To indicate this to the user, do not display the value of
1374                      the symbol in the "Symbols's Value" field.  Instead show
1375                      its name followed by () as a hint that the symbol is
1376                      invoked.  */
1377
1378                   if (strtab == NULL
1379                       || psym->st_name == 0
1380                       || psym->st_name >= strtablen)
1381                     name = "??";
1382                   else
1383                     name = strtab + psym->st_name;
1384
1385                   len = print_symbol (width, name);
1386                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1387                 }
1388               else
1389                 {
1390                   print_vma (psym->st_value, LONG_HEX);
1391
1392                   printf (is_32bit_elf ? "   " : " ");
1393                 }
1394
1395               if (psym->st_name == 0)
1396                 {
1397                   const char * sec_name = "<null>";
1398                   char name_buf[40];
1399
1400                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1401                     {
1402                       if (psym->st_shndx < elf_header.e_shnum)
1403                         sec_name
1404                           = SECTION_NAME (section_headers + psym->st_shndx);
1405                       else if (psym->st_shndx == SHN_ABS)
1406                         sec_name = "ABS";
1407                       else if (psym->st_shndx == SHN_COMMON)
1408                         sec_name = "COMMON";
1409                       else if ((elf_header.e_machine == EM_MIPS
1410                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1411                                || (elf_header.e_machine == EM_TI_C6000
1412                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1413                         sec_name = "SCOMMON";
1414                       else if (elf_header.e_machine == EM_MIPS
1415                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1416                         sec_name = "SUNDEF";
1417                       else if ((elf_header.e_machine == EM_X86_64
1418                                 || elf_header.e_machine == EM_L1OM
1419                                 || elf_header.e_machine == EM_K1OM)
1420                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1421                         sec_name = "LARGE_COMMON";
1422                       else if (elf_header.e_machine == EM_IA_64
1423                                && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1424                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1425                         sec_name = "ANSI_COM";
1426                       else if (is_ia64_vms ()
1427                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1428                         sec_name = "VMS_SYMVEC";
1429                       else
1430                         {
1431                           sprintf (name_buf, "<section 0x%x>",
1432                                    (unsigned int) psym->st_shndx);
1433                           sec_name = name_buf;
1434                         }
1435                     }
1436                   print_symbol (22, sec_name);
1437                 }
1438               else if (strtab == NULL)
1439                 printf (_("<string table index: %3ld>"), psym->st_name);
1440               else if (psym->st_name >= strtablen)
1441                 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1442               else
1443                 print_symbol (22, strtab + psym->st_name);
1444
1445               if (is_rela)
1446                 {
1447                   bfd_signed_vma off = rels[i].r_addend;
1448
1449                   if (off < 0)
1450                     printf (" - %" BFD_VMA_FMT "x", - off);
1451                   else
1452                     printf (" + %" BFD_VMA_FMT "x", off);
1453                 }
1454             }
1455         }
1456       else if (is_rela)
1457         {
1458           bfd_signed_vma off = rels[i].r_addend;
1459
1460           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1461           if (off < 0)
1462             printf ("-%" BFD_VMA_FMT "x", - off);
1463           else
1464             printf ("%" BFD_VMA_FMT "x", off);
1465         }
1466
1467       if (elf_header.e_machine == EM_SPARCV9
1468           && rtype != NULL
1469           && streq (rtype, "R_SPARC_OLO10"))
1470         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1471
1472       putchar ('\n');
1473
1474 #ifdef BFD64
1475       if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1476         {
1477           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1478           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1479           const char * rtype2 = elf_mips_reloc_type (type2);
1480           const char * rtype3 = elf_mips_reloc_type (type3);
1481
1482           printf ("                    Type2: ");
1483
1484           if (rtype2 == NULL)
1485             printf (_("unrecognized: %-7lx"),
1486                     (unsigned long) type2 & 0xffffffff);
1487           else
1488             printf ("%-17.17s", rtype2);
1489
1490           printf ("\n                    Type3: ");
1491
1492           if (rtype3 == NULL)
1493             printf (_("unrecognized: %-7lx"),
1494                     (unsigned long) type3 & 0xffffffff);
1495           else
1496             printf ("%-17.17s", rtype3);
1497
1498           putchar ('\n');
1499         }
1500 #endif /* BFD64 */
1501     }
1502
1503   free (rels);
1504 }
1505
1506 static const char *
1507 get_mips_dynamic_type (unsigned long type)
1508 {
1509   switch (type)
1510     {
1511     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1512     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1513     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1514     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1515     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1516     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1517     case DT_MIPS_MSYM: return "MIPS_MSYM";
1518     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1519     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1520     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1521     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1522     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1523     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1524     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1525     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1526     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1527     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1528     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1529     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1530     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1531     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1532     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1533     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1534     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1535     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1536     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1537     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1538     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1539     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1540     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1541     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1542     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1543     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1544     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1545     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1546     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1547     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1548     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1549     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1550     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1551     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1552     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1553     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1554     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1555     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1556     default:
1557       return NULL;
1558     }
1559 }
1560
1561 static const char *
1562 get_sparc64_dynamic_type (unsigned long type)
1563 {
1564   switch (type)
1565     {
1566     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1567     default:
1568       return NULL;
1569     }
1570 }
1571
1572 static const char *
1573 get_ppc_dynamic_type (unsigned long type)
1574 {
1575   switch (type)
1576     {
1577     case DT_PPC_GOT:    return "PPC_GOT";
1578     case DT_PPC_TLSOPT: return "PPC_TLSOPT";
1579     default:
1580       return NULL;
1581     }
1582 }
1583
1584 static const char *
1585 get_ppc64_dynamic_type (unsigned long type)
1586 {
1587   switch (type)
1588     {
1589     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1590     case DT_PPC64_OPD:    return "PPC64_OPD";
1591     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1592     case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
1593     default:
1594       return NULL;
1595     }
1596 }
1597
1598 static const char *
1599 get_parisc_dynamic_type (unsigned long type)
1600 {
1601   switch (type)
1602     {
1603     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1604     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1605     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1606     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1607     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1608     case DT_HP_PREINIT:         return "HP_PREINIT";
1609     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1610     case DT_HP_NEEDED:          return "HP_NEEDED";
1611     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1612     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1613     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1614     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1615     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1616     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1617     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1618     case DT_HP_FILTERED:        return "HP_FILTERED";
1619     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1620     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1621     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1622     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1623     case DT_PLT:                return "PLT";
1624     case DT_PLT_SIZE:           return "PLT_SIZE";
1625     case DT_DLT:                return "DLT";
1626     case DT_DLT_SIZE:           return "DLT_SIZE";
1627     default:
1628       return NULL;
1629     }
1630 }
1631
1632 static const char *
1633 get_ia64_dynamic_type (unsigned long type)
1634 {
1635   switch (type)
1636     {
1637     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1638     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1639     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1640     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1641     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1642     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1643     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1644     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1645     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1646     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1647     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1648     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1649     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1650     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1651     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1652     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1653     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1654     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1655     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1656     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1657     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1658     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1659     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1660     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1661     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1662     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1663     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1664     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1665     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1666     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1667     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1668     default:
1669       return NULL;
1670     }
1671 }
1672
1673 static const char *
1674 get_alpha_dynamic_type (unsigned long type)
1675 {
1676   switch (type)
1677     {
1678     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1679     default:
1680       return NULL;
1681     }
1682 }
1683
1684 static const char *
1685 get_score_dynamic_type (unsigned long type)
1686 {
1687   switch (type)
1688     {
1689     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1690     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1691     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1692     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1693     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1694     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1695     default:
1696       return NULL;
1697     }
1698 }
1699
1700 static const char *
1701 get_tic6x_dynamic_type (unsigned long type)
1702 {
1703   switch (type)
1704     {
1705     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1706     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1707     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
1708     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
1709     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
1710     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
1711     default:
1712       return NULL;
1713     }
1714 }
1715
1716 static const char *
1717 get_nios2_dynamic_type (unsigned long type)
1718 {
1719   switch (type)
1720     {
1721     case DT_NIOS2_GP: return "NIOS2_GP";
1722     default:
1723       return NULL;
1724     }
1725 }
1726
1727 static const char *
1728 get_dynamic_type (unsigned long type)
1729 {
1730   static char buff[64];
1731
1732   switch (type)
1733     {
1734     case DT_NULL:       return "NULL";
1735     case DT_NEEDED:     return "NEEDED";
1736     case DT_PLTRELSZ:   return "PLTRELSZ";
1737     case DT_PLTGOT:     return "PLTGOT";
1738     case DT_HASH:       return "HASH";
1739     case DT_STRTAB:     return "STRTAB";
1740     case DT_SYMTAB:     return "SYMTAB";
1741     case DT_RELA:       return "RELA";
1742     case DT_RELASZ:     return "RELASZ";
1743     case DT_RELAENT:    return "RELAENT";
1744     case DT_STRSZ:      return "STRSZ";
1745     case DT_SYMENT:     return "SYMENT";
1746     case DT_INIT:       return "INIT";
1747     case DT_FINI:       return "FINI";
1748     case DT_SONAME:     return "SONAME";
1749     case DT_RPATH:      return "RPATH";
1750     case DT_SYMBOLIC:   return "SYMBOLIC";
1751     case DT_REL:        return "REL";
1752     case DT_RELSZ:      return "RELSZ";
1753     case DT_RELENT:     return "RELENT";
1754     case DT_PLTREL:     return "PLTREL";
1755     case DT_DEBUG:      return "DEBUG";
1756     case DT_TEXTREL:    return "TEXTREL";
1757     case DT_JMPREL:     return "JMPREL";
1758     case DT_BIND_NOW:   return "BIND_NOW";
1759     case DT_INIT_ARRAY: return "INIT_ARRAY";
1760     case DT_FINI_ARRAY: return "FINI_ARRAY";
1761     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1762     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1763     case DT_RUNPATH:    return "RUNPATH";
1764     case DT_FLAGS:      return "FLAGS";
1765
1766     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1767     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1768
1769     case DT_CHECKSUM:   return "CHECKSUM";
1770     case DT_PLTPADSZ:   return "PLTPADSZ";
1771     case DT_MOVEENT:    return "MOVEENT";
1772     case DT_MOVESZ:     return "MOVESZ";
1773     case DT_FEATURE:    return "FEATURE";
1774     case DT_POSFLAG_1:  return "POSFLAG_1";
1775     case DT_SYMINSZ:    return "SYMINSZ";
1776     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
1777
1778     case DT_ADDRRNGLO:  return "ADDRRNGLO";
1779     case DT_CONFIG:     return "CONFIG";
1780     case DT_DEPAUDIT:   return "DEPAUDIT";
1781     case DT_AUDIT:      return "AUDIT";
1782     case DT_PLTPAD:     return "PLTPAD";
1783     case DT_MOVETAB:    return "MOVETAB";
1784     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
1785
1786     case DT_VERSYM:     return "VERSYM";
1787
1788     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1789     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1790     case DT_RELACOUNT:  return "RELACOUNT";
1791     case DT_RELCOUNT:   return "RELCOUNT";
1792     case DT_FLAGS_1:    return "FLAGS_1";
1793     case DT_VERDEF:     return "VERDEF";
1794     case DT_VERDEFNUM:  return "VERDEFNUM";
1795     case DT_VERNEED:    return "VERNEED";
1796     case DT_VERNEEDNUM: return "VERNEEDNUM";
1797
1798     case DT_AUXILIARY:  return "AUXILIARY";
1799     case DT_USED:       return "USED";
1800     case DT_FILTER:     return "FILTER";
1801
1802     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1803     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1804     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1805     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1806     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1807     case DT_GNU_HASH:   return "GNU_HASH";
1808
1809     default:
1810       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1811         {
1812           const char * result;
1813
1814           switch (elf_header.e_machine)
1815             {
1816             case EM_MIPS:
1817             case EM_MIPS_RS3_LE:
1818               result = get_mips_dynamic_type (type);
1819               break;
1820             case EM_SPARCV9:
1821               result = get_sparc64_dynamic_type (type);
1822               break;
1823             case EM_PPC:
1824               result = get_ppc_dynamic_type (type);
1825               break;
1826             case EM_PPC64:
1827               result = get_ppc64_dynamic_type (type);
1828               break;
1829             case EM_IA_64:
1830               result = get_ia64_dynamic_type (type);
1831               break;
1832             case EM_ALPHA:
1833               result = get_alpha_dynamic_type (type);
1834               break;
1835             case EM_SCORE:
1836               result = get_score_dynamic_type (type);
1837               break;
1838             case EM_TI_C6000:
1839               result = get_tic6x_dynamic_type (type);
1840               break;
1841             case EM_ALTERA_NIOS2:
1842               result = get_nios2_dynamic_type (type);
1843               break;
1844             default:
1845               result = NULL;
1846               break;
1847             }
1848
1849           if (result != NULL)
1850             return result;
1851
1852           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1853         }
1854       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1855                || (elf_header.e_machine == EM_PARISC
1856                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1857         {
1858           const char * result;
1859
1860           switch (elf_header.e_machine)
1861             {
1862             case EM_PARISC:
1863               result = get_parisc_dynamic_type (type);
1864               break;
1865             case EM_IA_64:
1866               result = get_ia64_dynamic_type (type);
1867               break;
1868             default:
1869               result = NULL;
1870               break;
1871             }
1872
1873           if (result != NULL)
1874             return result;
1875
1876           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1877                     type);
1878         }
1879       else
1880         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1881
1882       return buff;
1883     }
1884 }
1885
1886 static char *
1887 get_file_type (unsigned e_type)
1888 {
1889   static char buff[32];
1890
1891   switch (e_type)
1892     {
1893     case ET_NONE:       return _("NONE (None)");
1894     case ET_REL:        return _("REL (Relocatable file)");
1895     case ET_EXEC:       return _("EXEC (Executable file)");
1896     case ET_DYN:        return _("DYN (Shared object file)");
1897     case ET_CORE:       return _("CORE (Core file)");
1898
1899     default:
1900       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1901         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1902       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1903         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1904       else
1905         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1906       return buff;
1907     }
1908 }
1909
1910 static char *
1911 get_machine_name (unsigned e_machine)
1912 {
1913   static char buff[64]; /* XXX */
1914
1915   switch (e_machine)
1916     {
1917     case EM_NONE:               return _("None");
1918     case EM_AARCH64:            return "AArch64";
1919     case EM_M32:                return "WE32100";
1920     case EM_SPARC:              return "Sparc";
1921     case EM_SPU:                return "SPU";
1922     case EM_386:                return "Intel 80386";
1923     case EM_68K:                return "MC68000";
1924     case EM_88K:                return "MC88000";
1925     case EM_486:                return "Intel 80486";
1926     case EM_860:                return "Intel 80860";
1927     case EM_MIPS:               return "MIPS R3000";
1928     case EM_S370:               return "IBM System/370";
1929     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
1930     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
1931     case EM_PARISC:             return "HPPA";
1932     case EM_PPC_OLD:            return "Power PC (old)";
1933     case EM_SPARC32PLUS:        return "Sparc v8+" ;
1934     case EM_960:                return "Intel 90860";
1935     case EM_PPC:                return "PowerPC";
1936     case EM_PPC64:              return "PowerPC64";
1937     case EM_FR20:               return "Fujitsu FR20";
1938     case EM_RH32:               return "TRW RH32";
1939     case EM_MCORE:              return "MCORE";
1940     case EM_ARM:                return "ARM";
1941     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
1942     case EM_SH:                 return "Renesas / SuperH SH";
1943     case EM_SPARCV9:            return "Sparc v9";
1944     case EM_TRICORE:            return "Siemens Tricore";
1945     case EM_ARC:                return "ARC";
1946     case EM_H8_300:             return "Renesas H8/300";
1947     case EM_H8_300H:            return "Renesas H8/300H";
1948     case EM_H8S:                return "Renesas H8S";
1949     case EM_H8_500:             return "Renesas H8/500";
1950     case EM_IA_64:              return "Intel IA-64";
1951     case EM_MIPS_X:             return "Stanford MIPS-X";
1952     case EM_COLDFIRE:           return "Motorola Coldfire";
1953     case EM_ALPHA:              return "Alpha";
1954     case EM_CYGNUS_D10V:
1955     case EM_D10V:               return "d10v";
1956     case EM_CYGNUS_D30V:
1957     case EM_D30V:               return "d30v";
1958     case EM_CYGNUS_M32R:
1959     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
1960     case EM_CYGNUS_V850:
1961     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
1962     case EM_V850:               return "Renesas V850";
1963     case EM_CYGNUS_MN10300:
1964     case EM_MN10300:            return "mn10300";
1965     case EM_CYGNUS_MN10200:
1966     case EM_MN10200:            return "mn10200";
1967     case EM_MOXIE:              return "Moxie";
1968     case EM_CYGNUS_FR30:
1969     case EM_FR30:               return "Fujitsu FR30";
1970     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
1971     case EM_PJ_OLD:
1972     case EM_PJ:                 return "picoJava";
1973     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
1974     case EM_PCP:                return "Siemens PCP";
1975     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
1976     case EM_NDR1:               return "Denso NDR1 microprocesspr";
1977     case EM_STARCORE:           return "Motorola Star*Core processor";
1978     case EM_ME16:               return "Toyota ME16 processor";
1979     case EM_ST100:              return "STMicroelectronics ST100 processor";
1980     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
1981     case EM_PDSP:               return "Sony DSP processor";
1982     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
1983     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
1984     case EM_FX66:               return "Siemens FX66 microcontroller";
1985     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1986     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
1987     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
1988     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
1989     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
1990     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
1991     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
1992     case EM_SVX:                return "Silicon Graphics SVx";
1993     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
1994     case EM_VAX:                return "Digital VAX";
1995     case EM_AVR_OLD:
1996     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
1997     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
1998     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
1999     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2000     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2001     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2002     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2003     case EM_PRISM:              return "Vitesse Prism";
2004     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2005     case EM_L1OM:               return "Intel L1OM";
2006     case EM_K1OM:               return "Intel K1OM";
2007     case EM_S390_OLD:
2008     case EM_S390:               return "IBM S/390";
2009     case EM_SCORE:              return "SUNPLUS S+Core";
2010     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2011     case EM_OPENRISC:
2012     case EM_OR32:               return "OpenRISC";
2013     case EM_ARC_A5:             return "ARC International ARCompact processor";
2014     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2015     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2016     case EM_DLX:                return "OpenDLX";
2017     case EM_IP2K_OLD:
2018     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2019     case EM_IQ2000:             return "Vitesse IQ2000";
2020     case EM_XTENSA_OLD:
2021     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2022     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2023     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2024     case EM_NS32K:              return "National Semiconductor 32000 series";
2025     case EM_TPC:                return "Tenor Network TPC processor";
2026     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2027     case EM_MAX:                return "MAX Processor";
2028     case EM_CR:                 return "National Semiconductor CompactRISC";
2029     case EM_F2MC16:             return "Fujitsu F2MC16";
2030     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2031     case EM_LATTICEMICO32:      return "Lattice Mico32";
2032     case EM_M32C_OLD:
2033     case EM_M32C:               return "Renesas M32c";
2034     case EM_MT:                 return "Morpho Techologies MT processor";
2035     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2036     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2037     case EM_SEP:                return "Sharp embedded microprocessor";
2038     case EM_ARCA:               return "Arca RISC microprocessor";
2039     case EM_UNICORE:            return "Unicore";
2040     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2041     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2042     case EM_NIOS32:             return "Altera Nios";
2043     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2044     case EM_C166:
2045     case EM_XC16X:              return "Infineon Technologies xc16x";
2046     case EM_M16C:               return "Renesas M16C series microprocessors";
2047     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2048     case EM_CE:                 return "Freescale Communication Engine RISC core";
2049     case EM_TSK3000:            return "Altium TSK3000 core";
2050     case EM_RS08:               return "Freescale RS08 embedded processor";
2051     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2052     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2053     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2054     case EM_SE_C17:             return "Seiko Epson C17 family";
2055     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2056     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2057     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2058     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2059     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2060     case EM_R32C:               return "Renesas R32C series microprocessors";
2061     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2062     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2063     case EM_8051:               return "Intel 8051 and variants";
2064     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2065     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2066     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2067     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2068     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2069     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2070     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2071     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2072     case EM_CR16:
2073     case EM_MICROBLAZE:
2074     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2075     case EM_RL78:               return "Renesas RL78";
2076     case EM_RX:                 return "Renesas RX";
2077     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2078     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2079     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2080     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2081     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2082     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor family";
2083     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2084     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2085     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2086     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2087     case EM_CUDA:               return "NVIDIA CUDA architecture";
2088     case EM_XGATE:              return "Motorola XGATE embedded processor";
2089     default:
2090       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2091       return buff;
2092     }
2093 }
2094
2095 static void
2096 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2097 {
2098   unsigned eabi;
2099   int unknown = 0;
2100
2101   eabi = EF_ARM_EABI_VERSION (e_flags);
2102   e_flags &= ~ EF_ARM_EABIMASK;
2103
2104   /* Handle "generic" ARM flags.  */
2105   if (e_flags & EF_ARM_RELEXEC)
2106     {
2107       strcat (buf, ", relocatable executable");
2108       e_flags &= ~ EF_ARM_RELEXEC;
2109     }
2110
2111   if (e_flags & EF_ARM_HASENTRY)
2112     {
2113       strcat (buf, ", has entry point");
2114       e_flags &= ~ EF_ARM_HASENTRY;
2115     }
2116
2117   /* Now handle EABI specific flags.  */
2118   switch (eabi)
2119     {
2120     default:
2121       strcat (buf, ", <unrecognized EABI>");
2122       if (e_flags)
2123         unknown = 1;
2124       break;
2125
2126     case EF_ARM_EABI_VER1:
2127       strcat (buf, ", Version1 EABI");
2128       while (e_flags)
2129         {
2130           unsigned flag;
2131
2132           /* Process flags one bit at a time.  */
2133           flag = e_flags & - e_flags;
2134           e_flags &= ~ flag;
2135
2136           switch (flag)
2137             {
2138             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2139               strcat (buf, ", sorted symbol tables");
2140               break;
2141
2142             default:
2143               unknown = 1;
2144               break;
2145             }
2146         }
2147       break;
2148
2149     case EF_ARM_EABI_VER2:
2150       strcat (buf, ", Version2 EABI");
2151       while (e_flags)
2152         {
2153           unsigned flag;
2154
2155           /* Process flags one bit at a time.  */
2156           flag = e_flags & - e_flags;
2157           e_flags &= ~ flag;
2158
2159           switch (flag)
2160             {
2161             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2162               strcat (buf, ", sorted symbol tables");
2163               break;
2164
2165             case EF_ARM_DYNSYMSUSESEGIDX:
2166               strcat (buf, ", dynamic symbols use segment index");
2167               break;
2168
2169             case EF_ARM_MAPSYMSFIRST:
2170               strcat (buf, ", mapping symbols precede others");
2171               break;
2172
2173             default:
2174               unknown = 1;
2175               break;
2176             }
2177         }
2178       break;
2179
2180     case EF_ARM_EABI_VER3:
2181       strcat (buf, ", Version3 EABI");
2182       break;
2183
2184     case EF_ARM_EABI_VER4:
2185       strcat (buf, ", Version4 EABI");
2186       while (e_flags)
2187         {
2188           unsigned flag;
2189
2190           /* Process flags one bit at a time.  */
2191           flag = e_flags & - e_flags;
2192           e_flags &= ~ flag;
2193
2194           switch (flag)
2195             {
2196             case EF_ARM_BE8:
2197               strcat (buf, ", BE8");
2198               break;
2199
2200             case EF_ARM_LE8:
2201               strcat (buf, ", LE8");
2202               break;
2203
2204             default:
2205               unknown = 1;
2206               break;
2207             }
2208       break;
2209         }
2210       break;
2211
2212     case EF_ARM_EABI_VER5:
2213       strcat (buf, ", Version5 EABI");
2214       while (e_flags)
2215         {
2216           unsigned flag;
2217
2218           /* Process flags one bit at a time.  */
2219           flag = e_flags & - e_flags;
2220           e_flags &= ~ flag;
2221
2222           switch (flag)
2223             {
2224             case EF_ARM_BE8:
2225               strcat (buf, ", BE8");
2226               break;
2227
2228             case EF_ARM_LE8:
2229               strcat (buf, ", LE8");
2230               break;
2231
2232             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2233               strcat (buf, ", soft-float ABI");
2234               break;
2235
2236             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2237               strcat (buf, ", hard-float ABI");
2238               break;
2239
2240             default:
2241               unknown = 1;
2242               break;
2243             }
2244         }
2245       break;
2246
2247     case EF_ARM_EABI_UNKNOWN:
2248       strcat (buf, ", GNU EABI");
2249       while (e_flags)
2250         {
2251           unsigned flag;
2252
2253           /* Process flags one bit at a time.  */
2254           flag = e_flags & - e_flags;
2255           e_flags &= ~ flag;
2256
2257           switch (flag)
2258             {
2259             case EF_ARM_INTERWORK:
2260               strcat (buf, ", interworking enabled");
2261               break;
2262
2263             case EF_ARM_APCS_26:
2264               strcat (buf, ", uses APCS/26");
2265               break;
2266
2267             case EF_ARM_APCS_FLOAT:
2268               strcat (buf, ", uses APCS/float");
2269               break;
2270
2271             case EF_ARM_PIC:
2272               strcat (buf, ", position independent");
2273               break;
2274
2275             case EF_ARM_ALIGN8:
2276               strcat (buf, ", 8 bit structure alignment");
2277               break;
2278
2279             case EF_ARM_NEW_ABI:
2280               strcat (buf, ", uses new ABI");
2281               break;
2282
2283             case EF_ARM_OLD_ABI:
2284               strcat (buf, ", uses old ABI");
2285               break;
2286
2287             case EF_ARM_SOFT_FLOAT:
2288               strcat (buf, ", software FP");
2289               break;
2290
2291             case EF_ARM_VFP_FLOAT:
2292               strcat (buf, ", VFP");
2293               break;
2294
2295             case EF_ARM_MAVERICK_FLOAT:
2296               strcat (buf, ", Maverick FP");
2297               break;
2298
2299             default:
2300               unknown = 1;
2301               break;
2302             }
2303         }
2304     }
2305
2306   if (unknown)
2307     strcat (buf,_(", <unknown>"));
2308 }
2309
2310 static char *
2311 get_machine_flags (unsigned e_flags, unsigned e_machine)
2312 {
2313   static char buf[1024];
2314
2315   buf[0] = '\0';
2316
2317   if (e_flags)
2318     {
2319       switch (e_machine)
2320         {
2321         default:
2322           break;
2323
2324         case EM_ARM:
2325           decode_ARM_machine_flags (e_flags, buf);
2326           break;
2327
2328         case EM_BLACKFIN:
2329           if (e_flags & EF_BFIN_PIC)
2330             strcat (buf, ", PIC");
2331
2332           if (e_flags & EF_BFIN_FDPIC)
2333             strcat (buf, ", FDPIC");
2334
2335           if (e_flags & EF_BFIN_CODE_IN_L1)
2336             strcat (buf, ", code in L1");
2337
2338           if (e_flags & EF_BFIN_DATA_IN_L1)
2339             strcat (buf, ", data in L1");
2340
2341           break;
2342
2343         case EM_CYGNUS_FRV:
2344           switch (e_flags & EF_FRV_CPU_MASK)
2345             {
2346             case EF_FRV_CPU_GENERIC:
2347               break;
2348
2349             default:
2350               strcat (buf, ", fr???");
2351               break;
2352
2353             case EF_FRV_CPU_FR300:
2354               strcat (buf, ", fr300");
2355               break;
2356
2357             case EF_FRV_CPU_FR400:
2358               strcat (buf, ", fr400");
2359               break;
2360             case EF_FRV_CPU_FR405:
2361               strcat (buf, ", fr405");
2362               break;
2363
2364             case EF_FRV_CPU_FR450:
2365               strcat (buf, ", fr450");
2366               break;
2367
2368             case EF_FRV_CPU_FR500:
2369               strcat (buf, ", fr500");
2370               break;
2371             case EF_FRV_CPU_FR550:
2372               strcat (buf, ", fr550");
2373               break;
2374
2375             case EF_FRV_CPU_SIMPLE:
2376               strcat (buf, ", simple");
2377               break;
2378             case EF_FRV_CPU_TOMCAT:
2379               strcat (buf, ", tomcat");
2380               break;
2381             }
2382           break;
2383
2384         case EM_68K:
2385           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2386             strcat (buf, ", m68000");
2387           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2388             strcat (buf, ", cpu32");
2389           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2390             strcat (buf, ", fido_a");
2391           else
2392             {
2393               char const * isa = _("unknown");
2394               char const * mac = _("unknown mac");
2395               char const * additional = NULL;
2396
2397               switch (e_flags & EF_M68K_CF_ISA_MASK)
2398                 {
2399                 case EF_M68K_CF_ISA_A_NODIV:
2400                   isa = "A";
2401                   additional = ", nodiv";
2402                   break;
2403                 case EF_M68K_CF_ISA_A:
2404                   isa = "A";
2405                   break;
2406                 case EF_M68K_CF_ISA_A_PLUS:
2407                   isa = "A+";
2408                   break;
2409                 case EF_M68K_CF_ISA_B_NOUSP:
2410                   isa = "B";
2411                   additional = ", nousp";
2412                   break;
2413                 case EF_M68K_CF_ISA_B:
2414                   isa = "B";
2415                   break;
2416                 case EF_M68K_CF_ISA_C:
2417                   isa = "C";
2418                   break;
2419                 case EF_M68K_CF_ISA_C_NODIV:
2420                   isa = "C";
2421                   additional = ", nodiv";
2422                   break;
2423                 }
2424               strcat (buf, ", cf, isa ");
2425               strcat (buf, isa);
2426               if (additional)
2427                 strcat (buf, additional);
2428               if (e_flags & EF_M68K_CF_FLOAT)
2429                 strcat (buf, ", float");
2430               switch (e_flags & EF_M68K_CF_MAC_MASK)
2431                 {
2432                 case 0:
2433                   mac = NULL;
2434                   break;
2435                 case EF_M68K_CF_MAC:
2436                   mac = "mac";
2437                   break;
2438                 case EF_M68K_CF_EMAC:
2439                   mac = "emac";
2440                   break;
2441                 case EF_M68K_CF_EMAC_B:
2442                   mac = "emac_b";
2443                   break;
2444                 }
2445               if (mac)
2446                 {
2447                   strcat (buf, ", ");
2448                   strcat (buf, mac);
2449                 }
2450             }
2451           break;
2452
2453         case EM_PPC:
2454           if (e_flags & EF_PPC_EMB)
2455             strcat (buf, ", emb");
2456
2457           if (e_flags & EF_PPC_RELOCATABLE)
2458             strcat (buf, _(", relocatable"));
2459
2460           if (e_flags & EF_PPC_RELOCATABLE_LIB)
2461             strcat (buf, _(", relocatable-lib"));
2462           break;
2463
2464         case EM_V800:
2465           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2466             strcat (buf, ", RH850 ABI");
2467
2468           if (e_flags & EF_V800_850E3)
2469             strcat (buf, ", V3 architecture");
2470
2471           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2472             strcat (buf, ", FPU not used");
2473
2474           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2475             strcat (buf, ", regmode: COMMON");
2476
2477           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2478             strcat (buf, ", r4 not used");
2479
2480           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2481             strcat (buf, ", r30 not used");
2482
2483           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2484             strcat (buf, ", r5 not used");
2485
2486           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2487             strcat (buf, ", r2 not used");
2488
2489           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2490             {
2491               switch (e_flags & - e_flags)
2492                 {
2493                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2494                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2495                 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2496                 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2497                 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2498                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2499                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2500                 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2501                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2502                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2503                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2504                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2505                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2506                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2507                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2508                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2509                 default: break;
2510                 }
2511             }
2512           break;
2513
2514         case EM_V850:
2515         case EM_CYGNUS_V850:
2516           switch (e_flags & EF_V850_ARCH)
2517             {
2518             case E_V850E3V5_ARCH:
2519               strcat (buf, ", v850e3v5");
2520               break;
2521             case E_V850E2V3_ARCH:
2522               strcat (buf, ", v850e2v3");
2523               break;
2524             case E_V850E2_ARCH:
2525               strcat (buf, ", v850e2");
2526               break;
2527             case E_V850E1_ARCH:
2528               strcat (buf, ", v850e1");
2529               break;
2530             case E_V850E_ARCH:
2531               strcat (buf, ", v850e");
2532               break;
2533             case E_V850_ARCH:
2534               strcat (buf, ", v850");
2535               break;
2536             default:
2537               strcat (buf, _(", unknown v850 architecture variant"));
2538               break;
2539             }
2540           break;
2541
2542         case EM_M32R:
2543         case EM_CYGNUS_M32R:
2544           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2545             strcat (buf, ", m32r");
2546           break;
2547
2548         case EM_MIPS:
2549         case EM_MIPS_RS3_LE:
2550           if (e_flags & EF_MIPS_NOREORDER)
2551             strcat (buf, ", noreorder");
2552
2553           if (e_flags & EF_MIPS_PIC)
2554             strcat (buf, ", pic");
2555
2556           if (e_flags & EF_MIPS_CPIC)
2557             strcat (buf, ", cpic");
2558
2559           if (e_flags & EF_MIPS_UCODE)
2560             strcat (buf, ", ugen_reserved");
2561
2562           if (e_flags & EF_MIPS_ABI2)
2563             strcat (buf, ", abi2");
2564
2565           if (e_flags & EF_MIPS_OPTIONS_FIRST)
2566             strcat (buf, ", odk first");
2567
2568           if (e_flags & EF_MIPS_32BITMODE)
2569             strcat (buf, ", 32bitmode");
2570
2571           if (e_flags & EF_MIPS_NAN2008)
2572             strcat (buf, ", nan2008");
2573
2574           if (e_flags & EF_MIPS_FP64)
2575             strcat (buf, ", fp64");
2576
2577           switch ((e_flags & EF_MIPS_MACH))
2578             {
2579             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2580             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2581             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2582             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2583             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2584             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2585             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2586             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2587             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
2588             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2589             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2590             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2591             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
2592             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2593             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2594             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
2595             case 0:
2596             /* We simply ignore the field in this case to avoid confusion:
2597                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2598                extension.  */
2599               break;
2600             default: strcat (buf, _(", unknown CPU")); break;
2601             }
2602
2603           switch ((e_flags & EF_MIPS_ABI))
2604             {
2605             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2606             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2607             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2608             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2609             case 0:
2610             /* We simply ignore the field in this case to avoid confusion:
2611                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2612                This means it is likely to be an o32 file, but not for
2613                sure.  */
2614               break;
2615             default: strcat (buf, _(", unknown ABI")); break;
2616             }
2617
2618           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2619             strcat (buf, ", mdmx");
2620
2621           if (e_flags & EF_MIPS_ARCH_ASE_M16)
2622             strcat (buf, ", mips16");
2623
2624           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2625             strcat (buf, ", micromips");
2626
2627           switch ((e_flags & EF_MIPS_ARCH))
2628             {
2629             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2630             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2631             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2632             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2633             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2634             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2635             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2636             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2637             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2638             default: strcat (buf, _(", unknown ISA")); break;
2639             }
2640           break;
2641
2642         case EM_SH:
2643           switch ((e_flags & EF_SH_MACH_MASK))
2644             {
2645             case EF_SH1: strcat (buf, ", sh1"); break;
2646             case EF_SH2: strcat (buf, ", sh2"); break;
2647             case EF_SH3: strcat (buf, ", sh3"); break;
2648             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2649             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2650             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2651             case EF_SH3E: strcat (buf, ", sh3e"); break;
2652             case EF_SH4: strcat (buf, ", sh4"); break;
2653             case EF_SH5: strcat (buf, ", sh5"); break;
2654             case EF_SH2E: strcat (buf, ", sh2e"); break;
2655             case EF_SH4A: strcat (buf, ", sh4a"); break;
2656             case EF_SH2A: strcat (buf, ", sh2a"); break;
2657             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2658             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2659             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2660             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2661             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2662             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2663             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2664             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2665             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2666             default: strcat (buf, _(", unknown ISA")); break;
2667             }
2668
2669           if (e_flags & EF_SH_PIC)
2670             strcat (buf, ", pic");
2671
2672           if (e_flags & EF_SH_FDPIC)
2673             strcat (buf, ", fdpic");
2674           break;
2675
2676         case EM_SPARCV9:
2677           if (e_flags & EF_SPARC_32PLUS)
2678             strcat (buf, ", v8+");
2679
2680           if (e_flags & EF_SPARC_SUN_US1)
2681             strcat (buf, ", ultrasparcI");
2682
2683           if (e_flags & EF_SPARC_SUN_US3)
2684             strcat (buf, ", ultrasparcIII");
2685
2686           if (e_flags & EF_SPARC_HAL_R1)
2687             strcat (buf, ", halr1");
2688
2689           if (e_flags & EF_SPARC_LEDATA)
2690             strcat (buf, ", ledata");
2691
2692           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2693             strcat (buf, ", tso");
2694
2695           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2696             strcat (buf, ", pso");
2697
2698           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2699             strcat (buf, ", rmo");
2700           break;
2701
2702         case EM_PARISC:
2703           switch (e_flags & EF_PARISC_ARCH)
2704             {
2705             case EFA_PARISC_1_0:
2706               strcpy (buf, ", PA-RISC 1.0");
2707               break;
2708             case EFA_PARISC_1_1:
2709               strcpy (buf, ", PA-RISC 1.1");
2710               break;
2711             case EFA_PARISC_2_0:
2712               strcpy (buf, ", PA-RISC 2.0");
2713               break;
2714             default:
2715               break;
2716             }
2717           if (e_flags & EF_PARISC_TRAPNIL)
2718             strcat (buf, ", trapnil");
2719           if (e_flags & EF_PARISC_EXT)
2720             strcat (buf, ", ext");
2721           if (e_flags & EF_PARISC_LSB)
2722             strcat (buf, ", lsb");
2723           if (e_flags & EF_PARISC_WIDE)
2724             strcat (buf, ", wide");
2725           if (e_flags & EF_PARISC_NO_KABP)
2726             strcat (buf, ", no kabp");
2727           if (e_flags & EF_PARISC_LAZYSWAP)
2728             strcat (buf, ", lazyswap");
2729           break;
2730
2731         case EM_PJ:
2732         case EM_PJ_OLD:
2733           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2734             strcat (buf, ", new calling convention");
2735
2736           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2737             strcat (buf, ", gnu calling convention");
2738           break;
2739
2740         case EM_IA_64:
2741           if ((e_flags & EF_IA_64_ABI64))
2742             strcat (buf, ", 64-bit");
2743           else
2744             strcat (buf, ", 32-bit");
2745           if ((e_flags & EF_IA_64_REDUCEDFP))
2746             strcat (buf, ", reduced fp model");
2747           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2748             strcat (buf, ", no function descriptors, constant gp");
2749           else if ((e_flags & EF_IA_64_CONS_GP))
2750             strcat (buf, ", constant gp");
2751           if ((e_flags & EF_IA_64_ABSOLUTE))
2752             strcat (buf, ", absolute");
2753           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2754             {
2755               if ((e_flags & EF_IA_64_VMS_LINKAGES))
2756                 strcat (buf, ", vms_linkages");
2757               switch ((e_flags & EF_IA_64_VMS_COMCOD))
2758                 {
2759                 case EF_IA_64_VMS_COMCOD_SUCCESS:
2760                   break;
2761                 case EF_IA_64_VMS_COMCOD_WARNING:
2762                   strcat (buf, ", warning");
2763                   break;
2764                 case EF_IA_64_VMS_COMCOD_ERROR:
2765                   strcat (buf, ", error");
2766                   break;
2767                 case EF_IA_64_VMS_COMCOD_ABORT:
2768                   strcat (buf, ", abort");
2769                   break;
2770                 default:
2771                   abort ();
2772                 }
2773             }
2774           break;
2775
2776         case EM_VAX:
2777           if ((e_flags & EF_VAX_NONPIC))
2778             strcat (buf, ", non-PIC");
2779           if ((e_flags & EF_VAX_DFLOAT))
2780             strcat (buf, ", D-Float");
2781           if ((e_flags & EF_VAX_GFLOAT))
2782             strcat (buf, ", G-Float");
2783           break;
2784
2785         case EM_RL78:
2786           if (e_flags & E_FLAG_RL78_G10)
2787             strcat (buf, ", G10");
2788           break;
2789
2790         case EM_RX:
2791           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2792             strcat (buf, ", 64-bit doubles");
2793           if (e_flags & E_FLAG_RX_DSP)
2794             strcat (buf, ", dsp");
2795           if (e_flags & E_FLAG_RX_PID)
2796             strcat (buf, ", pid");
2797           if (e_flags & E_FLAG_RX_ABI)
2798             strcat (buf, ", RX ABI");
2799           break;
2800
2801         case EM_S390:
2802           if (e_flags & EF_S390_HIGH_GPRS)
2803             strcat (buf, ", highgprs");
2804           break;
2805
2806         case EM_TI_C6000:
2807           if ((e_flags & EF_C6000_REL))
2808             strcat (buf, ", relocatable module");
2809           break;
2810
2811         case EM_MSP430:
2812           strcat (buf, _(": architecture variant: "));
2813           switch (e_flags & EF_MSP430_MACH)
2814             {
2815             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
2816             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
2817             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
2818             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
2819             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
2820             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
2821             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
2822             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
2823             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
2824             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
2825             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
2826             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
2827             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
2828             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
2829             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
2830             default:
2831               strcat (buf, _(": unknown")); break;
2832             }
2833
2834           if (e_flags & ~ EF_MSP430_MACH)
2835             strcat (buf, _(": unknown extra flag bits also present"));
2836         }
2837     }
2838
2839   return buf;
2840 }
2841
2842 static const char *
2843 get_osabi_name (unsigned int osabi)
2844 {
2845   static char buff[32];
2846
2847   switch (osabi)
2848     {
2849     case ELFOSABI_NONE:         return "UNIX - System V";
2850     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
2851     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
2852     case ELFOSABI_GNU:          return "UNIX - GNU";
2853     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
2854     case ELFOSABI_AIX:          return "UNIX - AIX";
2855     case ELFOSABI_IRIX:         return "UNIX - IRIX";
2856     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
2857     case ELFOSABI_TRU64:        return "UNIX - TRU64";
2858     case ELFOSABI_MODESTO:      return "Novell - Modesto";
2859     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
2860     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
2861     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
2862     case ELFOSABI_AROS:         return "AROS";
2863     case ELFOSABI_FENIXOS:      return "FenixOS";
2864     default:
2865       if (osabi >= 64)
2866         switch (elf_header.e_machine)
2867           {
2868           case EM_ARM:
2869             switch (osabi)
2870               {
2871               case ELFOSABI_ARM:        return "ARM";
2872               default:
2873                 break;
2874               }
2875             break;
2876
2877           case EM_MSP430:
2878           case EM_MSP430_OLD:
2879             switch (osabi)
2880               {
2881               case ELFOSABI_STANDALONE: return _("Standalone App");
2882               default:
2883                 break;
2884               }
2885             break;
2886
2887           case EM_TI_C6000:
2888             switch (osabi)
2889               {
2890               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
2891               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
2892               default:
2893                 break;
2894               }
2895             break;
2896
2897           default:
2898             break;
2899           }
2900       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2901       return buff;
2902     }
2903 }
2904
2905 static const char *
2906 get_aarch64_segment_type (unsigned long type)
2907 {
2908   switch (type)
2909     {
2910     case PT_AARCH64_ARCHEXT:
2911       return "AARCH64_ARCHEXT";
2912     default:
2913       break;
2914     }
2915
2916   return NULL;
2917 }
2918
2919 static const char *
2920 get_arm_segment_type (unsigned long type)
2921 {
2922   switch (type)
2923     {
2924     case PT_ARM_EXIDX:
2925       return "EXIDX";
2926     default:
2927       break;
2928     }
2929
2930   return NULL;
2931 }
2932
2933 static const char *
2934 get_mips_segment_type (unsigned long type)
2935 {
2936   switch (type)
2937     {
2938     case PT_MIPS_REGINFO:
2939       return "REGINFO";
2940     case PT_MIPS_RTPROC:
2941       return "RTPROC";
2942     case PT_MIPS_OPTIONS:
2943       return "OPTIONS";
2944     default:
2945       break;
2946     }
2947
2948   return NULL;
2949 }
2950
2951 static const char *
2952 get_parisc_segment_type (unsigned long type)
2953 {
2954   switch (type)
2955     {
2956     case PT_HP_TLS:             return "HP_TLS";
2957     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
2958     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
2959     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
2960     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
2961     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
2962     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
2963     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
2964     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
2965     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
2966     case PT_HP_PARALLEL:        return "HP_PARALLEL";
2967     case PT_HP_FASTBIND:        return "HP_FASTBIND";
2968     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
2969     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
2970     case PT_HP_STACK:           return "HP_STACK";
2971     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
2972     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
2973     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
2974     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
2975     default:
2976       break;
2977     }
2978
2979   return NULL;
2980 }
2981
2982 static const char *
2983 get_ia64_segment_type (unsigned long type)
2984 {
2985   switch (type)
2986     {
2987     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
2988     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
2989     case PT_HP_TLS:             return "HP_TLS";
2990     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
2991     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
2992     case PT_IA_64_HP_STACK:     return "HP_STACK";
2993     default:
2994       break;
2995     }
2996
2997   return NULL;
2998 }
2999
3000 static const char *
3001 get_tic6x_segment_type (unsigned long type)
3002 {
3003   switch (type)
3004     {
3005     case PT_C6000_PHATTR:       return "C6000_PHATTR";
3006     default:
3007       break;
3008     }
3009
3010   return NULL;
3011 }
3012
3013 static const char *
3014 get_segment_type (unsigned long p_type)
3015 {
3016   static char buff[32];
3017
3018   switch (p_type)
3019     {
3020     case PT_NULL:       return "NULL";
3021     case PT_LOAD:       return "LOAD";
3022     case PT_DYNAMIC:    return "DYNAMIC";
3023     case PT_INTERP:     return "INTERP";
3024     case PT_NOTE:       return "NOTE";
3025     case PT_SHLIB:      return "SHLIB";
3026     case PT_PHDR:       return "PHDR";
3027     case PT_TLS:        return "TLS";
3028
3029     case PT_GNU_EH_FRAME:
3030                         return "GNU_EH_FRAME";
3031     case PT_GNU_STACK:  return "GNU_STACK";
3032     case PT_GNU_RELRO:  return "GNU_RELRO";
3033
3034     default:
3035       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3036         {
3037           const char * result;
3038
3039           switch (elf_header.e_machine)
3040             {
3041             case EM_AARCH64:
3042               result = get_aarch64_segment_type (p_type);
3043               break;
3044             case EM_ARM:
3045               result = get_arm_segment_type (p_type);
3046               break;
3047             case EM_MIPS:
3048             case EM_MIPS_RS3_LE:
3049               result = get_mips_segment_type (p_type);
3050               break;
3051             case EM_PARISC:
3052               result = get_parisc_segment_type (p_type);
3053               break;
3054             case EM_IA_64:
3055               result = get_ia64_segment_type (p_type);
3056               break;
3057             case EM_TI_C6000:
3058               result = get_tic6x_segment_type (p_type);
3059               break;
3060             default:
3061               result = NULL;
3062               break;
3063             }
3064
3065           if (result != NULL)
3066             return result;
3067
3068           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3069         }
3070       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3071         {
3072           const char * result;
3073
3074           switch (elf_header.e_machine)
3075             {
3076             case EM_PARISC:
3077               result = get_parisc_segment_type (p_type);
3078               break;
3079             case EM_IA_64:
3080               result = get_ia64_segment_type (p_type);
3081               break;
3082             default:
3083               result = NULL;
3084               break;
3085             }
3086
3087           if (result != NULL)
3088             return result;
3089
3090           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3091         }
3092       else
3093         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3094
3095       return buff;
3096     }
3097 }
3098
3099 static const char *
3100 get_mips_section_type_name (unsigned int sh_type)
3101 {
3102   switch (sh_type)
3103     {
3104     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3105     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3106     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3107     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3108     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3109     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3110     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3111     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3112     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3113     case SHT_MIPS_RELD:          return "MIPS_RELD";
3114     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3115     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3116     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3117     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3118     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3119     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3120     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3121     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3122     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3123     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3124     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3125     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3126     case SHT_MIPS_LINE:          return "MIPS_LINE";
3127     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3128     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3129     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3130     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3131     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3132     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3133     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3134     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3135     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3136     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3137     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3138     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3139     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3140     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3141     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3142     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3143     default:
3144       break;
3145     }
3146   return NULL;
3147 }
3148
3149 static const char *
3150 get_parisc_section_type_name (unsigned int sh_type)
3151 {
3152   switch (sh_type)
3153     {
3154     case SHT_PARISC_EXT:        return "PARISC_EXT";
3155     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
3156     case SHT_PARISC_DOC:        return "PARISC_DOC";
3157     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
3158     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
3159     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
3160     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
3161     default:
3162       break;
3163     }
3164   return NULL;
3165 }
3166
3167 static const char *
3168 get_ia64_section_type_name (unsigned int sh_type)
3169 {
3170   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
3171   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3172     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3173
3174   switch (sh_type)
3175     {
3176     case SHT_IA_64_EXT:                return "IA_64_EXT";
3177     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
3178     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
3179     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
3180     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3181     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
3182     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
3183     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
3184     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
3185     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
3186     default:
3187       break;
3188     }
3189   return NULL;
3190 }
3191
3192 static const char *
3193 get_x86_64_section_type_name (unsigned int sh_type)
3194 {
3195   switch (sh_type)
3196     {
3197     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
3198     default:
3199       break;
3200     }
3201   return NULL;
3202 }
3203
3204 static const char *
3205 get_aarch64_section_type_name (unsigned int sh_type)
3206 {
3207   switch (sh_type)
3208     {
3209     case SHT_AARCH64_ATTRIBUTES:
3210       return "AARCH64_ATTRIBUTES";
3211     default:
3212       break;
3213     }
3214   return NULL;
3215 }
3216
3217 static const char *
3218 get_arm_section_type_name (unsigned int sh_type)
3219 {
3220   switch (sh_type)
3221     {
3222     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
3223     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
3224     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
3225     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
3226     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
3227     default:
3228       break;
3229     }
3230   return NULL;
3231 }
3232
3233 static const char *
3234 get_tic6x_section_type_name (unsigned int sh_type)
3235 {
3236   switch (sh_type)
3237     {
3238     case SHT_C6000_UNWIND:
3239       return "C6000_UNWIND";
3240     case SHT_C6000_PREEMPTMAP:
3241       return "C6000_PREEMPTMAP";
3242     case SHT_C6000_ATTRIBUTES:
3243       return "C6000_ATTRIBUTES";
3244     case SHT_TI_ICODE:
3245       return "TI_ICODE";
3246     case SHT_TI_XREF:
3247       return "TI_XREF";
3248     case SHT_TI_HANDLER:
3249       return "TI_HANDLER";
3250     case SHT_TI_INITINFO:
3251       return "TI_INITINFO";
3252     case SHT_TI_PHATTRS:
3253       return "TI_PHATTRS";
3254     default:
3255       break;
3256     }
3257   return NULL;
3258 }
3259
3260 static const char *
3261 get_msp430x_section_type_name (unsigned int sh_type)
3262 {
3263   switch (sh_type)
3264     {
3265     case SHT_MSP430_SEC_FLAGS:   return "MSP430_SEC_FLAGS";
3266     case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3267     case SHT_MSP430_ATTRIBUTES:  return "MSP430_ATTRIBUTES";
3268     default: return NULL;
3269     }
3270 }
3271
3272 static const char *
3273 get_section_type_name (unsigned int sh_type)
3274 {
3275   static char buff[32];
3276
3277   switch (sh_type)
3278     {
3279     case SHT_NULL:              return "NULL";
3280     case SHT_PROGBITS:          return "PROGBITS";
3281     case SHT_SYMTAB:            return "SYMTAB";
3282     case SHT_STRTAB:            return "STRTAB";
3283     case SHT_RELA:              return "RELA";
3284     case SHT_HASH:              return "HASH";
3285     case SHT_DYNAMIC:           return "DYNAMIC";
3286     case SHT_NOTE:              return "NOTE";
3287     case SHT_NOBITS:            return "NOBITS";
3288     case SHT_REL:               return "REL";
3289     case SHT_SHLIB:             return "SHLIB";
3290     case SHT_DYNSYM:            return "DYNSYM";
3291     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
3292     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
3293     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
3294     case SHT_GNU_HASH:          return "GNU_HASH";
3295     case SHT_GROUP:             return "GROUP";
3296     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
3297     case SHT_GNU_verdef:        return "VERDEF";
3298     case SHT_GNU_verneed:       return "VERNEED";
3299     case SHT_GNU_versym:        return "VERSYM";
3300     case 0x6ffffff0:            return "VERSYM";
3301     case 0x6ffffffc:            return "VERDEF";
3302     case 0x7ffffffd:            return "AUXILIARY";
3303     case 0x7fffffff:            return "FILTER";
3304     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
3305
3306     default:
3307       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3308         {
3309           const char * result;
3310
3311           switch (elf_header.e_machine)
3312             {
3313             case EM_MIPS:
3314             case EM_MIPS_RS3_LE:
3315               result = get_mips_section_type_name (sh_type);
3316               break;
3317             case EM_PARISC:
3318               result = get_parisc_section_type_name (sh_type);
3319               break;
3320             case EM_IA_64:
3321               result = get_ia64_section_type_name (sh_type);
3322               break;
3323             case EM_X86_64:
3324             case EM_L1OM:
3325             case EM_K1OM:
3326               result = get_x86_64_section_type_name (sh_type);
3327               break;
3328             case EM_AARCH64:
3329               result = get_aarch64_section_type_name (sh_type);
3330               break;
3331             case EM_ARM:
3332               result = get_arm_section_type_name (sh_type);
3333               break;
3334             case EM_TI_C6000:
3335               result = get_tic6x_section_type_name (sh_type);
3336               break;
3337             case EM_MSP430:
3338               result = get_msp430x_section_type_name (sh_type);
3339               break;
3340             default:
3341               result = NULL;
3342               break;
3343             }
3344
3345           if (result != NULL)
3346             return result;
3347
3348           sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3349         }
3350       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3351         {
3352           const char * result;
3353
3354           switch (elf_header.e_machine)
3355             {
3356             case EM_IA_64:
3357               result = get_ia64_section_type_name (sh_type);
3358               break;
3359             default:
3360               result = NULL;
3361               break;
3362             }
3363
3364           if (result != NULL)
3365             return result;
3366
3367           sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3368         }
3369       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3370         sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3371       else
3372         /* This message is probably going to be displayed in a 15
3373            character wide field, so put the hex value first.  */
3374         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3375
3376       return buff;
3377     }
3378 }
3379
3380 #define OPTION_DEBUG_DUMP       512
3381 #define OPTION_DYN_SYMS         513
3382 #define OPTION_DWARF_DEPTH      514
3383 #define OPTION_DWARF_START      515
3384 #define OPTION_DWARF_CHECK      516
3385
3386 static struct option options[] =
3387 {
3388   {"all",              no_argument, 0, 'a'},
3389   {"file-header",      no_argument, 0, 'h'},
3390   {"program-headers",  no_argument, 0, 'l'},
3391   {"headers",          no_argument, 0, 'e'},
3392   {"histogram",        no_argument, 0, 'I'},
3393   {"segments",         no_argument, 0, 'l'},
3394   {"sections",         no_argument, 0, 'S'},
3395   {"section-headers",  no_argument, 0, 'S'},
3396   {"section-groups",   no_argument, 0, 'g'},
3397   {"section-details",  no_argument, 0, 't'},
3398   {"full-section-name",no_argument, 0, 'N'},
3399   {"symbols",          no_argument, 0, 's'},
3400   {"syms",             no_argument, 0, 's'},
3401   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
3402   {"relocs",           no_argument, 0, 'r'},
3403   {"notes",            no_argument, 0, 'n'},
3404   {"dynamic",          no_argument, 0, 'd'},
3405   {"arch-specific",    no_argument, 0, 'A'},
3406   {"version-info",     no_argument, 0, 'V'},
3407   {"use-dynamic",      no_argument, 0, 'D'},
3408   {"unwind",           no_argument, 0, 'u'},
3409   {"archive-index",    no_argument, 0, 'c'},
3410   {"hex-dump",         required_argument, 0, 'x'},
3411   {"relocated-dump",   required_argument, 0, 'R'},
3412   {"string-dump",      required_argument, 0, 'p'},
3413 #ifdef SUPPORT_DISASSEMBLY
3414   {"instruction-dump", required_argument, 0, 'i'},
3415 #endif
3416   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
3417
3418   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
3419   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
3420   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
3421
3422   {"version",          no_argument, 0, 'v'},
3423   {"wide",             no_argument, 0, 'W'},
3424   {"help",             no_argument, 0, 'H'},
3425   {0,                  no_argument, 0, 0}
3426 };
3427
3428 static void
3429 usage (FILE * stream)
3430 {
3431   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3432   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3433   fprintf (stream, _(" Options are:\n\
3434   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3435   -h --file-header       Display the ELF file header\n\
3436   -l --program-headers   Display the program headers\n\
3437      --segments          An alias for --program-headers\n\
3438   -S --section-headers   Display the sections' header\n\
3439      --sections          An alias for --section-headers\n\
3440   -g --section-groups    Display the section groups\n\
3441   -t --section-details   Display the section details\n\
3442   -e --headers           Equivalent to: -h -l -S\n\
3443   -s --syms              Display the symbol table\n\
3444      --symbols           An alias for --syms\n\
3445   --dyn-syms             Display the dynamic symbol table\n\
3446   -n --notes             Display the core notes (if present)\n\
3447   -r --relocs            Display the relocations (if present)\n\
3448   -u --unwind            Display the unwind info (if present)\n\
3449   -d --dynamic           Display the dynamic section (if present)\n\
3450   -V --version-info      Display the version sections (if present)\n\
3451   -A --arch-specific     Display architecture specific information (if any)\n\
3452   -c --archive-index     Display the symbol/file index in an archive\n\
3453   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
3454   -x --hex-dump=<number|name>\n\
3455                          Dump the contents of section <number|name> as bytes\n\
3456   -p --string-dump=<number|name>\n\
3457                          Dump the contents of section <number|name> as strings\n\
3458   -R --relocated-dump=<number|name>\n\
3459                          Dump the contents of section <number|name> as relocated bytes\n\
3460   -w[lLiaprmfFsoRt] or\n\
3461   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3462                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3463                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3464                =addr,=cu_index]\n\
3465                          Display the contents of DWARF2 debug sections\n"));
3466   fprintf (stream, _("\
3467   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
3468   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
3469                          or deeper\n"));
3470 #ifdef SUPPORT_DISASSEMBLY
3471   fprintf (stream, _("\
3472   -i --instruction-dump=<number|name>\n\
3473                          Disassemble the contents of section <number|name>\n"));
3474 #endif
3475   fprintf (stream, _("\
3476   -I --histogram         Display histogram of bucket list lengths\n\
3477   -W --wide              Allow output width to exceed 80 characters\n\
3478   @<file>                Read options from <file>\n\
3479   -H --help              Display this information\n\
3480   -v --version           Display the version number of readelf\n"));
3481
3482   if (REPORT_BUGS_TO[0] && stream == stdout)
3483     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3484
3485   exit (stream == stdout ? 0 : 1);
3486 }
3487
3488 /* Record the fact that the user wants the contents of section number
3489    SECTION to be displayed using the method(s) encoded as flags bits
3490    in TYPE.  Note, TYPE can be zero if we are creating the array for
3491    the first time.  */
3492
3493 static void
3494 request_dump_bynumber (unsigned int section, dump_type type)
3495 {
3496   if (section >= num_dump_sects)
3497     {
3498       dump_type * new_dump_sects;
3499
3500       new_dump_sects = (dump_type *) calloc (section + 1,
3501                                              sizeof (* dump_sects));
3502
3503       if (new_dump_sects == NULL)
3504         error (_("Out of memory allocating dump request table.\n"));
3505       else
3506         {
3507           /* Copy current flag settings.  */
3508           memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3509
3510           free (dump_sects);
3511
3512           dump_sects = new_dump_sects;
3513           num_dump_sects = section + 1;
3514         }
3515     }
3516
3517   if (dump_sects)
3518     dump_sects[section] |= type;
3519
3520   return;
3521 }
3522
3523 /* Request a dump by section name.  */
3524
3525 static void
3526 request_dump_byname (const char * section, dump_type type)
3527 {
3528   struct dump_list_entry * new_request;
3529
3530   new_request = (struct dump_list_entry *)
3531       malloc (sizeof (struct dump_list_entry));
3532   if (!new_request)
3533     error (_("Out of memory allocating dump request table.\n"));
3534
3535   new_request->name = strdup (section);
3536   if (!new_request->name)
3537     error (_("Out of memory allocating dump request table.\n"));
3538
3539   new_request->type = type;
3540
3541   new_request->next = dump_sects_byname;
3542   dump_sects_byname = new_request;
3543 }
3544
3545 static inline void
3546 request_dump (dump_type type)
3547 {
3548   int section;
3549   char * cp;
3550
3551   do_dump++;
3552   section = strtoul (optarg, & cp, 0);
3553
3554   if (! *cp && section >= 0)
3555     request_dump_bynumber (section, type);
3556   else
3557     request_dump_byname (optarg, type);
3558 }
3559
3560
3561 static void
3562 parse_args (int argc, char ** argv)
3563 {
3564   int c;
3565
3566   if (argc < 2)
3567     usage (stderr);
3568
3569   while ((c = getopt_long
3570           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3571     {
3572       switch (c)
3573         {
3574         case 0:
3575           /* Long options.  */
3576           break;
3577         case 'H':
3578           usage (stdout);
3579           break;
3580
3581         case 'a':
3582           do_syms++;
3583           do_reloc++;
3584           do_unwind++;
3585           do_dynamic++;
3586           do_header++;
3587           do_sections++;
3588           do_section_groups++;
3589           do_segments++;
3590           do_version++;
3591           do_histogram++;
3592           do_arch++;
3593           do_notes++;
3594           break;
3595         case 'g':
3596           do_section_groups++;
3597           break;
3598         case 't':
3599         case 'N':
3600           do_sections++;
3601           do_section_details++;
3602           break;
3603         case 'e':
3604           do_header++;
3605           do_sections++;
3606           do_segments++;
3607           break;
3608         case 'A':
3609           do_arch++;
3610           break;
3611         case 'D':
3612           do_using_dynamic++;
3613           break;
3614         case 'r':
3615           do_reloc++;
3616           break;
3617         case 'u':
3618           do_unwind++;
3619           break;
3620         case 'h':
3621           do_header++;
3622           break;
3623         case 'l':
3624           do_segments++;
3625           break;
3626         case 's':
3627           do_syms++;
3628           break;
3629         case 'S':
3630           do_sections++;
3631           break;
3632         case 'd':
3633           do_dynamic++;
3634           break;
3635         case 'I':
3636           do_histogram++;
3637           break;
3638         case 'n':
3639           do_notes++;
3640           break;
3641         case 'c':
3642           do_archive_index++;
3643           break;
3644         case 'x':
3645           request_dump (HEX_DUMP);
3646           break;
3647         case 'p':
3648           request_dump (STRING_DUMP);
3649           break;
3650         case 'R':
3651           request_dump (RELOC_DUMP);
3652           break;
3653         case 'w':
3654           do_dump++;
3655           if (optarg == 0)
3656             {
3657               do_debugging = 1;
3658               dwarf_select_sections_all ();
3659             }
3660           else
3661             {
3662               do_debugging = 0;
3663               dwarf_select_sections_by_letters (optarg);
3664             }
3665           break;
3666         case OPTION_DEBUG_DUMP:
3667           do_dump++;
3668           if (optarg == 0)
3669             do_debugging = 1;
3670           else
3671             {
3672               do_debugging = 0;
3673               dwarf_select_sections_by_names (optarg);
3674             }
3675           break;
3676         case OPTION_DWARF_DEPTH:
3677           {
3678             char *cp;
3679
3680             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3681           }
3682           break;
3683         case OPTION_DWARF_START:
3684           {
3685             char *cp;
3686
3687             dwarf_start_die = strtoul (optarg, & cp, 0);
3688           }
3689           break;
3690         case OPTION_DWARF_CHECK:
3691           dwarf_check = 1;
3692           break;
3693         case OPTION_DYN_SYMS:
3694           do_dyn_syms++;
3695           break;
3696 #ifdef SUPPORT_DISASSEMBLY
3697         case 'i':
3698           request_dump (DISASS_DUMP);
3699           break;
3700 #endif
3701         case 'v':
3702           print_version (program_name);
3703           break;
3704         case 'V':
3705           do_version++;
3706           break;
3707         case 'W':
3708           do_wide++;
3709           break;
3710         default:
3711           /* xgettext:c-format */
3712           error (_("Invalid option '-%c'\n"), c);
3713           /* Drop through.  */
3714         case '?':
3715           usage (stderr);
3716         }
3717     }
3718
3719   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3720       && !do_segments && !do_header && !do_dump && !do_version
3721       && !do_histogram && !do_debugging && !do_arch && !do_notes
3722       && !do_section_groups && !do_archive_index
3723       && !do_dyn_syms)
3724     usage (stderr);
3725   else if (argc < 3)
3726     {
3727       warn (_("Nothing to do.\n"));
3728       usage (stderr);
3729     }
3730 }
3731
3732 static const char *
3733 get_elf_class (unsigned int elf_class)
3734 {
3735   static char buff[32];
3736
3737   switch (elf_class)
3738     {
3739     case ELFCLASSNONE: return _("none");
3740     case ELFCLASS32:   return "ELF32";
3741     case ELFCLASS64:   return "ELF64";
3742     default:
3743       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3744       return buff;
3745     }
3746 }
3747
3748 static const char *
3749 get_data_encoding (unsigned int encoding)
3750 {
3751   static char buff[32];
3752
3753   switch (encoding)
3754     {
3755     case ELFDATANONE: return _("none");
3756     case ELFDATA2LSB: return _("2's complement, little endian");
3757     case ELFDATA2MSB: return _("2's complement, big endian");
3758     default:
3759       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3760       return buff;
3761     }
3762 }
3763
3764 /* Decode the data held in 'elf_header'.  */
3765
3766 static int
3767 process_file_header (void)
3768 {
3769   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
3770       || elf_header.e_ident[EI_MAG1] != ELFMAG1
3771       || elf_header.e_ident[EI_MAG2] != ELFMAG2
3772       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3773     {
3774       error
3775         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3776       return 0;
3777     }
3778
3779   init_dwarf_regnames (elf_header.e_machine);
3780
3781   if (do_header)
3782     {
3783       int i;
3784
3785       printf (_("ELF Header:\n"));
3786       printf (_("  Magic:   "));
3787       for (i = 0; i < EI_NIDENT; i++)
3788         printf ("%2.2x ", elf_header.e_ident[i]);
3789       printf ("\n");
3790       printf (_("  Class:                             %s\n"),
3791               get_elf_class (elf_header.e_ident[EI_CLASS]));
3792       printf (_("  Data:                              %s\n"),
3793               get_data_encoding (elf_header.e_ident[EI_DATA]));
3794       printf (_("  Version:                           %d %s\n"),
3795               elf_header.e_ident[EI_VERSION],
3796               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3797                ? "(current)"
3798                : (elf_header.e_ident[EI_VERSION] != EV_NONE
3799                   ? _("<unknown: %lx>")
3800                   : "")));
3801       printf (_("  OS/ABI:                            %s\n"),
3802               get_osabi_name (elf_header.e_ident[EI_OSABI]));
3803       printf (_("  ABI Version:                       %d\n"),
3804               elf_header.e_ident[EI_ABIVERSION]);
3805       printf (_("  Type:                              %s\n"),
3806               get_file_type (elf_header.e_type));
3807       printf (_("  Machine:                           %s\n"),
3808               get_machine_name (elf_header.e_machine));
3809       printf (_("  Version:                           0x%lx\n"),
3810               (unsigned long) elf_header.e_version);
3811
3812       printf (_("  Entry point address:               "));
3813       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3814       printf (_("\n  Start of program headers:          "));
3815       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3816       printf (_(" (bytes into file)\n  Start of section headers:          "));
3817       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3818       printf (_(" (bytes into file)\n"));
3819
3820       printf (_("  Flags:                             0x%lx%s\n"),
3821               (unsigned long) elf_header.e_flags,
3822               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3823       printf (_("  Size of this header:               %ld (bytes)\n"),
3824               (long) elf_header.e_ehsize);
3825       printf (_("  Size of program headers:           %ld (bytes)\n"),
3826               (long) elf_header.e_phentsize);
3827       printf (_("  Number of program headers:         %ld"),
3828               (long) elf_header.e_phnum);
3829       if (section_headers != NULL
3830           && elf_header.e_phnum == PN_XNUM
3831           && section_headers[0].sh_info != 0)
3832         printf (" (%ld)", (long) section_headers[0].sh_info);
3833       putc ('\n', stdout);
3834       printf (_("  Size of section headers:           %ld (bytes)\n"),
3835               (long) elf_header.e_shentsize);
3836       printf (_("  Number of section headers:         %ld"),
3837               (long) elf_header.e_shnum);
3838       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
3839         printf (" (%ld)", (long) section_headers[0].sh_size);
3840       putc ('\n', stdout);
3841       printf (_("  Section header string table index: %ld"),
3842               (long) elf_header.e_shstrndx);
3843       if (section_headers != NULL
3844           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3845         printf (" (%u)", section_headers[0].sh_link);
3846       else if (elf_header.e_shstrndx != SHN_UNDEF
3847                && elf_header.e_shstrndx >= elf_header.e_shnum)
3848         printf (_(" <corrupt: out of range>"));
3849       putc ('\n', stdout);
3850     }
3851
3852   if (section_headers != NULL)
3853     {
3854       if (elf_header.e_phnum == PN_XNUM
3855           && section_headers[0].sh_info != 0)
3856         elf_header.e_phnum = section_headers[0].sh_info;
3857       if (elf_header.e_shnum == SHN_UNDEF)
3858         elf_header.e_shnum = section_headers[0].sh_size;
3859       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3860         elf_header.e_shstrndx = section_headers[0].sh_link;
3861       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3862         elf_header.e_shstrndx = SHN_UNDEF;
3863       free (section_headers);
3864       section_headers = NULL;
3865     }
3866
3867   return 1;
3868 }
3869
3870
3871 static int
3872 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3873 {
3874   Elf32_External_Phdr * phdrs;
3875   Elf32_External_Phdr * external;
3876   Elf_Internal_Phdr *   internal;
3877   unsigned int i;
3878
3879   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3880                                             elf_header.e_phentsize,
3881                                             elf_header.e_phnum,
3882                                             _("program headers"));
3883   if (!phdrs)
3884     return 0;
3885
3886   for (i = 0, internal = pheaders, external = phdrs;
3887        i < elf_header.e_phnum;
3888        i++, internal++, external++)
3889     {
3890       internal->p_type   = BYTE_GET (external->p_type);
3891       internal->p_offset = BYTE_GET (external->p_offset);
3892       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
3893       internal->p_paddr  = BYTE_GET (external->p_paddr);
3894       internal->p_filesz = BYTE_GET (external->p_filesz);
3895       internal->p_memsz  = BYTE_GET (external->p_memsz);
3896       internal->p_flags  = BYTE_GET (external->p_flags);
3897       internal->p_align  = BYTE_GET (external->p_align);
3898     }
3899
3900   free (phdrs);
3901
3902   return 1;
3903 }
3904
3905 static int
3906 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3907 {
3908   Elf64_External_Phdr * phdrs;
3909   Elf64_External_Phdr * external;
3910   Elf_Internal_Phdr *   internal;
3911   unsigned int i;
3912
3913   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3914                                             elf_header.e_phentsize,
3915                                             elf_header.e_phnum,
3916                                             _("program headers"));
3917   if (!phdrs)
3918     return 0;
3919
3920   for (i = 0, internal = pheaders, external = phdrs;
3921        i < elf_header.e_phnum;
3922        i++, internal++, external++)
3923     {
3924       internal->p_type   = BYTE_GET (external->p_type);
3925       internal->p_flags  = BYTE_GET (external->p_flags);
3926       internal->p_offset = BYTE_GET (external->p_offset);
3927       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
3928       internal->p_paddr  = BYTE_GET (external->p_paddr);
3929       internal->p_filesz = BYTE_GET (external->p_filesz);
3930       internal->p_memsz  = BYTE_GET (external->p_memsz);
3931       internal->p_align  = BYTE_GET (external->p_align);
3932     }
3933
3934   free (phdrs);
3935
3936   return 1;
3937 }
3938
3939 /* Returns 1 if the program headers were read into `program_headers'.  */
3940
3941 static int
3942 get_program_headers (FILE * file)
3943 {
3944   Elf_Internal_Phdr * phdrs;
3945
3946   /* Check cache of prior read.  */
3947   if (program_headers != NULL)
3948     return 1;
3949
3950   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3951                                          sizeof (Elf_Internal_Phdr));
3952
3953   if (phdrs == NULL)
3954     {
3955       error (_("Out of memory\n"));
3956       return 0;
3957     }
3958
3959   if (is_32bit_elf
3960       ? get_32bit_program_headers (file, phdrs)
3961       : get_64bit_program_headers (file, phdrs))
3962     {
3963       program_headers = phdrs;
3964       return 1;
3965     }
3966
3967   free (phdrs);
3968   return 0;
3969 }
3970
3971 /* Returns 1 if the program headers were loaded.  */
3972
3973 static int
3974 process_program_headers (FILE * file)
3975 {
3976   Elf_Internal_Phdr * segment;
3977   unsigned int i;
3978
3979   if (elf_header.e_phnum == 0)
3980     {
3981       /* PR binutils/12467.  */
3982       if (elf_header.e_phoff != 0)
3983         warn (_("possibly corrupt ELF header - it has a non-zero program"
3984                 " header offset, but no program headers"));
3985       else if (do_segments)
3986         printf (_("\nThere are no program headers in this file.\n"));
3987       return 0;
3988     }
3989
3990   if (do_segments && !do_header)
3991     {
3992       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3993       printf (_("Entry point "));
3994       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3995       printf (_("\nThere are %d program headers, starting at offset "),
3996               elf_header.e_phnum);
3997       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3998       printf ("\n");
3999     }
4000
4001   if (! get_program_headers (file))
4002       return 0;
4003
4004   if (do_segments)
4005     {
4006       if (elf_header.e_phnum > 1)
4007         printf (_("\nProgram Headers:\n"));
4008       else
4009         printf (_("\nProgram Headers:\n"));
4010
4011       if (is_32bit_elf)
4012         printf
4013           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4014       else if (do_wide)
4015         printf
4016           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4017       else
4018         {
4019           printf
4020             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4021           printf
4022             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4023         }
4024     }
4025
4026   dynamic_addr = 0;
4027   dynamic_size = 0;
4028
4029   for (i = 0, segment = program_headers;
4030        i < elf_header.e_phnum;
4031        i++, segment++)
4032     {
4033       if (do_segments)
4034         {
4035           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4036
4037           if (is_32bit_elf)
4038             {
4039               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4040               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4041               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4042               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4043               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4044               printf ("%c%c%c ",
4045                       (segment->p_flags & PF_R ? 'R' : ' '),
4046                       (segment->p_flags & PF_W ? 'W' : ' '),
4047                       (segment->p_flags & PF_X ? 'E' : ' '));
4048               printf ("%#lx", (unsigned long) segment->p_align);
4049             }
4050           else if (do_wide)
4051             {
4052               if ((unsigned long) segment->p_offset == segment->p_offset)
4053                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4054               else
4055                 {
4056                   print_vma (segment->p_offset, FULL_HEX);
4057                   putchar (' ');
4058                 }
4059
4060               print_vma (segment->p_vaddr, FULL_HEX);
4061               putchar (' ');
4062               print_vma (segment->p_paddr, FULL_HEX);
4063               putchar (' ');
4064
4065               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4066                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4067               else
4068                 {
4069                   print_vma (segment->p_filesz, FULL_HEX);
4070                   putchar (' ');
4071                 }
4072
4073               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4074                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4075               else
4076                 {
4077                   print_vma (segment->p_memsz, FULL_HEX);
4078                 }
4079
4080               printf (" %c%c%c ",
4081                       (segment->p_flags & PF_R ? 'R' : ' '),
4082                       (segment->p_flags & PF_W ? 'W' : ' '),
4083                       (segment->p_flags & PF_X ? 'E' : ' '));
4084
4085               if ((unsigned long) segment->p_align == segment->p_align)
4086                 printf ("%#lx", (unsigned long) segment->p_align);
4087               else
4088                 {
4089                   print_vma (segment->p_align, PREFIX_HEX);
4090                 }
4091             }
4092           else
4093             {
4094               print_vma (segment->p_offset, FULL_HEX);
4095               putchar (' ');
4096               print_vma (segment->p_vaddr, FULL_HEX);
4097               putchar (' ');
4098               print_vma (segment->p_paddr, FULL_HEX);
4099               printf ("\n                 ");
4100               print_vma (segment->p_filesz, FULL_HEX);
4101               putchar (' ');
4102               print_vma (segment->p_memsz, FULL_HEX);
4103               printf ("  %c%c%c    ",
4104                       (segment->p_flags & PF_R ? 'R' : ' '),
4105                       (segment->p_flags & PF_W ? 'W' : ' '),
4106                       (segment->p_flags & PF_X ? 'E' : ' '));
4107               print_vma (segment->p_align, HEX);
4108             }
4109         }
4110
4111       switch (segment->p_type)
4112         {
4113         case PT_DYNAMIC:
4114           if (dynamic_addr)
4115             error (_("more than one dynamic segment\n"));
4116
4117           /* By default, assume that the .dynamic section is the first
4118              section in the DYNAMIC segment.  */
4119           dynamic_addr = segment->p_offset;
4120           dynamic_size = segment->p_filesz;
4121
4122           /* Try to locate the .dynamic section. If there is
4123              a section header table, we can easily locate it.  */
4124           if (section_headers != NULL)
4125             {
4126               Elf_Internal_Shdr * sec;
4127
4128               sec = find_section (".dynamic");
4129               if (sec == NULL || sec->sh_size == 0)
4130                 {
4131                   /* A corresponding .dynamic section is expected, but on
4132                      IA-64/OpenVMS it is OK for it to be missing.  */
4133                   if (!is_ia64_vms ())
4134                     error (_("no .dynamic section in the dynamic segment\n"));
4135                   break;
4136                 }
4137
4138               if (sec->sh_type == SHT_NOBITS)
4139                 {
4140                   dynamic_size = 0;
4141                   break;
4142                 }
4143
4144               dynamic_addr = sec->sh_offset;
4145               dynamic_size = sec->sh_size;
4146
4147               if (dynamic_addr < segment->p_offset
4148                   || dynamic_addr > segment->p_offset + segment->p_filesz)
4149                 warn (_("the .dynamic section is not contained"
4150                         " within the dynamic segment\n"));
4151               else if (dynamic_addr > segment->p_offset)
4152                 warn (_("the .dynamic section is not the first section"
4153                         " in the dynamic segment.\n"));
4154             }
4155           break;
4156
4157         case PT_INTERP:
4158           if (fseek (file, archive_file_offset + (long) segment->p_offset,
4159                      SEEK_SET))
4160             error (_("Unable to find program interpreter name\n"));
4161           else
4162             {
4163               char fmt [32];
4164               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
4165
4166               if (ret >= (int) sizeof (fmt) || ret < 0)
4167                 error (_("Internal error: failed to create format string to display program interpreter\n"));
4168
4169               program_interpreter[0] = 0;
4170               if (fscanf (file, fmt, program_interpreter) <= 0)
4171                 error (_("Unable to read program interpreter name\n"));
4172
4173               if (do_segments)
4174                 printf (_("\n      [Requesting program interpreter: %s]"),
4175                     program_interpreter);
4176             }
4177           break;
4178         }
4179
4180       if (do_segments)
4181         putc ('\n', stdout);
4182     }
4183
4184   if (do_segments && section_headers != NULL && string_table != NULL)
4185     {
4186       printf (_("\n Section to Segment mapping:\n"));
4187       printf (_("  Segment Sections...\n"));
4188
4189       for (i = 0; i < elf_header.e_phnum; i++)
4190         {
4191           unsigned int j;
4192           Elf_Internal_Shdr * section;
4193
4194           segment = program_headers + i;
4195           section = section_headers + 1;
4196
4197           printf ("   %2.2d     ", i);
4198
4199           for (j = 1; j < elf_header.e_shnum; j++, section++)
4200             {
4201               if (!ELF_TBSS_SPECIAL (section, segment)
4202                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4203                 printf ("%s ", SECTION_NAME (section));
4204             }
4205
4206           putc ('\n',stdout);
4207         }
4208     }
4209
4210   return 1;
4211 }
4212
4213
4214 /* Find the file offset corresponding to VMA by using the program headers.  */
4215
4216 static long
4217 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4218 {
4219   Elf_Internal_Phdr * seg;
4220
4221   if (! get_program_headers (file))
4222     {
4223       warn (_("Cannot interpret virtual addresses without program headers.\n"));
4224       return (long) vma;
4225     }
4226
4227   for (seg = program_headers;
4228        seg < program_headers + elf_header.e_phnum;
4229        ++seg)
4230     {
4231       if (seg->p_type != PT_LOAD)
4232         continue;
4233
4234       if (vma >= (seg->p_vaddr & -seg->p_align)
4235           && vma + size <= seg->p_vaddr + seg->p_filesz)
4236         return vma - seg->p_vaddr + seg->p_offset;
4237     }
4238
4239   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4240         (unsigned long) vma);
4241   return (long) vma;
4242 }
4243
4244
4245 static int
4246 get_32bit_section_headers (FILE * file, unsigned int num)
4247 {
4248   Elf32_External_Shdr * shdrs;
4249   Elf_Internal_Shdr *   internal;
4250   unsigned int i;
4251
4252   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4253                                             elf_header.e_shentsize, num,
4254                                             _("section headers"));
4255   if (!shdrs)
4256     return 0;
4257
4258   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4259                                                    sizeof (Elf_Internal_Shdr));
4260
4261   if (section_headers == NULL)
4262     {
4263       error (_("Out of memory\n"));
4264       return 0;
4265     }
4266
4267   for (i = 0, internal = section_headers;
4268        i < num;
4269        i++, internal++)
4270     {
4271       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4272       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4273       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4274       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4275       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4276       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4277       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4278       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4279       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4280       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4281     }
4282
4283   free (shdrs);
4284
4285   return 1;
4286 }
4287
4288 static int
4289 get_64bit_section_headers (FILE * file, unsigned int num)
4290 {
4291   Elf64_External_Shdr * shdrs;
4292   Elf_Internal_Shdr *   internal;
4293   unsigned int i;
4294
4295   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4296                                             elf_header.e_shentsize, num,
4297                                             _("section headers"));
4298   if (!shdrs)
4299     return 0;
4300
4301   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4302                                                    sizeof (Elf_Internal_Shdr));
4303
4304   if (section_headers == NULL)
4305     {
4306       error (_("Out of memory\n"));
4307       return 0;
4308     }
4309
4310   for (i = 0, internal = section_headers;
4311        i < num;
4312        i++, internal++)
4313     {
4314       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4315       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4316       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4317       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4318       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4319       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4320       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4321       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4322       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4323       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4324     }
4325
4326   free (shdrs);
4327
4328   return 1;
4329 }
4330
4331 static Elf_Internal_Sym *
4332 get_32bit_elf_symbols (FILE * file,
4333                        Elf_Internal_Shdr * section,
4334                        unsigned long * num_syms_return)
4335 {
4336   unsigned long number = 0;
4337   Elf32_External_Sym * esyms = NULL;
4338   Elf_External_Sym_Shndx * shndx = NULL;
4339   Elf_Internal_Sym * isyms = NULL;
4340   Elf_Internal_Sym * psym;
4341   unsigned int j;
4342
4343   /* Run some sanity checks first.  */
4344   if (section->sh_entsize == 0)
4345     {
4346       error (_("sh_entsize is zero\n"));
4347       goto exit_point;
4348     }
4349
4350   number = section->sh_size / section->sh_entsize;
4351
4352   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4353     {
4354       error (_("Invalid sh_entsize\n"));
4355       goto exit_point;
4356     }
4357
4358   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4359                                            section->sh_size, _("symbols"));
4360   if (esyms == NULL)
4361     goto exit_point;
4362
4363   shndx = NULL;
4364   if (symtab_shndx_hdr != NULL
4365       && (symtab_shndx_hdr->sh_link
4366           == (unsigned long) (section - section_headers)))
4367     {
4368       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4369                                                    symtab_shndx_hdr->sh_offset,
4370                                                    1, symtab_shndx_hdr->sh_size,
4371                                                    _("symbol table section indicies"));
4372       if (shndx == NULL)
4373         goto exit_point;
4374     }
4375
4376   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4377
4378   if (isyms == NULL)
4379     {
4380       error (_("Out of memory\n"));
4381       goto exit_point;
4382     }
4383
4384   for (j = 0, psym = isyms; j < number; j++, psym++)
4385     {
4386       psym->st_name  = BYTE_GET (esyms[j].st_name);
4387       psym->st_value = BYTE_GET (esyms[j].st_value);
4388       psym->st_size  = BYTE_GET (esyms[j].st_size);
4389       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4390       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4391         psym->st_shndx
4392           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4393       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4394         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4395       psym->st_info  = BYTE_GET (esyms[j].st_info);
4396       psym->st_other = BYTE_GET (esyms[j].st_other);
4397     }
4398
4399  exit_point:
4400   if (shndx != NULL)
4401     free (shndx);
4402   if (esyms != NULL)
4403     free (esyms);
4404
4405   if (num_syms_return != NULL)
4406     * num_syms_return = isyms == NULL ? 0 : number;
4407
4408   return isyms;
4409 }
4410
4411 static Elf_Internal_Sym *
4412 get_64bit_elf_symbols (FILE * file,
4413                        Elf_Internal_Shdr * section,
4414                        unsigned long * num_syms_return)
4415 {
4416   unsigned long number = 0;
4417   Elf64_External_Sym * esyms = NULL;
4418   Elf_External_Sym_Shndx * shndx = NULL;
4419   Elf_Internal_Sym * isyms = NULL;
4420   Elf_Internal_Sym * psym;
4421   unsigned int j;
4422
4423   /* Run some sanity checks first.  */
4424   if (section->sh_entsize == 0)
4425     {
4426       error (_("sh_entsize is zero\n"));
4427       goto exit_point;
4428     }
4429
4430   number = section->sh_size / section->sh_entsize;
4431
4432   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4433     {
4434       error (_("Invalid sh_entsize\n"));
4435       goto exit_point;
4436     }
4437
4438   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4439                                            section->sh_size, _("symbols"));
4440   if (!esyms)
4441     goto exit_point;
4442
4443   if (symtab_shndx_hdr != NULL
4444       && (symtab_shndx_hdr->sh_link
4445           == (unsigned long) (section - section_headers)))
4446     {
4447       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4448                                                    symtab_shndx_hdr->sh_offset,
4449                                                    1, symtab_shndx_hdr->sh_size,
4450                                                    _("symbol table section indicies"));
4451       if (shndx == NULL)
4452         goto exit_point;
4453     }
4454
4455   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4456
4457   if (isyms == NULL)
4458     {
4459       error (_("Out of memory\n"));
4460       goto exit_point;
4461     }
4462
4463   for (j = 0, psym = isyms; j < number; j++, psym++)
4464     {
4465       psym->st_name  = BYTE_GET (esyms[j].st_name);
4466       psym->st_info  = BYTE_GET (esyms[j].st_info);
4467       psym->st_other = BYTE_GET (esyms[j].st_other);
4468       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4469
4470       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4471         psym->st_shndx
4472           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4473       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4474         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4475
4476       psym->st_value = BYTE_GET (esyms[j].st_value);
4477       psym->st_size  = BYTE_GET (esyms[j].st_size);
4478     }
4479
4480  exit_point:
4481   if (shndx != NULL)
4482     free (shndx);
4483   if (esyms != NULL)
4484     free (esyms);
4485
4486   if (num_syms_return != NULL)
4487     * num_syms_return = isyms == NULL ? 0 : number;
4488
4489   return isyms;
4490 }
4491
4492 static const char *
4493 get_elf_section_flags (bfd_vma sh_flags)
4494 {
4495   static char buff[1024];
4496   char * p = buff;
4497   int field_size = is_32bit_elf ? 8 : 16;
4498   int sindex;
4499   int size = sizeof (buff) - (field_size + 4 + 1);
4500   bfd_vma os_flags = 0;
4501   bfd_vma proc_flags = 0;
4502   bfd_vma unknown_flags = 0;
4503   static const struct
4504     {
4505       const char * str;
4506       int len;
4507     }
4508   flags [] =
4509     {
4510       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
4511       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
4512       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
4513       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
4514       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
4515       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
4516       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4517       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4518       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
4519       /*  9 */ { STRING_COMMA_LEN ("TLS") },
4520       /* IA-64 specific.  */
4521       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4522       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4523       /* IA-64 OpenVMS specific.  */
4524       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4525       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4526       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4527       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4528       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4529       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4530       /* Generic.  */
4531       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4532       /* SPARC specific.  */
4533       /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4534     };
4535
4536   if (do_section_details)
4537     {
4538       sprintf (buff, "[%*.*lx]: ",
4539                field_size, field_size, (unsigned long) sh_flags);
4540       p += field_size + 4;
4541     }
4542
4543   while (sh_flags)
4544     {
4545       bfd_vma flag;
4546
4547       flag = sh_flags & - sh_flags;
4548       sh_flags &= ~ flag;
4549
4550       if (do_section_details)
4551         {
4552           switch (flag)
4553             {
4554             case SHF_WRITE:             sindex = 0; break;
4555             case SHF_ALLOC:             sindex = 1; break;
4556             case SHF_EXECINSTR:         sindex = 2; break;
4557             case SHF_MERGE:             sindex = 3; break;
4558             case SHF_STRINGS:           sindex = 4; break;
4559             case SHF_INFO_LINK:         sindex = 5; break;
4560             case SHF_LINK_ORDER:        sindex = 6; break;
4561             case SHF_OS_NONCONFORMING:  sindex = 7; break;
4562             case SHF_GROUP:             sindex = 8; break;
4563             case SHF_TLS:               sindex = 9; break;
4564             case SHF_EXCLUDE:           sindex = 18; break;
4565
4566             default:
4567               sindex = -1;
4568               switch (elf_header.e_machine)
4569                 {
4570                 case EM_IA_64:
4571                   if (flag == SHF_IA_64_SHORT)
4572                     sindex = 10;
4573                   else if (flag == SHF_IA_64_NORECOV)
4574                     sindex = 11;
4575 #ifdef BFD64
4576                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4577                     switch (flag)
4578                       {
4579                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
4580                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
4581                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
4582                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
4583                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4584                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
4585                       default:                        break;
4586                       }
4587 #endif
4588                   break;
4589
4590                 case EM_386:
4591                 case EM_486:
4592                 case EM_X86_64:
4593                 case EM_L1OM:
4594                 case EM_K1OM:
4595                 case EM_OLD_SPARCV9:
4596                 case EM_SPARC32PLUS:
4597                 case EM_SPARCV9:
4598                 case EM_SPARC:
4599                   if (flag == SHF_ORDERED)
4600                     sindex = 19;
4601                   break;
4602                 default:
4603                   break;
4604                 }
4605             }
4606
4607           if (sindex != -1)
4608             {
4609               if (p != buff + field_size + 4)
4610                 {
4611                   if (size < (10 + 2))
4612                     abort ();
4613                   size -= 2;
4614                   *p++ = ',';
4615                   *p++ = ' ';
4616                 }
4617
4618               size -= flags [sindex].len;
4619               p = stpcpy (p, flags [sindex].str);
4620             }
4621           else if (flag & SHF_MASKOS)
4622             os_flags |= flag;
4623           else if (flag & SHF_MASKPROC)
4624             proc_flags |= flag;
4625           else
4626             unknown_flags |= flag;
4627         }
4628       else
4629         {
4630           switch (flag)
4631             {
4632             case SHF_WRITE:             *p = 'W'; break;
4633             case SHF_ALLOC:             *p = 'A'; break;
4634             case SHF_EXECINSTR:         *p = 'X'; break;
4635             case SHF_MERGE:             *p = 'M'; break;
4636             case SHF_STRINGS:           *p = 'S'; break;
4637             case SHF_INFO_LINK:         *p = 'I'; break;
4638             case SHF_LINK_ORDER:        *p = 'L'; break;
4639             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
4640             case SHF_GROUP:             *p = 'G'; break;
4641             case SHF_TLS:               *p = 'T'; break;
4642             case SHF_EXCLUDE:           *p = 'E'; break;
4643
4644             default:
4645               if ((elf_header.e_machine == EM_X86_64
4646                    || elf_header.e_machine == EM_L1OM
4647                    || elf_header.e_machine == EM_K1OM)
4648                   && flag == SHF_X86_64_LARGE)
4649                 *p = 'l';
4650               else if (flag & SHF_MASKOS)
4651                 {
4652                   *p = 'o';
4653                   sh_flags &= ~ SHF_MASKOS;
4654                 }
4655               else if (flag & SHF_MASKPROC)
4656                 {
4657                   *p = 'p';
4658                   sh_flags &= ~ SHF_MASKPROC;
4659                 }
4660               else
4661                 *p = 'x';
4662               break;
4663             }
4664           p++;
4665         }
4666     }
4667
4668   if (do_section_details)
4669     {
4670       if (os_flags)
4671         {
4672           size -= 5 + field_size;
4673           if (p != buff + field_size + 4)
4674             {
4675               if (size < (2 + 1))
4676                 abort ();
4677               size -= 2;
4678               *p++ = ',';
4679               *p++ = ' ';
4680             }
4681           sprintf (p, "OS (%*.*lx)", field_size, field_size,
4682                    (unsigned long) os_flags);
4683           p += 5 + field_size;
4684         }
4685       if (proc_flags)
4686         {
4687           size -= 7 + field_size;
4688           if (p != buff + field_size + 4)
4689             {
4690               if (size < (2 + 1))
4691                 abort ();
4692               size -= 2;
4693               *p++ = ',';
4694               *p++ = ' ';
4695             }
4696           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4697                    (unsigned long) proc_flags);
4698           p += 7 + field_size;
4699         }
4700       if (unknown_flags)
4701         {
4702           size -= 10 + field_size;
4703           if (p != buff + field_size + 4)
4704             {
4705               if (size < (2 + 1))
4706                 abort ();
4707               size -= 2;
4708               *p++ = ',';
4709               *p++ = ' ';
4710             }
4711           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
4712                    (unsigned long) unknown_flags);
4713           p += 10 + field_size;
4714         }
4715     }
4716
4717   *p = '\0';
4718   return buff;
4719 }
4720
4721 static int
4722 process_section_headers (FILE * file)
4723 {
4724   Elf_Internal_Shdr * section;
4725   unsigned int i;
4726
4727   section_headers = NULL;
4728
4729   if (elf_header.e_shnum == 0)
4730     {
4731       /* PR binutils/12467.  */
4732       if (elf_header.e_shoff != 0)
4733         warn (_("possibly corrupt ELF file header - it has a non-zero"
4734                 " section header offset, but no section headers\n"));
4735       else if (do_sections)
4736         printf (_("\nThere are no sections in this file.\n"));
4737
4738       return 1;
4739     }
4740
4741   if (do_sections && !do_header)
4742     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4743             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4744
4745   if (is_32bit_elf)
4746     {
4747       if (! get_32bit_section_headers (file, elf_header.e_shnum))
4748         return 0;
4749     }
4750   else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4751     return 0;
4752
4753   /* Read in the string table, so that we have names to display.  */
4754   if (elf_header.e_shstrndx != SHN_UNDEF
4755        && elf_header.e_shstrndx < elf_header.e_shnum)
4756     {
4757       section = section_headers + elf_header.e_shstrndx;
4758
4759       if (section->sh_size != 0)
4760         {
4761           string_table = (char *) get_data (NULL, file, section->sh_offset,
4762                                             1, section->sh_size,
4763                                             _("string table"));
4764
4765           string_table_length = string_table != NULL ? section->sh_size : 0;
4766         }
4767     }
4768
4769   /* Scan the sections for the dynamic symbol table
4770      and dynamic string table and debug sections.  */
4771   dynamic_symbols = NULL;
4772   dynamic_strings = NULL;
4773   dynamic_syminfo = NULL;
4774   symtab_shndx_hdr = NULL;
4775
4776   eh_addr_size = is_32bit_elf ? 4 : 8;
4777   switch (elf_header.e_machine)
4778     {
4779     case EM_MIPS:
4780     case EM_MIPS_RS3_LE:
4781       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4782          FDE addresses.  However, the ABI also has a semi-official ILP32
4783          variant for which the normal FDE address size rules apply.
4784
4785          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4786          section, where XX is the size of longs in bits.  Unfortunately,
4787          earlier compilers provided no way of distinguishing ILP32 objects
4788          from LP64 objects, so if there's any doubt, we should assume that
4789          the official LP64 form is being used.  */
4790       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4791           && find_section (".gcc_compiled_long32") == NULL)
4792         eh_addr_size = 8;
4793       break;
4794
4795     case EM_H8_300:
4796     case EM_H8_300H:
4797       switch (elf_header.e_flags & EF_H8_MACH)
4798         {
4799         case E_H8_MACH_H8300:
4800         case E_H8_MACH_H8300HN:
4801         case E_H8_MACH_H8300SN:
4802         case E_H8_MACH_H8300SXN:
4803           eh_addr_size = 2;
4804           break;
4805         case E_H8_MACH_H8300H:
4806         case E_H8_MACH_H8300S:
4807         case E_H8_MACH_H8300SX:
4808           eh_addr_size = 4;
4809           break;
4810         }
4811       break;
4812
4813     case EM_M32C_OLD:
4814     case EM_M32C:
4815       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4816         {
4817         case EF_M32C_CPU_M16C:
4818           eh_addr_size = 2;
4819           break;
4820         }
4821       break;
4822     }
4823
4824 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4825   do                                                                        \
4826     {                                                                       \
4827       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;      \
4828       if (section->sh_entsize != expected_entsize)                          \
4829         {                                                               \
4830           error (_("Section %d has invalid sh_entsize of %" BFD_VMA_FMT "x\n"), \
4831                  i, section->sh_entsize);       \
4832           error (_("(Using the expected size of %d for the rest of this dump)\n"), \
4833                    (int) expected_entsize); \
4834           section->sh_entsize = expected_entsize;                       \
4835         } \
4836     }                                                                       \
4837   while (0)
4838
4839 #define CHECK_ENTSIZE(section, i, type)                                 \
4840   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
4841                         sizeof (Elf64_External_##type))
4842
4843   for (i = 0, section = section_headers;
4844        i < elf_header.e_shnum;
4845        i++, section++)
4846     {
4847       char * name = SECTION_NAME (section);
4848
4849       if (section->sh_type == SHT_DYNSYM)
4850         {
4851           if (dynamic_symbols != NULL)
4852             {
4853               error (_("File contains multiple dynamic symbol tables\n"));
4854               continue;
4855             }
4856
4857           CHECK_ENTSIZE (section, i, Sym);
4858           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
4859         }
4860       else if (section->sh_type == SHT_STRTAB
4861                && streq (name, ".dynstr"))
4862         {
4863           if (dynamic_strings != NULL)
4864             {
4865               error (_("File contains multiple dynamic string tables\n"));
4866               continue;
4867             }
4868
4869           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4870                                                1, section->sh_size,
4871                                                _("dynamic strings"));
4872           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
4873         }
4874       else if (section->sh_type == SHT_SYMTAB_SHNDX)
4875         {
4876           if (symtab_shndx_hdr != NULL)
4877             {
4878               error (_("File contains multiple symtab shndx tables\n"));
4879               continue;
4880             }
4881           symtab_shndx_hdr = section;
4882         }
4883       else if (section->sh_type == SHT_SYMTAB)
4884         CHECK_ENTSIZE (section, i, Sym);
4885       else if (section->sh_type == SHT_GROUP)
4886         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4887       else if (section->sh_type == SHT_REL)
4888         CHECK_ENTSIZE (section, i, Rel);
4889       else if (section->sh_type == SHT_RELA)
4890         CHECK_ENTSIZE (section, i, Rela);
4891       else if ((do_debugging || do_debug_info || do_debug_abbrevs
4892                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
4893                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
4894                 || do_debug_str || do_debug_loc || do_debug_ranges
4895                 || do_debug_addr || do_debug_cu_index)
4896                && (const_strneq (name, ".debug_")
4897                    || const_strneq (name, ".zdebug_")))
4898         {
4899           if (name[1] == 'z')
4900             name += sizeof (".zdebug_") - 1;
4901           else
4902             name += sizeof (".debug_") - 1;
4903
4904           if (do_debugging
4905               || (do_debug_info     && const_strneq (name, "info"))
4906               || (do_debug_info     && const_strneq (name, "types"))
4907               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
4908               || (do_debug_lines    && strcmp (name, "line") == 0)
4909               || (do_debug_lines    && const_strneq (name, "line."))
4910               || (do_debug_pubnames && const_strneq (name, "pubnames"))
4911               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
4912               || (do_debug_aranges  && const_strneq (name, "aranges"))
4913               || (do_debug_ranges   && const_strneq (name, "ranges"))
4914               || (do_debug_frames   && const_strneq (name, "frame"))
4915               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
4916               || (do_debug_macinfo  && const_strneq (name, "macro"))
4917               || (do_debug_str      && const_strneq (name, "str"))
4918               || (do_debug_loc      && const_strneq (name, "loc"))
4919               || (do_debug_addr     && const_strneq (name, "addr"))
4920               || (do_debug_cu_index && const_strneq (name, "cu_index"))
4921               || (do_debug_cu_index && const_strneq (name, "tu_index"))
4922               )
4923             request_dump_bynumber (i, DEBUG_DUMP);
4924         }
4925       /* Linkonce section to be combined with .debug_info at link time.  */
4926       else if ((do_debugging || do_debug_info)
4927                && const_strneq (name, ".gnu.linkonce.wi."))
4928         request_dump_bynumber (i, DEBUG_DUMP);
4929       else if (do_debug_frames && streq (name, ".eh_frame"))
4930         request_dump_bynumber (i, DEBUG_DUMP);
4931       else if (do_gdb_index && streq (name, ".gdb_index"))
4932         request_dump_bynumber (i, DEBUG_DUMP);
4933       /* Trace sections for Itanium VMS.  */
4934       else if ((do_debugging || do_trace_info || do_trace_abbrevs
4935                 || do_trace_aranges)
4936                && const_strneq (name, ".trace_"))
4937         {
4938           name += sizeof (".trace_") - 1;
4939
4940           if (do_debugging
4941               || (do_trace_info     && streq (name, "info"))
4942               || (do_trace_abbrevs  && streq (name, "abbrev"))
4943               || (do_trace_aranges  && streq (name, "aranges"))
4944               )
4945             request_dump_bynumber (i, DEBUG_DUMP);
4946         }
4947
4948     }
4949
4950   if (! do_sections)
4951     return 1;
4952
4953   if (elf_header.e_shnum > 1)
4954     printf (_("\nSection Headers:\n"));
4955   else
4956     printf (_("\nSection Header:\n"));
4957
4958   if (is_32bit_elf)
4959     {
4960       if (do_section_details)
4961         {
4962           printf (_("  [Nr] Name\n"));
4963           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
4964         }
4965       else
4966         printf
4967           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
4968     }
4969   else if (do_wide)
4970     {
4971       if (do_section_details)
4972         {
4973           printf (_("  [Nr] Name\n"));
4974           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
4975         }
4976       else
4977         printf
4978           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
4979     }
4980   else
4981     {
4982       if (do_section_details)
4983         {
4984           printf (_("  [Nr] Name\n"));
4985           printf (_("       Type              Address          Offset            Link\n"));
4986           printf (_("       Size              EntSize          Info              Align\n"));
4987         }
4988       else
4989         {
4990           printf (_("  [Nr] Name              Type             Address           Offset\n"));
4991           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
4992         }
4993     }
4994
4995   if (do_section_details)
4996     printf (_("       Flags\n"));
4997
4998   for (i = 0, section = section_headers;
4999        i < elf_header.e_shnum;
5000        i++, section++)
5001     {
5002       printf ("  [%2u] ", i);
5003       if (do_section_details)
5004         {
5005           print_symbol (INT_MAX, SECTION_NAME (section));
5006           printf ("\n      ");
5007         }
5008       else
5009         {
5010           print_symbol (-17, SECTION_NAME (section));
5011         }
5012
5013       printf (do_wide ? " %-15s " : " %-15.15s ",
5014               get_section_type_name (section->sh_type));
5015
5016       if (is_32bit_elf)
5017         {
5018           const char * link_too_big = NULL;
5019
5020           print_vma (section->sh_addr, LONG_HEX);
5021
5022           printf ( " %6.6lx %6.6lx %2.2lx",
5023                    (unsigned long) section->sh_offset,
5024                    (unsigned long) section->sh_size,
5025                    (unsigned long) section->sh_entsize);
5026
5027           if (do_section_details)
5028             fputs ("  ", stdout);
5029           else
5030             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5031
5032           if (section->sh_link >= elf_header.e_shnum)
5033             {
5034               link_too_big = "";
5035               /* The sh_link value is out of range.  Normally this indicates
5036                  an error but it can have special values in Solaris binaries.  */
5037               switch (elf_header.e_machine)
5038                 {
5039                 case EM_386:
5040                 case EM_486:
5041                 case EM_X86_64:
5042                 case EM_L1OM:
5043                 case EM_K1OM:
5044                 case EM_OLD_SPARCV9:
5045                 case EM_SPARC32PLUS:
5046                 case EM_SPARCV9:
5047                 case EM_SPARC:
5048                   if (section->sh_link == (SHN_BEFORE & 0xffff))
5049                     link_too_big = "BEFORE";
5050                   else if (section->sh_link == (SHN_AFTER & 0xffff))
5051                     link_too_big = "AFTER";
5052                   break;
5053                 default:
5054                   break;
5055                 }
5056             }
5057
5058           if (do_section_details)
5059             {
5060               if (link_too_big != NULL && * link_too_big)
5061                 printf ("<%s> ", link_too_big);
5062               else
5063                 printf ("%2u ", section->sh_link);
5064               printf ("%3u %2lu\n", section->sh_info,
5065                       (unsigned long) section->sh_addralign);
5066             }
5067           else
5068             printf ("%2u %3u %2lu\n",
5069                     section->sh_link,
5070                     section->sh_info,
5071                     (unsigned long) section->sh_addralign);
5072
5073           if (link_too_big && ! * link_too_big)
5074             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5075                   i, section->sh_link);
5076         }
5077       else if (do_wide)
5078         {
5079           print_vma (section->sh_addr, LONG_HEX);
5080
5081           if ((long) section->sh_offset == section->sh_offset)
5082             printf (" %6.6lx", (unsigned long) section->sh_offset);
5083           else
5084             {
5085               putchar (' ');
5086               print_vma (section->sh_offset, LONG_HEX);
5087             }
5088
5089           if ((unsigned long) section->sh_size == section->sh_size)
5090             printf (" %6.6lx", (unsigned long) section->sh_size);
5091           else
5092             {
5093               putchar (' ');
5094               print_vma (section->sh_size, LONG_HEX);
5095             }
5096
5097           if ((unsigned long) section->sh_entsize == section->sh_entsize)
5098             printf (" %2.2lx", (unsigned long) section->sh_entsize);
5099           else
5100             {
5101               putchar (' ');
5102               print_vma (section->sh_entsize, LONG_HEX);
5103             }
5104
5105           if (do_section_details)
5106             fputs ("  ", stdout);
5107           else
5108             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5109
5110           printf ("%2u %3u ", section->sh_link, section->sh_info);
5111
5112           if ((unsigned long) section->sh_addralign == section->sh_addralign)
5113             printf ("%2lu\n", (unsigned long) section->sh_addralign);
5114           else
5115             {
5116               print_vma (section->sh_addralign, DEC);
5117               putchar ('\n');
5118             }
5119         }
5120       else if (do_section_details)
5121         {
5122           printf ("       %-15.15s  ",
5123                   get_section_type_name (section->sh_type));
5124           print_vma (section->sh_addr, LONG_HEX);
5125           if ((long) section->sh_offset == section->sh_offset)
5126             printf ("  %16.16lx", (unsigned long) section->sh_offset);
5127           else
5128             {
5129               printf ("  ");
5130               print_vma (section->sh_offset, LONG_HEX);
5131             }
5132           printf ("  %u\n       ", section->sh_link);
5133           print_vma (section->sh_size, LONG_HEX);
5134           putchar (' ');
5135           print_vma (section->sh_entsize, LONG_HEX);
5136
5137           printf ("  %-16u  %lu\n",
5138                   section->sh_info,
5139                   (unsigned long) section->sh_addralign);
5140         }
5141       else
5142         {
5143           putchar (' ');
5144           print_vma (section->sh_addr, LONG_HEX);
5145           if ((long) section->sh_offset == section->sh_offset)
5146             printf ("  %8.8lx", (unsigned long) section->sh_offset);
5147           else
5148             {
5149               printf ("  ");
5150               print_vma (section->sh_offset, LONG_HEX);
5151             }
5152           printf ("\n       ");
5153           print_vma (section->sh_size, LONG_HEX);
5154           printf ("  ");
5155           print_vma (section->sh_entsize, LONG_HEX);
5156
5157           printf (" %3s ", get_elf_section_flags (section->sh_flags));
5158
5159           printf ("     %2u   %3u     %lu\n",
5160                   section->sh_link,
5161                   section->sh_info,
5162                   (unsigned long) section->sh_addralign);
5163         }
5164
5165       if (do_section_details)
5166         printf ("       %s\n", get_elf_section_flags (section->sh_flags));
5167     }
5168
5169   if (!do_section_details)
5170     {
5171       if (elf_header.e_machine == EM_X86_64
5172           || elf_header.e_machine == EM_L1OM
5173           || elf_header.e_machine == EM_K1OM)
5174         printf (_("Key to Flags:\n\
5175   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5176   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5177   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5178       else
5179         printf (_("Key to Flags:\n\
5180   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5181   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5182   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5183     }
5184
5185   return 1;
5186 }
5187
5188 static const char *
5189 get_group_flags (unsigned int flags)
5190 {
5191   static char buff[32];
5192   switch (flags)
5193     {
5194     case 0:
5195       return "";
5196
5197     case GRP_COMDAT:
5198       return "COMDAT ";
5199
5200    default:
5201       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5202       break;
5203     }
5204   return buff;
5205 }
5206
5207 static int
5208 process_section_groups (FILE * file)
5209 {
5210   Elf_Internal_Shdr * section;
5211   unsigned int i;
5212   struct group * group;
5213   Elf_Internal_Shdr * symtab_sec;
5214   Elf_Internal_Shdr * strtab_sec;
5215   Elf_Internal_Sym * symtab;
5216   unsigned long num_syms;
5217   char * strtab;
5218   size_t strtab_size;
5219
5220   /* Don't process section groups unless needed.  */
5221   if (!do_unwind && !do_section_groups)
5222     return 1;
5223
5224   if (elf_header.e_shnum == 0)
5225     {
5226       if (do_section_groups)
5227         printf (_("\nThere are no sections to group in this file.\n"));
5228
5229       return 1;
5230     }
5231
5232   if (section_headers == NULL)
5233     {
5234       error (_("Section headers are not available!\n"));
5235       /* PR 13622: This can happen with a corrupt ELF header.  */
5236       return 0;
5237     }
5238
5239   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5240                                                      sizeof (struct group *));
5241
5242   if (section_headers_groups == NULL)
5243     {
5244       error (_("Out of memory\n"));
5245       return 0;
5246     }
5247
5248   /* Scan the sections for the group section.  */
5249   group_count = 0;
5250   for (i = 0, section = section_headers;
5251        i < elf_header.e_shnum;
5252        i++, section++)
5253     if (section->sh_type == SHT_GROUP)
5254       group_count++;
5255
5256   if (group_count == 0)
5257     {
5258       if (do_section_groups)
5259         printf (_("\nThere are no section groups in this file.\n"));
5260
5261       return 1;
5262     }
5263
5264   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5265
5266   if (section_groups == NULL)
5267     {
5268       error (_("Out of memory\n"));
5269       return 0;
5270     }
5271
5272   symtab_sec = NULL;
5273   strtab_sec = NULL;
5274   symtab = NULL;
5275   num_syms = 0;
5276   strtab = NULL;
5277   strtab_size = 0;
5278   for (i = 0, section = section_headers, group = section_groups;
5279        i < elf_header.e_shnum;
5280        i++, section++)
5281     {
5282       if (section->sh_type == SHT_GROUP)
5283         {
5284           char * name = SECTION_NAME (section);
5285           char * group_name;
5286           unsigned char * start;
5287           unsigned char * indices;
5288           unsigned int entry, j, size;
5289           Elf_Internal_Shdr * sec;
5290           Elf_Internal_Sym * sym;
5291
5292           /* Get the symbol table.  */
5293           if (section->sh_link >= elf_header.e_shnum
5294               || ((sec = section_headers + section->sh_link)->sh_type
5295                   != SHT_SYMTAB))
5296             {
5297               error (_("Bad sh_link in group section `%s'\n"), name);
5298               continue;
5299             }
5300
5301           if (symtab_sec != sec)
5302             {
5303               symtab_sec = sec;
5304               if (symtab)
5305                 free (symtab);
5306               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5307             }
5308
5309           if (symtab == NULL)
5310             {
5311               error (_("Corrupt header in group section `%s'\n"), name);
5312               continue;
5313             }
5314
5315           if (section->sh_info >= num_syms)
5316             {
5317               error (_("Bad sh_info in group section `%s'\n"), name);
5318               continue;
5319             }
5320
5321           sym = symtab + section->sh_info;
5322
5323           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5324             {
5325               if (sym->st_shndx == 0
5326                   || sym->st_shndx >= elf_header.e_shnum)
5327                 {
5328                   error (_("Bad sh_info in group section `%s'\n"), name);
5329                   continue;
5330                 }
5331
5332               group_name = SECTION_NAME (section_headers + sym->st_shndx);
5333               strtab_sec = NULL;
5334               if (strtab)
5335                 free (strtab);
5336               strtab = NULL;
5337               strtab_size = 0;
5338             }
5339           else
5340             {
5341               /* Get the string table.  */
5342               if (symtab_sec->sh_link >= elf_header.e_shnum)
5343                 {
5344                   strtab_sec = NULL;
5345                   if (strtab)
5346                     free (strtab);
5347                   strtab = NULL;
5348                   strtab_size = 0;
5349                 }
5350               else if (strtab_sec
5351                        != (sec = section_headers + symtab_sec->sh_link))
5352                 {
5353                   strtab_sec = sec;
5354                   if (strtab)
5355                     free (strtab);
5356                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5357                                               1, strtab_sec->sh_size,
5358                                               _("string table"));
5359                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5360                 }
5361               group_name = sym->st_name < strtab_size
5362                 ? strtab + sym->st_name : _("<corrupt>");
5363             }
5364
5365           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5366                                               1, section->sh_size,
5367                                               _("section data"));
5368           if (start == NULL)
5369             continue;
5370
5371           indices = start;
5372           size = (section->sh_size / section->sh_entsize) - 1;
5373           entry = byte_get (indices, 4);
5374           indices += 4;
5375
5376           if (do_section_groups)
5377             {
5378               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5379                       get_group_flags (entry), i, name, group_name, size);
5380
5381               printf (_("   [Index]    Name\n"));
5382             }
5383
5384           group->group_index = i;
5385
5386           for (j = 0; j < size; j++)
5387             {
5388               struct group_list * g;
5389
5390               entry = byte_get (indices, 4);
5391               indices += 4;
5392
5393               if (entry >= elf_header.e_shnum)
5394                 {
5395                   error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5396                          entry, i, elf_header.e_shnum - 1);
5397                   continue;
5398                 }
5399
5400               if (section_headers_groups [entry] != NULL)
5401                 {
5402                   if (entry)
5403                     {
5404                       error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5405                              entry, i,
5406                              section_headers_groups [entry]->group_index);
5407                       continue;
5408                     }
5409                   else
5410                     {
5411                       /* Intel C/C++ compiler may put section 0 in a
5412                          section group. We just warn it the first time
5413                          and ignore it afterwards.  */
5414                       static int warned = 0;
5415                       if (!warned)
5416                         {
5417                           error (_("section 0 in group section [%5u]\n"),
5418                                  section_headers_groups [entry]->group_index);
5419                           warned++;
5420                         }
5421                     }
5422                 }
5423
5424               section_headers_groups [entry] = group;
5425
5426               if (do_section_groups)
5427                 {
5428                   sec = section_headers + entry;
5429                   printf ("   [%5u]   %s\n", entry, SECTION_NAME (sec));
5430                 }
5431
5432               g = (struct group_list *) xmalloc (sizeof (struct group_list));
5433               g->section_index = entry;
5434               g->next = group->root;
5435               group->root = g;
5436             }
5437
5438           if (start)
5439             free (start);
5440
5441           group++;
5442         }
5443     }
5444
5445   if (symtab)
5446     free (symtab);
5447   if (strtab)
5448     free (strtab);
5449   return 1;
5450 }
5451
5452 /* Data used to display dynamic fixups.  */
5453
5454 struct ia64_vms_dynfixup
5455 {
5456   bfd_vma needed_ident;         /* Library ident number.  */
5457   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
5458   bfd_vma fixup_needed;         /* Index of the library.  */
5459   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
5460   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
5461 };
5462
5463 /* Data used to display dynamic relocations.  */
5464
5465 struct ia64_vms_dynimgrela
5466 {
5467   bfd_vma img_rela_cnt;         /* Number of relocations.  */
5468   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
5469 };
5470
5471 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5472    library).  */
5473
5474 static void
5475 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5476                               const char *strtab, unsigned int strtab_sz)
5477 {
5478   Elf64_External_VMS_IMAGE_FIXUP *imfs;
5479   long i;
5480   const char *lib_name;
5481
5482   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5483                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
5484                    _("dynamic section image fixups"));
5485   if (!imfs)
5486     return;
5487
5488   if (fixup->needed < strtab_sz)
5489     lib_name = strtab + fixup->needed;
5490   else
5491     {
5492       warn ("corrupt library name index of 0x%lx found in dynamic entry",
5493             (unsigned long) fixup->needed);
5494       lib_name = "???";
5495     }
5496   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5497           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5498   printf
5499     (_("Seg Offset           Type                             SymVec DataType\n"));
5500
5501   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5502     {
5503       unsigned int type;
5504       const char *rtype;
5505
5506       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5507       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5508       type = BYTE_GET (imfs [i].type);
5509       rtype = elf_ia64_reloc_type (type);
5510       if (rtype == NULL)
5511         printf (" 0x%08x                       ", type);
5512       else
5513         printf (" %-32s ", rtype);
5514       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5515       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5516     }
5517
5518   free (imfs);
5519 }
5520
5521 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
5522
5523 static void
5524 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5525 {
5526   Elf64_External_VMS_IMAGE_RELA *imrs;
5527   long i;
5528
5529   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5530                    1, imgrela->img_rela_cnt * sizeof (*imrs),
5531                    _("dynamic section image relocations"));
5532   if (!imrs)
5533     return;
5534
5535   printf (_("\nImage relocs\n"));
5536   printf
5537     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
5538
5539   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5540     {
5541       unsigned int type;
5542       const char *rtype;
5543
5544       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5545       printf ("%08" BFD_VMA_FMT "x ",
5546               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5547       type = BYTE_GET (imrs [i].type);
5548       rtype = elf_ia64_reloc_type (type);
5549       if (rtype == NULL)
5550         printf ("0x%08x                      ", type);
5551       else
5552         printf ("%-31s ", rtype);
5553       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5554       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5555       printf ("%08" BFD_VMA_FMT "x\n",
5556               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5557     }
5558
5559   free (imrs);
5560 }
5561
5562 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
5563
5564 static int
5565 process_ia64_vms_dynamic_relocs (FILE *file)
5566 {
5567   struct ia64_vms_dynfixup fixup;
5568   struct ia64_vms_dynimgrela imgrela;
5569   Elf_Internal_Dyn *entry;
5570   int res = 0;
5571   bfd_vma strtab_off = 0;
5572   bfd_vma strtab_sz = 0;
5573   char *strtab = NULL;
5574
5575   memset (&fixup, 0, sizeof (fixup));
5576   memset (&imgrela, 0, sizeof (imgrela));
5577
5578   /* Note: the order of the entries is specified by the OpenVMS specs.  */
5579   for (entry = dynamic_section;
5580        entry < dynamic_section + dynamic_nent;
5581        entry++)
5582     {
5583       switch (entry->d_tag)
5584         {
5585         case DT_IA_64_VMS_STRTAB_OFFSET:
5586           strtab_off = entry->d_un.d_val;
5587           break;
5588         case DT_STRSZ:
5589           strtab_sz = entry->d_un.d_val;
5590           if (strtab == NULL)
5591             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5592                                1, strtab_sz, _("dynamic string section"));
5593           break;
5594
5595         case DT_IA_64_VMS_NEEDED_IDENT:
5596           fixup.needed_ident = entry->d_un.d_val;
5597           break;
5598         case DT_NEEDED:
5599           fixup.needed = entry->d_un.d_val;
5600           break;
5601         case DT_IA_64_VMS_FIXUP_NEEDED:
5602           fixup.fixup_needed = entry->d_un.d_val;
5603           break;
5604         case DT_IA_64_VMS_FIXUP_RELA_CNT:
5605           fixup.fixup_rela_cnt = entry->d_un.d_val;
5606           break;
5607         case DT_IA_64_VMS_FIXUP_RELA_OFF:
5608           fixup.fixup_rela_off = entry->d_un.d_val;
5609           res++;
5610           dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5611           break;
5612
5613         case DT_IA_64_VMS_IMG_RELA_CNT:
5614           imgrela.img_rela_cnt = entry->d_un.d_val;
5615           break;
5616         case DT_IA_64_VMS_IMG_RELA_OFF:
5617           imgrela.img_rela_off = entry->d_un.d_val;
5618           res++;
5619           dump_ia64_vms_dynamic_relocs (file, &imgrela);
5620           break;
5621
5622         default:
5623           break;
5624         }
5625     }
5626
5627   if (strtab != NULL)
5628     free (strtab);
5629
5630   return res;
5631 }
5632
5633 static struct
5634 {
5635   const char * name;
5636   int reloc;
5637   int size;
5638   int rela;
5639 } dynamic_relocations [] =
5640 {
5641     { "REL", DT_REL, DT_RELSZ, FALSE },
5642     { "RELA", DT_RELA, DT_RELASZ, TRUE },
5643     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5644 };
5645
5646 /* Process the reloc section.  */
5647
5648 static int
5649 process_relocs (FILE * file)
5650 {
5651   unsigned long rel_size;
5652   unsigned long rel_offset;
5653
5654
5655   if (!do_reloc)
5656     return 1;
5657
5658   if (do_using_dynamic)
5659     {
5660       int is_rela;
5661       const char * name;
5662       int has_dynamic_reloc;
5663       unsigned int i;
5664
5665       has_dynamic_reloc = 0;
5666
5667       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5668         {
5669           is_rela = dynamic_relocations [i].rela;
5670           name = dynamic_relocations [i].name;
5671           rel_size = dynamic_info [dynamic_relocations [i].size];
5672           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5673
5674           has_dynamic_reloc |= rel_size;
5675
5676           if (is_rela == UNKNOWN)
5677             {
5678               if (dynamic_relocations [i].reloc == DT_JMPREL)
5679                 switch (dynamic_info[DT_PLTREL])
5680                   {
5681                   case DT_REL:
5682                     is_rela = FALSE;
5683                     break;
5684                   case DT_RELA:
5685                     is_rela = TRUE;
5686                     break;
5687                   }
5688             }
5689
5690           if (rel_size)
5691             {
5692               printf
5693                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5694                  name, rel_offset, rel_size);
5695
5696               dump_relocations (file,
5697                                 offset_from_vma (file, rel_offset, rel_size),
5698                                 rel_size,
5699                                 dynamic_symbols, num_dynamic_syms,
5700                                 dynamic_strings, dynamic_strings_length, is_rela);
5701             }
5702         }
5703
5704       if (is_ia64_vms ())
5705         has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5706
5707       if (! has_dynamic_reloc)
5708         printf (_("\nThere are no dynamic relocations in this file.\n"));
5709     }
5710   else
5711     {
5712       Elf_Internal_Shdr * section;
5713       unsigned long i;
5714       int found = 0;
5715
5716       for (i = 0, section = section_headers;
5717            i < elf_header.e_shnum;
5718            i++, section++)
5719         {
5720           if (   section->sh_type != SHT_RELA
5721               && section->sh_type != SHT_REL)
5722             continue;
5723
5724           rel_offset = section->sh_offset;
5725           rel_size   = section->sh_size;
5726
5727           if (rel_size)
5728             {
5729               Elf_Internal_Shdr * strsec;
5730               int is_rela;
5731
5732               printf (_("\nRelocation section "));
5733
5734               if (string_table == NULL)
5735                 printf ("%d", section->sh_name);
5736               else
5737                 printf ("'%s'", SECTION_NAME (section));
5738
5739               printf (_(" at offset 0x%lx contains %lu entries:\n"),
5740                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5741
5742               is_rela = section->sh_type == SHT_RELA;
5743
5744               if (section->sh_link != 0
5745                   && section->sh_link < elf_header.e_shnum)
5746                 {
5747                   Elf_Internal_Shdr * symsec;
5748                   Elf_Internal_Sym *  symtab;
5749                   unsigned long nsyms;
5750                   unsigned long strtablen = 0;
5751                   char * strtab = NULL;
5752
5753                   symsec = section_headers + section->sh_link;
5754                   if (symsec->sh_type != SHT_SYMTAB
5755                       && symsec->sh_type != SHT_DYNSYM)
5756                     continue;
5757
5758                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
5759
5760                   if (symtab == NULL)
5761                     continue;
5762
5763                   if (symsec->sh_link != 0
5764                       && symsec->sh_link < elf_header.e_shnum)
5765                     {
5766                       strsec = section_headers + symsec->sh_link;
5767
5768                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5769                                                   1, strsec->sh_size,
5770                                                   _("string table"));
5771                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
5772                     }
5773
5774                   dump_relocations (file, rel_offset, rel_size,
5775                                     symtab, nsyms, strtab, strtablen, is_rela);
5776                   if (strtab)
5777                     free (strtab);
5778                   free (symtab);
5779                 }
5780               else
5781                 dump_relocations (file, rel_offset, rel_size,
5782                                   NULL, 0, NULL, 0, is_rela);
5783
5784               found = 1;
5785             }
5786         }
5787
5788       if (! found)
5789         printf (_("\nThere are no relocations in this file.\n"));
5790     }
5791
5792   return 1;
5793 }
5794
5795 /* Process the unwind section.  */
5796
5797 #include "unwind-ia64.h"
5798
5799 /* An absolute address consists of a section and an offset.  If the
5800    section is NULL, the offset itself is the address, otherwise, the
5801    address equals to LOAD_ADDRESS(section) + offset.  */
5802
5803 struct absaddr
5804   {
5805     unsigned short section;
5806     bfd_vma offset;
5807   };
5808
5809 #define ABSADDR(a) \
5810   ((a).section \
5811    ? section_headers [(a).section].sh_addr + (a).offset \
5812    : (a).offset)
5813
5814 struct ia64_unw_table_entry
5815   {
5816     struct absaddr start;
5817     struct absaddr end;
5818     struct absaddr info;
5819   };
5820
5821 struct ia64_unw_aux_info
5822   {
5823
5824     struct ia64_unw_table_entry *table; /* Unwind table.  */
5825     unsigned long table_len;    /* Length of unwind table.  */
5826     unsigned char * info;       /* Unwind info.  */
5827     unsigned long info_size;    /* Size of unwind info.  */
5828     bfd_vma info_addr;          /* starting address of unwind info.  */
5829     bfd_vma seg_base;           /* Starting address of segment.  */
5830     Elf_Internal_Sym * symtab;  /* The symbol table.  */
5831     unsigned long nsyms;        /* Number of symbols.  */
5832     char * strtab;              /* The string table.  */
5833     unsigned long strtab_size;  /* Size of string table.  */
5834   };
5835
5836 static void
5837 find_symbol_for_address (Elf_Internal_Sym * symtab,
5838                          unsigned long nsyms,
5839                          const char * strtab,
5840                          unsigned long strtab_size,
5841                          struct absaddr addr,
5842                          const char ** symname,
5843                          bfd_vma * offset)
5844 {
5845   bfd_vma dist = 0x100000;
5846   Elf_Internal_Sym * sym;
5847   Elf_Internal_Sym * best = NULL;
5848   unsigned long i;
5849
5850   REMOVE_ARCH_BITS (addr.offset);
5851
5852   for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
5853     {
5854       bfd_vma value = sym->st_value;
5855
5856       REMOVE_ARCH_BITS (value);
5857
5858       if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5859           && sym->st_name != 0
5860           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
5861           && addr.offset >= value
5862           && addr.offset - value < dist)
5863         {
5864           best = sym;
5865           dist = addr.offset - value;
5866           if (!dist)
5867             break;
5868         }
5869     }
5870
5871   if (best)
5872     {
5873       *symname = (best->st_name >= strtab_size
5874                   ? _("<corrupt>") : strtab + best->st_name);
5875       *offset = dist;
5876       return;
5877     }
5878
5879   *symname = NULL;
5880   *offset = addr.offset;
5881 }
5882
5883 static void
5884 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
5885 {
5886   struct ia64_unw_table_entry * tp;
5887   int in_body;
5888
5889   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5890     {
5891       bfd_vma stamp;
5892       bfd_vma offset;
5893       const unsigned char * dp;
5894       const unsigned char * head;
5895       const char * procname;
5896
5897       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5898                                aux->strtab_size, tp->start, &procname, &offset);
5899
5900       fputs ("\n<", stdout);
5901
5902       if (procname)
5903         {
5904           fputs (procname, stdout);
5905
5906           if (offset)
5907             printf ("+%lx", (unsigned long) offset);
5908         }
5909
5910       fputs (">: [", stdout);
5911       print_vma (tp->start.offset, PREFIX_HEX);
5912       fputc ('-', stdout);
5913       print_vma (tp->end.offset, PREFIX_HEX);
5914       printf ("], info at +0x%lx\n",
5915               (unsigned long) (tp->info.offset - aux->seg_base));
5916
5917       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5918       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5919
5920       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5921               (unsigned) UNW_VER (stamp),
5922               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5923               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5924               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5925               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5926
5927       if (UNW_VER (stamp) != 1)
5928         {
5929           printf (_("\tUnknown version.\n"));
5930           continue;
5931         }
5932
5933       in_body = 0;
5934       for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5935         dp = unw_decode (dp, in_body, & in_body);
5936     }
5937 }
5938
5939 static int
5940 slurp_ia64_unwind_table (FILE * file,
5941                          struct ia64_unw_aux_info * aux,
5942                          Elf_Internal_Shdr * sec)
5943 {
5944   unsigned long size, nrelas, i;
5945   Elf_Internal_Phdr * seg;
5946   struct ia64_unw_table_entry * tep;
5947   Elf_Internal_Shdr * relsec;
5948   Elf_Internal_Rela * rela;
5949   Elf_Internal_Rela * rp;
5950   unsigned char * table;
5951   unsigned char * tp;
5952   Elf_Internal_Sym * sym;
5953   const char * relname;
5954
5955   /* First, find the starting address of the segment that includes
5956      this section: */
5957
5958   if (elf_header.e_phnum)
5959     {
5960       if (! get_program_headers (file))
5961           return 0;
5962
5963       for (seg = program_headers;
5964            seg < program_headers + elf_header.e_phnum;
5965            ++seg)
5966         {
5967           if (seg->p_type != PT_LOAD)
5968             continue;
5969
5970           if (sec->sh_addr >= seg->p_vaddr
5971               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5972             {
5973               aux->seg_base = seg->p_vaddr;
5974               break;
5975             }
5976         }
5977     }
5978
5979   /* Second, build the unwind table from the contents of the unwind section:  */
5980   size = sec->sh_size;
5981   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5982                                       _("unwind table"));
5983   if (!table)
5984     return 0;
5985
5986   aux->table = (struct ia64_unw_table_entry *)
5987       xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5988   tep = aux->table;
5989   for (tp = table; tp < table + size; ++tep)
5990     {
5991       tep->start.section = SHN_UNDEF;
5992       tep->end.section   = SHN_UNDEF;
5993       tep->info.section  = SHN_UNDEF;
5994       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5995       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5996       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5997       tep->start.offset += aux->seg_base;
5998       tep->end.offset   += aux->seg_base;
5999       tep->info.offset  += aux->seg_base;
6000     }
6001   free (table);
6002
6003   /* Third, apply any relocations to the unwind table:  */
6004   for (relsec = section_headers;
6005        relsec < section_headers + elf_header.e_shnum;
6006        ++relsec)
6007     {
6008       if (relsec->sh_type != SHT_RELA
6009           || relsec->sh_info >= elf_header.e_shnum
6010           || section_headers + relsec->sh_info != sec)
6011         continue;
6012
6013       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6014                               & rela, & nrelas))
6015         return 0;
6016
6017       for (rp = rela; rp < rela + nrelas; ++rp)
6018         {
6019           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6020           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6021
6022           if (! const_strneq (relname, "R_IA64_SEGREL"))
6023             {
6024               warn (_("Skipping unexpected relocation type %s\n"), relname);
6025               continue;
6026             }
6027
6028           i = rp->r_offset / (3 * eh_addr_size);
6029
6030           switch (rp->r_offset/eh_addr_size % 3)
6031             {
6032             case 0:
6033               aux->table[i].start.section = sym->st_shndx;
6034               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
6035               break;
6036             case 1:
6037               aux->table[i].end.section   = sym->st_shndx;
6038               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
6039               break;
6040             case 2:
6041               aux->table[i].info.section  = sym->st_shndx;
6042               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
6043               break;
6044             default:
6045               break;
6046             }
6047         }
6048
6049       free (rela);
6050     }
6051
6052   aux->table_len = size / (3 * eh_addr_size);
6053   return 1;
6054 }
6055
6056 static void
6057 ia64_process_unwind (FILE * file)
6058 {
6059   Elf_Internal_Shdr * sec;
6060   Elf_Internal_Shdr * unwsec = NULL;
6061   Elf_Internal_Shdr * strsec;
6062   unsigned long i, unwcount = 0, unwstart = 0;
6063   struct ia64_unw_aux_info aux;
6064
6065   memset (& aux, 0, sizeof (aux));
6066
6067   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6068     {
6069       if (sec->sh_type == SHT_SYMTAB
6070           && sec->sh_link < elf_header.e_shnum)
6071         {
6072           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6073
6074           strsec = section_headers + sec->sh_link;
6075           assert (aux.strtab == NULL);
6076           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6077                                           1, strsec->sh_size,
6078                                           _("string table"));
6079           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6080         }
6081       else if (sec->sh_type == SHT_IA_64_UNWIND)
6082         unwcount++;
6083     }
6084
6085   if (!unwcount)
6086     printf (_("\nThere are no unwind sections in this file.\n"));
6087
6088   while (unwcount-- > 0)
6089     {
6090       char * suffix;
6091       size_t len, len2;
6092
6093       for (i = unwstart, sec = section_headers + unwstart;
6094            i < elf_header.e_shnum; ++i, ++sec)
6095         if (sec->sh_type == SHT_IA_64_UNWIND)
6096           {
6097             unwsec = sec;
6098             break;
6099           }
6100
6101       unwstart = i + 1;
6102       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6103
6104       if ((unwsec->sh_flags & SHF_GROUP) != 0)
6105         {
6106           /* We need to find which section group it is in.  */
6107           struct group_list * g = section_headers_groups [i]->root;
6108
6109           for (; g != NULL; g = g->next)
6110             {
6111               sec = section_headers + g->section_index;
6112
6113               if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6114                 break;
6115             }
6116
6117           if (g == NULL)
6118             i = elf_header.e_shnum;
6119         }
6120       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6121         {
6122           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
6123           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6124           suffix = SECTION_NAME (unwsec) + len;
6125           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6126                ++i, ++sec)
6127             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6128                 && streq (SECTION_NAME (sec) + len2, suffix))
6129               break;
6130         }
6131       else
6132         {
6133           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6134              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
6135           len = sizeof (ELF_STRING_ia64_unwind) - 1;
6136           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6137           suffix = "";
6138           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6139             suffix = SECTION_NAME (unwsec) + len;
6140           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6141                ++i, ++sec)
6142             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6143                 && streq (SECTION_NAME (sec) + len2, suffix))
6144               break;
6145         }
6146
6147       if (i == elf_header.e_shnum)
6148         {
6149           printf (_("\nCould not find unwind info section for "));
6150
6151           if (string_table == NULL)
6152             printf ("%d", unwsec->sh_name);
6153           else
6154             printf (_("'%s'"), SECTION_NAME (unwsec));
6155         }
6156       else
6157         {
6158           aux.info_addr = sec->sh_addr;
6159           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6160                                                  sec->sh_size,
6161                                                  _("unwind info"));
6162           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6163
6164           printf (_("\nUnwind section "));
6165
6166           if (string_table == NULL)
6167             printf ("%d", unwsec->sh_name);
6168           else
6169             printf (_("'%s'"), SECTION_NAME (unwsec));
6170
6171           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6172                   (unsigned long) unwsec->sh_offset,
6173                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6174
6175           (void) slurp_ia64_unwind_table (file, & aux, unwsec);
6176
6177           if (aux.table_len > 0)
6178             dump_ia64_unwind (& aux);
6179
6180           if (aux.table)
6181             free ((char *) aux.table);
6182           if (aux.info)
6183             free ((char *) aux.info);
6184           aux.table = NULL;
6185           aux.info = NULL;
6186         }
6187     }
6188
6189   if (aux.symtab)
6190     free (aux.symtab);
6191   if (aux.strtab)
6192     free ((char *) aux.strtab);
6193 }
6194
6195 struct hppa_unw_table_entry
6196   {
6197     struct absaddr start;
6198     struct absaddr end;
6199     unsigned int Cannot_unwind:1;                       /* 0 */
6200     unsigned int Millicode:1;                   /* 1 */
6201     unsigned int Millicode_save_sr0:1;          /* 2 */
6202     unsigned int Region_description:2;          /* 3..4 */
6203     unsigned int reserved1:1;                   /* 5 */
6204     unsigned int Entry_SR:1;                    /* 6 */
6205     unsigned int Entry_FR:4;     /* number saved */     /* 7..10 */
6206     unsigned int Entry_GR:5;     /* number saved */     /* 11..15 */
6207     unsigned int Args_stored:1;                 /* 16 */
6208     unsigned int Variable_Frame:1;                      /* 17 */
6209     unsigned int Separate_Package_Body:1;               /* 18 */
6210     unsigned int Frame_Extension_Millicode:1;   /* 19 */
6211     unsigned int Stack_Overflow_Check:1;                /* 20 */
6212     unsigned int Two_Instruction_SP_Increment:1;        /* 21 */
6213     unsigned int Ada_Region:1;                  /* 22 */
6214     unsigned int cxx_info:1;                    /* 23 */
6215     unsigned int cxx_try_catch:1;                       /* 24 */
6216     unsigned int sched_entry_seq:1;                     /* 25 */
6217     unsigned int reserved2:1;                   /* 26 */
6218     unsigned int Save_SP:1;                             /* 27 */
6219     unsigned int Save_RP:1;                             /* 28 */
6220     unsigned int Save_MRP_in_frame:1;           /* 29 */
6221     unsigned int extn_ptr_defined:1;            /* 30 */
6222     unsigned int Cleanup_defined:1;                     /* 31 */
6223
6224     unsigned int MPE_XL_interrupt_marker:1;             /* 0 */
6225     unsigned int HP_UX_interrupt_marker:1;              /* 1 */
6226     unsigned int Large_frame:1;                 /* 2 */
6227     unsigned int Pseudo_SP_Set:1;                       /* 3 */
6228     unsigned int reserved4:1;                   /* 4 */
6229     unsigned int Total_frame_size:27;           /* 5..31 */
6230   };
6231
6232 struct hppa_unw_aux_info
6233   {
6234     struct hppa_unw_table_entry *table; /* Unwind table.  */
6235     unsigned long table_len;    /* Length of unwind table.  */
6236     bfd_vma seg_base;           /* Starting address of segment.  */
6237     Elf_Internal_Sym * symtab;  /* The symbol table.  */
6238     unsigned long nsyms;        /* Number of symbols.  */
6239     char * strtab;              /* The string table.  */
6240     unsigned long strtab_size;  /* Size of string table.  */
6241   };
6242
6243 static void
6244 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
6245 {
6246   struct hppa_unw_table_entry * tp;
6247
6248   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6249     {
6250       bfd_vma offset;
6251       const char * procname;
6252
6253       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6254                                aux->strtab_size, tp->start, &procname,
6255                                &offset);
6256
6257       fputs ("\n<", stdout);
6258
6259       if (procname)
6260         {
6261           fputs (procname, stdout);
6262
6263           if (offset)
6264             printf ("+%lx", (unsigned long) offset);
6265         }
6266
6267       fputs (">: [", stdout);
6268       print_vma (tp->start.offset, PREFIX_HEX);
6269       fputc ('-', stdout);
6270       print_vma (tp->end.offset, PREFIX_HEX);
6271       printf ("]\n\t");
6272
6273 #define PF(_m) if (tp->_m) printf (#_m " ");
6274 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6275       PF(Cannot_unwind);
6276       PF(Millicode);
6277       PF(Millicode_save_sr0);
6278       /* PV(Region_description);  */
6279       PF(Entry_SR);
6280       PV(Entry_FR);
6281       PV(Entry_GR);
6282       PF(Args_stored);
6283       PF(Variable_Frame);
6284       PF(Separate_Package_Body);
6285       PF(Frame_Extension_Millicode);
6286       PF(Stack_Overflow_Check);
6287       PF(Two_Instruction_SP_Increment);
6288       PF(Ada_Region);
6289       PF(cxx_info);
6290       PF(cxx_try_catch);
6291       PF(sched_entry_seq);
6292       PF(Save_SP);
6293       PF(Save_RP);
6294       PF(Save_MRP_in_frame);
6295       PF(extn_ptr_defined);
6296       PF(Cleanup_defined);
6297       PF(MPE_XL_interrupt_marker);
6298       PF(HP_UX_interrupt_marker);
6299       PF(Large_frame);
6300       PF(Pseudo_SP_Set);
6301       PV(Total_frame_size);
6302 #undef PF
6303 #undef PV
6304     }
6305
6306   printf ("\n");
6307 }
6308
6309 static int
6310 slurp_hppa_unwind_table (FILE * file,
6311                          struct hppa_unw_aux_info * aux,
6312                          Elf_Internal_Shdr * sec)
6313 {
6314   unsigned long size, unw_ent_size, nentries, nrelas, i;
6315   Elf_Internal_Phdr * seg;
6316   struct hppa_unw_table_entry * tep;
6317   Elf_Internal_Shdr * relsec;
6318   Elf_Internal_Rela * rela;
6319   Elf_Internal_Rela * rp;
6320   unsigned char * table;
6321   unsigned char * tp;
6322   Elf_Internal_Sym * sym;
6323   const char * relname;
6324
6325   /* First, find the starting address of the segment that includes
6326      this section.  */
6327
6328   if (elf_header.e_phnum)
6329     {
6330       if (! get_program_headers (file))
6331         return 0;
6332
6333       for (seg = program_headers;
6334            seg < program_headers + elf_header.e_phnum;
6335            ++seg)
6336         {
6337           if (seg->p_type != PT_LOAD)
6338             continue;
6339
6340           if (sec->sh_addr >= seg->p_vaddr
6341               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6342             {
6343               aux->seg_base = seg->p_vaddr;
6344               break;
6345             }
6346         }
6347     }
6348
6349   /* Second, build the unwind table from the contents of the unwind
6350      section.  */
6351   size = sec->sh_size;
6352   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6353                                       _("unwind table"));
6354   if (!table)
6355     return 0;
6356
6357   unw_ent_size = 16;
6358   nentries = size / unw_ent_size;
6359   size = unw_ent_size * nentries;
6360
6361   tep = aux->table = (struct hppa_unw_table_entry *)
6362       xcmalloc (nentries, sizeof (aux->table[0]));
6363
6364   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6365     {
6366       unsigned int tmp1, tmp2;
6367
6368       tep->start.section = SHN_UNDEF;
6369       tep->end.section   = SHN_UNDEF;
6370
6371       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6372       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6373       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6374       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6375
6376       tep->start.offset += aux->seg_base;
6377       tep->end.offset   += aux->seg_base;
6378
6379       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6380       tep->Millicode = (tmp1 >> 30) & 0x1;
6381       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6382       tep->Region_description = (tmp1 >> 27) & 0x3;
6383       tep->reserved1 = (tmp1 >> 26) & 0x1;
6384       tep->Entry_SR = (tmp1 >> 25) & 0x1;
6385       tep->Entry_FR = (tmp1 >> 21) & 0xf;
6386       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6387       tep->Args_stored = (tmp1 >> 15) & 0x1;
6388       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6389       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6390       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6391       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6392       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6393       tep->Ada_Region = (tmp1 >> 9) & 0x1;
6394       tep->cxx_info = (tmp1 >> 8) & 0x1;
6395       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6396       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6397       tep->reserved2 = (tmp1 >> 5) & 0x1;
6398       tep->Save_SP = (tmp1 >> 4) & 0x1;
6399       tep->Save_RP = (tmp1 >> 3) & 0x1;
6400       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6401       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6402       tep->Cleanup_defined = tmp1 & 0x1;
6403
6404       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6405       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6406       tep->Large_frame = (tmp2 >> 29) & 0x1;
6407       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6408       tep->reserved4 = (tmp2 >> 27) & 0x1;
6409       tep->Total_frame_size = tmp2 & 0x7ffffff;
6410     }
6411   free (table);
6412
6413   /* Third, apply any relocations to the unwind table.  */
6414   for (relsec = section_headers;
6415        relsec < section_headers + elf_header.e_shnum;
6416        ++relsec)
6417     {
6418       if (relsec->sh_type != SHT_RELA
6419           || relsec->sh_info >= elf_header.e_shnum
6420           || section_headers + relsec->sh_info != sec)
6421         continue;
6422
6423       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6424                               & rela, & nrelas))
6425         return 0;
6426
6427       for (rp = rela; rp < rela + nrelas; ++rp)
6428         {
6429           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6430           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6431
6432           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
6433           if (! const_strneq (relname, "R_PARISC_SEGREL"))
6434             {
6435               warn (_("Skipping unexpected relocation type %s\n"), relname);
6436               continue;
6437             }
6438
6439           i = rp->r_offset / unw_ent_size;
6440
6441           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6442             {
6443             case 0:
6444               aux->table[i].start.section = sym->st_shndx;
6445               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
6446               break;
6447             case 1:
6448               aux->table[i].end.section   = sym->st_shndx;
6449               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
6450               break;
6451             default:
6452               break;
6453             }
6454         }
6455
6456       free (rela);
6457     }
6458
6459   aux->table_len = nentries;
6460
6461   return 1;
6462 }
6463
6464 static void
6465 hppa_process_unwind (FILE * file)
6466 {
6467   struct hppa_unw_aux_info aux;
6468   Elf_Internal_Shdr * unwsec = NULL;
6469   Elf_Internal_Shdr * strsec;
6470   Elf_Internal_Shdr * sec;
6471   unsigned long i;
6472
6473   if (string_table == NULL)
6474     return;
6475
6476   memset (& aux, 0, sizeof (aux));
6477
6478   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6479     {
6480       if (sec->sh_type == SHT_SYMTAB
6481           && sec->sh_link < elf_header.e_shnum)
6482         {
6483           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6484
6485           strsec = section_headers + sec->sh_link;
6486           assert (aux.strtab == NULL);
6487           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6488                                           1, strsec->sh_size,
6489                                           _("string table"));
6490           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6491         }
6492       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6493         unwsec = sec;
6494     }
6495
6496   if (!unwsec)
6497     printf (_("\nThere are no unwind sections in this file.\n"));
6498
6499   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6500     {
6501       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6502         {
6503           printf (_("\nUnwind section "));
6504           printf (_("'%s'"), SECTION_NAME (sec));
6505
6506           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6507                   (unsigned long) sec->sh_offset,
6508                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6509
6510           slurp_hppa_unwind_table (file, &aux, sec);
6511           if (aux.table_len > 0)
6512             dump_hppa_unwind (&aux);
6513
6514           if (aux.table)
6515             free ((char *) aux.table);
6516           aux.table = NULL;
6517         }
6518     }
6519
6520   if (aux.symtab)
6521     free (aux.symtab);
6522   if (aux.strtab)
6523     free ((char *) aux.strtab);
6524 }
6525
6526 struct arm_section
6527 {
6528   unsigned char *      data;            /* The unwind data.  */
6529   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
6530   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
6531   unsigned long        nrelas;          /* The number of relocations.  */
6532   unsigned int         rel_type;        /* REL or RELA ?  */
6533   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
6534 };
6535
6536 struct arm_unw_aux_info
6537 {
6538   FILE *              file;             /* The file containing the unwind sections.  */
6539   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
6540   unsigned long       nsyms;            /* Number of symbols.  */
6541   char *              strtab;           /* The file's string table.  */
6542   unsigned long       strtab_size;      /* Size of string table.  */
6543 };
6544
6545 static const char *
6546 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6547                         bfd_vma fn, struct absaddr addr)
6548 {
6549   const char *procname;
6550   bfd_vma sym_offset;
6551
6552   if (addr.section == SHN_UNDEF)
6553     addr.offset = fn;
6554
6555   find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6556                            aux->strtab_size, addr, &procname,
6557                            &sym_offset);
6558
6559   print_vma (fn, PREFIX_HEX);
6560
6561   if (procname)
6562     {
6563       fputs (" <", stdout);
6564       fputs (procname, stdout);
6565
6566       if (sym_offset)
6567         printf ("+0x%lx", (unsigned long) sym_offset);
6568       fputc ('>', stdout);
6569     }
6570
6571   return procname;
6572 }
6573
6574 static void
6575 arm_free_section (struct arm_section *arm_sec)
6576 {
6577   if (arm_sec->data != NULL)
6578     free (arm_sec->data);
6579
6580   if (arm_sec->rela != NULL)
6581     free (arm_sec->rela);
6582 }
6583
6584 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6585       cached section and install SEC instead.
6586    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6587       and return its valued in * WORDP, relocating if necessary.
6588    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6589       relocation's offset in ADDR.
6590    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6591       into the string table of the symbol associated with the reloc.  If no
6592       reloc was applied store -1 there.
6593    5) Return TRUE upon success, FALSE otherwise.  */
6594
6595 static bfd_boolean
6596 get_unwind_section_word (struct arm_unw_aux_info *  aux,
6597                          struct arm_section *       arm_sec,
6598                          Elf_Internal_Shdr *        sec,
6599                          bfd_vma                    word_offset,
6600                          unsigned int *             wordp,
6601                          struct absaddr *           addr,
6602                          bfd_vma *                  sym_name)
6603 {
6604   Elf_Internal_Rela *rp;
6605   Elf_Internal_Sym *sym;
6606   const char * relname;
6607   unsigned int word;
6608   bfd_boolean wrapped;
6609
6610   addr->section = SHN_UNDEF;
6611   addr->offset = 0;
6612
6613   if (sym_name != NULL)
6614     *sym_name = (bfd_vma) -1;
6615
6616   /* If necessary, update the section cache.  */
6617   if (sec != arm_sec->sec)
6618     {
6619       Elf_Internal_Shdr *relsec;
6620
6621       arm_free_section (arm_sec);
6622
6623       arm_sec->sec = sec;
6624       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6625                                 sec->sh_size, _("unwind data"));
6626       arm_sec->rela = NULL;
6627       arm_sec->nrelas = 0;
6628
6629       for (relsec = section_headers;
6630            relsec < section_headers + elf_header.e_shnum;
6631            ++relsec)
6632         {
6633           if (relsec->sh_info >= elf_header.e_shnum
6634               || section_headers + relsec->sh_info != sec
6635               /* PR 15745: Check the section type as well.  */
6636               || (relsec->sh_type != SHT_REL
6637                   && relsec->sh_type != SHT_RELA))
6638             continue;
6639
6640           arm_sec->rel_type = relsec->sh_type;
6641           if (relsec->sh_type == SHT_REL)
6642             {
6643               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6644                                      relsec->sh_size,
6645                                      & arm_sec->rela, & arm_sec->nrelas))
6646                 return FALSE;
6647             }
6648           else /* relsec->sh_type == SHT_RELA */
6649             {
6650               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6651                                       relsec->sh_size,
6652                                       & arm_sec->rela, & arm_sec->nrelas))
6653                 return FALSE;
6654             }
6655           break;
6656         }
6657
6658       arm_sec->next_rela = arm_sec->rela;
6659     }
6660
6661   /* If there is no unwind data we can do nothing.  */
6662   if (arm_sec->data == NULL)
6663     return FALSE;
6664
6665   /* Get the word at the required offset.  */
6666   word = byte_get (arm_sec->data + word_offset, 4);
6667
6668   /* Look through the relocs to find the one that applies to the provided offset.  */
6669   wrapped = FALSE;
6670   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6671     {
6672       bfd_vma prelval, offset;
6673
6674       if (rp->r_offset > word_offset && !wrapped)
6675         {
6676           rp = arm_sec->rela;
6677           wrapped = TRUE;
6678         }
6679       if (rp->r_offset > word_offset)
6680         break;
6681
6682       if (rp->r_offset & 3)
6683         {
6684           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6685                 (unsigned long) rp->r_offset);
6686           continue;
6687         }
6688
6689       if (rp->r_offset < word_offset)
6690         continue;
6691
6692       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6693
6694       if (arm_sec->rel_type == SHT_REL)
6695         {
6696           offset = word & 0x7fffffff;
6697           if (offset & 0x40000000)
6698             offset |= ~ (bfd_vma) 0x7fffffff;
6699         }
6700       else if (arm_sec->rel_type == SHT_RELA)
6701         offset = rp->r_addend;
6702       else
6703         abort ();
6704
6705       offset += sym->st_value;
6706       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6707
6708       /* Check that we are processing the expected reloc type.  */
6709       if (elf_header.e_machine == EM_ARM)
6710         {
6711           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6712
6713           if (streq (relname, "R_ARM_NONE"))
6714               continue;
6715
6716           if (! streq (relname, "R_ARM_PREL31"))
6717             {
6718               warn (_("Skipping unexpected relocation type %s\n"), relname);
6719               continue;
6720             }
6721         }
6722       else if (elf_header.e_machine == EM_TI_C6000)
6723         {
6724           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6725
6726           if (streq (relname, "R_C6000_NONE"))
6727             continue;
6728
6729           if (! streq (relname, "R_C6000_PREL31"))
6730             {
6731               warn (_("Skipping unexpected relocation type %s\n"), relname);
6732               continue;
6733             }
6734
6735           prelval >>= 1;
6736         }
6737       else
6738         /* This function currently only supports ARM and TI unwinders.  */
6739         abort ();
6740
6741       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6742       addr->section = sym->st_shndx;
6743       addr->offset = offset;
6744       if (sym_name)
6745         * sym_name = sym->st_name;
6746       break;
6747     }
6748
6749   *wordp = word;
6750   arm_sec->next_rela = rp;
6751
6752   return TRUE;
6753 }
6754
6755 static const char *tic6x_unwind_regnames[16] =
6756 {
6757   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6758   "A14", "A13", "A12", "A11", "A10",
6759   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6760 };
6761
6762 static void
6763 decode_tic6x_unwind_regmask (unsigned int mask)
6764 {
6765   int i;
6766
6767   for (i = 12; mask; mask >>= 1, i--)
6768     {
6769       if (mask & 1)
6770         {
6771           fputs (tic6x_unwind_regnames[i], stdout);
6772           if (mask > 1)
6773             fputs (", ", stdout);
6774         }
6775     }
6776 }
6777
6778 #define ADVANCE                                                 \
6779   if (remaining == 0 && more_words)                             \
6780     {                                                           \
6781       data_offset += 4;                                         \
6782       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
6783                                      data_offset, & word, & addr, NULL))        \
6784         return;                                                 \
6785       remaining = 4;                                            \
6786       more_words--;                                             \
6787     }                                                           \
6788
6789 #define GET_OP(OP)                      \
6790   ADVANCE;                              \
6791   if (remaining)                        \
6792     {                                   \
6793       remaining--;                      \
6794       (OP) = word >> 24;                \
6795       word <<= 8;                       \
6796     }                                   \
6797   else                                  \
6798     {                                   \
6799       printf (_("[Truncated opcode]\n"));       \
6800       return;                           \
6801     }                                   \
6802   printf ("0x%02x ", OP)
6803
6804 static void
6805 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6806                             unsigned int word, unsigned int remaining,
6807                             unsigned int more_words,
6808                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6809                             struct arm_section *data_arm_sec)
6810 {
6811   struct absaddr addr;
6812
6813   /* Decode the unwinding instructions.  */
6814   while (1)
6815     {
6816       unsigned int op, op2;
6817
6818       ADVANCE;
6819       if (remaining == 0)
6820         break;
6821       remaining--;
6822       op = word >> 24;
6823       word <<= 8;
6824
6825       printf ("  0x%02x ", op);
6826
6827       if ((op & 0xc0) == 0x00)
6828         {
6829           int offset = ((op & 0x3f) << 2) + 4;
6830
6831           printf ("     vsp = vsp + %d", offset);
6832         }
6833       else if ((op & 0xc0) == 0x40)
6834         {
6835           int offset = ((op & 0x3f) << 2) + 4;
6836
6837           printf ("     vsp = vsp - %d", offset);
6838         }
6839       else if ((op & 0xf0) == 0x80)
6840         {
6841           GET_OP (op2);
6842           if (op == 0x80 && op2 == 0)
6843             printf (_("Refuse to unwind"));
6844           else
6845             {
6846               unsigned int mask = ((op & 0x0f) << 8) | op2;
6847               int first = 1;
6848               int i;
6849
6850               printf ("pop {");
6851               for (i = 0; i < 12; i++)
6852                 if (mask & (1 << i))
6853                   {
6854                     if (first)
6855                       first = 0;
6856                     else
6857                       printf (", ");
6858                     printf ("r%d", 4 + i);
6859                   }
6860               printf ("}");
6861             }
6862         }
6863       else if ((op & 0xf0) == 0x90)
6864         {
6865           if (op == 0x9d || op == 0x9f)
6866             printf (_("     [Reserved]"));
6867           else
6868             printf ("     vsp = r%d", op & 0x0f);
6869         }
6870       else if ((op & 0xf0) == 0xa0)
6871         {
6872           int end = 4 + (op & 0x07);
6873           int first = 1;
6874           int i;
6875
6876           printf ("     pop {");
6877           for (i = 4; i <= end; i++)
6878             {
6879               if (first)
6880                 first = 0;
6881               else
6882                 printf (", ");
6883               printf ("r%d", i);
6884             }
6885           if (op & 0x08)
6886             {
6887               if (!first)
6888                 printf (", ");
6889               printf ("r14");
6890             }
6891           printf ("}");
6892         }
6893       else if (op == 0xb0)
6894         printf (_("     finish"));
6895       else if (op == 0xb1)
6896         {
6897           GET_OP (op2);
6898           if (op2 == 0 || (op2 & 0xf0) != 0)
6899             printf (_("[Spare]"));
6900           else
6901             {
6902               unsigned int mask = op2 & 0x0f;
6903               int first = 1;
6904               int i;
6905
6906               printf ("pop {");
6907               for (i = 0; i < 12; i++)
6908                 if (mask & (1 << i))
6909                   {
6910                     if (first)
6911                       first = 0;
6912                     else
6913                       printf (", ");
6914                     printf ("r%d", i);
6915                   }
6916               printf ("}");
6917             }
6918         }
6919       else if (op == 0xb2)
6920         {
6921           unsigned char buf[9];
6922           unsigned int i, len;
6923           unsigned long offset;
6924
6925           for (i = 0; i < sizeof (buf); i++)
6926             {
6927               GET_OP (buf[i]);
6928               if ((buf[i] & 0x80) == 0)
6929                 break;
6930             }
6931           assert (i < sizeof (buf));
6932           offset = read_uleb128 (buf, &len, buf + i + 1);
6933           assert (len == i + 1);
6934           offset = offset * 4 + 0x204;
6935           printf ("vsp = vsp + %ld", offset);
6936         }
6937       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
6938         {
6939           unsigned int first, last;
6940
6941           GET_OP (op2);
6942           first = op2 >> 4;
6943           last = op2 & 0x0f;
6944           if (op == 0xc8)
6945             first = first + 16;
6946           printf ("pop {D%d", first);
6947           if (last)
6948             printf ("-D%d", first + last);
6949           printf ("}");
6950         }
6951       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6952         {
6953           unsigned int count = op & 0x07;
6954
6955           printf ("pop {D8");
6956           if (count)
6957             printf ("-D%d", 8 + count);
6958           printf ("}");
6959         }
6960       else if (op >= 0xc0 && op <= 0xc5)
6961         {
6962           unsigned int count = op & 0x07;
6963
6964           printf ("     pop {wR10");
6965           if (count)
6966             printf ("-wR%d", 10 + count);
6967           printf ("}");
6968         }
6969       else if (op == 0xc6)
6970         {
6971           unsigned int first, last;
6972
6973           GET_OP (op2);
6974           first = op2 >> 4;
6975           last = op2 & 0x0f;
6976           printf ("pop {wR%d", first);
6977           if (last)
6978             printf ("-wR%d", first + last);
6979           printf ("}");
6980         }
6981       else if (op == 0xc7)
6982         {
6983           GET_OP (op2);
6984           if (op2 == 0 || (op2 & 0xf0) != 0)
6985             printf (_("[Spare]"));
6986           else
6987             {
6988               unsigned int mask = op2 & 0x0f;
6989               int first = 1;
6990               int i;
6991
6992               printf ("pop {");
6993               for (i = 0; i < 4; i++)
6994                 if (mask & (1 << i))
6995                   {
6996                     if (first)
6997                       first = 0;
6998                     else
6999                       printf (", ");
7000                     printf ("wCGR%d", i);
7001                   }
7002               printf ("}");
7003             }
7004         }
7005       else
7006         printf (_("     [unsupported opcode]"));
7007       printf ("\n");
7008     }
7009 }
7010
7011 static void
7012 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7013                             unsigned int word, unsigned int remaining,
7014                             unsigned int more_words,
7015                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7016                             struct arm_section *data_arm_sec)
7017 {
7018   struct absaddr addr;
7019
7020   /* Decode the unwinding instructions.  */
7021   while (1)
7022     {
7023       unsigned int op, op2;
7024
7025       ADVANCE;
7026       if (remaining == 0)
7027         break;
7028       remaining--;
7029       op = word >> 24;
7030       word <<= 8;
7031
7032       printf ("  0x%02x ", op);
7033
7034       if ((op & 0xc0) == 0x00)
7035         {
7036           int offset = ((op & 0x3f) << 3) + 8;
7037           printf ("     sp = sp + %d", offset);
7038         }
7039       else if ((op & 0xc0) == 0x80)
7040         {
7041           GET_OP (op2);
7042           if (op == 0x80 && op2 == 0)
7043             printf (_("Refuse to unwind"));
7044           else
7045             {
7046               unsigned int mask = ((op & 0x1f) << 8) | op2;
7047               if (op & 0x20)
7048                 printf ("pop compact {");
7049               else
7050                 printf ("pop {");
7051
7052               decode_tic6x_unwind_regmask (mask);
7053               printf("}");
7054             }
7055         }
7056       else if ((op & 0xf0) == 0xc0)
7057         {
7058           unsigned int reg;
7059           unsigned int nregs;
7060           unsigned int i;
7061           const char *name;
7062           struct
7063           {
7064               unsigned int offset;
7065               unsigned int reg;
7066           } regpos[16];
7067
7068           /* Scan entire instruction first so that GET_OP output is not
7069              interleaved with disassembly.  */
7070           nregs = 0;
7071           for (i = 0; nregs < (op & 0xf); i++)
7072             {
7073               GET_OP (op2);
7074               reg = op2 >> 4;
7075               if (reg != 0xf)
7076                 {
7077                   regpos[nregs].offset = i * 2;
7078                   regpos[nregs].reg = reg;
7079                   nregs++;
7080                 }
7081
7082               reg = op2 & 0xf;
7083               if (reg != 0xf)
7084                 {
7085                   regpos[nregs].offset = i * 2 + 1;
7086                   regpos[nregs].reg = reg;
7087                   nregs++;
7088                 }
7089             }
7090
7091           printf (_("pop frame {"));
7092           reg = nregs - 1;
7093           for (i = i * 2; i > 0; i--)
7094             {
7095               if (regpos[reg].offset == i - 1)
7096                 {
7097                   name = tic6x_unwind_regnames[regpos[reg].reg];
7098                   if (reg > 0)
7099                     reg--;
7100                 }
7101               else
7102                 name = _("[pad]");
7103
7104               fputs (name, stdout);
7105               if (i > 1)
7106                 printf (", ");
7107             }
7108
7109           printf ("}");
7110         }
7111       else if (op == 0xd0)
7112         printf ("     MOV FP, SP");
7113       else if (op == 0xd1)
7114         printf ("     __c6xabi_pop_rts");
7115       else if (op == 0xd2)
7116         {
7117           unsigned char buf[9];
7118           unsigned int i, len;
7119           unsigned long offset;
7120
7121           for (i = 0; i < sizeof (buf); i++)
7122             {
7123               GET_OP (buf[i]);
7124               if ((buf[i] & 0x80) == 0)
7125                 break;
7126             }
7127           assert (i < sizeof (buf));
7128           offset = read_uleb128 (buf, &len, buf + i + 1);
7129           assert (len == i + 1);
7130           offset = offset * 8 + 0x408;
7131           printf (_("sp = sp + %ld"), offset);
7132         }
7133       else if ((op & 0xf0) == 0xe0)
7134         {
7135           if ((op & 0x0f) == 7)
7136             printf ("     RETURN");
7137           else
7138             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7139         }
7140       else
7141         {
7142           printf (_("     [unsupported opcode]"));
7143         }
7144       putchar ('\n');
7145     }
7146 }
7147
7148 static bfd_vma
7149 arm_expand_prel31 (bfd_vma word, bfd_vma where)
7150 {
7151   bfd_vma offset;
7152
7153   offset = word & 0x7fffffff;
7154   if (offset & 0x40000000)
7155     offset |= ~ (bfd_vma) 0x7fffffff;
7156
7157   if (elf_header.e_machine == EM_TI_C6000)
7158     offset <<= 1;
7159
7160   return offset + where;
7161 }
7162
7163 static void
7164 decode_arm_unwind (struct arm_unw_aux_info *  aux,
7165                    unsigned int               word,
7166                    unsigned int               remaining,
7167                    bfd_vma                    data_offset,
7168                    Elf_Internal_Shdr *        data_sec,
7169                    struct arm_section *       data_arm_sec)
7170 {
7171   int per_index;
7172   unsigned int more_words = 0;
7173   struct absaddr addr;
7174   bfd_vma sym_name = (bfd_vma) -1;
7175
7176   if (remaining == 0)
7177     {
7178       /* Fetch the first word.
7179          Note - when decoding an object file the address extracted
7180          here will always be 0.  So we also pass in the sym_name
7181          parameter so that we can find the symbol associated with
7182          the personality routine.  */
7183       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7184                                      & word, & addr, & sym_name))
7185         return;
7186
7187       remaining = 4;
7188     }
7189
7190   if ((word & 0x80000000) == 0)
7191     {
7192       /* Expand prel31 for personality routine.  */
7193       bfd_vma fn;
7194       const char *procname;
7195
7196       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
7197       printf (_("  Personality routine: "));
7198       if (fn == 0
7199           && addr.section == SHN_UNDEF && addr.offset == 0
7200           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7201         {
7202           procname = aux->strtab + sym_name;
7203           print_vma (fn, PREFIX_HEX);
7204           if (procname)
7205             {
7206               fputs (" <", stdout);
7207               fputs (procname, stdout);
7208               fputc ('>', stdout);
7209             }
7210         }
7211       else
7212         procname = arm_print_vma_and_name (aux, fn, addr);
7213       fputc ('\n', stdout);
7214
7215       /* The GCC personality routines use the standard compact
7216          encoding, starting with one byte giving the number of
7217          words.  */
7218       if (procname != NULL
7219           && (const_strneq (procname, "__gcc_personality_v0")
7220               || const_strneq (procname, "__gxx_personality_v0")
7221               || const_strneq (procname, "__gcj_personality_v0")
7222               || const_strneq (procname, "__gnu_objc_personality_v0")))
7223         {
7224           remaining = 0;
7225           more_words = 1;
7226           ADVANCE;
7227           if (!remaining)
7228             {
7229               printf (_("  [Truncated data]\n"));
7230               return;
7231             }
7232           more_words = word >> 24;
7233           word <<= 8;
7234           remaining--;
7235           per_index = -1;
7236         }
7237       else
7238         return;
7239     }
7240   else
7241     {
7242       /* ARM EHABI Section 6.3:
7243
7244          An exception-handling table entry for the compact model looks like:
7245
7246            31 30-28 27-24 23-0
7247            -- ----- ----- ----
7248             1   0   index Data for personalityRoutine[index]    */
7249
7250       if (elf_header.e_machine == EM_ARM
7251           && (word & 0x70000000))
7252         warn (_("Corrupt ARM compact model table entry: %x \n"), word);
7253
7254       per_index = (word >> 24) & 0x7f;
7255       printf (_("  Compact model index: %d\n"), per_index);
7256       if (per_index == 0)
7257         {
7258           more_words = 0;
7259           word <<= 8;
7260           remaining--;
7261         }
7262       else if (per_index < 3)
7263         {
7264           more_words = (word >> 16) & 0xff;
7265           word <<= 16;
7266           remaining -= 2;
7267         }
7268     }
7269
7270   switch (elf_header.e_machine)
7271     {
7272     case EM_ARM:
7273       if (per_index < 3)
7274         {
7275           decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7276                                       data_offset, data_sec, data_arm_sec);
7277         }
7278       else
7279         {
7280           warn (_("Unknown ARM compact model index encountered\n"));
7281           printf (_("  [reserved]\n"));
7282         }
7283       break;
7284
7285     case EM_TI_C6000:
7286       if (per_index < 3)
7287         {
7288           decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
7289                                         data_offset, data_sec, data_arm_sec);
7290         }
7291       else if (per_index < 5)
7292         {
7293           if (((word >> 17) & 0x7f) == 0x7f)
7294             printf (_("  Restore stack from frame pointer\n"));
7295           else
7296             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
7297           printf (_("  Registers restored: "));
7298           if (per_index == 4)
7299             printf (" (compact) ");
7300           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7301           putchar ('\n');
7302           printf (_("  Return register: %s\n"),
7303                   tic6x_unwind_regnames[word & 0xf]);
7304         }
7305       else
7306         printf (_("  [reserved (%d)]\n"), per_index);
7307       break;
7308
7309     default:
7310       error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7311              elf_header.e_machine);
7312     }
7313
7314   /* Decode the descriptors.  Not implemented.  */
7315 }
7316
7317 static void
7318 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7319 {
7320   struct arm_section exidx_arm_sec, extab_arm_sec;
7321   unsigned int i, exidx_len;
7322
7323   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7324   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7325   exidx_len = exidx_sec->sh_size / 8;
7326
7327   for (i = 0; i < exidx_len; i++)
7328     {
7329       unsigned int exidx_fn, exidx_entry;
7330       struct absaddr fn_addr, entry_addr;
7331       bfd_vma fn;
7332
7333       fputc ('\n', stdout);
7334
7335       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7336                                      8 * i, & exidx_fn, & fn_addr, NULL)
7337           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7338                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
7339         {
7340           arm_free_section (& exidx_arm_sec);
7341           arm_free_section (& extab_arm_sec);
7342           return;
7343         }
7344
7345       /* ARM EHABI, Section 5:
7346          An index table entry consists of 2 words.
7347          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
7348       if (exidx_fn & 0x80000000)
7349         warn (_("corrupt index table entry: %x\n"), exidx_fn);
7350
7351       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
7352
7353       arm_print_vma_and_name (aux, fn, fn_addr);
7354       fputs (": ", stdout);
7355
7356       if (exidx_entry == 1)
7357         {
7358           print_vma (exidx_entry, PREFIX_HEX);
7359           fputs (" [cantunwind]\n", stdout);
7360         }
7361       else if (exidx_entry & 0x80000000)
7362         {
7363           print_vma (exidx_entry, PREFIX_HEX);
7364           fputc ('\n', stdout);
7365           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7366         }
7367       else
7368         {
7369           bfd_vma table, table_offset = 0;
7370           Elf_Internal_Shdr *table_sec;
7371
7372           fputs ("@", stdout);
7373           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
7374           print_vma (table, PREFIX_HEX);
7375           printf ("\n");
7376
7377           /* Locate the matching .ARM.extab.  */
7378           if (entry_addr.section != SHN_UNDEF
7379               && entry_addr.section < elf_header.e_shnum)
7380             {
7381               table_sec = section_headers + entry_addr.section;
7382               table_offset = entry_addr.offset;
7383             }
7384           else
7385             {
7386               table_sec = find_section_by_address (table);
7387               if (table_sec != NULL)
7388                 table_offset = table - table_sec->sh_addr;
7389             }
7390           if (table_sec == NULL)
7391             {
7392               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7393                     (unsigned long) table);
7394               continue;
7395             }
7396           decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7397                              &extab_arm_sec);
7398         }
7399     }
7400
7401   printf ("\n");
7402
7403   arm_free_section (&exidx_arm_sec);
7404   arm_free_section (&extab_arm_sec);
7405 }
7406
7407 /* Used for both ARM and C6X unwinding tables.  */
7408
7409 static void
7410 arm_process_unwind (FILE *file)
7411 {
7412   struct arm_unw_aux_info aux;
7413   Elf_Internal_Shdr *unwsec = NULL;
7414   Elf_Internal_Shdr *strsec;
7415   Elf_Internal_Shdr *sec;
7416   unsigned long i;
7417   unsigned int sec_type;
7418
7419   switch (elf_header.e_machine)
7420     {
7421     case EM_ARM:
7422       sec_type = SHT_ARM_EXIDX;
7423       break;
7424
7425     case EM_TI_C6000:
7426       sec_type = SHT_C6000_UNWIND;
7427       break;
7428
7429     default:
7430       error (_("Unsupported architecture type %d encountered when processing unwind table"),
7431              elf_header.e_machine);
7432       return;
7433     }
7434
7435   if (string_table == NULL)
7436     return;
7437
7438   memset (& aux, 0, sizeof (aux));
7439   aux.file = file;
7440
7441   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7442     {
7443       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7444         {
7445           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7446
7447           strsec = section_headers + sec->sh_link;
7448           assert (aux.strtab == NULL);
7449           aux.strtab = get_data (NULL, file, strsec->sh_offset,
7450                                  1, strsec->sh_size, _("string table"));
7451           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7452         }
7453       else if (sec->sh_type == sec_type)
7454         unwsec = sec;
7455     }
7456
7457   if (unwsec == NULL)
7458     printf (_("\nThere are no unwind sections in this file.\n"));
7459   else
7460     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7461       {
7462         if (sec->sh_type == sec_type)
7463           {
7464             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7465                     SECTION_NAME (sec),
7466                     (unsigned long) sec->sh_offset,
7467                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7468
7469             dump_arm_unwind (&aux, sec);
7470           }
7471       }
7472
7473   if (aux.symtab)
7474     free (aux.symtab);
7475   if (aux.strtab)
7476     free ((char *) aux.strtab);
7477 }
7478
7479 static void
7480 process_unwind (FILE * file)
7481 {
7482   struct unwind_handler
7483   {
7484     int machtype;
7485     void (* handler)(FILE *);
7486   } handlers[] =
7487   {
7488     { EM_ARM, arm_process_unwind },
7489     { EM_IA_64, ia64_process_unwind },
7490     { EM_PARISC, hppa_process_unwind },
7491     { EM_TI_C6000, arm_process_unwind },
7492     { 0, 0 }
7493   };
7494   int i;
7495
7496   if (!do_unwind)
7497     return;
7498
7499   for (i = 0; handlers[i].handler != NULL; i++)
7500     if (elf_header.e_machine == handlers[i].machtype)
7501       {
7502         handlers[i].handler (file);
7503         return;
7504       }
7505
7506   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7507           get_machine_name (elf_header.e_machine));
7508 }
7509
7510 static void
7511 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
7512 {
7513   switch (entry->d_tag)
7514     {
7515     case DT_MIPS_FLAGS:
7516       if (entry->d_un.d_val == 0)
7517         printf (_("NONE"));
7518       else
7519         {
7520           static const char * opts[] =
7521           {
7522             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7523             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7524             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7525             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7526             "RLD_ORDER_SAFE"
7527           };
7528           unsigned int cnt;
7529           int first = 1;
7530
7531           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
7532             if (entry->d_un.d_val & (1 << cnt))
7533               {
7534                 printf ("%s%s", first ? "" : " ", opts[cnt]);
7535                 first = 0;
7536               }
7537         }
7538       break;
7539
7540     case DT_MIPS_IVERSION:
7541       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7542         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
7543       else
7544         printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
7545       break;
7546
7547     case DT_MIPS_TIME_STAMP:
7548       {
7549         char timebuf[20];
7550         struct tm * tmp;
7551
7552         time_t atime = entry->d_un.d_val;
7553         tmp = gmtime (&atime);
7554         snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7555                   tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7556                   tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7557         printf (_("Time Stamp: %s"), timebuf);
7558       }
7559       break;
7560
7561     case DT_MIPS_RLD_VERSION:
7562     case DT_MIPS_LOCAL_GOTNO:
7563     case DT_MIPS_CONFLICTNO:
7564     case DT_MIPS_LIBLISTNO:
7565     case DT_MIPS_SYMTABNO:
7566     case DT_MIPS_UNREFEXTNO:
7567     case DT_MIPS_HIPAGENO:
7568     case DT_MIPS_DELTA_CLASS_NO:
7569     case DT_MIPS_DELTA_INSTANCE_NO:
7570     case DT_MIPS_DELTA_RELOC_NO:
7571     case DT_MIPS_DELTA_SYM_NO:
7572     case DT_MIPS_DELTA_CLASSSYM_NO:
7573     case DT_MIPS_COMPACT_SIZE:
7574       print_vma (entry->d_un.d_ptr, DEC);
7575       break;
7576
7577     default:
7578       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7579     }
7580     putchar ('\n');
7581 }
7582
7583 static void
7584 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
7585 {
7586   switch (entry->d_tag)
7587     {
7588     case DT_HP_DLD_FLAGS:
7589       {
7590         static struct
7591         {
7592           long int bit;
7593           const char * str;
7594         }
7595         flags[] =
7596         {
7597           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7598           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7599           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7600           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7601           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7602           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7603           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7604           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7605           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7606           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
7607           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7608           { DT_HP_GST, "HP_GST" },
7609           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7610           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7611           { DT_HP_NODELETE, "HP_NODELETE" },
7612           { DT_HP_GROUP, "HP_GROUP" },
7613           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
7614         };
7615         int first = 1;
7616         size_t cnt;
7617         bfd_vma val = entry->d_un.d_val;
7618
7619         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
7620           if (val & flags[cnt].bit)
7621             {
7622               if (! first)
7623                 putchar (' ');
7624               fputs (flags[cnt].str, stdout);
7625               first = 0;
7626               val ^= flags[cnt].bit;
7627             }
7628
7629         if (val != 0 || first)
7630           {
7631             if (! first)
7632               putchar (' ');
7633             print_vma (val, HEX);
7634           }
7635       }
7636       break;
7637
7638     default:
7639       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7640       break;
7641     }
7642   putchar ('\n');
7643 }
7644
7645 #ifdef BFD64
7646
7647 /* VMS vs Unix time offset and factor.  */
7648
7649 #define VMS_EPOCH_OFFSET 35067168000000000LL
7650 #define VMS_GRANULARITY_FACTOR 10000000
7651
7652 /* Display a VMS time in a human readable format.  */
7653
7654 static void
7655 print_vms_time (bfd_int64_t vmstime)
7656 {
7657   struct tm *tm;
7658   time_t unxtime;
7659
7660   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7661   tm = gmtime (&unxtime);
7662   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7663           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7664           tm->tm_hour, tm->tm_min, tm->tm_sec);
7665 }
7666 #endif /* BFD64 */
7667
7668 static void
7669 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
7670 {
7671   switch (entry->d_tag)
7672     {
7673     case DT_IA_64_PLT_RESERVE:
7674       /* First 3 slots reserved.  */
7675       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7676       printf (" -- ");
7677       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
7678       break;
7679
7680     case DT_IA_64_VMS_LINKTIME:
7681 #ifdef BFD64
7682       print_vms_time (entry->d_un.d_val);
7683 #endif
7684       break;
7685
7686     case DT_IA_64_VMS_LNKFLAGS:
7687       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7688       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7689         printf (" CALL_DEBUG");
7690       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7691         printf (" NOP0BUFS");
7692       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7693         printf (" P0IMAGE");
7694       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7695         printf (" MKTHREADS");
7696       if (entry->d_un.d_val & VMS_LF_UPCALLS)
7697         printf (" UPCALLS");
7698       if (entry->d_un.d_val & VMS_LF_IMGSTA)
7699         printf (" IMGSTA");
7700       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7701         printf (" INITIALIZE");
7702       if (entry->d_un.d_val & VMS_LF_MAIN)
7703         printf (" MAIN");
7704       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7705         printf (" EXE_INIT");
7706       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7707         printf (" TBK_IN_IMG");
7708       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7709         printf (" DBG_IN_IMG");
7710       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7711         printf (" TBK_IN_DSF");
7712       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7713         printf (" DBG_IN_DSF");
7714       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7715         printf (" SIGNATURES");
7716       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7717         printf (" REL_SEG_OFF");
7718       break;
7719
7720     default:
7721       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7722       break;
7723     }
7724   putchar ('\n');
7725 }
7726
7727 static int
7728 get_32bit_dynamic_section (FILE * file)
7729 {
7730   Elf32_External_Dyn * edyn;
7731   Elf32_External_Dyn * ext;
7732   Elf_Internal_Dyn * entry;
7733
7734   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7735                                           dynamic_size, _("dynamic section"));
7736   if (!edyn)
7737     return 0;
7738
7739 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7740    might not have the luxury of section headers.  Look for the DT_NULL
7741    terminator to determine the number of entries.  */
7742   for (ext = edyn, dynamic_nent = 0;
7743        (char *) ext < (char *) edyn + dynamic_size;
7744        ext++)
7745     {
7746       dynamic_nent++;
7747       if (BYTE_GET (ext->d_tag) == DT_NULL)
7748         break;
7749     }
7750
7751   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7752                                                   sizeof (* entry));
7753   if (dynamic_section == NULL)
7754     {
7755       error (_("Out of memory\n"));
7756       free (edyn);
7757       return 0;
7758     }
7759
7760   for (ext = edyn, entry = dynamic_section;
7761        entry < dynamic_section + dynamic_nent;
7762        ext++, entry++)
7763     {
7764       entry->d_tag      = BYTE_GET (ext->d_tag);
7765       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7766     }
7767
7768   free (edyn);
7769
7770   return 1;
7771 }
7772
7773 static int
7774 get_64bit_dynamic_section (FILE * file)
7775 {
7776   Elf64_External_Dyn * edyn;
7777   Elf64_External_Dyn * ext;
7778   Elf_Internal_Dyn * entry;
7779
7780   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7781                                           dynamic_size, _("dynamic section"));
7782   if (!edyn)
7783     return 0;
7784
7785 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7786    might not have the luxury of section headers.  Look for the DT_NULL
7787    terminator to determine the number of entries.  */
7788   for (ext = edyn, dynamic_nent = 0;
7789        (char *) ext < (char *) edyn + dynamic_size;
7790        ext++)
7791     {
7792       dynamic_nent++;
7793       if (BYTE_GET (ext->d_tag) == DT_NULL)
7794         break;
7795     }
7796
7797   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7798                                                   sizeof (* entry));
7799   if (dynamic_section == NULL)
7800     {
7801       error (_("Out of memory\n"));
7802       free (edyn);
7803       return 0;
7804     }
7805
7806   for (ext = edyn, entry = dynamic_section;
7807        entry < dynamic_section + dynamic_nent;
7808        ext++, entry++)
7809     {
7810       entry->d_tag      = BYTE_GET (ext->d_tag);
7811       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7812     }
7813
7814   free (edyn);
7815
7816   return 1;
7817 }
7818
7819 static void
7820 print_dynamic_flags (bfd_vma flags)
7821 {
7822   int first = 1;
7823
7824   while (flags)
7825     {
7826       bfd_vma flag;
7827
7828       flag = flags & - flags;
7829       flags &= ~ flag;
7830
7831       if (first)
7832         first = 0;
7833       else
7834         putc (' ', stdout);
7835
7836       switch (flag)
7837         {
7838         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
7839         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
7840         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
7841         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
7842         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
7843         default:                fputs (_("unknown"), stdout); break;
7844         }
7845     }
7846   puts ("");
7847 }
7848
7849 /* Parse and display the contents of the dynamic section.  */
7850
7851 static int
7852 process_dynamic_section (FILE * file)
7853 {
7854   Elf_Internal_Dyn * entry;
7855
7856   if (dynamic_size == 0)
7857     {
7858       if (do_dynamic)
7859         printf (_("\nThere is no dynamic section in this file.\n"));
7860
7861       return 1;
7862     }
7863
7864   if (is_32bit_elf)
7865     {
7866       if (! get_32bit_dynamic_section (file))
7867         return 0;
7868     }
7869   else if (! get_64bit_dynamic_section (file))
7870     return 0;
7871
7872   /* Find the appropriate symbol table.  */
7873   if (dynamic_symbols == NULL)
7874     {
7875       for (entry = dynamic_section;
7876            entry < dynamic_section + dynamic_nent;
7877            ++entry)
7878         {
7879           Elf_Internal_Shdr section;
7880
7881           if (entry->d_tag != DT_SYMTAB)
7882             continue;
7883
7884           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7885
7886           /* Since we do not know how big the symbol table is,
7887              we default to reading in the entire file (!) and
7888              processing that.  This is overkill, I know, but it
7889              should work.  */
7890           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
7891
7892           if (archive_file_offset != 0)
7893             section.sh_size = archive_file_size - section.sh_offset;
7894           else
7895             {
7896               if (fseek (file, 0, SEEK_END))
7897                 error (_("Unable to seek to end of file!\n"));
7898
7899               section.sh_size = ftell (file) - section.sh_offset;
7900             }
7901
7902           if (is_32bit_elf)
7903             section.sh_entsize = sizeof (Elf32_External_Sym);
7904           else
7905             section.sh_entsize = sizeof (Elf64_External_Sym);
7906
7907           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
7908           if (num_dynamic_syms < 1)
7909             {
7910               error (_("Unable to determine the number of symbols to load\n"));
7911               continue;
7912             }
7913         }
7914     }
7915
7916   /* Similarly find a string table.  */
7917   if (dynamic_strings == NULL)
7918     {
7919       for (entry = dynamic_section;
7920            entry < dynamic_section + dynamic_nent;
7921            ++entry)
7922         {
7923           unsigned long offset;
7924           long str_tab_len;
7925
7926           if (entry->d_tag != DT_STRTAB)
7927             continue;
7928
7929           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7930
7931           /* Since we do not know how big the string table is,
7932              we default to reading in the entire file (!) and
7933              processing that.  This is overkill, I know, but it
7934              should work.  */
7935
7936           offset = offset_from_vma (file, entry->d_un.d_val, 0);
7937
7938           if (archive_file_offset != 0)
7939             str_tab_len = archive_file_size - offset;
7940           else
7941             {
7942               if (fseek (file, 0, SEEK_END))
7943                 error (_("Unable to seek to end of file\n"));
7944               str_tab_len = ftell (file) - offset;
7945             }
7946
7947           if (str_tab_len < 1)
7948             {
7949               error
7950                 (_("Unable to determine the length of the dynamic string table\n"));
7951               continue;
7952             }
7953
7954           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7955                                                str_tab_len,
7956                                                _("dynamic string table"));
7957           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
7958           break;
7959         }
7960     }
7961
7962   /* And find the syminfo section if available.  */
7963   if (dynamic_syminfo == NULL)
7964     {
7965       unsigned long syminsz = 0;
7966
7967       for (entry = dynamic_section;
7968            entry < dynamic_section + dynamic_nent;
7969            ++entry)
7970         {
7971           if (entry->d_tag == DT_SYMINENT)
7972             {
7973               /* Note: these braces are necessary to avoid a syntax
7974                  error from the SunOS4 C compiler.  */
7975               assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7976             }
7977           else if (entry->d_tag == DT_SYMINSZ)
7978             syminsz = entry->d_un.d_val;
7979           else if (entry->d_tag == DT_SYMINFO)
7980             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7981                                                       syminsz);
7982         }
7983
7984       if (dynamic_syminfo_offset != 0 && syminsz != 0)
7985         {
7986           Elf_External_Syminfo * extsyminfo;
7987           Elf_External_Syminfo * extsym;
7988           Elf_Internal_Syminfo * syminfo;
7989
7990           /* There is a syminfo section.  Read the data.  */
7991           extsyminfo = (Elf_External_Syminfo *)
7992               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7993                         _("symbol information"));
7994           if (!extsyminfo)
7995             return 0;
7996
7997           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
7998           if (dynamic_syminfo == NULL)
7999             {
8000               error (_("Out of memory\n"));
8001               return 0;
8002             }
8003
8004           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
8005           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8006                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8007                ++syminfo, ++extsym)
8008             {
8009               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8010               syminfo->si_flags = BYTE_GET (extsym->si_flags);
8011             }
8012
8013           free (extsyminfo);
8014         }
8015     }
8016
8017   if (do_dynamic && dynamic_addr)
8018     printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
8019             dynamic_addr, dynamic_nent);
8020   if (do_dynamic)
8021     printf (_("  Tag        Type                         Name/Value\n"));
8022
8023   for (entry = dynamic_section;
8024        entry < dynamic_section + dynamic_nent;
8025        entry++)
8026     {
8027       if (do_dynamic)
8028         {
8029           const char * dtype;
8030
8031           putchar (' ');
8032           print_vma (entry->d_tag, FULL_HEX);
8033           dtype = get_dynamic_type (entry->d_tag);
8034           printf (" (%s)%*s", dtype,
8035                   ((is_32bit_elf ? 27 : 19)
8036                    - (int) strlen (dtype)),
8037                   " ");
8038         }
8039
8040       switch (entry->d_tag)
8041         {
8042         case DT_FLAGS:
8043           if (do_dynamic)
8044             print_dynamic_flags (entry->d_un.d_val);
8045           break;
8046
8047         case DT_AUXILIARY:
8048         case DT_FILTER:
8049         case DT_CONFIG:
8050         case DT_DEPAUDIT:
8051         case DT_AUDIT:
8052           if (do_dynamic)
8053             {
8054               switch (entry->d_tag)
8055                 {
8056                 case DT_AUXILIARY:
8057                   printf (_("Auxiliary library"));
8058                   break;
8059
8060                 case DT_FILTER:
8061                   printf (_("Filter library"));
8062                   break;
8063
8064                 case DT_CONFIG:
8065                   printf (_("Configuration file"));
8066                   break;
8067
8068                 case DT_DEPAUDIT:
8069                   printf (_("Dependency audit library"));
8070                   break;
8071
8072                 case DT_AUDIT:
8073                   printf (_("Audit library"));
8074                   break;
8075                 }
8076
8077               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8078                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
8079               else
8080                 {
8081                   printf (": ");
8082                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8083                   putchar ('\n');
8084                 }
8085             }
8086           break;
8087
8088         case DT_FEATURE:
8089           if (do_dynamic)
8090             {
8091               printf (_("Flags:"));
8092
8093               if (entry->d_un.d_val == 0)
8094                 printf (_(" None\n"));
8095               else
8096                 {
8097                   unsigned long int val = entry->d_un.d_val;
8098
8099                   if (val & DTF_1_PARINIT)
8100                     {
8101                       printf (" PARINIT");
8102                       val ^= DTF_1_PARINIT;
8103                     }
8104                   if (val & DTF_1_CONFEXP)
8105                     {
8106                       printf (" CONFEXP");
8107                       val ^= DTF_1_CONFEXP;
8108                     }
8109                   if (val != 0)
8110                     printf (" %lx", val);
8111                   puts ("");
8112                 }
8113             }
8114           break;
8115
8116         case DT_POSFLAG_1:
8117           if (do_dynamic)
8118             {
8119               printf (_("Flags:"));
8120
8121               if (entry->d_un.d_val == 0)
8122                 printf (_(" None\n"));
8123               else
8124                 {
8125                   unsigned long int val = entry->d_un.d_val;
8126
8127                   if (val & DF_P1_LAZYLOAD)
8128                     {
8129                       printf (" LAZYLOAD");
8130                       val ^= DF_P1_LAZYLOAD;
8131                     }
8132                   if (val & DF_P1_GROUPPERM)
8133                     {
8134                       printf (" GROUPPERM");
8135                       val ^= DF_P1_GROUPPERM;
8136                     }
8137                   if (val != 0)
8138                     printf (" %lx", val);
8139                   puts ("");
8140                 }
8141             }
8142           break;
8143
8144         case DT_FLAGS_1:
8145           if (do_dynamic)
8146             {
8147               printf (_("Flags:"));
8148               if (entry->d_un.d_val == 0)
8149                 printf (_(" None\n"));
8150               else
8151                 {
8152                   unsigned long int val = entry->d_un.d_val;
8153
8154                   if (val & DF_1_NOW)
8155                     {
8156                       printf (" NOW");
8157                       val ^= DF_1_NOW;
8158                     }
8159                   if (val & DF_1_GLOBAL)
8160                     {
8161                       printf (" GLOBAL");
8162                       val ^= DF_1_GLOBAL;
8163                     }
8164                   if (val & DF_1_GROUP)
8165                     {
8166                       printf (" GROUP");
8167                       val ^= DF_1_GROUP;
8168                     }
8169                   if (val & DF_1_NODELETE)
8170                     {
8171                       printf (" NODELETE");
8172                       val ^= DF_1_NODELETE;
8173                     }
8174                   if (val & DF_1_LOADFLTR)
8175                     {
8176                       printf (" LOADFLTR");
8177                       val ^= DF_1_LOADFLTR;
8178                     }
8179                   if (val & DF_1_INITFIRST)
8180                     {
8181                       printf (" INITFIRST");
8182                       val ^= DF_1_INITFIRST;
8183                     }
8184                   if (val & DF_1_NOOPEN)
8185                     {
8186                       printf (" NOOPEN");
8187                       val ^= DF_1_NOOPEN;
8188                     }
8189                   if (val & DF_1_ORIGIN)
8190                     {
8191                       printf (" ORIGIN");
8192                       val ^= DF_1_ORIGIN;
8193                     }
8194                   if (val & DF_1_DIRECT)
8195                     {
8196                       printf (" DIRECT");
8197                       val ^= DF_1_DIRECT;
8198                     }
8199                   if (val & DF_1_TRANS)
8200                     {
8201                       printf (" TRANS");
8202                       val ^= DF_1_TRANS;
8203                     }
8204                   if (val & DF_1_INTERPOSE)
8205                     {
8206                       printf (" INTERPOSE");
8207                       val ^= DF_1_INTERPOSE;
8208                     }
8209                   if (val & DF_1_NODEFLIB)
8210                     {
8211                       printf (" NODEFLIB");
8212                       val ^= DF_1_NODEFLIB;
8213                     }
8214                   if (val & DF_1_NODUMP)
8215                     {
8216                       printf (" NODUMP");
8217                       val ^= DF_1_NODUMP;
8218                     }
8219                   if (val & DF_1_CONFALT)
8220                     {
8221                       printf (" CONFALT");
8222                       val ^= DF_1_CONFALT;
8223                     }
8224                   if (val & DF_1_ENDFILTEE)
8225                     {
8226                       printf (" ENDFILTEE");
8227                       val ^= DF_1_ENDFILTEE;
8228                     }
8229                   if (val & DF_1_DISPRELDNE)
8230                     {
8231                       printf (" DISPRELDNE");
8232                       val ^= DF_1_DISPRELDNE;
8233                     }
8234                   if (val & DF_1_DISPRELPND)
8235                     {
8236                       printf (" DISPRELPND");
8237                       val ^= DF_1_DISPRELPND;
8238                     }
8239                   if (val & DF_1_NODIRECT)
8240                     {
8241                       printf (" NODIRECT");
8242                       val ^= DF_1_NODIRECT;
8243                     }
8244                   if (val & DF_1_IGNMULDEF)
8245                     {
8246                       printf (" IGNMULDEF");
8247                       val ^= DF_1_IGNMULDEF;
8248                     }
8249                   if (val & DF_1_NOKSYMS)
8250                     {
8251                       printf (" NOKSYMS");
8252                       val ^= DF_1_NOKSYMS;
8253                     }
8254                   if (val & DF_1_NOHDR)
8255                     {
8256                       printf (" NOHDR");
8257                       val ^= DF_1_NOHDR;
8258                     }
8259                   if (val & DF_1_EDITED)
8260                     {
8261                       printf (" EDITED");
8262                       val ^= DF_1_EDITED;
8263                     }
8264                   if (val & DF_1_NORELOC)
8265                     {
8266                       printf (" NORELOC");
8267                       val ^= DF_1_NORELOC;
8268                     }
8269                   if (val & DF_1_SYMINTPOSE)
8270                     {
8271                       printf (" SYMINTPOSE");
8272                       val ^= DF_1_SYMINTPOSE;
8273                     }
8274                   if (val & DF_1_GLOBAUDIT)
8275                     {
8276                       printf (" GLOBAUDIT");
8277                       val ^= DF_1_GLOBAUDIT;
8278                     }
8279                   if (val & DF_1_SINGLETON)
8280                     {
8281                       printf (" SINGLETON");
8282                       val ^= DF_1_SINGLETON;
8283                     }
8284                   if (val != 0)
8285                     printf (" %lx", val);
8286                   puts ("");
8287                 }
8288             }
8289           break;
8290
8291         case DT_PLTREL:
8292           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8293           if (do_dynamic)
8294             puts (get_dynamic_type (entry->d_un.d_val));
8295           break;
8296
8297         case DT_NULL    :
8298         case DT_NEEDED  :
8299         case DT_PLTGOT  :
8300         case DT_HASH    :
8301         case DT_STRTAB  :
8302         case DT_SYMTAB  :
8303         case DT_RELA    :
8304         case DT_INIT    :
8305         case DT_FINI    :
8306         case DT_SONAME  :
8307         case DT_RPATH   :
8308         case DT_SYMBOLIC:
8309         case DT_REL     :
8310         case DT_DEBUG   :
8311         case DT_TEXTREL :
8312         case DT_JMPREL  :
8313         case DT_RUNPATH :
8314           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8315
8316           if (do_dynamic)
8317             {
8318               char * name;
8319
8320               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8321                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8322               else
8323                 name = NULL;
8324
8325               if (name)
8326                 {
8327                   switch (entry->d_tag)
8328                     {
8329                     case DT_NEEDED:
8330                       printf (_("Shared library: [%s]"), name);
8331
8332                       if (streq (name, program_interpreter))
8333                         printf (_(" program interpreter"));
8334                       break;
8335
8336                     case DT_SONAME:
8337                       printf (_("Library soname: [%s]"), name);
8338                       break;
8339
8340                     case DT_RPATH:
8341                       printf (_("Library rpath: [%s]"), name);
8342                       break;
8343
8344                     case DT_RUNPATH:
8345                       printf (_("Library runpath: [%s]"), name);
8346                       break;
8347
8348                     default:
8349                       print_vma (entry->d_un.d_val, PREFIX_HEX);
8350                       break;
8351                     }
8352                 }
8353               else
8354                 print_vma (entry->d_un.d_val, PREFIX_HEX);
8355
8356               putchar ('\n');
8357             }
8358           break;
8359
8360         case DT_PLTRELSZ:
8361         case DT_RELASZ  :
8362         case DT_STRSZ   :
8363         case DT_RELSZ   :
8364         case DT_RELAENT :
8365         case DT_SYMENT  :
8366         case DT_RELENT  :
8367           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8368         case DT_PLTPADSZ:
8369         case DT_MOVEENT :
8370         case DT_MOVESZ  :
8371         case DT_INIT_ARRAYSZ:
8372         case DT_FINI_ARRAYSZ:
8373         case DT_GNU_CONFLICTSZ:
8374         case DT_GNU_LIBLISTSZ:
8375           if (do_dynamic)
8376             {
8377               print_vma (entry->d_un.d_val, UNSIGNED);
8378               printf (_(" (bytes)\n"));
8379             }
8380           break;
8381
8382         case DT_VERDEFNUM:
8383         case DT_VERNEEDNUM:
8384         case DT_RELACOUNT:
8385         case DT_RELCOUNT:
8386           if (do_dynamic)
8387             {
8388               print_vma (entry->d_un.d_val, UNSIGNED);
8389               putchar ('\n');
8390             }
8391           break;
8392
8393         case DT_SYMINSZ:
8394         case DT_SYMINENT:
8395         case DT_SYMINFO:
8396         case DT_USED:
8397         case DT_INIT_ARRAY:
8398         case DT_FINI_ARRAY:
8399           if (do_dynamic)
8400             {
8401               if (entry->d_tag == DT_USED
8402                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
8403                 {
8404                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8405
8406                   if (*name)
8407                     {
8408                       printf (_("Not needed object: [%s]\n"), name);
8409                       break;
8410                     }
8411                 }
8412
8413               print_vma (entry->d_un.d_val, PREFIX_HEX);
8414               putchar ('\n');
8415             }
8416           break;
8417
8418         case DT_BIND_NOW:
8419           /* The value of this entry is ignored.  */
8420           if (do_dynamic)
8421             putchar ('\n');
8422           break;
8423
8424         case DT_GNU_PRELINKED:
8425           if (do_dynamic)
8426             {
8427               struct tm * tmp;
8428               time_t atime = entry->d_un.d_val;
8429
8430               tmp = gmtime (&atime);
8431               printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8432                       tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8433                       tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8434
8435             }
8436           break;
8437
8438         case DT_GNU_HASH:
8439           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8440           if (do_dynamic)
8441             {
8442               print_vma (entry->d_un.d_val, PREFIX_HEX);
8443               putchar ('\n');
8444             }
8445           break;
8446
8447         default:
8448           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
8449             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
8450               entry->d_un.d_val;
8451
8452           if (do_dynamic)
8453             {
8454               switch (elf_header.e_machine)
8455                 {
8456                 case EM_MIPS:
8457                 case EM_MIPS_RS3_LE:
8458                   dynamic_section_mips_val (entry);
8459                   break;
8460                 case EM_PARISC:
8461                   dynamic_section_parisc_val (entry);
8462                   break;
8463                 case EM_IA_64:
8464                   dynamic_section_ia64_val (entry);
8465                   break;
8466                 default:
8467                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8468                   putchar ('\n');
8469                 }
8470             }
8471           break;
8472         }
8473     }
8474
8475   return 1;
8476 }
8477
8478 static char *
8479 get_ver_flags (unsigned int flags)
8480 {
8481   static char buff[32];
8482
8483   buff[0] = 0;
8484
8485   if (flags == 0)
8486     return _("none");
8487
8488   if (flags & VER_FLG_BASE)
8489     strcat (buff, "BASE ");
8490
8491   if (flags & VER_FLG_WEAK)
8492     {
8493       if (flags & VER_FLG_BASE)
8494         strcat (buff, "| ");
8495
8496       strcat (buff, "WEAK ");
8497     }
8498
8499   if (flags & VER_FLG_INFO)
8500     {
8501       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8502         strcat (buff, "| ");
8503
8504       strcat (buff, "INFO ");
8505     }
8506
8507   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
8508     strcat (buff, _("| <unknown>"));
8509
8510   return buff;
8511 }
8512
8513 /* Display the contents of the version sections.  */
8514
8515 static int
8516 process_version_sections (FILE * file)
8517 {
8518   Elf_Internal_Shdr * section;
8519   unsigned i;
8520   int found = 0;
8521
8522   if (! do_version)
8523     return 1;
8524
8525   for (i = 0, section = section_headers;
8526        i < elf_header.e_shnum;
8527        i++, section++)
8528     {
8529       switch (section->sh_type)
8530         {
8531         case SHT_GNU_verdef:
8532           {
8533             Elf_External_Verdef * edefs;
8534             unsigned int idx;
8535             unsigned int cnt;
8536             char * endbuf;
8537
8538             found = 1;
8539
8540             printf
8541               (_("\nVersion definition section '%s' contains %u entries:\n"),
8542                SECTION_NAME (section), section->sh_info);
8543
8544             printf (_("  Addr: 0x"));
8545             printf_vma (section->sh_addr);
8546             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8547                     (unsigned long) section->sh_offset, section->sh_link,
8548                     section->sh_link < elf_header.e_shnum
8549                     ? SECTION_NAME (section_headers + section->sh_link)
8550                     : _("<corrupt>"));
8551
8552             edefs = (Elf_External_Verdef *)
8553                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8554                           _("version definition section"));
8555             if (!edefs)
8556               break;
8557             endbuf = (char *) edefs + section->sh_size;
8558
8559             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8560               {
8561                 char * vstart;
8562                 Elf_External_Verdef * edef;
8563                 Elf_Internal_Verdef ent;
8564                 Elf_External_Verdaux * eaux;
8565                 Elf_Internal_Verdaux aux;
8566                 int j;
8567                 int isum;
8568
8569                 /* Check for very large indicies.  */
8570                 if (idx > (size_t) (endbuf - (char *) edefs))
8571                   break;
8572
8573                 vstart = ((char *) edefs) + idx;
8574                 if (vstart + sizeof (*edef) > endbuf)
8575                   break;
8576
8577                 edef = (Elf_External_Verdef *) vstart;
8578
8579                 ent.vd_version = BYTE_GET (edef->vd_version);
8580                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
8581                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
8582                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
8583                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
8584                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
8585                 ent.vd_next    = BYTE_GET (edef->vd_next);
8586
8587                 printf (_("  %#06x: Rev: %d  Flags: %s"),
8588                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8589
8590                 printf (_("  Index: %d  Cnt: %d  "),
8591                         ent.vd_ndx, ent.vd_cnt);
8592
8593                 /* Check for overflow.  */
8594                 if (ent.vd_aux > (size_t) (endbuf - vstart))
8595                   break;
8596
8597                 vstart += ent.vd_aux;
8598
8599                 eaux = (Elf_External_Verdaux *) vstart;
8600
8601                 aux.vda_name = BYTE_GET (eaux->vda_name);
8602                 aux.vda_next = BYTE_GET (eaux->vda_next);
8603
8604                 if (VALID_DYNAMIC_NAME (aux.vda_name))
8605                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
8606                 else
8607                   printf (_("Name index: %ld\n"), aux.vda_name);
8608
8609                 isum = idx + ent.vd_aux;
8610
8611                 for (j = 1; j < ent.vd_cnt; j++)
8612                   {
8613                     /* Check for overflow.  */
8614                     if (aux.vda_next > (size_t) (endbuf - vstart))
8615                       break;
8616
8617                     isum   += aux.vda_next;
8618                     vstart += aux.vda_next;
8619
8620                     eaux = (Elf_External_Verdaux *) vstart;
8621                     if (vstart + sizeof (*eaux) > endbuf)
8622                       break;
8623
8624                     aux.vda_name = BYTE_GET (eaux->vda_name);
8625                     aux.vda_next = BYTE_GET (eaux->vda_next);
8626
8627                     if (VALID_DYNAMIC_NAME (aux.vda_name))
8628                       printf (_("  %#06x: Parent %d: %s\n"),
8629                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
8630                     else
8631                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
8632                               isum, j, aux.vda_name);
8633                   }
8634
8635                 if (j < ent.vd_cnt)
8636                   printf (_("  Version def aux past end of section\n"));
8637
8638                 idx += ent.vd_next;
8639               }
8640
8641             if (cnt < section->sh_info)
8642               printf (_("  Version definition past end of section\n"));
8643
8644             free (edefs);
8645           }
8646           break;
8647
8648         case SHT_GNU_verneed:
8649           {
8650             Elf_External_Verneed * eneed;
8651             unsigned int idx;
8652             unsigned int cnt;
8653             char * endbuf;
8654
8655             found = 1;
8656
8657             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8658                     SECTION_NAME (section), section->sh_info);
8659
8660             printf (_(" Addr: 0x"));
8661             printf_vma (section->sh_addr);
8662             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8663                     (unsigned long) section->sh_offset, section->sh_link,
8664                     section->sh_link < elf_header.e_shnum
8665                     ? SECTION_NAME (section_headers + section->sh_link)
8666                     : _("<corrupt>"));
8667
8668             eneed = (Elf_External_Verneed *) get_data (NULL, file,
8669                                                        section->sh_offset, 1,
8670                                                        section->sh_size,
8671                                                        _("Version Needs section"));
8672             if (!eneed)
8673               break;
8674             endbuf = (char *) eneed + section->sh_size;
8675
8676             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8677               {
8678                 Elf_External_Verneed * entry;
8679                 Elf_Internal_Verneed ent;
8680                 int j;
8681                 int isum;
8682                 char * vstart;
8683
8684                 if (idx > (size_t) (endbuf - (char *) eneed))
8685                   break;
8686
8687                 vstart = ((char *) eneed) + idx;
8688                 if (vstart + sizeof (*entry) > endbuf)
8689                   break;
8690
8691                 entry = (Elf_External_Verneed *) vstart;
8692
8693                 ent.vn_version = BYTE_GET (entry->vn_version);
8694                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
8695                 ent.vn_file    = BYTE_GET (entry->vn_file);
8696                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
8697                 ent.vn_next    = BYTE_GET (entry->vn_next);
8698
8699                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
8700
8701                 if (VALID_DYNAMIC_NAME (ent.vn_file))
8702                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
8703                 else
8704                   printf (_("  File: %lx"), ent.vn_file);
8705
8706                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
8707
8708                 /* Check for overflow.  */
8709                 if (ent.vn_aux > (size_t) (endbuf - vstart))
8710                   break;
8711
8712                 vstart += ent.vn_aux;
8713
8714                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8715                   {
8716                     Elf_External_Vernaux * eaux;
8717                     Elf_Internal_Vernaux aux;
8718
8719                     if (vstart + sizeof (*eaux) > endbuf)
8720                       break;
8721                     eaux = (Elf_External_Vernaux *) vstart;
8722
8723                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
8724                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
8725                     aux.vna_other = BYTE_GET (eaux->vna_other);
8726                     aux.vna_name  = BYTE_GET (eaux->vna_name);
8727                     aux.vna_next  = BYTE_GET (eaux->vna_next);
8728
8729                     if (VALID_DYNAMIC_NAME (aux.vna_name))
8730                       printf (_("  %#06x:   Name: %s"),
8731                               isum, GET_DYNAMIC_NAME (aux.vna_name));
8732                     else
8733                       printf (_("  %#06x:   Name index: %lx"),
8734                               isum, aux.vna_name);
8735
8736                     printf (_("  Flags: %s  Version: %d\n"),
8737                             get_ver_flags (aux.vna_flags), aux.vna_other);
8738
8739                     /* Check for overflow.  */
8740                     if (aux.vna_next > (size_t) (endbuf - vstart))
8741                       break;
8742
8743                     isum   += aux.vna_next;
8744                     vstart += aux.vna_next;
8745                   }
8746
8747                 if (j < ent.vn_cnt)
8748                   warn (_("Missing Version Needs auxillary information\n"));
8749
8750                 idx += ent.vn_next;
8751               }
8752
8753             if (cnt < section->sh_info)
8754               warn (_("Missing Version Needs information\n"));
8755
8756             free (eneed);
8757           }
8758           break;
8759
8760         case SHT_GNU_versym:
8761           {
8762             Elf_Internal_Shdr * link_section;
8763             int total;
8764             int cnt;
8765             unsigned char * edata;
8766             unsigned short * data;
8767             char * strtab;
8768             Elf_Internal_Sym * symbols;
8769             Elf_Internal_Shdr * string_sec;
8770             unsigned long num_syms;
8771             long off;
8772
8773             if (section->sh_link >= elf_header.e_shnum)
8774               break;
8775
8776             link_section = section_headers + section->sh_link;
8777             total = section->sh_size / sizeof (Elf_External_Versym);
8778
8779             if (link_section->sh_link >= elf_header.e_shnum)
8780               break;
8781
8782             found = 1;
8783
8784             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
8785             if (symbols == NULL)
8786               break;
8787
8788             string_sec = section_headers + link_section->sh_link;
8789
8790             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8791                                         string_sec->sh_size,
8792                                         _("version string table"));
8793             if (!strtab)
8794               {
8795                 free (symbols);
8796                 break;
8797               }
8798
8799             printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8800                     SECTION_NAME (section), total);
8801
8802             printf (_(" Addr: "));
8803             printf_vma (section->sh_addr);
8804             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8805                     (unsigned long) section->sh_offset, section->sh_link,
8806                     SECTION_NAME (link_section));
8807
8808             off = offset_from_vma (file,
8809                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8810                                    total * sizeof (short));
8811             edata = (unsigned char *) get_data (NULL, file, off, total,
8812                                                 sizeof (short),
8813                                                 _("version symbol data"));
8814             if (!edata)
8815               {
8816                 free (strtab);
8817                 free (symbols);
8818                 break;
8819               }
8820
8821             data = (short unsigned int *) cmalloc (total, sizeof (short));
8822
8823             for (cnt = total; cnt --;)
8824               data[cnt] = byte_get (edata + cnt * sizeof (short),
8825                                     sizeof (short));
8826
8827             free (edata);
8828
8829             for (cnt = 0; cnt < total; cnt += 4)
8830               {
8831                 int j, nn;
8832                 int check_def, check_need;
8833                 char * name;
8834
8835                 printf ("  %03x:", cnt);
8836
8837                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
8838                   switch (data[cnt + j])
8839                     {
8840                     case 0:
8841                       fputs (_("   0 (*local*)    "), stdout);
8842                       break;
8843
8844                     case 1:
8845                       fputs (_("   1 (*global*)   "), stdout);
8846                       break;
8847
8848                     default:
8849                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8850                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
8851
8852                       /* If this index value is greater than the size of the symbols
8853                          array, break to avoid an out-of-bounds read.  */
8854                       if ((unsigned long)(cnt + j) >= num_syms)
8855                         {
8856                           warn (_("invalid index into symbol array\n"));
8857                           break;
8858                         }
8859
8860                       check_def = 1;
8861                       check_need = 1;
8862                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8863                           || section_headers[symbols[cnt + j].st_shndx].sh_type
8864                              != SHT_NOBITS)
8865                         {
8866                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
8867                             check_def = 0;
8868                           else
8869                             check_need = 0;
8870                         }
8871
8872                       if (check_need
8873                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
8874                         {
8875                           Elf_Internal_Verneed ivn;
8876                           unsigned long offset;
8877
8878                           offset = offset_from_vma
8879                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8880                              sizeof (Elf_External_Verneed));
8881
8882                           do
8883                             {
8884                               Elf_Internal_Vernaux ivna;
8885                               Elf_External_Verneed evn;
8886                               Elf_External_Vernaux evna;
8887                               unsigned long a_off;
8888
8889                               if (get_data (&evn, file, offset, sizeof (evn), 1,
8890                                             _("version need")) == NULL)
8891                                 break;
8892
8893                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
8894                               ivn.vn_next = BYTE_GET (evn.vn_next);
8895
8896                               a_off = offset + ivn.vn_aux;
8897
8898                               do
8899                                 {
8900                                   if (get_data (&evna, file, a_off, sizeof (evna),
8901                                                 1, _("version need aux (2)")) == NULL)
8902                                     {
8903                                       ivna.vna_next  = 0;
8904                                       ivna.vna_other = 0;
8905                                     }
8906                                   else
8907                                     {
8908                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
8909                                       ivna.vna_other = BYTE_GET (evna.vna_other);
8910                                     }
8911
8912                                   a_off += ivna.vna_next;
8913                                 }
8914                               while (ivna.vna_other != data[cnt + j]
8915                                      && ivna.vna_next != 0);
8916
8917                               if (ivna.vna_other == data[cnt + j])
8918                                 {
8919                                   ivna.vna_name = BYTE_GET (evna.vna_name);
8920
8921                                   if (ivna.vna_name >= string_sec->sh_size)
8922                                     name = _("*invalid*");
8923                                   else
8924                                     name = strtab + ivna.vna_name;
8925                                   nn += printf ("(%s%-*s",
8926                                                 name,
8927                                                 12 - (int) strlen (name),
8928                                                 ")");
8929                                   check_def = 0;
8930                                   break;
8931                                 }
8932
8933                               offset += ivn.vn_next;
8934                             }
8935                           while (ivn.vn_next);
8936                         }
8937
8938                       if (check_def && data[cnt + j] != 0x8001
8939                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8940                         {
8941                           Elf_Internal_Verdef ivd;
8942                           Elf_External_Verdef evd;
8943                           unsigned long offset;
8944
8945                           offset = offset_from_vma
8946                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8947                              sizeof evd);
8948
8949                           do
8950                             {
8951                               if (get_data (&evd, file, offset, sizeof (evd), 1,
8952                                             _("version def")) == NULL)
8953                                 {
8954                                   ivd.vd_next = 0;
8955                                   ivd.vd_ndx  = 0;
8956                                 }
8957                               else
8958                                 {
8959                                   ivd.vd_next = BYTE_GET (evd.vd_next);
8960                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
8961                                 }
8962
8963                               offset += ivd.vd_next;
8964                             }
8965                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
8966                                  && ivd.vd_next != 0);
8967
8968                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
8969                             {
8970                               Elf_External_Verdaux evda;
8971                               Elf_Internal_Verdaux ivda;
8972
8973                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
8974
8975                               if (get_data (&evda, file,
8976                                             offset - ivd.vd_next + ivd.vd_aux,
8977                                             sizeof (evda), 1,
8978                                             _("version def aux")) == NULL)
8979                                 break;
8980
8981                               ivda.vda_name = BYTE_GET (evda.vda_name);
8982
8983                               if (ivda.vda_name >= string_sec->sh_size)
8984                                 name = _("*invalid*");
8985                               else
8986                                 name = strtab + ivda.vda_name;
8987                               nn += printf ("(%s%-*s",
8988                                             name,
8989                                             12 - (int) strlen (name),
8990                                             ")");
8991                             }
8992                         }
8993
8994                       if (nn < 18)
8995                         printf ("%*c", 18 - nn, ' ');
8996                     }
8997
8998                 putchar ('\n');
8999               }
9000
9001             free (data);
9002             free (strtab);
9003             free (symbols);
9004           }
9005           break;
9006
9007         default:
9008           break;
9009         }
9010     }
9011
9012   if (! found)
9013     printf (_("\nNo version information found in this file.\n"));
9014
9015   return 1;
9016 }
9017
9018 static const char *
9019 get_symbol_binding (unsigned int binding)
9020 {
9021   static char buff[32];
9022
9023   switch (binding)
9024     {
9025     case STB_LOCAL:     return "LOCAL";
9026     case STB_GLOBAL:    return "GLOBAL";
9027     case STB_WEAK:      return "WEAK";
9028     default:
9029       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
9030         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9031                   binding);
9032       else if (binding >= STB_LOOS && binding <= STB_HIOS)
9033         {
9034           if (binding == STB_GNU_UNIQUE
9035               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9036                   /* GNU is still using the default value 0.  */
9037                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9038             return "UNIQUE";
9039           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9040         }
9041       else
9042         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
9043       return buff;
9044     }
9045 }
9046
9047 static const char *
9048 get_symbol_type (unsigned int type)
9049 {
9050   static char buff[32];
9051
9052   switch (type)
9053     {
9054     case STT_NOTYPE:    return "NOTYPE";
9055     case STT_OBJECT:    return "OBJECT";
9056     case STT_FUNC:      return "FUNC";
9057     case STT_SECTION:   return "SECTION";
9058     case STT_FILE:      return "FILE";
9059     case STT_COMMON:    return "COMMON";
9060     case STT_TLS:       return "TLS";
9061     case STT_RELC:      return "RELC";
9062     case STT_SRELC:     return "SRELC";
9063     default:
9064       if (type >= STT_LOPROC && type <= STT_HIPROC)
9065         {
9066           if (elf_header.e_machine == EM_ARM)
9067             {
9068               if (type == STT_ARM_TFUNC)
9069                 return "THUMB_FUNC";
9070               if (type == STT_ARM_16BIT)
9071                 return "THUMB_LABEL";
9072             }
9073
9074           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
9075             return "REGISTER";
9076
9077           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9078             return "PARISC_MILLI";
9079
9080           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
9081         }
9082       else if (type >= STT_LOOS && type <= STT_HIOS)
9083         {
9084           if (elf_header.e_machine == EM_PARISC)
9085             {
9086               if (type == STT_HP_OPAQUE)
9087                 return "HP_OPAQUE";
9088               if (type == STT_HP_STUB)
9089                 return "HP_STUB";
9090             }
9091
9092           if (type == STT_GNU_IFUNC
9093               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9094                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9095                   /* GNU is still using the default value 0.  */
9096                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9097             return "IFUNC";
9098
9099           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
9100         }
9101       else
9102         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
9103       return buff;
9104     }
9105 }
9106
9107 static const char *
9108 get_symbol_visibility (unsigned int visibility)
9109 {
9110   switch (visibility)
9111     {
9112     case STV_DEFAULT:   return "DEFAULT";
9113     case STV_INTERNAL:  return "INTERNAL";
9114     case STV_HIDDEN:    return "HIDDEN";
9115     case STV_PROTECTED: return "PROTECTED";
9116     default: abort ();
9117     }
9118 }
9119
9120 static const char *
9121 get_mips_symbol_other (unsigned int other)
9122 {
9123   switch (other)
9124     {
9125     case STO_OPTIONAL:
9126       return "OPTIONAL";
9127     case STO_MIPS_PLT:
9128       return "MIPS PLT";
9129     case STO_MIPS_PIC:
9130       return "MIPS PIC";
9131     case STO_MICROMIPS:
9132       return "MICROMIPS";
9133     case STO_MICROMIPS | STO_MIPS_PIC:
9134       return "MICROMIPS, MIPS PIC";
9135     case STO_MIPS16:
9136       return "MIPS16";
9137     default:
9138       return NULL;
9139     }
9140 }
9141
9142 static const char *
9143 get_ia64_symbol_other (unsigned int other)
9144 {
9145   if (is_ia64_vms ())
9146     {
9147       static char res[32];
9148
9149       res[0] = 0;
9150
9151       /* Function types is for images and .STB files only.  */
9152       switch (elf_header.e_type)
9153         {
9154         case ET_DYN:
9155         case ET_EXEC:
9156           switch (VMS_ST_FUNC_TYPE (other))
9157             {
9158             case VMS_SFT_CODE_ADDR:
9159               strcat (res, " CA");
9160               break;
9161             case VMS_SFT_SYMV_IDX:
9162               strcat (res, " VEC");
9163               break;
9164             case VMS_SFT_FD:
9165               strcat (res, " FD");
9166               break;
9167             case VMS_SFT_RESERVE:
9168               strcat (res, " RSV");
9169               break;
9170             default:
9171               abort ();
9172             }
9173           break;
9174         default:
9175           break;
9176         }
9177       switch (VMS_ST_LINKAGE (other))
9178         {
9179         case VMS_STL_IGNORE:
9180           strcat (res, " IGN");
9181           break;
9182         case VMS_STL_RESERVE:
9183           strcat (res, " RSV");
9184           break;
9185         case VMS_STL_STD:
9186           strcat (res, " STD");
9187           break;
9188         case VMS_STL_LNK:
9189           strcat (res, " LNK");
9190           break;
9191         default:
9192           abort ();
9193         }
9194
9195       if (res[0] != 0)
9196         return res + 1;
9197       else
9198         return res;
9199     }
9200   return NULL;
9201 }
9202
9203 static const char *
9204 get_symbol_other (unsigned int other)
9205 {
9206   const char * result = NULL;
9207   static char buff [32];
9208
9209   if (other == 0)
9210     return "";
9211
9212   switch (elf_header.e_machine)
9213     {
9214     case EM_MIPS:
9215       result = get_mips_symbol_other (other);
9216       break;
9217     case EM_IA_64:
9218       result = get_ia64_symbol_other (other);
9219       break;
9220     default:
9221       break;
9222     }
9223
9224   if (result)
9225     return result;
9226
9227   snprintf (buff, sizeof buff, _("<other>: %x"), other);
9228   return buff;
9229 }
9230
9231 static const char *
9232 get_symbol_index_type (unsigned int type)
9233 {
9234   static char buff[32];
9235
9236   switch (type)
9237     {
9238     case SHN_UNDEF:     return "UND";
9239     case SHN_ABS:       return "ABS";
9240     case SHN_COMMON:    return "COM";
9241     default:
9242       if (type == SHN_IA_64_ANSI_COMMON
9243           && elf_header.e_machine == EM_IA_64
9244           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9245         return "ANSI_COM";
9246       else if ((elf_header.e_machine == EM_X86_64
9247                 || elf_header.e_machine == EM_L1OM
9248                 || elf_header.e_machine == EM_K1OM)
9249                && type == SHN_X86_64_LCOMMON)
9250         return "LARGE_COM";
9251       else if ((type == SHN_MIPS_SCOMMON
9252                 && elf_header.e_machine == EM_MIPS)
9253                || (type == SHN_TIC6X_SCOMMON
9254                    && elf_header.e_machine == EM_TI_C6000))
9255         return "SCOM";
9256       else if (type == SHN_MIPS_SUNDEFINED
9257                && elf_header.e_machine == EM_MIPS)
9258         return "SUND";
9259       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
9260         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
9261       else if (type >= SHN_LOOS && type <= SHN_HIOS)
9262         sprintf (buff, "OS [0x%04x]", type & 0xffff);
9263       else if (type >= SHN_LORESERVE)
9264         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
9265       else if (type >= elf_header.e_shnum)
9266         sprintf (buff, "bad section index[%3d]", type);
9267       else
9268         sprintf (buff, "%3d", type);
9269       break;
9270     }
9271
9272   return buff;
9273 }
9274
9275 static bfd_vma *
9276 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
9277 {
9278   unsigned char * e_data;
9279   bfd_vma * i_data;
9280
9281   e_data = (unsigned char *) cmalloc (number, ent_size);
9282
9283   if (e_data == NULL)
9284     {
9285       error (_("Out of memory\n"));
9286       return NULL;
9287     }
9288
9289   if (fread (e_data, ent_size, number, file) != number)
9290     {
9291       error (_("Unable to read in dynamic data\n"));
9292       return NULL;
9293     }
9294
9295   i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
9296
9297   if (i_data == NULL)
9298     {
9299       error (_("Out of memory\n"));
9300       free (e_data);
9301       return NULL;
9302     }
9303
9304   while (number--)
9305     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
9306
9307   free (e_data);
9308
9309   return i_data;
9310 }
9311
9312 static void
9313 print_dynamic_symbol (bfd_vma si, unsigned long hn)
9314 {
9315   Elf_Internal_Sym * psym;
9316   int n;
9317
9318   psym = dynamic_symbols + si;
9319
9320   n = print_vma (si, DEC_5);
9321   if (n < 5)
9322     fputs (&"     "[n], stdout);
9323   printf (" %3lu: ", hn);
9324   print_vma (psym->st_value, LONG_HEX);
9325   putchar (' ');
9326   print_vma (psym->st_size, DEC_5);
9327
9328   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9329   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9330   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9331   /* Check to see if any other bits in the st_other field are set.
9332      Note - displaying this information disrupts the layout of the
9333      table being generated, but for the moment this case is very
9334      rare.  */
9335   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9336     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9337   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9338   if (VALID_DYNAMIC_NAME (psym->st_name))
9339     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9340   else
9341     printf (_(" <corrupt: %14ld>"), psym->st_name);
9342   putchar ('\n');
9343 }
9344
9345 /* Dump the symbol table.  */
9346 static int
9347 process_symbol_table (FILE * file)
9348 {
9349   Elf_Internal_Shdr * section;
9350   bfd_vma nbuckets = 0;
9351   bfd_vma nchains = 0;
9352   bfd_vma * buckets = NULL;
9353   bfd_vma * chains = NULL;
9354   bfd_vma ngnubuckets = 0;
9355   bfd_vma * gnubuckets = NULL;
9356   bfd_vma * gnuchains = NULL;
9357   bfd_vma gnusymidx = 0;
9358
9359   if (!do_syms && !do_dyn_syms && !do_histogram)
9360     return 1;
9361
9362   if (dynamic_info[DT_HASH]
9363       && (do_histogram
9364           || (do_using_dynamic
9365               && !do_dyn_syms
9366               && dynamic_strings != NULL)))
9367     {
9368       unsigned char nb[8];
9369       unsigned char nc[8];
9370       int hash_ent_size = 4;
9371
9372       if ((elf_header.e_machine == EM_ALPHA
9373            || elf_header.e_machine == EM_S390
9374            || elf_header.e_machine == EM_S390_OLD)
9375           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9376         hash_ent_size = 8;
9377
9378       if (fseek (file,
9379                  (archive_file_offset
9380                   + offset_from_vma (file, dynamic_info[DT_HASH],
9381                                      sizeof nb + sizeof nc)),
9382                  SEEK_SET))
9383         {
9384           error (_("Unable to seek to start of dynamic information\n"));
9385           goto no_hash;
9386         }
9387
9388       if (fread (nb, hash_ent_size, 1, file) != 1)
9389         {
9390           error (_("Failed to read in number of buckets\n"));
9391           goto no_hash;
9392         }
9393
9394       if (fread (nc, hash_ent_size, 1, file) != 1)
9395         {
9396           error (_("Failed to read in number of chains\n"));
9397           goto no_hash;
9398         }
9399
9400       nbuckets = byte_get (nb, hash_ent_size);
9401       nchains  = byte_get (nc, hash_ent_size);
9402
9403       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9404       chains  = get_dynamic_data (file, nchains, hash_ent_size);
9405
9406     no_hash:
9407       if (buckets == NULL || chains == NULL)
9408         {
9409           if (do_using_dynamic)
9410             return 0;
9411           free (buckets);
9412           free (chains);
9413           buckets = NULL;
9414           chains = NULL;
9415           nbuckets = 0;
9416           nchains = 0;
9417         }
9418     }
9419
9420   if (dynamic_info_DT_GNU_HASH
9421       && (do_histogram
9422           || (do_using_dynamic
9423               && !do_dyn_syms
9424               && dynamic_strings != NULL)))
9425     {
9426       unsigned char nb[16];
9427       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9428       bfd_vma buckets_vma;
9429
9430       if (fseek (file,
9431                  (archive_file_offset
9432                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9433                                      sizeof nb)),
9434                  SEEK_SET))
9435         {
9436           error (_("Unable to seek to start of dynamic information\n"));
9437           goto no_gnu_hash;
9438         }
9439
9440       if (fread (nb, 16, 1, file) != 1)
9441         {
9442           error (_("Failed to read in number of buckets\n"));
9443           goto no_gnu_hash;
9444         }
9445
9446       ngnubuckets = byte_get (nb, 4);
9447       gnusymidx = byte_get (nb + 4, 4);
9448       bitmaskwords = byte_get (nb + 8, 4);
9449       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
9450       if (is_32bit_elf)
9451         buckets_vma += bitmaskwords * 4;
9452       else
9453         buckets_vma += bitmaskwords * 8;
9454
9455       if (fseek (file,
9456                  (archive_file_offset
9457                   + offset_from_vma (file, buckets_vma, 4)),
9458                  SEEK_SET))
9459         {
9460           error (_("Unable to seek to start of dynamic information\n"));
9461           goto no_gnu_hash;
9462         }
9463
9464       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
9465
9466       if (gnubuckets == NULL)
9467         goto no_gnu_hash;
9468
9469       for (i = 0; i < ngnubuckets; i++)
9470         if (gnubuckets[i] != 0)
9471           {
9472             if (gnubuckets[i] < gnusymidx)
9473               return 0;
9474
9475             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9476               maxchain = gnubuckets[i];
9477           }
9478
9479       if (maxchain == 0xffffffff)
9480         goto no_gnu_hash;
9481
9482       maxchain -= gnusymidx;
9483
9484       if (fseek (file,
9485                  (archive_file_offset
9486                   + offset_from_vma (file, buckets_vma
9487                                            + 4 * (ngnubuckets + maxchain), 4)),
9488                  SEEK_SET))
9489         {
9490           error (_("Unable to seek to start of dynamic information\n"));
9491           goto no_gnu_hash;
9492         }
9493
9494       do
9495         {
9496           if (fread (nb, 4, 1, file) != 1)
9497             {
9498               error (_("Failed to determine last chain length\n"));
9499               goto no_gnu_hash;
9500             }
9501
9502           if (maxchain + 1 == 0)
9503             goto no_gnu_hash;
9504
9505           ++maxchain;
9506         }
9507       while ((byte_get (nb, 4) & 1) == 0);
9508
9509       if (fseek (file,
9510                  (archive_file_offset
9511                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9512                  SEEK_SET))
9513         {
9514           error (_("Unable to seek to start of dynamic information\n"));
9515           goto no_gnu_hash;
9516         }
9517
9518       gnuchains = get_dynamic_data (file, maxchain, 4);
9519
9520     no_gnu_hash:
9521       if (gnuchains == NULL)
9522         {
9523           free (gnubuckets);
9524           gnubuckets = NULL;
9525           ngnubuckets = 0;
9526           if (do_using_dynamic)
9527             return 0;
9528         }
9529     }
9530
9531   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9532       && do_syms
9533       && do_using_dynamic
9534       && dynamic_strings != NULL)
9535     {
9536       unsigned long hn;
9537
9538       if (dynamic_info[DT_HASH])
9539         {
9540           bfd_vma si;
9541
9542           printf (_("\nSymbol table for image:\n"));
9543           if (is_32bit_elf)
9544             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9545           else
9546             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9547
9548           for (hn = 0; hn < nbuckets; hn++)
9549             {
9550               if (! buckets[hn])
9551                 continue;
9552
9553               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9554                 print_dynamic_symbol (si, hn);
9555             }
9556         }
9557
9558       if (dynamic_info_DT_GNU_HASH)
9559         {
9560           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9561           if (is_32bit_elf)
9562             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9563           else
9564             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9565
9566           for (hn = 0; hn < ngnubuckets; ++hn)
9567             if (gnubuckets[hn] != 0)
9568               {
9569                 bfd_vma si = gnubuckets[hn];
9570                 bfd_vma off = si - gnusymidx;
9571
9572                 do
9573                   {
9574                     print_dynamic_symbol (si, hn);
9575                     si++;
9576                   }
9577                 while ((gnuchains[off++] & 1) == 0);
9578               }
9579         }
9580     }
9581   else if (do_dyn_syms || (do_syms && !do_using_dynamic))
9582     {
9583       unsigned int i;
9584
9585       for (i = 0, section = section_headers;
9586            i < elf_header.e_shnum;
9587            i++, section++)
9588         {
9589           unsigned int si;
9590           char * strtab = NULL;
9591           unsigned long int strtab_size = 0;
9592           Elf_Internal_Sym * symtab;
9593           Elf_Internal_Sym * psym;
9594           unsigned long num_syms;
9595
9596           if ((section->sh_type != SHT_SYMTAB
9597                && section->sh_type != SHT_DYNSYM)
9598               || (!do_syms
9599                   && section->sh_type == SHT_SYMTAB))
9600             continue;
9601
9602           if (section->sh_entsize == 0)
9603             {
9604               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9605                       SECTION_NAME (section));
9606               continue;
9607             }
9608
9609           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9610                   SECTION_NAME (section),
9611                   (unsigned long) (section->sh_size / section->sh_entsize));
9612
9613           if (is_32bit_elf)
9614             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
9615           else
9616             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
9617
9618           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
9619           if (symtab == NULL)
9620             continue;
9621
9622           if (section->sh_link == elf_header.e_shstrndx)
9623             {
9624               strtab = string_table;
9625               strtab_size = string_table_length;
9626             }
9627           else if (section->sh_link < elf_header.e_shnum)
9628             {
9629               Elf_Internal_Shdr * string_sec;
9630
9631               string_sec = section_headers + section->sh_link;
9632
9633               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9634                                           1, string_sec->sh_size,
9635                                           _("string table"));
9636               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
9637             }
9638
9639           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
9640             {
9641               printf ("%6d: ", si);
9642               print_vma (psym->st_value, LONG_HEX);
9643               putchar (' ');
9644               print_vma (psym->st_size, DEC_5);
9645               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9646               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9647               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9648               /* Check to see if any other bits in the st_other field are set.
9649                  Note - displaying this information disrupts the layout of the
9650                  table being generated, but for the moment this case is very rare.  */
9651               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9652                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9653               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
9654               print_symbol (25, psym->st_name < strtab_size
9655                             ? strtab + psym->st_name : _("<corrupt>"));
9656
9657               if (section->sh_type == SHT_DYNSYM
9658                   && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9659                 {
9660                   unsigned char data[2];
9661                   unsigned short vers_data;
9662                   unsigned long offset;
9663                   int is_nobits;
9664                   int check_def;
9665
9666                   offset = offset_from_vma
9667                     (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9668                      sizeof data + si * sizeof (vers_data));
9669
9670                   if (get_data (&data, file, offset + si * sizeof (vers_data),
9671                                 sizeof (data), 1, _("version data")) == NULL)
9672                     break;
9673
9674                   vers_data = byte_get (data, 2);
9675
9676                   is_nobits = (psym->st_shndx < elf_header.e_shnum
9677                                && section_headers[psym->st_shndx].sh_type
9678                                   == SHT_NOBITS);
9679
9680                   check_def = (psym->st_shndx != SHN_UNDEF);
9681
9682                   if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
9683                     {
9684                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
9685                           && (is_nobits || ! check_def))
9686                         {
9687                           Elf_External_Verneed evn;
9688                           Elf_Internal_Verneed ivn;
9689                           Elf_Internal_Vernaux ivna;
9690
9691                           /* We must test both.  */
9692                           offset = offset_from_vma
9693                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9694                              sizeof evn);
9695
9696                           do
9697                             {
9698                               unsigned long vna_off;
9699
9700                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9701                                             _("version need")) == NULL)
9702                                 {
9703                                   ivna.vna_next = 0;
9704                                   ivna.vna_other = 0;
9705                                   ivna.vna_name = 0;
9706                                   break;
9707                                 }
9708
9709                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9710                               ivn.vn_next = BYTE_GET (evn.vn_next);
9711
9712                               vna_off = offset + ivn.vn_aux;
9713
9714                               do
9715                                 {
9716                                   Elf_External_Vernaux evna;
9717
9718                                   if (get_data (&evna, file, vna_off,
9719                                                 sizeof (evna), 1,
9720                                                 _("version need aux (3)")) == NULL)
9721                                     {
9722                                       ivna.vna_next = 0;
9723                                       ivna.vna_other = 0;
9724                                       ivna.vna_name = 0;
9725                                     }
9726                                   else
9727                                     {
9728                                       ivna.vna_other = BYTE_GET (evna.vna_other);
9729                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
9730                                       ivna.vna_name  = BYTE_GET (evna.vna_name);
9731                                     }
9732
9733                                   vna_off += ivna.vna_next;
9734                                 }
9735                               while (ivna.vna_other != vers_data
9736                                      && ivna.vna_next != 0);
9737
9738                               if (ivna.vna_other == vers_data)
9739                                 break;
9740
9741                               offset += ivn.vn_next;
9742                             }
9743                           while (ivn.vn_next != 0);
9744
9745                           if (ivna.vna_other == vers_data)
9746                             {
9747                               printf ("@%s (%d)",
9748                                       ivna.vna_name < strtab_size
9749                                       ? strtab + ivna.vna_name : _("<corrupt>"),
9750                                       ivna.vna_other);
9751                               check_def = 0;
9752                             }
9753                           else if (! is_nobits)
9754                             error (_("bad dynamic symbol\n"));
9755                           else
9756                             check_def = 1;
9757                         }
9758
9759                       if (check_def)
9760                         {
9761                           if (vers_data != 0x8001
9762                               && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9763                             {
9764                               Elf_Internal_Verdef ivd;
9765                               Elf_Internal_Verdaux ivda;
9766                               Elf_External_Verdaux evda;
9767                               unsigned long off;
9768
9769                               off = offset_from_vma
9770                                 (file,
9771                                  version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9772                                  sizeof (Elf_External_Verdef));
9773
9774                               do
9775                                 {
9776                                   Elf_External_Verdef evd;
9777
9778                                   if (get_data (&evd, file, off, sizeof (evd),
9779                                                 1, _("version def")) == NULL)
9780                                     {
9781                                       ivd.vd_ndx = 0;
9782                                       ivd.vd_aux = 0;
9783                                       ivd.vd_next = 0;
9784                                     }
9785                                   else
9786                                     {
9787                                       ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9788                                       ivd.vd_aux = BYTE_GET (evd.vd_aux);
9789                                       ivd.vd_next = BYTE_GET (evd.vd_next);
9790                                     }
9791
9792                                   off += ivd.vd_next;
9793                                 }
9794                               while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
9795                                      && ivd.vd_next != 0);
9796
9797                               off -= ivd.vd_next;
9798                               off += ivd.vd_aux;
9799
9800                               if (get_data (&evda, file, off, sizeof (evda),
9801                                             1, _("version def aux")) == NULL)
9802                                 break;
9803
9804                               ivda.vda_name = BYTE_GET (evda.vda_name);
9805
9806                               if (psym->st_name != ivda.vda_name)
9807                                 printf ((vers_data & VERSYM_HIDDEN)
9808                                         ? "@%s" : "@@%s",
9809                                         ivda.vda_name < strtab_size
9810                                         ? strtab + ivda.vda_name : _("<corrupt>"));
9811                             }
9812                         }
9813                     }
9814                 }
9815
9816               putchar ('\n');
9817             }
9818
9819           free (symtab);
9820           if (strtab != string_table)
9821             free (strtab);
9822         }
9823     }
9824   else if (do_syms)
9825     printf
9826       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9827
9828   if (do_histogram && buckets != NULL)
9829     {
9830       unsigned long * lengths;
9831       unsigned long * counts;
9832       unsigned long hn;
9833       bfd_vma si;
9834       unsigned long maxlength = 0;
9835       unsigned long nzero_counts = 0;
9836       unsigned long nsyms = 0;
9837
9838       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9839               (unsigned long) nbuckets);
9840       printf (_(" Length  Number     %% of total  Coverage\n"));
9841
9842       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
9843       if (lengths == NULL)
9844         {
9845           error (_("Out of memory\n"));
9846           return 0;
9847         }
9848       for (hn = 0; hn < nbuckets; ++hn)
9849         {
9850           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
9851             {
9852               ++nsyms;
9853               if (maxlength < ++lengths[hn])
9854                 ++maxlength;
9855             }
9856         }
9857
9858       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9859       if (counts == NULL)
9860         {
9861           free (lengths);
9862           error (_("Out of memory\n"));
9863           return 0;
9864         }
9865
9866       for (hn = 0; hn < nbuckets; ++hn)
9867         ++counts[lengths[hn]];
9868
9869       if (nbuckets > 0)
9870         {
9871           unsigned long i;
9872           printf ("      0  %-10lu (%5.1f%%)\n",
9873                   counts[0], (counts[0] * 100.0) / nbuckets);
9874           for (i = 1; i <= maxlength; ++i)
9875             {
9876               nzero_counts += counts[i] * i;
9877               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
9878                       i, counts[i], (counts[i] * 100.0) / nbuckets,
9879                       (nzero_counts * 100.0) / nsyms);
9880             }
9881         }
9882
9883       free (counts);
9884       free (lengths);
9885     }
9886
9887   if (buckets != NULL)
9888     {
9889       free (buckets);
9890       free (chains);
9891     }
9892
9893   if (do_histogram && gnubuckets != NULL)
9894     {
9895       unsigned long * lengths;
9896       unsigned long * counts;
9897       unsigned long hn;
9898       unsigned long maxlength = 0;
9899       unsigned long nzero_counts = 0;
9900       unsigned long nsyms = 0;
9901
9902       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
9903       if (lengths == NULL)
9904         {
9905           error (_("Out of memory\n"));
9906           return 0;
9907         }
9908
9909       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9910               (unsigned long) ngnubuckets);
9911       printf (_(" Length  Number     %% of total  Coverage\n"));
9912
9913       for (hn = 0; hn < ngnubuckets; ++hn)
9914         if (gnubuckets[hn] != 0)
9915           {
9916             bfd_vma off, length = 1;
9917
9918             for (off = gnubuckets[hn] - gnusymidx;
9919                  (gnuchains[off] & 1) == 0; ++off)
9920               ++length;
9921             lengths[hn] = length;
9922             if (length > maxlength)
9923               maxlength = length;
9924             nsyms += length;
9925           }
9926
9927       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9928       if (counts == NULL)
9929         {
9930           free (lengths);
9931           error (_("Out of memory\n"));
9932           return 0;
9933         }
9934
9935       for (hn = 0; hn < ngnubuckets; ++hn)
9936         ++counts[lengths[hn]];
9937
9938       if (ngnubuckets > 0)
9939         {
9940           unsigned long j;
9941           printf ("      0  %-10lu (%5.1f%%)\n",
9942                   counts[0], (counts[0] * 100.0) / ngnubuckets);
9943           for (j = 1; j <= maxlength; ++j)
9944             {
9945               nzero_counts += counts[j] * j;
9946               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
9947                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9948                       (nzero_counts * 100.0) / nsyms);
9949             }
9950         }
9951
9952       free (counts);
9953       free (lengths);
9954       free (gnubuckets);
9955       free (gnuchains);
9956     }
9957
9958   return 1;
9959 }
9960
9961 static int
9962 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
9963 {
9964   unsigned int i;
9965
9966   if (dynamic_syminfo == NULL
9967       || !do_dynamic)
9968     /* No syminfo, this is ok.  */
9969     return 1;
9970
9971   /* There better should be a dynamic symbol section.  */
9972   if (dynamic_symbols == NULL || dynamic_strings == NULL)
9973     return 0;
9974
9975   if (dynamic_addr)
9976     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9977             dynamic_syminfo_offset, dynamic_syminfo_nent);
9978
9979   printf (_(" Num: Name                           BoundTo     Flags\n"));
9980   for (i = 0; i < dynamic_syminfo_nent; ++i)
9981     {
9982       unsigned short int flags = dynamic_syminfo[i].si_flags;
9983
9984       printf ("%4d: ", i);
9985       if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9986         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9987       else
9988         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
9989       putchar (' ');
9990
9991       switch (dynamic_syminfo[i].si_boundto)
9992         {
9993         case SYMINFO_BT_SELF:
9994           fputs ("SELF       ", stdout);
9995           break;
9996         case SYMINFO_BT_PARENT:
9997           fputs ("PARENT     ", stdout);
9998           break;
9999         default:
10000           if (dynamic_syminfo[i].si_boundto > 0
10001               && dynamic_syminfo[i].si_boundto < dynamic_nent
10002               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
10003             {
10004               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
10005               putchar (' ' );
10006             }
10007           else
10008             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10009           break;
10010         }
10011
10012       if (flags & SYMINFO_FLG_DIRECT)
10013         printf (" DIRECT");
10014       if (flags & SYMINFO_FLG_PASSTHRU)
10015         printf (" PASSTHRU");
10016       if (flags & SYMINFO_FLG_COPY)
10017         printf (" COPY");
10018       if (flags & SYMINFO_FLG_LAZYLOAD)
10019         printf (" LAZYLOAD");
10020
10021       puts ("");
10022     }
10023
10024   return 1;
10025 }
10026
10027 /* Check to see if the given reloc needs to be handled in a target specific
10028    manner.  If so then process the reloc and return TRUE otherwise return
10029    FALSE.  */
10030
10031 static bfd_boolean
10032 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10033                                 unsigned char *     start,
10034                                 Elf_Internal_Sym *  symtab)
10035 {
10036   unsigned int reloc_type = get_reloc_type (reloc->r_info);
10037
10038   switch (elf_header.e_machine)
10039     {
10040     case EM_MSP430:
10041     case EM_MSP430_OLD:
10042       {
10043         static Elf_Internal_Sym * saved_sym = NULL;
10044
10045         switch (reloc_type)
10046           {
10047           case 10: /* R_MSP430_SYM_DIFF */
10048             if (uses_msp430x_relocs ())
10049               break;
10050           case 21: /* R_MSP430X_SYM_DIFF */
10051             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10052             return TRUE;
10053
10054           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10055           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10056             goto handle_sym_diff;
10057
10058           case 5: /* R_MSP430_16_BYTE */
10059           case 9: /* R_MSP430_8 */
10060             if (uses_msp430x_relocs ())
10061               break;
10062             goto handle_sym_diff;
10063
10064           case 2: /* R_MSP430_ABS16 */
10065           case 15: /* R_MSP430X_ABS16 */
10066             if (! uses_msp430x_relocs ())
10067               break;
10068             goto handle_sym_diff;
10069
10070           handle_sym_diff:
10071             if (saved_sym != NULL)
10072               {
10073                 bfd_vma value;
10074
10075                 value = reloc->r_addend
10076                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10077                      - saved_sym->st_value);
10078
10079                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10080
10081                 saved_sym = NULL;
10082                 return TRUE;
10083               }
10084             break;
10085
10086           default:
10087             if (saved_sym != NULL)
10088               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc"));
10089             break;
10090           }
10091         break;
10092       }
10093
10094     case EM_MN10300:
10095     case EM_CYGNUS_MN10300:
10096       {
10097         static Elf_Internal_Sym * saved_sym = NULL;
10098
10099         switch (reloc_type)
10100           {
10101           case 34: /* R_MN10300_ALIGN */
10102             return TRUE;
10103           case 33: /* R_MN10300_SYM_DIFF */
10104             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10105             return TRUE;
10106           case 1: /* R_MN10300_32 */
10107           case 2: /* R_MN10300_16 */
10108             if (saved_sym != NULL)
10109               {
10110                 bfd_vma value;
10111
10112                 value = reloc->r_addend
10113                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10114                      - saved_sym->st_value);
10115
10116                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10117
10118                 saved_sym = NULL;
10119                 return TRUE;
10120               }
10121             break;
10122           default:
10123             if (saved_sym != NULL)
10124               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10125             break;
10126           }
10127         break;
10128       }
10129     }
10130
10131   return FALSE;
10132 }
10133
10134 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10135    DWARF debug sections.  This is a target specific test.  Note - we do not
10136    go through the whole including-target-headers-multiple-times route, (as
10137    we have already done with <elf/h8.h>) because this would become very
10138    messy and even then this function would have to contain target specific
10139    information (the names of the relocs instead of their numeric values).
10140    FIXME: This is not the correct way to solve this problem.  The proper way
10141    is to have target specific reloc sizing and typing functions created by
10142    the reloc-macros.h header, in the same way that it already creates the
10143    reloc naming functions.  */
10144
10145 static bfd_boolean
10146 is_32bit_abs_reloc (unsigned int reloc_type)
10147 {
10148   switch (elf_header.e_machine)
10149     {
10150     case EM_386:
10151     case EM_486:
10152       return reloc_type == 1; /* R_386_32.  */
10153     case EM_68K:
10154       return reloc_type == 1; /* R_68K_32.  */
10155     case EM_860:
10156       return reloc_type == 1; /* R_860_32.  */
10157     case EM_960:
10158       return reloc_type == 2; /* R_960_32.  */
10159     case EM_AARCH64:
10160       return reloc_type == 258; /* R_AARCH64_ABS32 */
10161     case EM_ALPHA:
10162       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
10163     case EM_ARC:
10164       return reloc_type == 1; /* R_ARC_32.  */
10165     case EM_ARM:
10166       return reloc_type == 2; /* R_ARM_ABS32 */
10167     case EM_AVR_OLD:
10168     case EM_AVR:
10169       return reloc_type == 1;
10170     case EM_ADAPTEVA_EPIPHANY:
10171       return reloc_type == 3;
10172     case EM_BLACKFIN:
10173       return reloc_type == 0x12; /* R_byte4_data.  */
10174     case EM_CRIS:
10175       return reloc_type == 3; /* R_CRIS_32.  */
10176     case EM_CR16:
10177       return reloc_type == 3; /* R_CR16_NUM32.  */
10178     case EM_CRX:
10179       return reloc_type == 15; /* R_CRX_NUM32.  */
10180     case EM_CYGNUS_FRV:
10181       return reloc_type == 1;
10182     case EM_CYGNUS_D10V:
10183     case EM_D10V:
10184       return reloc_type == 6; /* R_D10V_32.  */
10185     case EM_CYGNUS_D30V:
10186     case EM_D30V:
10187       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
10188     case EM_DLX:
10189       return reloc_type == 3; /* R_DLX_RELOC_32.  */
10190     case EM_CYGNUS_FR30:
10191     case EM_FR30:
10192       return reloc_type == 3; /* R_FR30_32.  */
10193     case EM_H8S:
10194     case EM_H8_300:
10195     case EM_H8_300H:
10196       return reloc_type == 1; /* R_H8_DIR32.  */
10197     case EM_IA_64:
10198       return reloc_type == 0x65; /* R_IA64_SECREL32LSB.  */
10199     case EM_IP2K_OLD:
10200     case EM_IP2K:
10201       return reloc_type == 2; /* R_IP2K_32.  */
10202     case EM_IQ2000:
10203       return reloc_type == 2; /* R_IQ2000_32.  */
10204     case EM_LATTICEMICO32:
10205       return reloc_type == 3; /* R_LM32_32.  */
10206     case EM_M32C_OLD:
10207     case EM_M32C:
10208       return reloc_type == 3; /* R_M32C_32.  */
10209     case EM_M32R:
10210       return reloc_type == 34; /* R_M32R_32_RELA.  */
10211     case EM_MCORE:
10212       return reloc_type == 1; /* R_MCORE_ADDR32.  */
10213     case EM_CYGNUS_MEP:
10214       return reloc_type == 4; /* R_MEP_32.  */
10215     case EM_METAG:
10216       return reloc_type == 2; /* R_METAG_ADDR32.  */
10217     case EM_MICROBLAZE:
10218       return reloc_type == 1; /* R_MICROBLAZE_32.  */
10219     case EM_MIPS:
10220       return reloc_type == 2; /* R_MIPS_32.  */
10221     case EM_MMIX:
10222       return reloc_type == 4; /* R_MMIX_32.  */
10223     case EM_CYGNUS_MN10200:
10224     case EM_MN10200:
10225       return reloc_type == 1; /* R_MN10200_32.  */
10226     case EM_CYGNUS_MN10300:
10227     case EM_MN10300:
10228       return reloc_type == 1; /* R_MN10300_32.  */
10229     case EM_MOXIE:
10230       return reloc_type == 1; /* R_MOXIE_32.  */
10231     case EM_MSP430_OLD:
10232     case EM_MSP430:
10233       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
10234     case EM_MT:
10235       return reloc_type == 2; /* R_MT_32.  */
10236     case EM_ALTERA_NIOS2:
10237       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
10238     case EM_NIOS32:
10239       return reloc_type == 1; /* R_NIOS_32.  */
10240     case EM_OPENRISC:
10241     case EM_OR32:
10242       return reloc_type == 1; /* R_OR32_32.  */
10243     case EM_PARISC:
10244       return (reloc_type == 1 /* R_PARISC_DIR32.  */
10245               || reloc_type == 41); /* R_PARISC_SECREL32.  */
10246     case EM_PJ:
10247     case EM_PJ_OLD:
10248       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
10249     case EM_PPC64:
10250       return reloc_type == 1; /* R_PPC64_ADDR32.  */
10251     case EM_PPC:
10252       return reloc_type == 1; /* R_PPC_ADDR32.  */
10253     case EM_RL78:
10254       return reloc_type == 1; /* R_RL78_DIR32.  */
10255     case EM_RX:
10256       return reloc_type == 1; /* R_RX_DIR32.  */
10257     case EM_S370:
10258       return reloc_type == 1; /* R_I370_ADDR31.  */
10259     case EM_S390_OLD:
10260     case EM_S390:
10261       return reloc_type == 4; /* R_S390_32.  */
10262     case EM_SCORE:
10263       return reloc_type == 8; /* R_SCORE_ABS32.  */
10264     case EM_SH:
10265       return reloc_type == 1; /* R_SH_DIR32.  */
10266     case EM_SPARC32PLUS:
10267     case EM_SPARCV9:
10268     case EM_SPARC:
10269       return reloc_type == 3 /* R_SPARC_32.  */
10270         || reloc_type == 23; /* R_SPARC_UA32.  */
10271     case EM_SPU:
10272       return reloc_type == 6; /* R_SPU_ADDR32 */
10273     case EM_TI_C6000:
10274       return reloc_type == 1; /* R_C6000_ABS32.  */
10275     case EM_TILEGX:
10276       return reloc_type == 2; /* R_TILEGX_32.  */
10277     case EM_TILEPRO:
10278       return reloc_type == 1; /* R_TILEPRO_32.  */
10279     case EM_CYGNUS_V850:
10280     case EM_V850:
10281       return reloc_type == 6; /* R_V850_ABS32.  */
10282     case EM_V800:
10283       return reloc_type == 0x33; /* R_V810_WORD.  */
10284     case EM_VAX:
10285       return reloc_type == 1; /* R_VAX_32.  */
10286     case EM_X86_64:
10287     case EM_L1OM:
10288     case EM_K1OM:
10289       return reloc_type == 10; /* R_X86_64_32.  */
10290     case EM_XC16X:
10291     case EM_C166:
10292       return reloc_type == 3; /* R_XC16C_ABS_32.  */
10293     case EM_XGATE:
10294       return reloc_type == 4; /* R_XGATE_32.  */
10295     case EM_XSTORMY16:
10296       return reloc_type == 1; /* R_XSTROMY16_32.  */
10297     case EM_XTENSA_OLD:
10298     case EM_XTENSA:
10299       return reloc_type == 1; /* R_XTENSA_32.  */
10300     default:
10301       error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10302              elf_header.e_machine);
10303       abort ();
10304     }
10305 }
10306
10307 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10308    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
10309
10310 static bfd_boolean
10311 is_32bit_pcrel_reloc (unsigned int reloc_type)
10312 {
10313   switch (elf_header.e_machine)
10314     {
10315     case EM_386:
10316     case EM_486:
10317       return reloc_type == 2;  /* R_386_PC32.  */
10318     case EM_68K:
10319       return reloc_type == 4;  /* R_68K_PC32.  */
10320     case EM_AARCH64:
10321       return reloc_type == 261; /* R_AARCH64_PREL32 */
10322     case EM_ADAPTEVA_EPIPHANY:
10323       return reloc_type == 6;
10324     case EM_ALPHA:
10325       return reloc_type == 10; /* R_ALPHA_SREL32.  */
10326     case EM_ARM:
10327       return reloc_type == 3;  /* R_ARM_REL32 */
10328     case EM_MICROBLAZE:
10329       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
10330     case EM_PARISC:
10331       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
10332     case EM_PPC:
10333       return reloc_type == 26; /* R_PPC_REL32.  */
10334     case EM_PPC64:
10335       return reloc_type == 26; /* R_PPC64_REL32.  */
10336     case EM_S390_OLD:
10337     case EM_S390:
10338       return reloc_type == 5;  /* R_390_PC32.  */
10339     case EM_SH:
10340       return reloc_type == 2;  /* R_SH_REL32.  */
10341     case EM_SPARC32PLUS:
10342     case EM_SPARCV9:
10343     case EM_SPARC:
10344       return reloc_type == 6;  /* R_SPARC_DISP32.  */
10345     case EM_SPU:
10346       return reloc_type == 13; /* R_SPU_REL32.  */
10347     case EM_TILEGX:
10348       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
10349     case EM_TILEPRO:
10350       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
10351     case EM_X86_64:
10352     case EM_L1OM:
10353     case EM_K1OM:
10354       return reloc_type == 2;  /* R_X86_64_PC32.  */
10355     case EM_XTENSA_OLD:
10356     case EM_XTENSA:
10357       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
10358     default:
10359       /* Do not abort or issue an error message here.  Not all targets use
10360          pc-relative 32-bit relocs in their DWARF debug information and we
10361          have already tested for target coverage in is_32bit_abs_reloc.  A
10362          more helpful warning message will be generated by apply_relocations
10363          anyway, so just return.  */
10364       return FALSE;
10365     }
10366 }
10367
10368 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10369    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
10370
10371 static bfd_boolean
10372 is_64bit_abs_reloc (unsigned int reloc_type)
10373 {
10374   switch (elf_header.e_machine)
10375     {
10376     case EM_AARCH64:
10377       return reloc_type == 257; /* R_AARCH64_ABS64.  */
10378     case EM_ALPHA:
10379       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
10380     case EM_IA_64:
10381       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
10382     case EM_PARISC:
10383       return reloc_type == 80; /* R_PARISC_DIR64.  */
10384     case EM_PPC64:
10385       return reloc_type == 38; /* R_PPC64_ADDR64.  */
10386     case EM_SPARC32PLUS:
10387     case EM_SPARCV9:
10388     case EM_SPARC:
10389       return reloc_type == 54; /* R_SPARC_UA64.  */
10390     case EM_X86_64:
10391     case EM_L1OM:
10392     case EM_K1OM:
10393       return reloc_type == 1; /* R_X86_64_64.  */
10394     case EM_S390_OLD:
10395     case EM_S390:
10396       return reloc_type == 22;  /* R_S390_64.  */
10397     case EM_TILEGX:
10398       return reloc_type == 1; /* R_TILEGX_64.  */
10399     case EM_MIPS:
10400       return reloc_type == 18;  /* R_MIPS_64.  */
10401     default:
10402       return FALSE;
10403     }
10404 }
10405
10406 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10407    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
10408
10409 static bfd_boolean
10410 is_64bit_pcrel_reloc (unsigned int reloc_type)
10411 {
10412   switch (elf_header.e_machine)
10413     {
10414     case EM_AARCH64:
10415       return reloc_type == 260; /* R_AARCH64_PREL64.  */
10416     case EM_ALPHA:
10417       return reloc_type == 11; /* R_ALPHA_SREL64.  */
10418     case EM_IA_64:
10419       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
10420     case EM_PARISC:
10421       return reloc_type == 72; /* R_PARISC_PCREL64.  */
10422     case EM_PPC64:
10423       return reloc_type == 44; /* R_PPC64_REL64.  */
10424     case EM_SPARC32PLUS:
10425     case EM_SPARCV9:
10426     case EM_SPARC:
10427       return reloc_type == 46; /* R_SPARC_DISP64.  */
10428     case EM_X86_64:
10429     case EM_L1OM:
10430     case EM_K1OM:
10431       return reloc_type == 24; /* R_X86_64_PC64.  */
10432     case EM_S390_OLD:
10433     case EM_S390:
10434       return reloc_type == 23;  /* R_S390_PC64.  */
10435     case EM_TILEGX:
10436       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
10437     default:
10438       return FALSE;
10439     }
10440 }
10441
10442 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10443    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
10444
10445 static bfd_boolean
10446 is_24bit_abs_reloc (unsigned int reloc_type)
10447 {
10448   switch (elf_header.e_machine)
10449     {
10450     case EM_CYGNUS_MN10200:
10451     case EM_MN10200:
10452       return reloc_type == 4; /* R_MN10200_24.  */
10453     default:
10454       return FALSE;
10455     }
10456 }
10457
10458 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10459    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
10460
10461 static bfd_boolean
10462 is_16bit_abs_reloc (unsigned int reloc_type)
10463 {
10464   switch (elf_header.e_machine)
10465     {
10466     case EM_AVR_OLD:
10467     case EM_AVR:
10468       return reloc_type == 4; /* R_AVR_16.  */
10469     case EM_ADAPTEVA_EPIPHANY:
10470       return reloc_type == 5;
10471     case EM_CYGNUS_D10V:
10472     case EM_D10V:
10473       return reloc_type == 3; /* R_D10V_16.  */
10474     case EM_H8S:
10475     case EM_H8_300:
10476     case EM_H8_300H:
10477       return reloc_type == R_H8_DIR16;
10478     case EM_IP2K_OLD:
10479     case EM_IP2K:
10480       return reloc_type == 1; /* R_IP2K_16.  */
10481     case EM_M32C_OLD:
10482     case EM_M32C:
10483       return reloc_type == 1; /* R_M32C_16 */
10484     case EM_MSP430:
10485       if (uses_msp430x_relocs ())
10486         return reloc_type == 2; /* R_MSP430_ABS16.  */
10487     case EM_MSP430_OLD:
10488       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
10489     case EM_ALTERA_NIOS2:
10490       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
10491     case EM_NIOS32:
10492       return reloc_type == 9; /* R_NIOS_16.  */
10493     case EM_TI_C6000:
10494       return reloc_type == 2; /* R_C6000_ABS16.  */
10495     case EM_XC16X:
10496     case EM_C166:
10497       return reloc_type == 2; /* R_XC16C_ABS_16.  */
10498     case EM_CYGNUS_MN10200:
10499     case EM_MN10200:
10500       return reloc_type == 2; /* R_MN10200_16.  */
10501     case EM_CYGNUS_MN10300:
10502     case EM_MN10300:
10503       return reloc_type == 2; /* R_MN10300_16.  */
10504     case EM_XGATE:
10505       return reloc_type == 3; /* R_XGATE_16.  */
10506     default:
10507       return FALSE;
10508     }
10509 }
10510
10511 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10512    relocation entries (possibly formerly used for SHT_GROUP sections).  */
10513
10514 static bfd_boolean
10515 is_none_reloc (unsigned int reloc_type)
10516 {
10517   switch (elf_header.e_machine)
10518     {
10519     case EM_68K:     /* R_68K_NONE.  */
10520     case EM_386:     /* R_386_NONE.  */
10521     case EM_SPARC32PLUS:
10522     case EM_SPARCV9:
10523     case EM_SPARC:   /* R_SPARC_NONE.  */
10524     case EM_MIPS:    /* R_MIPS_NONE.  */
10525     case EM_PARISC:  /* R_PARISC_NONE.  */
10526     case EM_ALPHA:   /* R_ALPHA_NONE.  */
10527     case EM_ADAPTEVA_EPIPHANY:
10528     case EM_PPC:     /* R_PPC_NONE.  */
10529     case EM_PPC64:   /* R_PPC64_NONE.  */
10530     case EM_ARM:     /* R_ARM_NONE.  */
10531     case EM_IA_64:   /* R_IA64_NONE.  */
10532     case EM_SH:      /* R_SH_NONE.  */
10533     case EM_S390_OLD:
10534     case EM_S390:    /* R_390_NONE.  */
10535     case EM_CRIS:    /* R_CRIS_NONE.  */
10536     case EM_X86_64:  /* R_X86_64_NONE.  */
10537     case EM_L1OM:    /* R_X86_64_NONE.  */
10538     case EM_K1OM:    /* R_X86_64_NONE.  */
10539     case EM_MN10300: /* R_MN10300_NONE.  */
10540     case EM_MOXIE:   /* R_MOXIE_NONE.  */
10541     case EM_M32R:    /* R_M32R_NONE.  */
10542     case EM_TI_C6000:/* R_C6000_NONE.  */
10543     case EM_TILEGX:  /* R_TILEGX_NONE.  */
10544     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
10545     case EM_XC16X:
10546     case EM_C166:    /* R_XC16X_NONE.  */
10547     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
10548     case EM_NIOS32:  /* R_NIOS_NONE.  */
10549       return reloc_type == 0;
10550     case EM_AARCH64:
10551       return reloc_type == 0 || reloc_type == 256;
10552     case EM_XTENSA_OLD:
10553     case EM_XTENSA:
10554       return (reloc_type == 0      /* R_XTENSA_NONE.  */
10555               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
10556               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
10557               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
10558     case EM_METAG:
10559       return reloc_type == 3; /* R_METAG_NONE.  */
10560     }
10561   return FALSE;
10562 }
10563
10564 /* Apply relocations to a section.
10565    Note: So far support has been added only for those relocations
10566    which can be found in debug sections.
10567    FIXME: Add support for more relocations ?  */
10568
10569 static void
10570 apply_relocations (void * file,
10571                    Elf_Internal_Shdr * section,
10572                    unsigned char * start)
10573 {
10574   Elf_Internal_Shdr * relsec;
10575   unsigned char * end = start + section->sh_size;
10576
10577   if (elf_header.e_type != ET_REL)
10578     return;
10579
10580   /* Find the reloc section associated with the section.  */
10581   for (relsec = section_headers;
10582        relsec < section_headers + elf_header.e_shnum;
10583        ++relsec)
10584     {
10585       bfd_boolean is_rela;
10586       unsigned long num_relocs;
10587       Elf_Internal_Rela * relocs;
10588       Elf_Internal_Rela * rp;
10589       Elf_Internal_Shdr * symsec;
10590       Elf_Internal_Sym * symtab;
10591       unsigned long num_syms;
10592       Elf_Internal_Sym * sym;
10593
10594       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10595           || relsec->sh_info >= elf_header.e_shnum
10596           || section_headers + relsec->sh_info != section
10597           || relsec->sh_size == 0
10598           || relsec->sh_link >= elf_header.e_shnum)
10599         continue;
10600
10601       is_rela = relsec->sh_type == SHT_RELA;
10602
10603       if (is_rela)
10604         {
10605           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10606                                   relsec->sh_size, & relocs, & num_relocs))
10607             return;
10608         }
10609       else
10610         {
10611           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10612                                  relsec->sh_size, & relocs, & num_relocs))
10613             return;
10614         }
10615
10616       /* SH uses RELA but uses in place value instead of the addend field.  */
10617       if (elf_header.e_machine == EM_SH)
10618         is_rela = FALSE;
10619
10620       symsec = section_headers + relsec->sh_link;
10621       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
10622
10623       for (rp = relocs; rp < relocs + num_relocs; ++rp)
10624         {
10625           bfd_vma         addend;
10626           unsigned int    reloc_type;
10627           unsigned int    reloc_size;
10628           unsigned char * rloc;
10629           unsigned long   sym_index;
10630
10631           reloc_type = get_reloc_type (rp->r_info);
10632
10633           if (target_specific_reloc_handling (rp, start, symtab))
10634             continue;
10635           else if (is_none_reloc (reloc_type))
10636             continue;
10637           else if (is_32bit_abs_reloc (reloc_type)
10638                    || is_32bit_pcrel_reloc (reloc_type))
10639             reloc_size = 4;
10640           else if (is_64bit_abs_reloc (reloc_type)
10641                    || is_64bit_pcrel_reloc (reloc_type))
10642             reloc_size = 8;
10643           else if (is_24bit_abs_reloc (reloc_type))
10644             reloc_size = 3;
10645           else if (is_16bit_abs_reloc (reloc_type))
10646             reloc_size = 2;
10647           else
10648             {
10649               warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10650                     reloc_type, SECTION_NAME (section));
10651               continue;
10652             }
10653
10654           rloc = start + rp->r_offset;
10655           if ((rloc + reloc_size) > end || (rloc < start))
10656             {
10657               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10658                     (unsigned long) rp->r_offset,
10659                     SECTION_NAME (section));
10660               continue;
10661             }
10662
10663           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10664           if (sym_index >= num_syms)
10665             {
10666               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10667                     sym_index, SECTION_NAME (section));
10668               continue;
10669             }
10670           sym = symtab + sym_index;
10671
10672           /* If the reloc has a symbol associated with it,
10673              make sure that it is of an appropriate type.
10674
10675              Relocations against symbols without type can happen.
10676              Gcc -feliminate-dwarf2-dups may generate symbols
10677              without type for debug info.
10678
10679              Icc generates relocations against function symbols
10680              instead of local labels.
10681
10682              Relocations against object symbols can happen, eg when
10683              referencing a global array.  For an example of this see
10684              the _clz.o binary in libgcc.a.  */
10685           if (sym != symtab
10686               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
10687             {
10688               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10689                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
10690                     (long int)(rp - relocs),
10691                     SECTION_NAME (relsec));
10692               continue;
10693             }
10694
10695           addend = 0;
10696           if (is_rela)
10697             addend += rp->r_addend;
10698           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10699              partial_inplace.  */
10700           if (!is_rela
10701               || (elf_header.e_machine == EM_XTENSA
10702                   && reloc_type == 1)
10703               || ((elf_header.e_machine == EM_PJ
10704                    || elf_header.e_machine == EM_PJ_OLD)
10705                   && reloc_type == 1)
10706               || ((elf_header.e_machine == EM_D30V
10707                    || elf_header.e_machine == EM_CYGNUS_D30V)
10708                   && reloc_type == 12))
10709             addend += byte_get (rloc, reloc_size);
10710
10711           if (is_32bit_pcrel_reloc (reloc_type)
10712               || is_64bit_pcrel_reloc (reloc_type))
10713             {
10714               /* On HPPA, all pc-relative relocations are biased by 8.  */
10715               if (elf_header.e_machine == EM_PARISC)
10716                 addend -= 8;
10717               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
10718                         reloc_size);
10719             }
10720           else
10721             byte_put (rloc, addend + sym->st_value, reloc_size);
10722         }
10723
10724       free (symtab);
10725       free (relocs);
10726       break;
10727     }
10728 }
10729
10730 #ifdef SUPPORT_DISASSEMBLY
10731 static int
10732 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10733 {
10734   printf (_("\nAssembly dump of section %s\n"),
10735           SECTION_NAME (section));
10736
10737   /* XXX -- to be done --- XXX */
10738
10739   return 1;
10740 }
10741 #endif
10742
10743 /* Reads in the contents of SECTION from FILE, returning a pointer
10744    to a malloc'ed buffer or NULL if something went wrong.  */
10745
10746 static char *
10747 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10748 {
10749   bfd_size_type num_bytes;
10750
10751   num_bytes = section->sh_size;
10752
10753   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10754     {
10755       printf (_("\nSection '%s' has no data to dump.\n"),
10756               SECTION_NAME (section));
10757       return NULL;
10758     }
10759
10760   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10761                              _("section contents"));
10762 }
10763
10764
10765 static void
10766 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10767 {
10768   Elf_Internal_Shdr * relsec;
10769   bfd_size_type num_bytes;
10770   char * data;
10771   char * end;
10772   char * start;
10773   char * name = SECTION_NAME (section);
10774   bfd_boolean some_strings_shown;
10775
10776   start = get_section_contents (section, file);
10777   if (start == NULL)
10778     return;
10779
10780   printf (_("\nString dump of section '%s':\n"), name);
10781
10782   /* If the section being dumped has relocations against it the user might
10783      be expecting these relocations to have been applied.  Check for this
10784      case and issue a warning message in order to avoid confusion.
10785      FIXME: Maybe we ought to have an option that dumps a section with
10786      relocs applied ?  */
10787   for (relsec = section_headers;
10788        relsec < section_headers + elf_header.e_shnum;
10789        ++relsec)
10790     {
10791       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10792           || relsec->sh_info >= elf_header.e_shnum
10793           || section_headers + relsec->sh_info != section
10794           || relsec->sh_size == 0
10795           || relsec->sh_link >= elf_header.e_shnum)
10796         continue;
10797
10798       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10799       break;
10800     }
10801
10802   num_bytes = section->sh_size;
10803   data = start;
10804   end  = start + num_bytes;
10805   some_strings_shown = FALSE;
10806
10807   while (data < end)
10808     {
10809       while (!ISPRINT (* data))
10810         if (++ data >= end)
10811           break;
10812
10813       if (data < end)
10814         {
10815 #ifndef __MSVCRT__
10816           /* PR 11128: Use two separate invocations in order to work
10817              around bugs in the Solaris 8 implementation of printf.  */
10818           printf ("  [%6tx]  ", data - start);
10819           printf ("%s\n", data);
10820 #else
10821           printf ("  [%6Ix]  %s\n", (size_t) (data - start), data);
10822 #endif
10823           data += strlen (data);
10824           some_strings_shown = TRUE;
10825         }
10826     }
10827
10828   if (! some_strings_shown)
10829     printf (_("  No strings found in this section."));
10830
10831   free (start);
10832
10833   putchar ('\n');
10834 }
10835
10836 static void
10837 dump_section_as_bytes (Elf_Internal_Shdr * section,
10838                        FILE * file,
10839                        bfd_boolean relocate)
10840 {
10841   Elf_Internal_Shdr * relsec;
10842   bfd_size_type bytes;
10843   bfd_vma addr;
10844   unsigned char * data;
10845   unsigned char * start;
10846
10847   start = (unsigned char *) get_section_contents (section, file);
10848   if (start == NULL)
10849     return;
10850
10851   printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10852
10853   if (relocate)
10854     {
10855       apply_relocations (file, section, start);
10856     }
10857   else
10858     {
10859       /* If the section being dumped has relocations against it the user might
10860          be expecting these relocations to have been applied.  Check for this
10861          case and issue a warning message in order to avoid confusion.
10862          FIXME: Maybe we ought to have an option that dumps a section with
10863          relocs applied ?  */
10864       for (relsec = section_headers;
10865            relsec < section_headers + elf_header.e_shnum;
10866            ++relsec)
10867         {
10868           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10869               || relsec->sh_info >= elf_header.e_shnum
10870               || section_headers + relsec->sh_info != section
10871               || relsec->sh_size == 0
10872               || relsec->sh_link >= elf_header.e_shnum)
10873             continue;
10874
10875           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10876           break;
10877         }
10878     }
10879
10880   addr = section->sh_addr;
10881   bytes = section->sh_size;
10882   data = start;
10883
10884   while (bytes)
10885     {
10886       int j;
10887       int k;
10888       int lbytes;
10889
10890       lbytes = (bytes > 16 ? 16 : bytes);
10891
10892       printf ("  0x%8.8lx ", (unsigned long) addr);
10893
10894       for (j = 0; j < 16; j++)
10895         {
10896           if (j < lbytes)
10897             printf ("%2.2x", data[j]);
10898           else
10899             printf ("  ");
10900
10901           if ((j & 3) == 3)
10902             printf (" ");
10903         }
10904
10905       for (j = 0; j < lbytes; j++)
10906         {
10907           k = data[j];
10908           if (k >= ' ' && k < 0x7f)
10909             printf ("%c", k);
10910           else
10911             printf (".");
10912         }
10913
10914       putchar ('\n');
10915
10916       data  += lbytes;
10917       addr  += lbytes;
10918       bytes -= lbytes;
10919     }
10920
10921   free (start);
10922
10923   putchar ('\n');
10924 }
10925
10926 /* Uncompresses a section that was compressed using zlib, in place.  */
10927
10928 static int
10929 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10930                              dwarf_size_type *size ATTRIBUTE_UNUSED)
10931 {
10932 #ifndef HAVE_ZLIB_H
10933   return FALSE;
10934 #else
10935   dwarf_size_type compressed_size = *size;
10936   unsigned char * compressed_buffer = *buffer;
10937   dwarf_size_type uncompressed_size;
10938   unsigned char * uncompressed_buffer;
10939   z_stream strm;
10940   int rc;
10941   dwarf_size_type header_size = 12;
10942
10943   /* Read the zlib header.  In this case, it should be "ZLIB" followed
10944      by the uncompressed section size, 8 bytes in big-endian order.  */
10945   if (compressed_size < header_size
10946       || ! streq ((char *) compressed_buffer, "ZLIB"))
10947     return 0;
10948
10949   uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10950   uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10951   uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10952   uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10953   uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10954   uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10955   uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10956   uncompressed_size += compressed_buffer[11];
10957
10958   /* It is possible the section consists of several compressed
10959      buffers concatenated together, so we uncompress in a loop.  */
10960   strm.zalloc = NULL;
10961   strm.zfree = NULL;
10962   strm.opaque = NULL;
10963   strm.avail_in = compressed_size - header_size;
10964   strm.next_in = (Bytef *) compressed_buffer + header_size;
10965   strm.avail_out = uncompressed_size;
10966   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
10967
10968   rc = inflateInit (& strm);
10969   while (strm.avail_in > 0)
10970     {
10971       if (rc != Z_OK)
10972         goto fail;
10973       strm.next_out = ((Bytef *) uncompressed_buffer
10974                        + (uncompressed_size - strm.avail_out));
10975       rc = inflate (&strm, Z_FINISH);
10976       if (rc != Z_STREAM_END)
10977         goto fail;
10978       rc = inflateReset (& strm);
10979     }
10980   rc = inflateEnd (& strm);
10981   if (rc != Z_OK
10982       || strm.avail_out != 0)
10983     goto fail;
10984
10985   free (compressed_buffer);
10986   *buffer = uncompressed_buffer;
10987   *size = uncompressed_size;
10988   return 1;
10989
10990  fail:
10991   free (uncompressed_buffer);
10992   /* Indicate decompression failure.  */
10993   *buffer = NULL;
10994   return 0;
10995 #endif  /* HAVE_ZLIB_H */
10996 }
10997
10998 static int
10999 load_specific_debug_section (enum dwarf_section_display_enum debug,
11000                              Elf_Internal_Shdr * sec, void * file)
11001 {
11002   struct dwarf_section * section = &debug_displays [debug].section;
11003   char buf [64];
11004
11005   /* If it is already loaded, do nothing.  */
11006   if (section->start != NULL)
11007     return 1;
11008
11009   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11010   section->address = sec->sh_addr;
11011   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11012                                                sec->sh_offset, 1,
11013                                                sec->sh_size, buf);
11014   if (section->start == NULL)
11015     section->size = 0;
11016   else
11017     {
11018       section->size = sec->sh_size;
11019       if (uncompress_section_contents (&section->start, &section->size))
11020         sec->sh_size = section->size;
11021     }
11022
11023   if (section->start == NULL)
11024     return 0;
11025
11026   if (debug_displays [debug].relocate)
11027     apply_relocations ((FILE *) file, sec, section->start);
11028
11029   return 1;
11030 }
11031
11032 /* If this is not NULL, load_debug_section will only look for sections
11033    within the list of sections given here.  */
11034 unsigned int *section_subset = NULL;
11035
11036 int
11037 load_debug_section (enum dwarf_section_display_enum debug, void * file)
11038 {
11039   struct dwarf_section * section = &debug_displays [debug].section;
11040   Elf_Internal_Shdr * sec;
11041
11042   /* Locate the debug section.  */
11043   sec = find_section_in_set (section->uncompressed_name, section_subset);
11044   if (sec != NULL)
11045     section->name = section->uncompressed_name;
11046   else
11047     {
11048       sec = find_section_in_set (section->compressed_name, section_subset);
11049       if (sec != NULL)
11050         section->name = section->compressed_name;
11051     }
11052   if (sec == NULL)
11053     return 0;
11054
11055   /* If we're loading from a subset of sections, and we've loaded
11056      a section matching this name before, it's likely that it's a
11057      different one.  */
11058   if (section_subset != NULL)
11059     free_debug_section (debug);
11060
11061   return load_specific_debug_section (debug, sec, (FILE *) file);
11062 }
11063
11064 void
11065 free_debug_section (enum dwarf_section_display_enum debug)
11066 {
11067   struct dwarf_section * section = &debug_displays [debug].section;
11068
11069   if (section->start == NULL)
11070     return;
11071
11072   free ((char *) section->start);
11073   section->start = NULL;
11074   section->address = 0;
11075   section->size = 0;
11076 }
11077
11078 static int
11079 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
11080 {
11081   char * name = SECTION_NAME (section);
11082   bfd_size_type length;
11083   int result = 1;
11084   int i;
11085
11086   length = section->sh_size;
11087   if (length == 0)
11088     {
11089       printf (_("\nSection '%s' has no debugging data.\n"), name);
11090       return 0;
11091     }
11092   if (section->sh_type == SHT_NOBITS)
11093     {
11094       /* There is no point in dumping the contents of a debugging section
11095          which has the NOBITS type - the bits in the file will be random.
11096          This can happen when a file containing a .eh_frame section is
11097          stripped with the --only-keep-debug command line option.  */
11098       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
11099       return 0;
11100     }
11101
11102   if (const_strneq (name, ".gnu.linkonce.wi."))
11103     name = ".debug_info";
11104
11105   /* See if we know how to display the contents of this section.  */
11106   for (i = 0; i < max; i++)
11107     if (streq (debug_displays[i].section.uncompressed_name, name)
11108         || (i == line && const_strneq (name, ".debug_line."))
11109         || streq (debug_displays[i].section.compressed_name, name))
11110       {
11111         struct dwarf_section * sec = &debug_displays [i].section;
11112         int secondary = (section != find_section (name));
11113
11114         if (secondary)
11115           free_debug_section ((enum dwarf_section_display_enum) i);
11116
11117         if (i == line && const_strneq (name, ".debug_line."))
11118           sec->name = name;
11119         else if (streq (sec->uncompressed_name, name))
11120           sec->name = sec->uncompressed_name;
11121         else
11122           sec->name = sec->compressed_name;
11123         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
11124                                          section, file))
11125           {
11126             /* If this debug section is part of a CU/TU set in a .dwp file,
11127                restrict load_debug_section to the sections in that set.  */
11128             section_subset = find_cu_tu_set (file, shndx);
11129
11130             result &= debug_displays[i].display (sec, file);
11131
11132             section_subset = NULL;
11133
11134             if (secondary || (i != info && i != abbrev))
11135               free_debug_section ((enum dwarf_section_display_enum) i);
11136           }
11137
11138         break;
11139       }
11140
11141   if (i == max)
11142     {
11143       printf (_("Unrecognized debug section: %s\n"), name);
11144       result = 0;
11145     }
11146
11147   return result;
11148 }
11149
11150 /* Set DUMP_SECTS for all sections where dumps were requested
11151    based on section name.  */
11152
11153 static void
11154 initialise_dumps_byname (void)
11155 {
11156   struct dump_list_entry * cur;
11157
11158   for (cur = dump_sects_byname; cur; cur = cur->next)
11159     {
11160       unsigned int i;
11161       int any;
11162
11163       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11164         if (streq (SECTION_NAME (section_headers + i), cur->name))
11165           {
11166             request_dump_bynumber (i, cur->type);
11167             any = 1;
11168           }
11169
11170       if (!any)
11171         warn (_("Section '%s' was not dumped because it does not exist!\n"),
11172               cur->name);
11173     }
11174 }
11175
11176 static void
11177 process_section_contents (FILE * file)
11178 {
11179   Elf_Internal_Shdr * section;
11180   unsigned int i;
11181
11182   if (! do_dump)
11183     return;
11184
11185   initialise_dumps_byname ();
11186
11187   for (i = 0, section = section_headers;
11188        i < elf_header.e_shnum && i < num_dump_sects;
11189        i++, section++)
11190     {
11191 #ifdef SUPPORT_DISASSEMBLY
11192       if (dump_sects[i] & DISASS_DUMP)
11193         disassemble_section (section, file);
11194 #endif
11195       if (dump_sects[i] & HEX_DUMP)
11196         dump_section_as_bytes (section, file, FALSE);
11197
11198       if (dump_sects[i] & RELOC_DUMP)
11199         dump_section_as_bytes (section, file, TRUE);
11200
11201       if (dump_sects[i] & STRING_DUMP)
11202         dump_section_as_strings (section, file);
11203
11204       if (dump_sects[i] & DEBUG_DUMP)
11205         display_debug_section (i, section, file);
11206     }
11207
11208   /* Check to see if the user requested a
11209      dump of a section that does not exist.  */
11210   while (i++ < num_dump_sects)
11211     if (dump_sects[i])
11212       warn (_("Section %d was not dumped because it does not exist!\n"), i);
11213 }
11214
11215 static void
11216 process_mips_fpe_exception (int mask)
11217 {
11218   if (mask)
11219     {
11220       int first = 1;
11221       if (mask & OEX_FPU_INEX)
11222         fputs ("INEX", stdout), first = 0;
11223       if (mask & OEX_FPU_UFLO)
11224         printf ("%sUFLO", first ? "" : "|"), first = 0;
11225       if (mask & OEX_FPU_OFLO)
11226         printf ("%sOFLO", first ? "" : "|"), first = 0;
11227       if (mask & OEX_FPU_DIV0)
11228         printf ("%sDIV0", first ? "" : "|"), first = 0;
11229       if (mask & OEX_FPU_INVAL)
11230         printf ("%sINVAL", first ? "" : "|");
11231     }
11232   else
11233     fputs ("0", stdout);
11234 }
11235
11236 /* Display's the value of TAG at location P.  If TAG is
11237    greater than 0 it is assumed to be an unknown tag, and
11238    a message is printed to this effect.  Otherwise it is
11239    assumed that a message has already been printed.
11240
11241    If the bottom bit of TAG is set it assumed to have a
11242    string value, otherwise it is assumed to have an integer
11243    value.
11244
11245    Returns an updated P pointing to the first unread byte
11246    beyond the end of TAG's value.
11247
11248    Reads at or beyond END will not be made.  */
11249
11250 static unsigned char *
11251 display_tag_value (int tag,
11252                    unsigned char * p,
11253                    const unsigned char * const end)
11254 {
11255   unsigned long val;
11256
11257   if (tag > 0)
11258     printf ("  Tag_unknown_%d: ", tag);
11259
11260   if (p >= end)
11261     {
11262       warn (_("corrupt tag\n"));
11263     }
11264   else if (tag & 1)
11265     {
11266       /* FIXME: we could read beyond END here.  */
11267       printf ("\"%s\"\n", p);
11268       p += strlen ((char *) p) + 1;
11269     }
11270   else
11271     {
11272       unsigned int len;
11273
11274       val = read_uleb128 (p, &len, end);
11275       p += len;
11276       printf ("%ld (0x%lx)\n", val, val);
11277     }
11278
11279   return p;
11280 }
11281
11282 /* ARM EABI attributes section.  */
11283 typedef struct
11284 {
11285   int tag;
11286   const char * name;
11287   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
11288   int type;
11289   const char ** table;
11290 } arm_attr_public_tag;
11291
11292 static const char * arm_attr_tag_CPU_arch[] =
11293   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11294    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11295 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11296 static const char * arm_attr_tag_THUMB_ISA_use[] =
11297   {"No", "Thumb-1", "Thumb-2"};
11298 static const char * arm_attr_tag_FP_arch[] =
11299   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11300    "FP for ARMv8"};
11301 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
11302 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
11303   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11304 static const char * arm_attr_tag_PCS_config[] =
11305   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11306    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11307 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11308   {"V6", "SB", "TLS", "Unused"};
11309 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11310   {"Absolute", "PC-relative", "SB-relative", "None"};
11311 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11312   {"Absolute", "PC-relative", "None"};
11313 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11314   {"None", "direct", "GOT-indirect"};
11315 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11316   {"None", "??? 1", "2", "??? 3", "4"};
11317 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11318 static const char * arm_attr_tag_ABI_FP_denormal[] =
11319   {"Unused", "Needed", "Sign only"};
11320 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11321 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11322 static const char * arm_attr_tag_ABI_FP_number_model[] =
11323   {"Unused", "Finite", "RTABI", "IEEE 754"};
11324 static const char * arm_attr_tag_ABI_enum_size[] =
11325   {"Unused", "small", "int", "forced to int"};
11326 static const char * arm_attr_tag_ABI_HardFP_use[] =
11327   {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11328 static const char * arm_attr_tag_ABI_VFP_args[] =
11329   {"AAPCS", "VFP registers", "custom"};
11330 static const char * arm_attr_tag_ABI_WMMX_args[] =
11331   {"AAPCS", "WMMX registers", "custom"};
11332 static const char * arm_attr_tag_ABI_optimization_goals[] =
11333   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11334     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11335 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11336   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11337     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11338 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
11339 static const char * arm_attr_tag_FP_HP_extension[] =
11340   {"Not Allowed", "Allowed"};
11341 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
11342   {"None", "IEEE 754", "Alternative Format"};
11343 static const char * arm_attr_tag_MPextension_use[] =
11344   {"Not Allowed", "Allowed"};
11345 static const char * arm_attr_tag_DIV_use[] =
11346   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11347     "Allowed in v7-A with integer division extension"};
11348 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11349 static const char * arm_attr_tag_Virtualization_use[] =
11350   {"Not Allowed", "TrustZone", "Virtualization Extensions",
11351     "TrustZone and Virtualization Extensions"};
11352 static const char * arm_attr_tag_MPextension_use_legacy[] =
11353   {"Not Allowed", "Allowed"};
11354
11355 #define LOOKUP(id, name) \
11356   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11357 static arm_attr_public_tag arm_attr_public_tags[] =
11358 {
11359   {4, "CPU_raw_name", 1, NULL},
11360   {5, "CPU_name", 1, NULL},
11361   LOOKUP(6, CPU_arch),
11362   {7, "CPU_arch_profile", 0, NULL},
11363   LOOKUP(8, ARM_ISA_use),
11364   LOOKUP(9, THUMB_ISA_use),
11365   LOOKUP(10, FP_arch),
11366   LOOKUP(11, WMMX_arch),
11367   LOOKUP(12, Advanced_SIMD_arch),
11368   LOOKUP(13, PCS_config),
11369   LOOKUP(14, ABI_PCS_R9_use),
11370   LOOKUP(15, ABI_PCS_RW_data),
11371   LOOKUP(16, ABI_PCS_RO_data),
11372   LOOKUP(17, ABI_PCS_GOT_use),
11373   LOOKUP(18, ABI_PCS_wchar_t),
11374   LOOKUP(19, ABI_FP_rounding),
11375   LOOKUP(20, ABI_FP_denormal),
11376   LOOKUP(21, ABI_FP_exceptions),
11377   LOOKUP(22, ABI_FP_user_exceptions),
11378   LOOKUP(23, ABI_FP_number_model),
11379   {24, "ABI_align_needed", 0, NULL},
11380   {25, "ABI_align_preserved", 0, NULL},
11381   LOOKUP(26, ABI_enum_size),
11382   LOOKUP(27, ABI_HardFP_use),
11383   LOOKUP(28, ABI_VFP_args),
11384   LOOKUP(29, ABI_WMMX_args),
11385   LOOKUP(30, ABI_optimization_goals),
11386   LOOKUP(31, ABI_FP_optimization_goals),
11387   {32, "compatibility", 0, NULL},
11388   LOOKUP(34, CPU_unaligned_access),
11389   LOOKUP(36, FP_HP_extension),
11390   LOOKUP(38, ABI_FP_16bit_format),
11391   LOOKUP(42, MPextension_use),
11392   LOOKUP(44, DIV_use),
11393   {64, "nodefaults", 0, NULL},
11394   {65, "also_compatible_with", 0, NULL},
11395   LOOKUP(66, T2EE_use),
11396   {67, "conformance", 1, NULL},
11397   LOOKUP(68, Virtualization_use),
11398   LOOKUP(70, MPextension_use_legacy)
11399 };
11400 #undef LOOKUP
11401
11402 static unsigned char *
11403 display_arm_attribute (unsigned char * p,
11404                        const unsigned char * const end)
11405 {
11406   int tag;
11407   unsigned int len;
11408   int val;
11409   arm_attr_public_tag * attr;
11410   unsigned i;
11411   int type;
11412
11413   tag = read_uleb128 (p, &len, end);
11414   p += len;
11415   attr = NULL;
11416   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11417     {
11418       if (arm_attr_public_tags[i].tag == tag)
11419         {
11420           attr = &arm_attr_public_tags[i];
11421           break;
11422         }
11423     }
11424
11425   if (attr)
11426     {
11427       printf ("  Tag_%s: ", attr->name);
11428       switch (attr->type)
11429         {
11430         case 0:
11431           switch (tag)
11432             {
11433             case 7: /* Tag_CPU_arch_profile.  */
11434               val = read_uleb128 (p, &len, end);
11435               p += len;
11436               switch (val)
11437                 {
11438                 case 0: printf (_("None\n")); break;
11439                 case 'A': printf (_("Application\n")); break;
11440                 case 'R': printf (_("Realtime\n")); break;
11441                 case 'M': printf (_("Microcontroller\n")); break;
11442                 case 'S': printf (_("Application or Realtime\n")); break;
11443                 default: printf ("??? (%d)\n", val); break;
11444                 }
11445               break;
11446
11447             case 24: /* Tag_align_needed.  */
11448               val = read_uleb128 (p, &len, end);
11449               p += len;
11450               switch (val)
11451                 {
11452                 case 0: printf (_("None\n")); break;
11453                 case 1: printf (_("8-byte\n")); break;
11454                 case 2: printf (_("4-byte\n")); break;
11455                 case 3: printf ("??? 3\n"); break;
11456                 default:
11457                   if (val <= 12)
11458                     printf (_("8-byte and up to %d-byte extended\n"),
11459                             1 << val);
11460                   else
11461                     printf ("??? (%d)\n", val);
11462                   break;
11463                 }
11464               break;
11465
11466             case 25: /* Tag_align_preserved.  */
11467               val = read_uleb128 (p, &len, end);
11468               p += len;
11469               switch (val)
11470                 {
11471                 case 0: printf (_("None\n")); break;
11472                 case 1: printf (_("8-byte, except leaf SP\n")); break;
11473                 case 2: printf (_("8-byte\n")); break;
11474                 case 3: printf ("??? 3\n"); break;
11475                 default:
11476                   if (val <= 12)
11477                     printf (_("8-byte and up to %d-byte extended\n"),
11478                             1 << val);
11479                   else
11480                     printf ("??? (%d)\n", val);
11481                   break;
11482                 }
11483               break;
11484
11485             case 32: /* Tag_compatibility.  */
11486               val = read_uleb128 (p, &len, end);
11487               p += len;
11488               printf (_("flag = %d, vendor = %s\n"), val, p);
11489               p += strlen ((char *) p) + 1;
11490               break;
11491
11492             case 64: /* Tag_nodefaults.  */
11493               p++;
11494               printf (_("True\n"));
11495               break;
11496
11497             case 65: /* Tag_also_compatible_with.  */
11498               val = read_uleb128 (p, &len, end);
11499               p += len;
11500               if (val == 6 /* Tag_CPU_arch.  */)
11501                 {
11502                   val = read_uleb128 (p, &len, end);
11503                   p += len;
11504                   if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
11505                     printf ("??? (%d)\n", val);
11506                   else
11507                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11508                 }
11509               else
11510                 printf ("???\n");
11511               while (*(p++) != '\0' /* NUL terminator.  */);
11512               break;
11513
11514             default:
11515               abort ();
11516             }
11517           return p;
11518
11519         case 1:
11520           return display_tag_value (-1, p, end);
11521         case 2:
11522           return display_tag_value (0, p, end);
11523
11524         default:
11525           assert (attr->type & 0x80);
11526           val = read_uleb128 (p, &len, end);
11527           p += len;
11528           type = attr->type & 0x7f;
11529           if (val >= type)
11530             printf ("??? (%d)\n", val);
11531           else
11532             printf ("%s\n", attr->table[val]);
11533           return p;
11534         }
11535     }
11536
11537   return display_tag_value (tag, p, end);
11538 }
11539
11540 static unsigned char *
11541 display_gnu_attribute (unsigned char * p,
11542                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
11543                        const unsigned char * const end)
11544 {
11545   int tag;
11546   unsigned int len;
11547   int val;
11548
11549   tag = read_uleb128 (p, &len, end);
11550   p += len;
11551
11552   /* Tag_compatibility is the only generic GNU attribute defined at
11553      present.  */
11554   if (tag == 32)
11555     {
11556       val = read_uleb128 (p, &len, end);
11557       p += len;
11558       if (p == end)
11559         {
11560           printf (_("flag = %d, vendor = <corrupt>\n"), val);
11561           warn (_("corrupt vendor attribute\n"));
11562         }
11563       else
11564         {
11565           printf (_("flag = %d, vendor = %s\n"), val, p);
11566           p += strlen ((char *) p) + 1;
11567         }
11568       return p;
11569     }
11570
11571   if ((tag & 2) == 0 && display_proc_gnu_attribute)
11572     return display_proc_gnu_attribute (p, tag, end);
11573
11574   return display_tag_value (tag, p, end);
11575 }
11576
11577 static unsigned char *
11578 display_power_gnu_attribute (unsigned char * p,
11579                              int tag,
11580                              const unsigned char * const end)
11581 {
11582   unsigned int len;
11583   int val;
11584
11585   if (tag == Tag_GNU_Power_ABI_FP)
11586     {
11587       val = read_uleb128 (p, &len, end);
11588       p += len;
11589       printf ("  Tag_GNU_Power_ABI_FP: ");
11590
11591       switch (val)
11592         {
11593         case 0:
11594           printf (_("Hard or soft float\n"));
11595           break;
11596         case 1:
11597           printf (_("Hard float\n"));
11598           break;
11599         case 2:
11600           printf (_("Soft float\n"));
11601           break;
11602         case 3:
11603           printf (_("Single-precision hard float\n"));
11604           break;
11605         default:
11606           printf ("??? (%d)\n", val);
11607           break;
11608         }
11609       return p;
11610    }
11611
11612   if (tag == Tag_GNU_Power_ABI_Vector)
11613     {
11614       val = read_uleb128 (p, &len, end);
11615       p += len;
11616       printf ("  Tag_GNU_Power_ABI_Vector: ");
11617       switch (val)
11618         {
11619         case 0:
11620           printf (_("Any\n"));
11621           break;
11622         case 1:
11623           printf (_("Generic\n"));
11624           break;
11625         case 2:
11626           printf ("AltiVec\n");
11627           break;
11628         case 3:
11629           printf ("SPE\n");
11630           break;
11631         default:
11632           printf ("??? (%d)\n", val);
11633           break;
11634         }
11635       return p;
11636    }
11637
11638   if (tag == Tag_GNU_Power_ABI_Struct_Return)
11639     {
11640       if (p == end)
11641         {
11642           warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
11643           return p;
11644         }
11645
11646       val = read_uleb128 (p, &len, end);
11647       p += len;
11648       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
11649       switch (val)
11650        {
11651        case 0:
11652          printf (_("Any\n"));
11653          break;
11654        case 1:
11655          printf ("r3/r4\n");
11656          break;
11657        case 2:
11658          printf (_("Memory\n"));
11659          break;
11660        default:
11661          printf ("??? (%d)\n", val);
11662          break;
11663        }
11664       return p;
11665     }
11666
11667   return display_tag_value (tag & 1, p, end);
11668 }
11669
11670 static void
11671 display_sparc_hwcaps (int mask)
11672 {
11673   if (mask)
11674     {
11675       int first = 1;
11676       if (mask & ELF_SPARC_HWCAP_MUL32)
11677         fputs ("mul32", stdout), first = 0;
11678       if (mask & ELF_SPARC_HWCAP_DIV32)
11679         printf ("%sdiv32", first ? "" : "|"), first = 0;
11680       if (mask & ELF_SPARC_HWCAP_FSMULD)
11681         printf ("%sfsmuld", first ? "" : "|"), first = 0;
11682       if (mask & ELF_SPARC_HWCAP_V8PLUS)
11683         printf ("%sv8plus", first ? "" : "|"), first = 0;
11684       if (mask & ELF_SPARC_HWCAP_POPC)
11685         printf ("%spopc", first ? "" : "|"), first = 0;
11686       if (mask & ELF_SPARC_HWCAP_VIS)
11687         printf ("%svis", first ? "" : "|"), first = 0;
11688       if (mask & ELF_SPARC_HWCAP_VIS2)
11689         printf ("%svis2", first ? "" : "|"), first = 0;
11690       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11691         printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11692       if (mask & ELF_SPARC_HWCAP_FMAF)
11693         printf ("%sfmaf", first ? "" : "|"), first = 0;
11694       if (mask & ELF_SPARC_HWCAP_VIS3)
11695         printf ("%svis3", first ? "" : "|"), first = 0;
11696       if (mask & ELF_SPARC_HWCAP_HPC)
11697         printf ("%shpc", first ? "" : "|"), first = 0;
11698       if (mask & ELF_SPARC_HWCAP_RANDOM)
11699         printf ("%srandom", first ? "" : "|"), first = 0;
11700       if (mask & ELF_SPARC_HWCAP_TRANS)
11701         printf ("%strans", first ? "" : "|"), first = 0;
11702       if (mask & ELF_SPARC_HWCAP_FJFMAU)
11703         printf ("%sfjfmau", first ? "" : "|"), first = 0;
11704       if (mask & ELF_SPARC_HWCAP_IMA)
11705         printf ("%sima", first ? "" : "|"), first = 0;
11706       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11707         printf ("%scspare", first ? "" : "|"), first = 0;
11708     }
11709   else
11710     fputc('0', stdout);
11711   fputc('\n', stdout);
11712 }
11713
11714 static unsigned char *
11715 display_sparc_gnu_attribute (unsigned char * p,
11716                              int tag,
11717                              const unsigned char * const end)
11718 {
11719   if (tag == Tag_GNU_Sparc_HWCAPS)
11720     {
11721       unsigned int len;
11722       int val;
11723
11724       val = read_uleb128 (p, &len, end);
11725       p += len;
11726       printf ("  Tag_GNU_Sparc_HWCAPS: ");
11727       display_sparc_hwcaps (val);
11728       return p;
11729    }
11730
11731   return display_tag_value (tag, p, end);
11732 }
11733
11734 static unsigned char *
11735 display_mips_gnu_attribute (unsigned char * p,
11736                             int tag,
11737                             const unsigned char * const end)
11738 {
11739   if (tag == Tag_GNU_MIPS_ABI_FP)
11740     {
11741       unsigned int len;
11742       int val;
11743
11744       val = read_uleb128 (p, &len, end);
11745       p += len;
11746       printf ("  Tag_GNU_MIPS_ABI_FP: ");
11747
11748       switch (val)
11749         {
11750         case Val_GNU_MIPS_ABI_FP_ANY:
11751           printf (_("Hard or soft float\n"));
11752           break;
11753         case Val_GNU_MIPS_ABI_FP_DOUBLE:
11754           printf (_("Hard float (double precision)\n"));
11755           break;
11756         case Val_GNU_MIPS_ABI_FP_SINGLE:
11757           printf (_("Hard float (single precision)\n"));
11758           break;
11759         case Val_GNU_MIPS_ABI_FP_SOFT:
11760           printf (_("Soft float\n"));
11761           break;
11762         case Val_GNU_MIPS_ABI_FP_64:
11763           printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
11764           break;
11765         default:
11766           printf ("??? (%d)\n", val);
11767           break;
11768         }
11769       return p;
11770    }
11771
11772   if (tag == Tag_GNU_MIPS_ABI_MSA)
11773     {
11774       unsigned int len;
11775       int val;
11776
11777       val = read_uleb128 (p, &len, end);
11778       p += len;
11779       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
11780
11781       switch (val)
11782         {
11783         case Val_GNU_MIPS_ABI_MSA_ANY:
11784           printf (_("Any MSA or not\n"));
11785           break;
11786         case Val_GNU_MIPS_ABI_MSA_128:
11787           printf (_("128-bit MSA\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 }