binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright 1998-2013 Free Software Foundation, Inc.
   3
   4    Originally developed by Eric Youngdale <eric@andante.jic.com>
   5    Modifications by Nick Clifton <nickc@redhat.com>
   6
   7    This file is part of GNU Binutils.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  22    02110-1301, USA.  */
  23 \f
  24 /* The difference between readelf and objdump:
  25
  26   Both programs are capable of displaying the contents of ELF format files,
  27   so why does the binutils project have two file dumpers ?
  28
  29   The reason is that objdump sees an ELF file through a BFD filter of the
  30   world; if BFD has a bug where, say, it disagrees about a machine constant
  31   in e_flags, then the odds are good that it will remain internally
  32   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
  33   GAS sees it the BFD way.  There was need for a tool to go find out what
  34   the file actually says.
  35
  36   This is why the readelf program does not link against the BFD library - it
  37   exists as an independent program to help verify the correct working of BFD.
  38
  39   There is also the case that readelf can provide more information about an
  40   ELF file than is provided by objdump.  In particular it can display DWARF
  41   debugging information which (at the moment) objdump cannot.  */
  42 \f
  43 #include "sysdep.h"
  44 #include <assert.h>
  45 #include <time.h>
  46 #ifdef HAVE_ZLIB_H
  47 #include <zlib.h>
  48 #endif
  49 #ifdef HAVE_WCHAR_H
  50 #include <wchar.h>
  51 #endif
  52
  53 #if __GNUC__ >= 2
  54 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  55    as this will allow us to read in and parse 64bit and 32bit ELF files.
  56    Only do this if we believe that the compiler can support a 64 bit
  57    data type.  For now we only rely on GCC being able to do this.  */
  58 #define BFD64
  59 #endif
  60
  61 #include "bfd.h"
  62 #include "bucomm.h"
  63 #include "elfcomm.h"
  64 #include "dwarf.h"
  65
  66 #include "elf/common.h"
  67 #include "elf/external.h"
  68 #include "elf/internal.h"
  69
  70
  71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  72    we can obtain the H8 reloc numbers.  We need these for the
  73    get_reloc_size() function.  We include h8.h again after defining
  74    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  75
  76 #include "elf/h8.h"
  77 #undef _ELF_H8_H
  78
  79 /* Undo the effects of #including reloc-macros.h.  */
  80
  81 #undef START_RELOC_NUMBERS
  82 #undef RELOC_NUMBER
  83 #undef FAKE_RELOC
  84 #undef EMPTY_RELOC
  85 #undef END_RELOC_NUMBERS
  86 #undef _RELOC_MACROS_H
  87
  88 /* The following headers use the elf/reloc-macros.h file to
  89    automatically generate relocation recognition functions
  90    such as elf_mips_reloc_type()  */
  91
  92 #define RELOC_MACROS_GEN_FUNC
  93
  94 #include "elf/aarch64.h"
  95 #include "elf/alpha.h"
  96 #include "elf/arc.h"
  97 #include "elf/arm.h"
  98 #include "elf/avr.h"
  99 #include "elf/bfin.h"
 100 #include "elf/cr16.h"
 101 #include "elf/cris.h"
 102 #include "elf/crx.h"
 103 #include "elf/d10v.h"
 104 #include "elf/d30v.h"
 105 #include "elf/dlx.h"
 106 #include "elf/epiphany.h"
 107 #include "elf/fr30.h"
 108 #include "elf/frv.h"
 109 #include "elf/h8.h"
 110 #include "elf/hppa.h"
 111 #include "elf/i386.h"
 112 #include "elf/i370.h"
 113 #include "elf/i860.h"
 114 #include "elf/i960.h"
 115 #include "elf/ia64.h"
 116 #include "elf/ip2k.h"
 117 #include "elf/lm32.h"
 118 #include "elf/iq2000.h"
 119 #include "elf/m32c.h"
 120 #include "elf/m32r.h"
 121 #include "elf/m68k.h"
 122 #include "elf/m68hc11.h"
 123 #include "elf/mcore.h"
 124 #include "elf/mep.h"
 125 #include "elf/metag.h"
 126 #include "elf/microblaze.h"
 127 #include "elf/mips.h"
 128 #include "elf/mmix.h"
 129 #include "elf/mn10200.h"
 130 #include "elf/mn10300.h"
 131 #include "elf/moxie.h"
 132 #include "elf/mt.h"
 133 #include "elf/msp430.h"
 134 #include "elf/nios2.h"
 135 #include "elf/or32.h"
 136 #include "elf/pj.h"
 137 #include "elf/ppc.h"
 138 #include "elf/ppc64.h"
 139 #include "elf/rl78.h"
 140 #include "elf/rx.h"
 141 #include "elf/s390.h"
 142 #include "elf/score.h"
 143 #include "elf/sh.h"
 144 #include "elf/sparc.h"
 145 #include "elf/spu.h"
 146 #include "elf/tic6x.h"
 147 #include "elf/tilegx.h"
 148 #include "elf/tilepro.h"
 149 #include "elf/v850.h"
 150 #include "elf/vax.h"
 151 #include "elf/x86-64.h"
 152 #include "elf/xc16x.h"
 153 #include "elf/xgate.h"
 154 #include "elf/xstormy16.h"
 155 #include "elf/xtensa.h"
 156
 157 #include "getopt.h"
 158 #include "libiberty.h"
 159 #include "safe-ctype.h"
 160 #include "filenames.h"
 161
 162 #ifndef offsetof
 163 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 164 #endif
 165
 166 char * program_name = "readelf";
 167 static long archive_file_offset;
 168 static unsigned long archive_file_size;
 169 static unsigned long dynamic_addr;
 170 static bfd_size_type dynamic_size;
 171 static unsigned int dynamic_nent;
 172 static char * dynamic_strings;
 173 static unsigned long dynamic_strings_length;
 174 static char * string_table;
 175 static unsigned long string_table_length;
 176 static unsigned long num_dynamic_syms;
 177 static Elf_Internal_Sym * dynamic_symbols;
 178 static Elf_Internal_Syminfo * dynamic_syminfo;
 179 static unsigned long dynamic_syminfo_offset;
 180 static unsigned int dynamic_syminfo_nent;
 181 static char program_interpreter[PATH_MAX];
 182 static bfd_vma dynamic_info[DT_ENCODING];
 183 static bfd_vma dynamic_info_DT_GNU_HASH;
 184 static bfd_vma version_info[16];
 185 static Elf_Internal_Ehdr elf_header;
 186 static Elf_Internal_Shdr * section_headers;
 187 static Elf_Internal_Phdr * program_headers;
 188 static Elf_Internal_Dyn *  dynamic_section;
 189 static Elf_Internal_Shdr * symtab_shndx_hdr;
 190 static int show_name;
 191 static int do_dynamic;
 192 static int do_syms;
 193 static int do_dyn_syms;
 194 static int do_reloc;
 195 static int do_sections;
 196 static int do_section_groups;
 197 static int do_section_details;
 198 static int do_segments;
 199 static int do_unwind;
 200 static int do_using_dynamic;
 201 static int do_header;
 202 static int do_dump;
 203 static int do_version;
 204 static int do_histogram;
 205 static int do_debugging;
 206 static int do_arch;
 207 static int do_notes;
 208 static int do_archive_index;
 209 static int is_32bit_elf;
 210
 211 struct group_list
 212 {
 213   struct group_list * next;
 214   unsigned int section_index;
 215 };
 216
 217 struct group
 218 {
 219   struct group_list * root;
 220   unsigned int group_index;
 221 };
 222
 223 static size_t group_count;
 224 static struct group * section_groups;
 225 static struct group ** section_headers_groups;
 226
 227
 228 /* Flag bits indicating particular types of dump.  */
 229 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 230 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 231 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 232 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 233 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 234
 235 typedef unsigned char dump_type;
 236
 237 /* A linked list of the section names for which dumps were requested.  */
 238 struct dump_list_entry
 239 {
 240   char * name;
 241   dump_type type;
 242   struct dump_list_entry * next;
 243 };
 244 static struct dump_list_entry * dump_sects_byname;
 245
 246 /* A dynamic array of flags indicating for which sections a dump
 247    has been requested via command line switches.  */
 248 static dump_type *   cmdline_dump_sects = NULL;
 249 static unsigned int  num_cmdline_dump_sects = 0;
 250
 251 /* A dynamic array of flags indicating for which sections a dump of
 252    some kind has been requested.  It is reset on a per-object file
 253    basis and then initialised from the cmdline_dump_sects array,
 254    the results of interpreting the -w switch, and the
 255    dump_sects_byname list.  */
 256 static dump_type *   dump_sects = NULL;
 257 static unsigned int  num_dump_sects = 0;
 258
 259
 260 /* How to print a vma value.  */
 261 typedef enum print_mode
 262 {
 263   HEX,
 264   DEC,
 265   DEC_5,
 266   UNSIGNED,
 267   PREFIX_HEX,
 268   FULL_HEX,
 269   LONG_HEX
 270 }
 271 print_mode;
 272
 273 #define UNKNOWN -1
 274
 275 #define SECTION_NAME(X)                                         \
 276   ((X) == NULL ? _("<none>")                                    \
 277    : string_table == NULL ? _("<no-name>")                      \
 278    : ((X)->sh_name >= string_table_length ? _("<corrupt>")      \
 279   : string_table + (X)->sh_name))
 280
 281 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 282
 283 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 284   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 285    : get_64bit_elf_symbols (file, section, sym_count))
 286
 287 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 288 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 289    already been called and verified that the string exists.  */
 290 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 291
 292 #define REMOVE_ARCH_BITS(ADDR)                  \
 293   do                                            \
 294     {                                           \
 295       if (elf_header.e_machine == EM_ARM)       \
 296         (ADDR) &= ~1;                           \
 297     }                                           \
 298   while (0)
 299 \f
 300 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
 301    Put the retrieved data into VAR, if it is not NULL.  Otherwise allocate a buffer
 302    using malloc and fill that.  In either case return the pointer to the start of
 303    the retrieved data or NULL if something went wrong.  If something does go wrong
 304    emit an error message using REASON as part of the context.  */
 305
 306 static void *
 307 get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
 308           const char * reason)
 309 {
 310   void * mvar;
 311
 312   if (size == 0 || nmemb == 0)
 313     return NULL;
 314
 315   if (fseek (file, archive_file_offset + offset, SEEK_SET))
 316     {
 317       error (_("Unable to seek to 0x%lx for %s\n"),
 318              (unsigned long) archive_file_offset + offset, reason);
 319       return NULL;
 320     }
 321
 322   mvar = var;
 323   if (mvar == NULL)
 324     {
 325       /* Check for overflow.  */
 326       if (nmemb < (~(size_t) 0 - 1) / size)
 327         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 328         mvar = malloc (size * nmemb + 1);
 329
 330       if (mvar == NULL)
 331         {
 332           error (_("Out of memory allocating 0x%lx bytes for %s\n"),
 333                  (unsigned long)(size * nmemb), reason);
 334           return NULL;
 335         }
 336
 337       ((char *) mvar)[size * nmemb] = '\0';
 338     }
 339
 340   if (fread (mvar, size, nmemb, file) != nmemb)
 341     {
 342       error (_("Unable to read in 0x%lx bytes of %s\n"),
 343              (unsigned long)(size * nmemb), reason);
 344       if (mvar != var)
 345         free (mvar);
 346       return NULL;
 347     }
 348
 349   return mvar;
 350 }
 351
 352 /* Print a VMA value.  */
 353
 354 static int
 355 print_vma (bfd_vma vma, print_mode mode)
 356 {
 357   int nc = 0;
 358
 359   switch (mode)
 360     {
 361     case FULL_HEX:
 362       nc = printf ("0x");
 363       /* Drop through.  */
 364
 365     case LONG_HEX:
 366 #ifdef BFD64
 367       if (is_32bit_elf)
 368         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 369 #endif
 370       printf_vma (vma);
 371       return nc + 16;
 372
 373     case DEC_5:
 374       if (vma <= 99999)
 375         return printf ("%5" BFD_VMA_FMT "d", vma);
 376       /* Drop through.  */
 377
 378     case PREFIX_HEX:
 379       nc = printf ("0x");
 380       /* Drop through.  */
 381
 382     case HEX:
 383       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 384
 385     case DEC:
 386       return printf ("%" BFD_VMA_FMT "d", vma);
 387
 388     case UNSIGNED:
 389       return printf ("%" BFD_VMA_FMT "u", vma);
 390     }
 391   return 0;
 392 }
 393
 394 /* Display a symbol on stdout.  Handles the display of control characters and
 395    multibye characters (assuming the host environment supports them).
 396
 397    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 398
 399    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 400    padding as necessary.
 401
 402    Returns the number of emitted characters.  */
 403
 404 static unsigned int
 405 print_symbol (int width, const char *symbol)
 406 {
 407   bfd_boolean extra_padding = FALSE;
 408   int num_printed = 0;
 409 #ifdef HAVE_MBSTATE_T
 410   mbstate_t state;
 411 #endif
 412   int width_remaining;
 413
 414   if (width < 0)
 415     {
 416       /* Keep the width positive.  This also helps.  */
 417       width = - width;
 418       extra_padding = TRUE;
 419     }
 420
 421   if (do_wide)
 422     /* Set the remaining width to a very large value.
 423        This simplifies the code below.  */
 424     width_remaining = INT_MAX;
 425   else
 426     width_remaining = width;
 427
 428 #ifdef HAVE_MBSTATE_T
 429   /* Initialise the multibyte conversion state.  */
 430   memset (& state, 0, sizeof (state));
 431 #endif
 432
 433   while (width_remaining)
 434     {
 435       size_t  n;
 436       const char c = *symbol++;
 437
 438       if (c == 0)
 439         break;
 440
 441       /* Do not print control characters directly as they can affect terminal
 442          settings.  Such characters usually appear in the names generated
 443          by the assembler for local labels.  */
 444       if (ISCNTRL (c))
 445         {
 446           if (width_remaining < 2)
 447             break;
 448
 449           printf ("^%c", c + 0x40);
 450           width_remaining -= 2;
 451           num_printed += 2;
 452         }
 453       else if (ISPRINT (c))
 454         {
 455           putchar (c);
 456           width_remaining --;
 457           num_printed ++;
 458         }
 459       else
 460         {
 461 #ifdef HAVE_MBSTATE_T
 462           wchar_t w;
 463 #endif
 464           /* Let printf do the hard work of displaying multibyte characters.  */
 465           printf ("%.1s", symbol - 1);
 466           width_remaining --;
 467           num_printed ++;
 468
 469 #ifdef HAVE_MBSTATE_T
 470           /* Try to find out how many bytes made up the character that was
 471              just printed.  Advance the symbol pointer past the bytes that
 472              were displayed.  */
 473           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 474 #else
 475           n = 1;
 476 #endif
 477           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 478             symbol += (n - 1);
 479         }
 480     }
 481
 482   if (extra_padding && num_printed < width)
 483     {
 484       /* Fill in the remaining spaces.  */
 485       printf ("%-*s", width - num_printed, " ");
 486       num_printed = width;
 487     }
 488
 489   return num_printed;
 490 }
 491
 492 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 493
 494 static Elf_Internal_Shdr *
 495 find_section (const char * name)
 496 {
 497   unsigned int i;
 498
 499   for (i = 0; i < elf_header.e_shnum; i++)
 500     if (streq (SECTION_NAME (section_headers + i), name))
 501       return section_headers + i;
 502
 503   return NULL;
 504 }
 505
 506 /* Return a pointer to a section containing ADDR, or NULL if no such
 507    section exists.  */
 508
 509 static Elf_Internal_Shdr *
 510 find_section_by_address (bfd_vma addr)
 511 {
 512   unsigned int i;
 513
 514   for (i = 0; i < elf_header.e_shnum; i++)
 515     {
 516       Elf_Internal_Shdr *sec = section_headers + i;
 517       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 518         return sec;
 519     }
 520
 521   return NULL;
 522 }
 523
 524 /* Return a pointer to section NAME, or NULL if no such section exists,
 525    restricted to the list of sections given in SET.  */
 526
 527 static Elf_Internal_Shdr *
 528 find_section_in_set (const char * name, unsigned int * set)
 529 {
 530   unsigned int i;
 531
 532   if (set != NULL)
 533     {
 534       while ((i = *set++) > 0)
 535         if (streq (SECTION_NAME (section_headers + i), name))
 536           return section_headers + i;
 537     }
 538
 539   return find_section (name);
 540 }
 541
 542 /* Read an unsigned LEB128 encoded value from p.  Set *PLEN to the number of
 543    bytes read.  */
 544
 545 static inline unsigned long
 546 read_uleb128 (unsigned char *data,
 547               unsigned int *length_return,
 548               const unsigned char * const end)
 549 {
 550   return read_leb128 (data, length_return, FALSE, end);
 551 }
 552
 553 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
 554    This OS has so many departures from the ELF standard that we test it at
 555    many places.  */
 556
 557 static inline int
 558 is_ia64_vms (void)
 559 {
 560   return elf_header.e_machine == EM_IA_64
 561     && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 562 }
 563
 564 /* Guess the relocation size commonly used by the specific machines.  */
 565
 566 static int
 567 guess_is_rela (unsigned int e_machine)
 568 {
 569   switch (e_machine)
 570     {
 571       /* Targets that use REL relocations.  */
 572     case EM_386:
 573     case EM_486:
 574     case EM_960:
 575     case EM_ARM:
 576     case EM_D10V:
 577     case EM_CYGNUS_D10V:
 578     case EM_DLX:
 579     case EM_MIPS:
 580     case EM_MIPS_RS3_LE:
 581     case EM_CYGNUS_M32R:
 582     case EM_OPENRISC:
 583     case EM_OR32:
 584     case EM_SCORE:
 585     case EM_XGATE:
 586       return FALSE;
 587
 588       /* Targets that use RELA relocations.  */
 589     case EM_68K:
 590     case EM_860:
 591     case EM_AARCH64:
 592     case EM_ADAPTEVA_EPIPHANY:
 593     case EM_ALPHA:
 594     case EM_ALTERA_NIOS2:
 595     case EM_AVR:
 596     case EM_AVR_OLD:
 597     case EM_BLACKFIN:
 598     case EM_CR16:
 599     case EM_CRIS:
 600     case EM_CRX:
 601     case EM_D30V:
 602     case EM_CYGNUS_D30V:
 603     case EM_FR30:
 604     case EM_CYGNUS_FR30:
 605     case EM_CYGNUS_FRV:
 606     case EM_H8S:
 607     case EM_H8_300:
 608     case EM_H8_300H:
 609     case EM_IA_64:
 610     case EM_IP2K:
 611     case EM_IP2K_OLD:
 612     case EM_IQ2000:
 613     case EM_LATTICEMICO32:
 614     case EM_M32C_OLD:
 615     case EM_M32C:
 616     case EM_M32R:
 617     case EM_MCORE:
 618     case EM_CYGNUS_MEP:
 619     case EM_METAG:
 620     case EM_MMIX:
 621     case EM_MN10200:
 622     case EM_CYGNUS_MN10200:
 623     case EM_MN10300:
 624     case EM_CYGNUS_MN10300:
 625     case EM_MOXIE:
 626     case EM_MSP430:
 627     case EM_MSP430_OLD:
 628     case EM_MT:
 629     case EM_NIOS32:
 630     case EM_PPC64:
 631     case EM_PPC:
 632     case EM_RL78:
 633     case EM_RX:
 634     case EM_S390:
 635     case EM_S390_OLD:
 636     case EM_SH:
 637     case EM_SPARC:
 638     case EM_SPARC32PLUS:
 639     case EM_SPARCV9:
 640     case EM_SPU:
 641     case EM_TI_C6000:
 642     case EM_TILEGX:
 643     case EM_TILEPRO:
 644     case EM_V800:
 645     case EM_V850:
 646     case EM_CYGNUS_V850:
 647     case EM_VAX:
 648     case EM_X86_64:
 649     case EM_L1OM:
 650     case EM_K1OM:
 651     case EM_XSTORMY16:
 652     case EM_XTENSA:
 653     case EM_XTENSA_OLD:
 654     case EM_MICROBLAZE:
 655     case EM_MICROBLAZE_OLD:
 656       return TRUE;
 657
 658     case EM_68HC05:
 659     case EM_68HC08:
 660     case EM_68HC11:
 661     case EM_68HC16:
 662     case EM_FX66:
 663     case EM_ME16:
 664     case EM_MMA:
 665     case EM_NCPU:
 666     case EM_NDR1:
 667     case EM_PCP:
 668     case EM_ST100:
 669     case EM_ST19:
 670     case EM_ST7:
 671     case EM_ST9PLUS:
 672     case EM_STARCORE:
 673     case EM_SVX:
 674     case EM_TINYJ:
 675     default:
 676       warn (_("Don't know about relocations on this machine architecture\n"));
 677       return FALSE;
 678     }
 679 }
 680
 681 static int
 682 slurp_rela_relocs (FILE * file,
 683                    unsigned long rel_offset,
 684                    unsigned long rel_size,
 685                    Elf_Internal_Rela ** relasp,
 686                    unsigned long * nrelasp)
 687 {
 688   Elf_Internal_Rela * relas;
 689   unsigned long nrelas;
 690   unsigned int i;
 691
 692   if (is_32bit_elf)
 693     {
 694       Elf32_External_Rela * erelas;
 695
 696       erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
 697                                                  rel_size, _("32-bit relocation data"));
 698       if (!erelas)
 699         return 0;
 700
 701       nrelas = rel_size / sizeof (Elf32_External_Rela);
 702
 703       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 704                                              sizeof (Elf_Internal_Rela));
 705
 706       if (relas == NULL)
 707         {
 708           free (erelas);
 709           error (_("out of memory parsing relocs\n"));
 710           return 0;
 711         }
 712
 713       for (i = 0; i < nrelas; i++)
 714         {
 715           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 716           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 717           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 718         }
 719
 720       free (erelas);
 721     }
 722   else
 723     {
 724       Elf64_External_Rela * erelas;
 725
 726       erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
 727                                                  rel_size, _("64-bit relocation data"));
 728       if (!erelas)
 729         return 0;
 730
 731       nrelas = rel_size / sizeof (Elf64_External_Rela);
 732
 733       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 734                                              sizeof (Elf_Internal_Rela));
 735
 736       if (relas == NULL)
 737         {
 738           free (erelas);
 739           error (_("out of memory parsing relocs\n"));
 740           return 0;
 741         }
 742
 743       for (i = 0; i < nrelas; i++)
 744         {
 745           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 746           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 747           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 748
 749           /* The #ifdef BFD64 below is to prevent a compile time
 750              warning.  We know that if we do not have a 64 bit data
 751              type that we will never execute this code anyway.  */
 752 #ifdef BFD64
 753           if (elf_header.e_machine == EM_MIPS
 754               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 755             {
 756               /* In little-endian objects, r_info isn't really a
 757                  64-bit little-endian value: it has a 32-bit
 758                  little-endian symbol index followed by four
 759                  individual byte fields.  Reorder INFO
 760                  accordingly.  */
 761               bfd_vma inf = relas[i].r_info;
 762               inf = (((inf & 0xffffffff) << 32)
 763                       | ((inf >> 56) & 0xff)
 764                       | ((inf >> 40) & 0xff00)
 765                       | ((inf >> 24) & 0xff0000)
 766                       | ((inf >> 8) & 0xff000000));
 767               relas[i].r_info = inf;
 768             }
 769 #endif /* BFD64 */
 770         }
 771
 772       free (erelas);
 773     }
 774   *relasp = relas;
 775   *nrelasp = nrelas;
 776   return 1;
 777 }
 778
 779 static int
 780 slurp_rel_relocs (FILE * file,
 781                   unsigned long rel_offset,
 782                   unsigned long rel_size,
 783                   Elf_Internal_Rela ** relsp,
 784                   unsigned long * nrelsp)
 785 {
 786   Elf_Internal_Rela * rels;
 787   unsigned long nrels;
 788   unsigned int i;
 789
 790   if (is_32bit_elf)
 791     {
 792       Elf32_External_Rel * erels;
 793
 794       erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
 795                                                rel_size, _("32-bit relocation data"));
 796       if (!erels)
 797         return 0;
 798
 799       nrels = rel_size / sizeof (Elf32_External_Rel);
 800
 801       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 802
 803       if (rels == NULL)
 804         {
 805           free (erels);
 806           error (_("out of memory parsing relocs\n"));
 807           return 0;
 808         }
 809
 810       for (i = 0; i < nrels; i++)
 811         {
 812           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 813           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 814           rels[i].r_addend = 0;
 815         }
 816
 817       free (erels);
 818     }
 819   else
 820     {
 821       Elf64_External_Rel * erels;
 822
 823       erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
 824                                                rel_size, _("64-bit relocation data"));
 825       if (!erels)
 826         return 0;
 827
 828       nrels = rel_size / sizeof (Elf64_External_Rel);
 829
 830       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 831
 832       if (rels == NULL)
 833         {
 834           free (erels);
 835           error (_("out of memory parsing relocs\n"));
 836           return 0;
 837         }
 838
 839       for (i = 0; i < nrels; i++)
 840         {
 841           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 842           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 843           rels[i].r_addend = 0;
 844
 845           /* The #ifdef BFD64 below is to prevent a compile time
 846              warning.  We know that if we do not have a 64 bit data
 847              type that we will never execute this code anyway.  */
 848 #ifdef BFD64
 849           if (elf_header.e_machine == EM_MIPS
 850               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 851             {
 852               /* In little-endian objects, r_info isn't really a
 853                  64-bit little-endian value: it has a 32-bit
 854                  little-endian symbol index followed by four
 855                  individual byte fields.  Reorder INFO
 856                  accordingly.  */
 857               bfd_vma inf = rels[i].r_info;
 858               inf = (((inf & 0xffffffff) << 32)
 859                      | ((inf >> 56) & 0xff)
 860                      | ((inf >> 40) & 0xff00)
 861                      | ((inf >> 24) & 0xff0000)
 862                      | ((inf >> 8) & 0xff000000));
 863               rels[i].r_info = inf;
 864             }
 865 #endif /* BFD64 */
 866         }
 867
 868       free (erels);
 869     }
 870   *relsp = rels;
 871   *nrelsp = nrels;
 872   return 1;
 873 }
 874
 875 /* Returns the reloc type extracted from the reloc info field.  */
 876
 877 static unsigned int
 878 get_reloc_type (bfd_vma reloc_info)
 879 {
 880   if (is_32bit_elf)
 881     return ELF32_R_TYPE (reloc_info);
 882
 883   switch (elf_header.e_machine)
 884     {
 885     case EM_MIPS:
 886       /* Note: We assume that reloc_info has already been adjusted for us.  */
 887       return ELF64_MIPS_R_TYPE (reloc_info);
 888
 889     case EM_SPARCV9:
 890       return ELF64_R_TYPE_ID (reloc_info);
 891
 892     default:
 893       return ELF64_R_TYPE (reloc_info);
 894     }
 895 }
 896
 897 /* Return the symbol index extracted from the reloc info field.  */
 898
 899 static bfd_vma
 900 get_reloc_symindex (bfd_vma reloc_info)
 901 {
 902   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
 903 }
 904
 905 static inline bfd_boolean
 906 uses_msp430x_relocs (void)
 907 {
 908   return
 909     elf_header.e_machine == EM_MSP430 /* Paranoia.  */
 910     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
 911     && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
 912         /* TI compiler uses ELFOSABI_NONE.  */
 913         || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
 914 }
 915
 916 /* Display the contents of the relocation data found at the specified
 917    offset.  */
 918
 919 static void
 920 dump_relocations (FILE * file,
 921                   unsigned long rel_offset,
 922                   unsigned long rel_size,
 923                   Elf_Internal_Sym * symtab,
 924                   unsigned long nsyms,
 925                   char * strtab,
 926                   unsigned long strtablen,
 927                   int is_rela)
 928 {
 929   unsigned int i;
 930   Elf_Internal_Rela * rels;
 931
 932   if (is_rela == UNKNOWN)
 933     is_rela = guess_is_rela (elf_header.e_machine);
 934
 935   if (is_rela)
 936     {
 937       if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
 938         return;
 939     }
 940   else
 941     {
 942       if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
 943         return;
 944     }
 945
 946   if (is_32bit_elf)
 947     {
 948       if (is_rela)
 949         {
 950           if (do_wide)
 951             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
 952           else
 953             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
 954         }
 955       else
 956         {
 957           if (do_wide)
 958             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
 959           else
 960             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
 961         }
 962     }
 963   else
 964     {
 965       if (is_rela)
 966         {
 967           if (do_wide)
 968             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
 969           else
 970             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
 971         }
 972       else
 973         {
 974           if (do_wide)
 975             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
 976           else
 977             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
 978         }
 979     }
 980
 981   for (i = 0; i < rel_size; i++)
 982     {
 983       const char * rtype;
 984       bfd_vma offset;
 985       bfd_vma inf;
 986       bfd_vma symtab_index;
 987       bfd_vma type;
 988
 989       offset = rels[i].r_offset;
 990       inf    = rels[i].r_info;
 991
 992       type = get_reloc_type (inf);
 993       symtab_index = get_reloc_symindex  (inf);
 994
 995       if (is_32bit_elf)
 996         {
 997           printf ("%8.8lx  %8.8lx ",
 998                   (unsigned long) offset & 0xffffffff,
 999                   (unsigned long) inf & 0xffffffff);
1000         }
1001       else
1002         {
1003 #if BFD_HOST_64BIT_LONG
1004           printf (do_wide
1005                   ? "%16.16lx  %16.16lx "
1006                   : "%12.12lx  %12.12lx ",
1007                   offset, inf);
1008 #elif BFD_HOST_64BIT_LONG_LONG
1009 #ifndef __MSVCRT__
1010           printf (do_wide
1011                   ? "%16.16llx  %16.16llx "
1012                   : "%12.12llx  %12.12llx ",
1013                   offset, inf);
1014 #else
1015           printf (do_wide
1016                   ? "%16.16I64x  %16.16I64x "
1017                   : "%12.12I64x  %12.12I64x ",
1018                   offset, inf);
1019 #endif
1020 #else
1021           printf (do_wide
1022                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1023                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1024                   _bfd_int64_high (offset),
1025                   _bfd_int64_low (offset),
1026                   _bfd_int64_high (inf),
1027                   _bfd_int64_low (inf));
1028 #endif
1029         }
1030
1031       switch (elf_header.e_machine)
1032         {
1033         default:
1034           rtype = NULL;
1035           break;
1036
1037         case EM_AARCH64:
1038           rtype = elf_aarch64_reloc_type (type);
1039           break;
1040
1041         case EM_M32R:
1042         case EM_CYGNUS_M32R:
1043           rtype = elf_m32r_reloc_type (type);
1044           break;
1045
1046         case EM_386:
1047         case EM_486:
1048           rtype = elf_i386_reloc_type (type);
1049           break;
1050
1051         case EM_68HC11:
1052         case EM_68HC12:
1053           rtype = elf_m68hc11_reloc_type (type);
1054           break;
1055
1056         case EM_68K:
1057           rtype = elf_m68k_reloc_type (type);
1058           break;
1059
1060         case EM_960:
1061           rtype = elf_i960_reloc_type (type);
1062           break;
1063
1064         case EM_AVR:
1065         case EM_AVR_OLD:
1066           rtype = elf_avr_reloc_type (type);
1067           break;
1068
1069         case EM_OLD_SPARCV9:
1070         case EM_SPARC32PLUS:
1071         case EM_SPARCV9:
1072         case EM_SPARC:
1073           rtype = elf_sparc_reloc_type (type);
1074           break;
1075
1076         case EM_SPU:
1077           rtype = elf_spu_reloc_type (type);
1078           break;
1079
1080         case EM_V800:
1081           rtype = v800_reloc_type (type);
1082           break;
1083         case EM_V850:
1084         case EM_CYGNUS_V850:
1085           rtype = v850_reloc_type (type);
1086           break;
1087
1088         case EM_D10V:
1089         case EM_CYGNUS_D10V:
1090           rtype = elf_d10v_reloc_type (type);
1091           break;
1092
1093         case EM_D30V:
1094         case EM_CYGNUS_D30V:
1095           rtype = elf_d30v_reloc_type (type);
1096           break;
1097
1098         case EM_DLX:
1099           rtype = elf_dlx_reloc_type (type);
1100           break;
1101
1102         case EM_SH:
1103           rtype = elf_sh_reloc_type (type);
1104           break;
1105
1106         case EM_MN10300:
1107         case EM_CYGNUS_MN10300:
1108           rtype = elf_mn10300_reloc_type (type);
1109           break;
1110
1111         case EM_MN10200:
1112         case EM_CYGNUS_MN10200:
1113           rtype = elf_mn10200_reloc_type (type);
1114           break;
1115
1116         case EM_FR30:
1117         case EM_CYGNUS_FR30:
1118           rtype = elf_fr30_reloc_type (type);
1119           break;
1120
1121         case EM_CYGNUS_FRV:
1122           rtype = elf_frv_reloc_type (type);
1123           break;
1124
1125         case EM_MCORE:
1126           rtype = elf_mcore_reloc_type (type);
1127           break;
1128
1129         case EM_MMIX:
1130           rtype = elf_mmix_reloc_type (type);
1131           break;
1132
1133         case EM_MOXIE:
1134           rtype = elf_moxie_reloc_type (type);
1135           break;
1136
1137         case EM_MSP430:
1138           if (uses_msp430x_relocs ())
1139             {
1140               rtype = elf_msp430x_reloc_type (type);
1141               break;
1142             }
1143         case EM_MSP430_OLD:
1144           rtype = elf_msp430_reloc_type (type);
1145           break;
1146
1147         case EM_PPC:
1148           rtype = elf_ppc_reloc_type (type);
1149           break;
1150
1151         case EM_PPC64:
1152           rtype = elf_ppc64_reloc_type (type);
1153           break;
1154
1155         case EM_MIPS:
1156         case EM_MIPS_RS3_LE:
1157           rtype = elf_mips_reloc_type (type);
1158           break;
1159
1160         case EM_ALPHA:
1161           rtype = elf_alpha_reloc_type (type);
1162           break;
1163
1164         case EM_ARM:
1165           rtype = elf_arm_reloc_type (type);
1166           break;
1167
1168         case EM_ARC:
1169           rtype = elf_arc_reloc_type (type);
1170           break;
1171
1172         case EM_PARISC:
1173           rtype = elf_hppa_reloc_type (type);
1174           break;
1175
1176         case EM_H8_300:
1177         case EM_H8_300H:
1178         case EM_H8S:
1179           rtype = elf_h8_reloc_type (type);
1180           break;
1181
1182         case EM_OPENRISC:
1183         case EM_OR32:
1184           rtype = elf_or32_reloc_type (type);
1185           break;
1186
1187         case EM_PJ:
1188         case EM_PJ_OLD:
1189           rtype = elf_pj_reloc_type (type);
1190           break;
1191         case EM_IA_64:
1192           rtype = elf_ia64_reloc_type (type);
1193           break;
1194
1195         case EM_CRIS:
1196           rtype = elf_cris_reloc_type (type);
1197           break;
1198
1199         case EM_860:
1200           rtype = elf_i860_reloc_type (type);
1201           break;
1202
1203         case EM_X86_64:
1204         case EM_L1OM:
1205         case EM_K1OM:
1206           rtype = elf_x86_64_reloc_type (type);
1207           break;
1208
1209         case EM_S370:
1210           rtype = i370_reloc_type (type);
1211           break;
1212
1213         case EM_S390_OLD:
1214         case EM_S390:
1215           rtype = elf_s390_reloc_type (type);
1216           break;
1217
1218         case EM_SCORE:
1219           rtype = elf_score_reloc_type (type);
1220           break;
1221
1222         case EM_XSTORMY16:
1223           rtype = elf_xstormy16_reloc_type (type);
1224           break;
1225
1226         case EM_CRX:
1227           rtype = elf_crx_reloc_type (type);
1228           break;
1229
1230         case EM_VAX:
1231           rtype = elf_vax_reloc_type (type);
1232           break;
1233
1234         case EM_ADAPTEVA_EPIPHANY:
1235           rtype = elf_epiphany_reloc_type (type);
1236           break;
1237
1238         case EM_IP2K:
1239         case EM_IP2K_OLD:
1240           rtype = elf_ip2k_reloc_type (type);
1241           break;
1242
1243         case EM_IQ2000:
1244           rtype = elf_iq2000_reloc_type (type);
1245           break;
1246
1247         case EM_XTENSA_OLD:
1248         case EM_XTENSA:
1249           rtype = elf_xtensa_reloc_type (type);
1250           break;
1251
1252         case EM_LATTICEMICO32:
1253           rtype = elf_lm32_reloc_type (type);
1254           break;
1255
1256         case EM_M32C_OLD:
1257         case EM_M32C:
1258           rtype = elf_m32c_reloc_type (type);
1259           break;
1260
1261         case EM_MT:
1262           rtype = elf_mt_reloc_type (type);
1263           break;
1264
1265         case EM_BLACKFIN:
1266           rtype = elf_bfin_reloc_type (type);
1267           break;
1268
1269         case EM_CYGNUS_MEP:
1270           rtype = elf_mep_reloc_type (type);
1271           break;
1272
1273         case EM_CR16:
1274           rtype = elf_cr16_reloc_type (type);
1275           break;
1276
1277         case EM_MICROBLAZE:
1278         case EM_MICROBLAZE_OLD:
1279           rtype = elf_microblaze_reloc_type (type);
1280           break;
1281
1282         case EM_RL78:
1283           rtype = elf_rl78_reloc_type (type);
1284           break;
1285
1286         case EM_RX:
1287           rtype = elf_rx_reloc_type (type);
1288           break;
1289
1290         case EM_METAG:
1291           rtype = elf_metag_reloc_type (type);
1292           break;
1293
1294         case EM_XC16X:
1295         case EM_C166:
1296           rtype = elf_xc16x_reloc_type (type);
1297           break;
1298
1299         case EM_TI_C6000:
1300           rtype = elf_tic6x_reloc_type (type);
1301           break;
1302
1303         case EM_TILEGX:
1304           rtype = elf_tilegx_reloc_type (type);
1305           break;
1306
1307         case EM_TILEPRO:
1308           rtype = elf_tilepro_reloc_type (type);
1309           break;
1310
1311         case EM_XGATE:
1312           rtype = elf_xgate_reloc_type (type);
1313           break;
1314
1315         case EM_ALTERA_NIOS2:
1316           rtype = elf_nios2_reloc_type (type);
1317           break;
1318         }
1319
1320       if (rtype == NULL)
1321         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1322       else
1323         printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1324
1325       if (elf_header.e_machine == EM_ALPHA
1326           && rtype != NULL
1327           && streq (rtype, "R_ALPHA_LITUSE")
1328           && is_rela)
1329         {
1330           switch (rels[i].r_addend)
1331             {
1332             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1333             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1334             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1335             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1336             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1337             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1338             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1339             default: rtype = NULL;
1340             }
1341           if (rtype)
1342             printf (" (%s)", rtype);
1343           else
1344             {
1345               putchar (' ');
1346               printf (_("<unknown addend: %lx>"),
1347                       (unsigned long) rels[i].r_addend);
1348             }
1349         }
1350       else if (symtab_index)
1351         {
1352           if (symtab == NULL || symtab_index >= nsyms)
1353             printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1354           else
1355             {
1356               Elf_Internal_Sym * psym;
1357
1358               psym = symtab + symtab_index;
1359
1360               printf (" ");
1361
1362               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1363                 {
1364                   const char * name;
1365                   unsigned int len;
1366                   unsigned int width = is_32bit_elf ? 8 : 14;
1367
1368                   /* Relocations against GNU_IFUNC symbols do not use the value
1369                      of the symbol as the address to relocate against.  Instead
1370                      they invoke the function named by the symbol and use its
1371                      result as the address for relocation.
1372
1373                      To indicate this to the user, do not display the value of
1374                      the symbol in the "Symbols's Value" field.  Instead show
1375                      its name followed by () as a hint that the symbol is
1376                      invoked.  */
1377
1378                   if (strtab == NULL
1379                       || psym->st_name == 0
1380                       || psym->st_name >= strtablen)
1381                     name = "??";
1382                   else
1383                     name = strtab + psym->st_name;
1384
1385                   len = print_symbol (width, name);
1386                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1387                 }
1388               else
1389                 {
1390                   print_vma (psym->st_value, LONG_HEX);
1391
1392                   printf (is_32bit_elf ? "   " : " ");
1393                 }
1394
1395               if (psym->st_name == 0)
1396                 {
1397                   const char * sec_name = "<null>";
1398                   char name_buf[40];
1399
1400                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1401                     {
1402                       if (psym->st_shndx < elf_header.e_shnum)
1403                         sec_name
1404                           = SECTION_NAME (section_headers + psym->st_shndx);
1405                       else if (psym->st_shndx == SHN_ABS)
1406                         sec_name = "ABS";
1407                       else if (psym->st_shndx == SHN_COMMON)
1408                         sec_name = "COMMON";
1409                       else if ((elf_header.e_machine == EM_MIPS
1410                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1411                                || (elf_header.e_machine == EM_TI_C6000
1412                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1413                         sec_name = "SCOMMON";
1414                       else if (elf_header.e_machine == EM_MIPS
1415                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1416                         sec_name = "SUNDEF";
1417                       else if ((elf_header.e_machine == EM_X86_64
1418                                 || elf_header.e_machine == EM_L1OM
1419                                 || elf_header.e_machine == EM_K1OM)
1420                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1421                         sec_name = "LARGE_COMMON";
1422                       else if (elf_header.e_machine == EM_IA_64
1423                                && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1424                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1425                         sec_name = "ANSI_COM";
1426                       else if (is_ia64_vms ()
1427                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1428                         sec_name = "VMS_SYMVEC";
1429                       else
1430                         {
1431                           sprintf (name_buf, "<section 0x%x>",
1432                                    (unsigned int) psym->st_shndx);
1433                           sec_name = name_buf;
1434                         }
1435                     }
1436                   print_symbol (22, sec_name);
1437                 }
1438               else if (strtab == NULL)
1439                 printf (_("<string table index: %3ld>"), psym->st_name);
1440               else if (psym->st_name >= strtablen)
1441                 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1442               else
1443                 print_symbol (22, strtab + psym->st_name);
1444
1445               if (is_rela)
1446                 {
1447                   bfd_signed_vma off = rels[i].r_addend;
1448
1449                   if (off < 0)
1450                     printf (" - %" BFD_VMA_FMT "x", - off);
1451                   else
1452                     printf (" + %" BFD_VMA_FMT "x", off);
1453                 }
1454             }
1455         }
1456       else if (is_rela)
1457         {
1458           bfd_signed_vma off = rels[i].r_addend;
1459
1460           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1461           if (off < 0)
1462             printf ("-%" BFD_VMA_FMT "x", - off);
1463           else
1464             printf ("%" BFD_VMA_FMT "x", off);
1465         }
1466
1467       if (elf_header.e_machine == EM_SPARCV9
1468           && rtype != NULL
1469           && streq (rtype, "R_SPARC_OLO10"))
1470         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1471
1472       putchar ('\n');
1473
1474 #ifdef BFD64
1475       if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1476         {
1477           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1478           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1479           const char * rtype2 = elf_mips_reloc_type (type2);
1480           const char * rtype3 = elf_mips_reloc_type (type3);
1481
1482           printf ("                    Type2: ");
1483
1484           if (rtype2 == NULL)
1485             printf (_("unrecognized: %-7lx"),
1486                     (unsigned long) type2 & 0xffffffff);
1487           else
1488             printf ("%-17.17s", rtype2);
1489
1490           printf ("\n                    Type3: ");
1491
1492           if (rtype3 == NULL)
1493             printf (_("unrecognized: %-7lx"),
1494                     (unsigned long) type3 & 0xffffffff);
1495           else
1496             printf ("%-17.17s", rtype3);
1497
1498           putchar ('\n');
1499         }
1500 #endif /* BFD64 */
1501     }
1502
1503   free (rels);
1504 }
1505
1506 static const char *
1507 get_mips_dynamic_type (unsigned long type)
1508 {
1509   switch (type)
1510     {
1511     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1512     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1513     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1514     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1515     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1516     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1517     case DT_MIPS_MSYM: return "MIPS_MSYM";
1518     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1519     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1520     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1521     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1522     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1523     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1524     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1525     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1526     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1527     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1528     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1529     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1530     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1531     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1532     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1533     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1534     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1535     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1536     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1537     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1538     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1539     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1540     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1541     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1542     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1543     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1544     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1545     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1546     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1547     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1548     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1549     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1550     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1551     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1552     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1553     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1554     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1555     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1556     default:
1557       return NULL;
1558     }
1559 }
1560
1561 static const char *
1562 get_sparc64_dynamic_type (unsigned long type)
1563 {
1564   switch (type)
1565     {
1566     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1567     default:
1568       return NULL;
1569     }
1570 }
1571
1572 static const char *
1573 get_ppc_dynamic_type (unsigned long type)
1574 {
1575   switch (type)
1576     {
1577     case DT_PPC_GOT:    return "PPC_GOT";
1578     case DT_PPC_TLSOPT: return "PPC_TLSOPT";
1579     default:
1580       return NULL;
1581     }
1582 }
1583
1584 static const char *
1585 get_ppc64_dynamic_type (unsigned long type)
1586 {
1587   switch (type)
1588     {
1589     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1590     case DT_PPC64_OPD:    return "PPC64_OPD";
1591     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1592     case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
1593     default:
1594       return NULL;
1595     }
1596 }
1597
1598 static const char *
1599 get_parisc_dynamic_type (unsigned long type)
1600 {
1601   switch (type)
1602     {
1603     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1604     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1605     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1606     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1607     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1608     case DT_HP_PREINIT:         return "HP_PREINIT";
1609     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1610     case DT_HP_NEEDED:          return "HP_NEEDED";
1611     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1612     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1613     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1614     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1615     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1616     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1617     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1618     case DT_HP_FILTERED:        return "HP_FILTERED";
1619     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1620     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1621     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1622     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1623     case DT_PLT:                return "PLT";
1624     case DT_PLT_SIZE:           return "PLT_SIZE";
1625     case DT_DLT:                return "DLT";
1626     case DT_DLT_SIZE:           return "DLT_SIZE";
1627     default:
1628       return NULL;
1629     }
1630 }
1631
1632 static const char *
1633 get_ia64_dynamic_type (unsigned long type)
1634 {
1635   switch (type)
1636     {
1637     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1638     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1639     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1640     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1641     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1642     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1643     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1644     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1645     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1646     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1647     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1648     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1649     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1650     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1651     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1652     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1653     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1654     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1655     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1656     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1657     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1658     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1659     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1660     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1661     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1662     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1663     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1664     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1665     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1666     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1667     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1668     default:
1669       return NULL;
1670     }
1671 }
1672
1673 static const char *
1674 get_alpha_dynamic_type (unsigned long type)
1675 {
1676   switch (type)
1677     {
1678     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1679     default:
1680       return NULL;
1681     }
1682 }
1683
1684 static const char *
1685 get_score_dynamic_type (unsigned long type)
1686 {
1687   switch (type)
1688     {
1689     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1690     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1691     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1692     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1693     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1694     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1695     default:
1696       return NULL;
1697     }
1698 }
1699
1700 static const char *
1701 get_tic6x_dynamic_type (unsigned long type)
1702 {
1703   switch (type)
1704     {
1705     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1706     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1707     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
1708     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
1709     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
1710     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
1711     default:
1712       return NULL;
1713     }
1714 }
1715
1716 static const char *
1717 get_nios2_dynamic_type (unsigned long type)
1718 {
1719   switch (type)
1720     {
1721     case DT_NIOS2_GP: return "NIOS2_GP";
1722     default:
1723       return NULL;
1724     }
1725 }
1726
1727 static const char *
1728 get_dynamic_type (unsigned long type)
1729 {
1730   static char buff[64];
1731
1732   switch (type)
1733     {
1734     case DT_NULL:       return "NULL";
1735     case DT_NEEDED:     return "NEEDED";
1736     case DT_PLTRELSZ:   return "PLTRELSZ";
1737     case DT_PLTGOT:     return "PLTGOT";
1738     case DT_HASH:       return "HASH";
1739     case DT_STRTAB:     return "STRTAB";
1740     case DT_SYMTAB:     return "SYMTAB";
1741     case DT_RELA:       return "RELA";
1742     case DT_RELASZ:     return "RELASZ";
1743     case DT_RELAENT:    return "RELAENT";
1744     case DT_STRSZ:      return "STRSZ";
1745     case DT_SYMENT:     return "SYMENT";
1746     case DT_INIT:       return "INIT";
1747     case DT_FINI:       return "FINI";
1748     case DT_SONAME:     return "SONAME";
1749     case DT_RPATH:      return "RPATH";
1750     case DT_SYMBOLIC:   return "SYMBOLIC";
1751     case DT_REL:        return "REL";
1752     case DT_RELSZ:      return "RELSZ";
1753     case DT_RELENT:     return "RELENT";
1754     case DT_PLTREL:     return "PLTREL";
1755     case DT_DEBUG:      return "DEBUG";
1756     case DT_TEXTREL:    return "TEXTREL";
1757     case DT_JMPREL:     return "JMPREL";
1758     case DT_BIND_NOW:   return "BIND_NOW";
1759     case DT_INIT_ARRAY: return "INIT_ARRAY";
1760     case DT_FINI_ARRAY: return "FINI_ARRAY";
1761     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1762     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1763     case DT_RUNPATH:    return "RUNPATH";
1764     case DT_FLAGS:      return "FLAGS";
1765
1766     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1767     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1768
1769     case DT_CHECKSUM:   return "CHECKSUM";
1770     case DT_PLTPADSZ:   return "PLTPADSZ";
1771     case DT_MOVEENT:    return "MOVEENT";
1772     case DT_MOVESZ:     return "MOVESZ";
1773     case DT_FEATURE:    return "FEATURE";
1774     case DT_POSFLAG_1:  return "POSFLAG_1";
1775     case DT_SYMINSZ:    return "SYMINSZ";
1776     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
1777
1778     case DT_ADDRRNGLO:  return "ADDRRNGLO";
1779     case DT_CONFIG:     return "CONFIG";
1780     case DT_DEPAUDIT:   return "DEPAUDIT";
1781     case DT_AUDIT:      return "AUDIT";
1782     case DT_PLTPAD:     return "PLTPAD";
1783     case DT_MOVETAB:    return "MOVETAB";
1784     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
1785
1786     case DT_VERSYM:     return "VERSYM";
1787
1788     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1789     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1790     case DT_RELACOUNT:  return "RELACOUNT";
1791     case DT_RELCOUNT:   return "RELCOUNT";
1792     case DT_FLAGS_1:    return "FLAGS_1";
1793     case DT_VERDEF:     return "VERDEF";
1794     case DT_VERDEFNUM:  return "VERDEFNUM";
1795     case DT_VERNEED:    return "VERNEED";
1796     case DT_VERNEEDNUM: return "VERNEEDNUM";
1797
1798     case DT_AUXILIARY:  return "AUXILIARY";
1799     case DT_USED:       return "USED";
1800     case DT_FILTER:     return "FILTER";
1801
1802     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1803     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1804     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1805     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1806     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1807     case DT_GNU_HASH:   return "GNU_HASH";
1808
1809     default:
1810       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1811         {
1812           const char * result;
1813
1814           switch (elf_header.e_machine)
1815             {
1816             case EM_MIPS:
1817             case EM_MIPS_RS3_LE:
1818               result = get_mips_dynamic_type (type);
1819               break;
1820             case EM_SPARCV9:
1821               result = get_sparc64_dynamic_type (type);
1822               break;
1823             case EM_PPC:
1824               result = get_ppc_dynamic_type (type);
1825               break;
1826             case EM_PPC64:
1827               result = get_ppc64_dynamic_type (type);
1828               break;
1829             case EM_IA_64:
1830               result = get_ia64_dynamic_type (type);
1831               break;
1832             case EM_ALPHA:
1833               result = get_alpha_dynamic_type (type);
1834               break;
1835             case EM_SCORE:
1836               result = get_score_dynamic_type (type);
1837               break;
1838             case EM_TI_C6000:
1839               result = get_tic6x_dynamic_type (type);
1840               break;
1841             case EM_ALTERA_NIOS2:
1842               result = get_nios2_dynamic_type (type);
1843               break;
1844             default:
1845               result = NULL;
1846               break;
1847             }
1848
1849           if (result != NULL)
1850             return result;
1851
1852           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1853         }
1854       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1855                || (elf_header.e_machine == EM_PARISC
1856                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1857         {
1858           const char * result;
1859
1860           switch (elf_header.e_machine)
1861             {
1862             case EM_PARISC:
1863               result = get_parisc_dynamic_type (type);
1864               break;
1865             case EM_IA_64:
1866               result = get_ia64_dynamic_type (type);
1867               break;
1868             default:
1869               result = NULL;
1870               break;
1871             }
1872
1873           if (result != NULL)
1874             return result;
1875
1876           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1877                     type);
1878         }
1879       else
1880         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1881
1882       return buff;
1883     }
1884 }
1885
1886 static char *
1887 get_file_type (unsigned e_type)
1888 {
1889   static char buff[32];
1890
1891   switch (e_type)
1892     {
1893     case ET_NONE:       return _("NONE (None)");
1894     case ET_REL:        return _("REL (Relocatable file)");
1895     case ET_EXEC:       return _("EXEC (Executable file)");
1896     case ET_DYN:        return _("DYN (Shared object file)");
1897     case ET_CORE:       return _("CORE (Core file)");
1898
1899     default:
1900       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1901         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1902       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1903         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1904       else
1905         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1906       return buff;
1907     }
1908 }
1909
1910 static char *
1911 get_machine_name (unsigned e_machine)
1912 {
1913   static char buff[64]; /* XXX */
1914
1915   switch (e_machine)
1916     {
1917     case EM_NONE:               return _("None");
1918     case EM_AARCH64:            return "AArch64";
1919     case EM_M32:                return "WE32100";
1920     case EM_SPARC:              return "Sparc";
1921     case EM_SPU:                return "SPU";
1922     case EM_386:                return "Intel 80386";
1923     case EM_68K:                return "MC68000";
1924     case EM_88K:                return "MC88000";
1925     case EM_486:                return "Intel 80486";
1926     case EM_860:                return "Intel 80860";
1927     case EM_MIPS:               return "MIPS R3000";
1928     case EM_S370:               return "IBM System/370";
1929     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
1930     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
1931     case EM_PARISC:             return "HPPA";
1932     case EM_PPC_OLD:            return "Power PC (old)";
1933     case EM_SPARC32PLUS:        return "Sparc v8+" ;
1934     case EM_960:                return "Intel 90860";
1935     case EM_PPC:                return "PowerPC";
1936     case EM_PPC64:              return "PowerPC64";
1937     case EM_FR20:               return "Fujitsu FR20";
1938     case EM_RH32:               return "TRW RH32";
1939     case EM_MCORE:              return "MCORE";
1940     case EM_ARM:                return "ARM";
1941     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
1942     case EM_SH:                 return "Renesas / SuperH SH";
1943     case EM_SPARCV9:            return "Sparc v9";
1944     case EM_TRICORE:            return "Siemens Tricore";
1945     case EM_ARC:                return "ARC";
1946     case EM_H8_300:             return "Renesas H8/300";
1947     case EM_H8_300H:            return "Renesas H8/300H";
1948     case EM_H8S:                return "Renesas H8S";
1949     case EM_H8_500:             return "Renesas H8/500";
1950     case EM_IA_64:              return "Intel IA-64";
1951     case EM_MIPS_X:             return "Stanford MIPS-X";
1952     case EM_COLDFIRE:           return "Motorola Coldfire";
1953     case EM_ALPHA:              return "Alpha";
1954     case EM_CYGNUS_D10V:
1955     case EM_D10V:               return "d10v";
1956     case EM_CYGNUS_D30V:
1957     case EM_D30V:               return "d30v";
1958     case EM_CYGNUS_M32R:
1959     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
1960     case EM_CYGNUS_V850:
1961     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
1962     case EM_V850:               return "Renesas V850";
1963     case EM_CYGNUS_MN10300:
1964     case EM_MN10300:            return "mn10300";
1965     case EM_CYGNUS_MN10200:
1966     case EM_MN10200:            return "mn10200";
1967     case EM_MOXIE:              return "Moxie";
1968     case EM_CYGNUS_FR30:
1969     case EM_FR30:               return "Fujitsu FR30";
1970     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
1971     case EM_PJ_OLD:
1972     case EM_PJ:                 return "picoJava";
1973     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
1974     case EM_PCP:                return "Siemens PCP";
1975     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
1976     case EM_NDR1:               return "Denso NDR1 microprocesspr";
1977     case EM_STARCORE:           return "Motorola Star*Core processor";
1978     case EM_ME16:               return "Toyota ME16 processor";
1979     case EM_ST100:              return "STMicroelectronics ST100 processor";
1980     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
1981     case EM_PDSP:               return "Sony DSP processor";
1982     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
1983     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
1984     case EM_FX66:               return "Siemens FX66 microcontroller";
1985     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1986     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
1987     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
1988     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
1989     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
1990     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
1991     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
1992     case EM_SVX:                return "Silicon Graphics SVx";
1993     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
1994     case EM_VAX:                return "Digital VAX";
1995     case EM_AVR_OLD:
1996     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
1997     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
1998     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
1999     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2000     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2001     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2002     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2003     case EM_PRISM:              return "Vitesse Prism";
2004     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2005     case EM_L1OM:               return "Intel L1OM";
2006     case EM_K1OM:               return "Intel K1OM";
2007     case EM_S390_OLD:
2008     case EM_S390:               return "IBM S/390";
2009     case EM_SCORE:              return "SUNPLUS S+Core";
2010     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2011     case EM_OPENRISC:
2012     case EM_OR32:               return "OpenRISC";
2013     case EM_ARC_A5:             return "ARC International ARCompact processor";
2014     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2015     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2016     case EM_DLX:                return "OpenDLX";
2017     case EM_IP2K_OLD:
2018     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2019     case EM_IQ2000:             return "Vitesse IQ2000";
2020     case EM_XTENSA_OLD:
2021     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2022     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2023     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2024     case EM_NS32K:              return "National Semiconductor 32000 series";
2025     case EM_TPC:                return "Tenor Network TPC processor";
2026     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2027     case EM_MAX:                return "MAX Processor";
2028     case EM_CR:                 return "National Semiconductor CompactRISC";
2029     case EM_F2MC16:             return "Fujitsu F2MC16";
2030     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2031     case EM_LATTICEMICO32:      return "Lattice Mico32";
2032     case EM_M32C_OLD:
2033     case EM_M32C:               return "Renesas M32c";
2034     case EM_MT:                 return "Morpho Techologies MT processor";
2035     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2036     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2037     case EM_SEP:                return "Sharp embedded microprocessor";
2038     case EM_ARCA:               return "Arca RISC microprocessor";
2039     case EM_UNICORE:            return "Unicore";
2040     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2041     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2042     case EM_NIOS32:             return "Altera Nios";
2043     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2044     case EM_C166:
2045     case EM_XC16X:              return "Infineon Technologies xc16x";
2046     case EM_M16C:               return "Renesas M16C series microprocessors";
2047     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2048     case EM_CE:                 return "Freescale Communication Engine RISC core";
2049     case EM_TSK3000:            return "Altium TSK3000 core";
2050     case EM_RS08:               return "Freescale RS08 embedded processor";
2051     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2052     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2053     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2054     case EM_SE_C17:             return "Seiko Epson C17 family";
2055     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2056     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2057     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2058     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2059     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2060     case EM_R32C:               return "Renesas R32C series microprocessors";
2061     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2062     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2063     case EM_8051:               return "Intel 8051 and variants";
2064     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2065     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2066     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2067     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2068     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2069     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2070     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2071     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2072     case EM_CR16:
2073     case EM_MICROBLAZE:
2074     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2075     case EM_RL78:               return "Renesas RL78";
2076     case EM_RX:                 return "Renesas RX";
2077     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2078     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2079     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2080     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2081     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2082     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor family";
2083     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2084     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2085     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2086     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2087     case EM_CUDA:               return "NVIDIA CUDA architecture";
2088     case EM_XGATE:              return "Motorola XGATE embedded processor";
2089     default:
2090       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2091       return buff;
2092     }
2093 }
2094
2095 static void
2096 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2097 {
2098   unsigned eabi;
2099   int unknown = 0;
2100
2101   eabi = EF_ARM_EABI_VERSION (e_flags);
2102   e_flags &= ~ EF_ARM_EABIMASK;
2103
2104   /* Handle "generic" ARM flags.  */
2105   if (e_flags & EF_ARM_RELEXEC)
2106     {
2107       strcat (buf, ", relocatable executable");
2108       e_flags &= ~ EF_ARM_RELEXEC;
2109     }
2110
2111   if (e_flags & EF_ARM_HASENTRY)
2112     {
2113       strcat (buf, ", has entry point");
2114       e_flags &= ~ EF_ARM_HASENTRY;
2115     }
2116
2117   /* Now handle EABI specific flags.  */
2118   switch (eabi)
2119     {
2120     default:
2121       strcat (buf, ", <unrecognized EABI>");
2122       if (e_flags)
2123         unknown = 1;
2124       break;
2125
2126     case EF_ARM_EABI_VER1:
2127       strcat (buf, ", Version1 EABI");
2128       while (e_flags)
2129         {
2130           unsigned flag;
2131
2132           /* Process flags one bit at a time.  */
2133           flag = e_flags & - e_flags;
2134           e_flags &= ~ flag;
2135
2136           switch (flag)
2137             {
2138             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2139               strcat (buf, ", sorted symbol tables");
2140               break;
2141
2142             default:
2143               unknown = 1;
2144               break;
2145             }
2146         }
2147       break;
2148
2149     case EF_ARM_EABI_VER2:
2150       strcat (buf, ", Version2 EABI");
2151       while (e_flags)
2152         {
2153           unsigned flag;
2154
2155           /* Process flags one bit at a time.  */
2156           flag = e_flags & - e_flags;
2157           e_flags &= ~ flag;
2158
2159           switch (flag)
2160             {
2161             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2162               strcat (buf, ", sorted symbol tables");
2163               break;
2164
2165             case EF_ARM_DYNSYMSUSESEGIDX:
2166               strcat (buf, ", dynamic symbols use segment index");
2167               break;
2168
2169             case EF_ARM_MAPSYMSFIRST:
2170               strcat (buf, ", mapping symbols precede others");
2171               break;
2172
2173             default:
2174               unknown = 1;
2175               break;
2176             }
2177         }
2178       break;
2179
2180     case EF_ARM_EABI_VER3:
2181       strcat (buf, ", Version3 EABI");
2182       break;
2183
2184     case EF_ARM_EABI_VER4:
2185       strcat (buf, ", Version4 EABI");
2186       while (e_flags)
2187         {
2188           unsigned flag;
2189
2190           /* Process flags one bit at a time.  */
2191           flag = e_flags & - e_flags;
2192           e_flags &= ~ flag;
2193
2194           switch (flag)
2195             {
2196             case EF_ARM_BE8:
2197               strcat (buf, ", BE8");
2198               break;
2199
2200             case EF_ARM_LE8:
2201               strcat (buf, ", LE8");
2202               break;
2203
2204             default:
2205               unknown = 1;
2206               break;
2207             }
2208       break;
2209         }
2210       break;
2211
2212     case EF_ARM_EABI_VER5:
2213       strcat (buf, ", Version5 EABI");
2214       while (e_flags)
2215         {
2216           unsigned flag;
2217
2218           /* Process flags one bit at a time.  */
2219           flag = e_flags & - e_flags;
2220           e_flags &= ~ flag;
2221
2222           switch (flag)
2223             {
2224             case EF_ARM_BE8:
2225               strcat (buf, ", BE8");
2226               break;
2227
2228             case EF_ARM_LE8:
2229               strcat (buf, ", LE8");
2230               break;
2231
2232             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2233               strcat (buf, ", soft-float ABI");
2234               break;
2235
2236             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2237               strcat (buf, ", hard-float ABI");
2238               break;
2239
2240             default:
2241               unknown = 1;
2242               break;
2243             }
2244         }
2245       break;
2246
2247     case EF_ARM_EABI_UNKNOWN:
2248       strcat (buf, ", GNU EABI");
2249       while (e_flags)
2250         {
2251           unsigned flag;
2252
2253           /* Process flags one bit at a time.  */
2254           flag = e_flags & - e_flags;
2255           e_flags &= ~ flag;
2256
2257           switch (flag)
2258             {
2259             case EF_ARM_INTERWORK:
2260               strcat (buf, ", interworking enabled");
2261               break;
2262
2263             case EF_ARM_APCS_26:
2264               strcat (buf, ", uses APCS/26");
2265               break;
2266
2267             case EF_ARM_APCS_FLOAT:
2268               strcat (buf, ", uses APCS/float");
2269               break;
2270
2271             case EF_ARM_PIC:
2272               strcat (buf, ", position independent");
2273               break;
2274
2275             case EF_ARM_ALIGN8:
2276               strcat (buf, ", 8 bit structure alignment");
2277               break;
2278
2279             case EF_ARM_NEW_ABI:
2280               strcat (buf, ", uses new ABI");
2281               break;
2282
2283             case EF_ARM_OLD_ABI:
2284               strcat (buf, ", uses old ABI");
2285               break;
2286
2287             case EF_ARM_SOFT_FLOAT:
2288               strcat (buf, ", software FP");
2289               break;
2290
2291             case EF_ARM_VFP_FLOAT:
2292               strcat (buf, ", VFP");
2293               break;
2294
2295             case EF_ARM_MAVERICK_FLOAT:
2296               strcat (buf, ", Maverick FP");
2297               break;
2298
2299             default:
2300               unknown = 1;
2301               break;
2302             }
2303         }
2304     }
2305
2306   if (unknown)
2307     strcat (buf,_(", <unknown>"));
2308 }
2309
2310 static char *
2311 get_machine_flags (unsigned e_flags, unsigned e_machine)
2312 {
2313   static char buf[1024];
2314
2315   buf[0] = '\0';
2316
2317   if (e_flags)
2318     {
2319       switch (e_machine)
2320         {
2321         default:
2322           break;
2323
2324         case EM_ARM:
2325           decode_ARM_machine_flags (e_flags, buf);
2326           break;
2327
2328         case EM_BLACKFIN:
2329           if (e_flags & EF_BFIN_PIC)
2330             strcat (buf, ", PIC");
2331
2332           if (e_flags & EF_BFIN_FDPIC)
2333             strcat (buf, ", FDPIC");
2334
2335           if (e_flags & EF_BFIN_CODE_IN_L1)
2336             strcat (buf, ", code in L1");
2337
2338           if (e_flags & EF_BFIN_DATA_IN_L1)
2339             strcat (buf, ", data in L1");
2340
2341           break;
2342
2343         case EM_CYGNUS_FRV:
2344           switch (e_flags & EF_FRV_CPU_MASK)
2345             {
2346             case EF_FRV_CPU_GENERIC:
2347               break;
2348
2349             default:
2350               strcat (buf, ", fr???");
2351               break;
2352
2353             case EF_FRV_CPU_FR300:
2354               strcat (buf, ", fr300");
2355               break;
2356
2357             case EF_FRV_CPU_FR400:
2358               strcat (buf, ", fr400");
2359               break;
2360             case EF_FRV_CPU_FR405:
2361               strcat (buf, ", fr405");
2362               break;
2363
2364             case EF_FRV_CPU_FR450:
2365               strcat (buf, ", fr450");
2366               break;
2367
2368             case EF_FRV_CPU_FR500:
2369               strcat (buf, ", fr500");
2370               break;
2371             case EF_FRV_CPU_FR550:
2372               strcat (buf, ", fr550");
2373               break;
2374
2375             case EF_FRV_CPU_SIMPLE:
2376               strcat (buf, ", simple");
2377               break;
2378             case EF_FRV_CPU_TOMCAT:
2379               strcat (buf, ", tomcat");
2380               break;
2381             }
2382           break;
2383
2384         case EM_68K:
2385           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2386             strcat (buf, ", m68000");
2387           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2388             strcat (buf, ", cpu32");
2389           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2390             strcat (buf, ", fido_a");
2391           else
2392             {
2393               char const * isa = _("unknown");
2394               char const * mac = _("unknown mac");
2395               char const * additional = NULL;
2396
2397               switch (e_flags & EF_M68K_CF_ISA_MASK)
2398                 {
2399                 case EF_M68K_CF_ISA_A_NODIV:
2400                   isa = "A";
2401                   additional = ", nodiv";
2402                   break;
2403                 case EF_M68K_CF_ISA_A:
2404                   isa = "A";
2405                   break;
2406                 case EF_M68K_CF_ISA_A_PLUS:
2407                   isa = "A+";
2408                   break;
2409                 case EF_M68K_CF_ISA_B_NOUSP:
2410                   isa = "B";
2411                   additional = ", nousp";
2412                   break;
2413                 case EF_M68K_CF_ISA_B:
2414                   isa = "B";
2415                   break;
2416                 case EF_M68K_CF_ISA_C:
2417                   isa = "C";
2418                   break;
2419                 case EF_M68K_CF_ISA_C_NODIV:
2420                   isa = "C";
2421                   additional = ", nodiv";
2422                   break;
2423                 }
2424               strcat (buf, ", cf, isa ");
2425               strcat (buf, isa);
2426               if (additional)
2427                 strcat (buf, additional);
2428               if (e_flags & EF_M68K_CF_FLOAT)
2429                 strcat (buf, ", float");
2430               switch (e_flags & EF_M68K_CF_MAC_MASK)
2431                 {
2432                 case 0:
2433                   mac = NULL;
2434                   break;
2435                 case EF_M68K_CF_MAC:
2436                   mac = "mac";
2437                   break;
2438                 case EF_M68K_CF_EMAC:
2439                   mac = "emac";
2440                   break;
2441                 case EF_M68K_CF_EMAC_B:
2442                   mac = "emac_b";
2443                   break;
2444                 }
2445               if (mac)
2446                 {
2447                   strcat (buf, ", ");
2448                   strcat (buf, mac);
2449                 }
2450             }
2451           break;
2452
2453         case EM_PPC:
2454           if (e_flags & EF_PPC_EMB)
2455             strcat (buf, ", emb");
2456
2457           if (e_flags & EF_PPC_RELOCATABLE)
2458             strcat (buf, _(", relocatable"));
2459
2460           if (e_flags & EF_PPC_RELOCATABLE_LIB)
2461             strcat (buf, _(", relocatable-lib"));
2462           break;
2463
2464         case EM_V800:
2465           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2466             strcat (buf, ", RH850 ABI");
2467
2468           if (e_flags & EF_V800_850E3)
2469             strcat (buf, ", V3 architecture");
2470
2471           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2472             strcat (buf, ", FPU not used");
2473
2474           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2475             strcat (buf, ", regmode: COMMON");
2476
2477           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2478             strcat (buf, ", r4 not used");
2479
2480           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2481             strcat (buf, ", r30 not used");
2482
2483           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2484             strcat (buf, ", r5 not used");
2485
2486           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2487             strcat (buf, ", r2 not used");
2488
2489           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2490             {
2491               switch (e_flags & - e_flags)
2492                 {
2493                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2494                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2495                 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2496                 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2497                 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2498                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2499                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2500                 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2501                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2502                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2503                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2504                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2505                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2506                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2507                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2508                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2509                 default: break;
2510                 }
2511             }
2512           break;
2513
2514         case EM_V850:
2515         case EM_CYGNUS_V850:
2516           switch (e_flags & EF_V850_ARCH)
2517             {
2518             case E_V850E3V5_ARCH:
2519               strcat (buf, ", v850e3v5");
2520               break;
2521             case E_V850E2V3_ARCH:
2522               strcat (buf, ", v850e2v3");
2523               break;
2524             case E_V850E2_ARCH:
2525               strcat (buf, ", v850e2");
2526               break;
2527             case E_V850E1_ARCH:
2528               strcat (buf, ", v850e1");
2529               break;
2530             case E_V850E_ARCH:
2531               strcat (buf, ", v850e");
2532               break;
2533             case E_V850_ARCH:
2534               strcat (buf, ", v850");
2535               break;
2536             default:
2537               strcat (buf, _(", unknown v850 architecture variant"));
2538               break;
2539             }
2540           break;
2541
2542         case EM_M32R:
2543         case EM_CYGNUS_M32R:
2544           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2545             strcat (buf, ", m32r");
2546           break;
2547
2548         case EM_MIPS:
2549         case EM_MIPS_RS3_LE:
2550           if (e_flags & EF_MIPS_NOREORDER)
2551             strcat (buf, ", noreorder");
2552
2553           if (e_flags & EF_MIPS_PIC)
2554             strcat (buf, ", pic");
2555
2556           if (e_flags & EF_MIPS_CPIC)
2557             strcat (buf, ", cpic");
2558
2559           if (e_flags & EF_MIPS_UCODE)
2560             strcat (buf, ", ugen_reserved");
2561
2562           if (e_flags & EF_MIPS_ABI2)
2563             strcat (buf, ", abi2");
2564
2565           if (e_flags & EF_MIPS_OPTIONS_FIRST)
2566             strcat (buf, ", odk first");
2567
2568           if (e_flags & EF_MIPS_32BITMODE)
2569             strcat (buf, ", 32bitmode");
2570
2571           if (e_flags & EF_MIPS_NAN2008)
2572             strcat (buf, ", nan2008");
2573
2574           switch ((e_flags & EF_MIPS_MACH))
2575             {
2576             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2577             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2578             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2579             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2580             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2581             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2582             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2583             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2584             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
2585             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2586             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2587             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2588             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
2589             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2590             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2591             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
2592             case 0:
2593             /* We simply ignore the field in this case to avoid confusion:
2594                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2595                extension.  */
2596               break;
2597             default: strcat (buf, _(", unknown CPU")); break;
2598             }
2599
2600           switch ((e_flags & EF_MIPS_ABI))
2601             {
2602             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2603             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2604             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2605             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2606             case 0:
2607             /* We simply ignore the field in this case to avoid confusion:
2608                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2609                This means it is likely to be an o32 file, but not for
2610                sure.  */
2611               break;
2612             default: strcat (buf, _(", unknown ABI")); break;
2613             }
2614
2615           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2616             strcat (buf, ", mdmx");
2617
2618           if (e_flags & EF_MIPS_ARCH_ASE_M16)
2619             strcat (buf, ", mips16");
2620
2621           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2622             strcat (buf, ", micromips");
2623
2624           switch ((e_flags & EF_MIPS_ARCH))
2625             {
2626             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2627             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2628             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2629             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2630             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2631             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2632             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2633             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2634             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2635             default: strcat (buf, _(", unknown ISA")); break;
2636             }
2637           break;
2638
2639         case EM_SH:
2640           switch ((e_flags & EF_SH_MACH_MASK))
2641             {
2642             case EF_SH1: strcat (buf, ", sh1"); break;
2643             case EF_SH2: strcat (buf, ", sh2"); break;
2644             case EF_SH3: strcat (buf, ", sh3"); break;
2645             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2646             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2647             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2648             case EF_SH3E: strcat (buf, ", sh3e"); break;
2649             case EF_SH4: strcat (buf, ", sh4"); break;
2650             case EF_SH5: strcat (buf, ", sh5"); break;
2651             case EF_SH2E: strcat (buf, ", sh2e"); break;
2652             case EF_SH4A: strcat (buf, ", sh4a"); break;
2653             case EF_SH2A: strcat (buf, ", sh2a"); break;
2654             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2655             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2656             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2657             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2658             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2659             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2660             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2661             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2662             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2663             default: strcat (buf, _(", unknown ISA")); break;
2664             }
2665
2666           if (e_flags & EF_SH_PIC)
2667             strcat (buf, ", pic");
2668
2669           if (e_flags & EF_SH_FDPIC)
2670             strcat (buf, ", fdpic");
2671           break;
2672
2673         case EM_SPARCV9:
2674           if (e_flags & EF_SPARC_32PLUS)
2675             strcat (buf, ", v8+");
2676
2677           if (e_flags & EF_SPARC_SUN_US1)
2678             strcat (buf, ", ultrasparcI");
2679
2680           if (e_flags & EF_SPARC_SUN_US3)
2681             strcat (buf, ", ultrasparcIII");
2682
2683           if (e_flags & EF_SPARC_HAL_R1)
2684             strcat (buf, ", halr1");
2685
2686           if (e_flags & EF_SPARC_LEDATA)
2687             strcat (buf, ", ledata");
2688
2689           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2690             strcat (buf, ", tso");
2691
2692           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2693             strcat (buf, ", pso");
2694
2695           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2696             strcat (buf, ", rmo");
2697           break;
2698
2699         case EM_PARISC:
2700           switch (e_flags & EF_PARISC_ARCH)
2701             {
2702             case EFA_PARISC_1_0:
2703               strcpy (buf, ", PA-RISC 1.0");
2704               break;
2705             case EFA_PARISC_1_1:
2706               strcpy (buf, ", PA-RISC 1.1");
2707               break;
2708             case EFA_PARISC_2_0:
2709               strcpy (buf, ", PA-RISC 2.0");
2710               break;
2711             default:
2712               break;
2713             }
2714           if (e_flags & EF_PARISC_TRAPNIL)
2715             strcat (buf, ", trapnil");
2716           if (e_flags & EF_PARISC_EXT)
2717             strcat (buf, ", ext");
2718           if (e_flags & EF_PARISC_LSB)
2719             strcat (buf, ", lsb");
2720           if (e_flags & EF_PARISC_WIDE)
2721             strcat (buf, ", wide");
2722           if (e_flags & EF_PARISC_NO_KABP)
2723             strcat (buf, ", no kabp");
2724           if (e_flags & EF_PARISC_LAZYSWAP)
2725             strcat (buf, ", lazyswap");
2726           break;
2727
2728         case EM_PJ:
2729         case EM_PJ_OLD:
2730           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2731             strcat (buf, ", new calling convention");
2732
2733           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2734             strcat (buf, ", gnu calling convention");
2735           break;
2736
2737         case EM_IA_64:
2738           if ((e_flags & EF_IA_64_ABI64))
2739             strcat (buf, ", 64-bit");
2740           else
2741             strcat (buf, ", 32-bit");
2742           if ((e_flags & EF_IA_64_REDUCEDFP))
2743             strcat (buf, ", reduced fp model");
2744           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2745             strcat (buf, ", no function descriptors, constant gp");
2746           else if ((e_flags & EF_IA_64_CONS_GP))
2747             strcat (buf, ", constant gp");
2748           if ((e_flags & EF_IA_64_ABSOLUTE))
2749             strcat (buf, ", absolute");
2750           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2751             {
2752               if ((e_flags & EF_IA_64_VMS_LINKAGES))
2753                 strcat (buf, ", vms_linkages");
2754               switch ((e_flags & EF_IA_64_VMS_COMCOD))
2755                 {
2756                 case EF_IA_64_VMS_COMCOD_SUCCESS:
2757                   break;
2758                 case EF_IA_64_VMS_COMCOD_WARNING:
2759                   strcat (buf, ", warning");
2760                   break;
2761                 case EF_IA_64_VMS_COMCOD_ERROR:
2762                   strcat (buf, ", error");
2763                   break;
2764                 case EF_IA_64_VMS_COMCOD_ABORT:
2765                   strcat (buf, ", abort");
2766                   break;
2767                 default:
2768                   abort ();
2769                 }
2770             }
2771           break;
2772
2773         case EM_VAX:
2774           if ((e_flags & EF_VAX_NONPIC))
2775             strcat (buf, ", non-PIC");
2776           if ((e_flags & EF_VAX_DFLOAT))
2777             strcat (buf, ", D-Float");
2778           if ((e_flags & EF_VAX_GFLOAT))
2779             strcat (buf, ", G-Float");
2780           break;
2781
2782         case EM_RX:
2783           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2784             strcat (buf, ", 64-bit doubles");
2785           if (e_flags & E_FLAG_RX_DSP)
2786             strcat (buf, ", dsp");
2787           if (e_flags & E_FLAG_RX_PID)
2788             strcat (buf, ", pid");
2789           if (e_flags & E_FLAG_RX_ABI)
2790             strcat (buf, ", RX ABI");
2791           break;
2792
2793         case EM_S390:
2794           if (e_flags & EF_S390_HIGH_GPRS)
2795             strcat (buf, ", highgprs");
2796           break;
2797
2798         case EM_TI_C6000:
2799           if ((e_flags & EF_C6000_REL))
2800             strcat (buf, ", relocatable module");
2801           break;
2802
2803         case EM_MSP430:
2804           strcat (buf, _(": architecture variant: "));
2805           switch (e_flags & EF_MSP430_MACH)
2806             {
2807             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
2808             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
2809             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
2810             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
2811             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
2812             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
2813             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
2814             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
2815             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
2816             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
2817             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
2818             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
2819             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
2820             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
2821             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
2822             default:
2823               strcat (buf, _(": unknown")); break;
2824             }
2825
2826           if (e_flags & ~ EF_MSP430_MACH)
2827             strcat (buf, _(": unknown extra flag bits also present"));
2828         }
2829     }
2830
2831   return buf;
2832 }
2833
2834 static const char *
2835 get_osabi_name (unsigned int osabi)
2836 {
2837   static char buff[32];
2838
2839   switch (osabi)
2840     {
2841     case ELFOSABI_NONE:         return "UNIX - System V";
2842     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
2843     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
2844     case ELFOSABI_GNU:          return "UNIX - GNU";
2845     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
2846     case ELFOSABI_AIX:          return "UNIX - AIX";
2847     case ELFOSABI_IRIX:         return "UNIX - IRIX";
2848     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
2849     case ELFOSABI_TRU64:        return "UNIX - TRU64";
2850     case ELFOSABI_MODESTO:      return "Novell - Modesto";
2851     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
2852     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
2853     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
2854     case ELFOSABI_AROS:         return "AROS";
2855     case ELFOSABI_FENIXOS:      return "FenixOS";
2856     default:
2857       if (osabi >= 64)
2858         switch (elf_header.e_machine)
2859           {
2860           case EM_ARM:
2861             switch (osabi)
2862               {
2863               case ELFOSABI_ARM:        return "ARM";
2864               default:
2865                 break;
2866               }
2867             break;
2868
2869           case EM_MSP430:
2870           case EM_MSP430_OLD:
2871             switch (osabi)
2872               {
2873               case ELFOSABI_STANDALONE: return _("Standalone App");
2874               default:
2875                 break;
2876               }
2877             break;
2878
2879           case EM_TI_C6000:
2880             switch (osabi)
2881               {
2882               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
2883               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
2884               default:
2885                 break;
2886               }
2887             break;
2888
2889           default:
2890             break;
2891           }
2892       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2893       return buff;
2894     }
2895 }
2896
2897 static const char *
2898 get_aarch64_segment_type (unsigned long type)
2899 {
2900   switch (type)
2901     {
2902     case PT_AARCH64_ARCHEXT:
2903       return "AARCH64_ARCHEXT";
2904     default:
2905       break;
2906     }
2907
2908   return NULL;
2909 }
2910
2911 static const char *
2912 get_arm_segment_type (unsigned long type)
2913 {
2914   switch (type)
2915     {
2916     case PT_ARM_EXIDX:
2917       return "EXIDX";
2918     default:
2919       break;
2920     }
2921
2922   return NULL;
2923 }
2924
2925 static const char *
2926 get_mips_segment_type (unsigned long type)
2927 {
2928   switch (type)
2929     {
2930     case PT_MIPS_REGINFO:
2931       return "REGINFO";
2932     case PT_MIPS_RTPROC:
2933       return "RTPROC";
2934     case PT_MIPS_OPTIONS:
2935       return "OPTIONS";
2936     default:
2937       break;
2938     }
2939
2940   return NULL;
2941 }
2942
2943 static const char *
2944 get_parisc_segment_type (unsigned long type)
2945 {
2946   switch (type)
2947     {
2948     case PT_HP_TLS:             return "HP_TLS";
2949     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
2950     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
2951     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
2952     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
2953     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
2954     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
2955     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
2956     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
2957     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
2958     case PT_HP_PARALLEL:        return "HP_PARALLEL";
2959     case PT_HP_FASTBIND:        return "HP_FASTBIND";
2960     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
2961     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
2962     case PT_HP_STACK:           return "HP_STACK";
2963     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
2964     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
2965     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
2966     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
2967     default:
2968       break;
2969     }
2970
2971   return NULL;
2972 }
2973
2974 static const char *
2975 get_ia64_segment_type (unsigned long type)
2976 {
2977   switch (type)
2978     {
2979     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
2980     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
2981     case PT_HP_TLS:             return "HP_TLS";
2982     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
2983     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
2984     case PT_IA_64_HP_STACK:     return "HP_STACK";
2985     default:
2986       break;
2987     }
2988
2989   return NULL;
2990 }
2991
2992 static const char *
2993 get_tic6x_segment_type (unsigned long type)
2994 {
2995   switch (type)
2996     {
2997     case PT_C6000_PHATTR:       return "C6000_PHATTR";
2998     default:
2999       break;
3000     }
3001
3002   return NULL;
3003 }
3004
3005 static const char *
3006 get_segment_type (unsigned long p_type)
3007 {
3008   static char buff[32];
3009
3010   switch (p_type)
3011     {
3012     case PT_NULL:       return "NULL";
3013     case PT_LOAD:       return "LOAD";
3014     case PT_DYNAMIC:    return "DYNAMIC";
3015     case PT_INTERP:     return "INTERP";
3016     case PT_NOTE:       return "NOTE";
3017     case PT_SHLIB:      return "SHLIB";
3018     case PT_PHDR:       return "PHDR";
3019     case PT_TLS:        return "TLS";
3020
3021     case PT_GNU_EH_FRAME:
3022                         return "GNU_EH_FRAME";
3023     case PT_GNU_STACK:  return "GNU_STACK";
3024     case PT_GNU_RELRO:  return "GNU_RELRO";
3025
3026     default:
3027       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3028         {
3029           const char * result;
3030
3031           switch (elf_header.e_machine)
3032             {
3033             case EM_AARCH64:
3034               result = get_aarch64_segment_type (p_type);
3035               break;
3036             case EM_ARM:
3037               result = get_arm_segment_type (p_type);
3038               break;
3039             case EM_MIPS:
3040             case EM_MIPS_RS3_LE:
3041               result = get_mips_segment_type (p_type);
3042               break;
3043             case EM_PARISC:
3044               result = get_parisc_segment_type (p_type);
3045               break;
3046             case EM_IA_64:
3047               result = get_ia64_segment_type (p_type);
3048               break;
3049             case EM_TI_C6000:
3050               result = get_tic6x_segment_type (p_type);
3051               break;
3052             default:
3053               result = NULL;
3054               break;
3055             }
3056
3057           if (result != NULL)
3058             return result;
3059
3060           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3061         }
3062       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3063         {
3064           const char * result;
3065
3066           switch (elf_header.e_machine)
3067             {
3068             case EM_PARISC:
3069               result = get_parisc_segment_type (p_type);
3070               break;
3071             case EM_IA_64:
3072               result = get_ia64_segment_type (p_type);
3073               break;
3074             default:
3075               result = NULL;
3076               break;
3077             }
3078
3079           if (result != NULL)
3080             return result;
3081
3082           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3083         }
3084       else
3085         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3086
3087       return buff;
3088     }
3089 }
3090
3091 static const char *
3092 get_mips_section_type_name (unsigned int sh_type)
3093 {
3094   switch (sh_type)
3095     {
3096     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3097     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3098     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3099     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3100     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3101     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3102     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3103     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3104     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3105     case SHT_MIPS_RELD:          return "MIPS_RELD";
3106     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3107     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3108     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3109     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3110     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3111     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3112     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3113     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3114     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3115     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3116     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3117     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3118     case SHT_MIPS_LINE:          return "MIPS_LINE";
3119     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3120     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3121     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3122     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3123     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3124     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3125     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3126     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3127     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3128     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3129     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3130     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3131     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3132     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3133     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3134     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3135     default:
3136       break;
3137     }
3138   return NULL;
3139 }
3140
3141 static const char *
3142 get_parisc_section_type_name (unsigned int sh_type)
3143 {
3144   switch (sh_type)
3145     {
3146     case SHT_PARISC_EXT:        return "PARISC_EXT";
3147     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
3148     case SHT_PARISC_DOC:        return "PARISC_DOC";
3149     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
3150     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
3151     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
3152     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
3153     default:
3154       break;
3155     }
3156   return NULL;
3157 }
3158
3159 static const char *
3160 get_ia64_section_type_name (unsigned int sh_type)
3161 {
3162   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
3163   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3164     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3165
3166   switch (sh_type)
3167     {
3168     case SHT_IA_64_EXT:                return "IA_64_EXT";
3169     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
3170     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
3171     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
3172     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3173     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
3174     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
3175     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
3176     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
3177     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
3178     default:
3179       break;
3180     }
3181   return NULL;
3182 }
3183
3184 static const char *
3185 get_x86_64_section_type_name (unsigned int sh_type)
3186 {
3187   switch (sh_type)
3188     {
3189     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
3190     default:
3191       break;
3192     }
3193   return NULL;
3194 }
3195
3196 static const char *
3197 get_aarch64_section_type_name (unsigned int sh_type)
3198 {
3199   switch (sh_type)
3200     {
3201     case SHT_AARCH64_ATTRIBUTES:
3202       return "AARCH64_ATTRIBUTES";
3203     default:
3204       break;
3205     }
3206   return NULL;
3207 }
3208
3209 static const char *
3210 get_arm_section_type_name (unsigned int sh_type)
3211 {
3212   switch (sh_type)
3213     {
3214     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
3215     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
3216     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
3217     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
3218     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
3219     default:
3220       break;
3221     }
3222   return NULL;
3223 }
3224
3225 static const char *
3226 get_tic6x_section_type_name (unsigned int sh_type)
3227 {
3228   switch (sh_type)
3229     {
3230     case SHT_C6000_UNWIND:
3231       return "C6000_UNWIND";
3232     case SHT_C6000_PREEMPTMAP:
3233       return "C6000_PREEMPTMAP";
3234     case SHT_C6000_ATTRIBUTES:
3235       return "C6000_ATTRIBUTES";
3236     case SHT_TI_ICODE:
3237       return "TI_ICODE";
3238     case SHT_TI_XREF:
3239       return "TI_XREF";
3240     case SHT_TI_HANDLER:
3241       return "TI_HANDLER";
3242     case SHT_TI_INITINFO:
3243       return "TI_INITINFO";
3244     case SHT_TI_PHATTRS:
3245       return "TI_PHATTRS";
3246     default:
3247       break;
3248     }
3249   return NULL;
3250 }
3251
3252 static const char *
3253 get_msp430x_section_type_name (unsigned int sh_type)
3254 {
3255   switch (sh_type)
3256     {
3257     case SHT_MSP430_SEC_FLAGS:   return "MSP430_SEC_FLAGS";
3258     case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3259     case SHT_MSP430_ATTRIBUTES:  return "MSP430_ATTRIBUTES";
3260     default: return NULL;
3261     }
3262 }
3263
3264 static const char *
3265 get_section_type_name (unsigned int sh_type)
3266 {
3267   static char buff[32];
3268
3269   switch (sh_type)
3270     {
3271     case SHT_NULL:              return "NULL";
3272     case SHT_PROGBITS:          return "PROGBITS";
3273     case SHT_SYMTAB:            return "SYMTAB";
3274     case SHT_STRTAB:            return "STRTAB";
3275     case SHT_RELA:              return "RELA";
3276     case SHT_HASH:              return "HASH";
3277     case SHT_DYNAMIC:           return "DYNAMIC";
3278     case SHT_NOTE:              return "NOTE";
3279     case SHT_NOBITS:            return "NOBITS";
3280     case SHT_REL:               return "REL";
3281     case SHT_SHLIB:             return "SHLIB";
3282     case SHT_DYNSYM:            return "DYNSYM";
3283     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
3284     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
3285     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
3286     case SHT_GNU_HASH:          return "GNU_HASH";
3287     case SHT_GROUP:             return "GROUP";
3288     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
3289     case SHT_GNU_verdef:        return "VERDEF";
3290     case SHT_GNU_verneed:       return "VERNEED";
3291     case SHT_GNU_versym:        return "VERSYM";
3292     case 0x6ffffff0:            return "VERSYM";
3293     case 0x6ffffffc:            return "VERDEF";
3294     case 0x7ffffffd:            return "AUXILIARY";
3295     case 0x7fffffff:            return "FILTER";
3296     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
3297
3298     default:
3299       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3300         {
3301           const char * result;
3302
3303           switch (elf_header.e_machine)
3304             {
3305             case EM_MIPS:
3306             case EM_MIPS_RS3_LE:
3307               result = get_mips_section_type_name (sh_type);
3308               break;
3309             case EM_PARISC:
3310               result = get_parisc_section_type_name (sh_type);
3311               break;
3312             case EM_IA_64:
3313               result = get_ia64_section_type_name (sh_type);
3314               break;
3315             case EM_X86_64:
3316             case EM_L1OM:
3317             case EM_K1OM:
3318               result = get_x86_64_section_type_name (sh_type);
3319               break;
3320             case EM_AARCH64:
3321               result = get_aarch64_section_type_name (sh_type);
3322               break;
3323             case EM_ARM:
3324               result = get_arm_section_type_name (sh_type);
3325               break;
3326             case EM_TI_C6000:
3327               result = get_tic6x_section_type_name (sh_type);
3328               break;
3329             case EM_MSP430:
3330               result = get_msp430x_section_type_name (sh_type);
3331               break;
3332             default:
3333               result = NULL;
3334               break;
3335             }
3336
3337           if (result != NULL)
3338             return result;
3339
3340           sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3341         }
3342       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3343         {
3344           const char * result;
3345
3346           switch (elf_header.e_machine)
3347             {
3348             case EM_IA_64:
3349               result = get_ia64_section_type_name (sh_type);
3350               break;
3351             default:
3352               result = NULL;
3353               break;
3354             }
3355
3356           if (result != NULL)
3357             return result;
3358
3359           sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3360         }
3361       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3362         sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3363       else
3364         /* This message is probably going to be displayed in a 15
3365            character wide field, so put the hex value first.  */
3366         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3367
3368       return buff;
3369     }
3370 }
3371
3372 #define OPTION_DEBUG_DUMP       512
3373 #define OPTION_DYN_SYMS         513
3374 #define OPTION_DWARF_DEPTH      514
3375 #define OPTION_DWARF_START      515
3376 #define OPTION_DWARF_CHECK      516
3377
3378 static struct option options[] =
3379 {
3380   {"all",              no_argument, 0, 'a'},
3381   {"file-header",      no_argument, 0, 'h'},
3382   {"program-headers",  no_argument, 0, 'l'},
3383   {"headers",          no_argument, 0, 'e'},
3384   {"histogram",        no_argument, 0, 'I'},
3385   {"segments",         no_argument, 0, 'l'},
3386   {"sections",         no_argument, 0, 'S'},
3387   {"section-headers",  no_argument, 0, 'S'},
3388   {"section-groups",   no_argument, 0, 'g'},
3389   {"section-details",  no_argument, 0, 't'},
3390   {"full-section-name",no_argument, 0, 'N'},
3391   {"symbols",          no_argument, 0, 's'},
3392   {"syms",             no_argument, 0, 's'},
3393   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
3394   {"relocs",           no_argument, 0, 'r'},
3395   {"notes",            no_argument, 0, 'n'},
3396   {"dynamic",          no_argument, 0, 'd'},
3397   {"arch-specific",    no_argument, 0, 'A'},
3398   {"version-info",     no_argument, 0, 'V'},
3399   {"use-dynamic",      no_argument, 0, 'D'},
3400   {"unwind",           no_argument, 0, 'u'},
3401   {"archive-index",    no_argument, 0, 'c'},
3402   {"hex-dump",         required_argument, 0, 'x'},
3403   {"relocated-dump",   required_argument, 0, 'R'},
3404   {"string-dump",      required_argument, 0, 'p'},
3405 #ifdef SUPPORT_DISASSEMBLY
3406   {"instruction-dump", required_argument, 0, 'i'},
3407 #endif
3408   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
3409
3410   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
3411   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
3412   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
3413
3414   {"version",          no_argument, 0, 'v'},
3415   {"wide",             no_argument, 0, 'W'},
3416   {"help",             no_argument, 0, 'H'},
3417   {0,                  no_argument, 0, 0}
3418 };
3419
3420 static void
3421 usage (FILE * stream)
3422 {
3423   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3424   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3425   fprintf (stream, _(" Options are:\n\
3426   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3427   -h --file-header       Display the ELF file header\n\
3428   -l --program-headers   Display the program headers\n\
3429      --segments          An alias for --program-headers\n\
3430   -S --section-headers   Display the sections' header\n\
3431      --sections          An alias for --section-headers\n\
3432   -g --section-groups    Display the section groups\n\
3433   -t --section-details   Display the section details\n\
3434   -e --headers           Equivalent to: -h -l -S\n\
3435   -s --syms              Display the symbol table\n\
3436      --symbols           An alias for --syms\n\
3437   --dyn-syms             Display the dynamic symbol table\n\
3438   -n --notes             Display the core notes (if present)\n\
3439   -r --relocs            Display the relocations (if present)\n\
3440   -u --unwind            Display the unwind info (if present)\n\
3441   -d --dynamic           Display the dynamic section (if present)\n\
3442   -V --version-info      Display the version sections (if present)\n\
3443   -A --arch-specific     Display architecture specific information (if any)\n\
3444   -c --archive-index     Display the symbol/file index in an archive\n\
3445   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
3446   -x --hex-dump=<number|name>\n\
3447                          Dump the contents of section <number|name> as bytes\n\
3448   -p --string-dump=<number|name>\n\
3449                          Dump the contents of section <number|name> as strings\n\
3450   -R --relocated-dump=<number|name>\n\
3451                          Dump the contents of section <number|name> as relocated bytes\n\
3452   -w[lLiaprmfFsoRt] or\n\
3453   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3454                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3455                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3456                =addr,=cu_index]\n\
3457                          Display the contents of DWARF2 debug sections\n"));
3458   fprintf (stream, _("\
3459   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
3460   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
3461                          or deeper\n"));
3462 #ifdef SUPPORT_DISASSEMBLY
3463   fprintf (stream, _("\
3464   -i --instruction-dump=<number|name>\n\
3465                          Disassemble the contents of section <number|name>\n"));
3466 #endif
3467   fprintf (stream, _("\
3468   -I --histogram         Display histogram of bucket list lengths\n\
3469   -W --wide              Allow output width to exceed 80 characters\n\
3470   @<file>                Read options from <file>\n\
3471   -H --help              Display this information\n\
3472   -v --version           Display the version number of readelf\n"));
3473
3474   if (REPORT_BUGS_TO[0] && stream == stdout)
3475     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3476
3477   exit (stream == stdout ? 0 : 1);
3478 }
3479
3480 /* Record the fact that the user wants the contents of section number
3481    SECTION to be displayed using the method(s) encoded as flags bits
3482    in TYPE.  Note, TYPE can be zero if we are creating the array for
3483    the first time.  */
3484
3485 static void
3486 request_dump_bynumber (unsigned int section, dump_type type)
3487 {
3488   if (section >= num_dump_sects)
3489     {
3490       dump_type * new_dump_sects;
3491
3492       new_dump_sects = (dump_type *) calloc (section + 1,
3493                                              sizeof (* dump_sects));
3494
3495       if (new_dump_sects == NULL)
3496         error (_("Out of memory allocating dump request table.\n"));
3497       else
3498         {
3499           /* Copy current flag settings.  */
3500           memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3501
3502           free (dump_sects);
3503
3504           dump_sects = new_dump_sects;
3505           num_dump_sects = section + 1;
3506         }
3507     }
3508
3509   if (dump_sects)
3510     dump_sects[section] |= type;
3511
3512   return;
3513 }
3514
3515 /* Request a dump by section name.  */
3516
3517 static void
3518 request_dump_byname (const char * section, dump_type type)
3519 {
3520   struct dump_list_entry * new_request;
3521
3522   new_request = (struct dump_list_entry *)
3523       malloc (sizeof (struct dump_list_entry));
3524   if (!new_request)
3525     error (_("Out of memory allocating dump request table.\n"));
3526
3527   new_request->name = strdup (section);
3528   if (!new_request->name)
3529     error (_("Out of memory allocating dump request table.\n"));
3530
3531   new_request->type = type;
3532
3533   new_request->next = dump_sects_byname;
3534   dump_sects_byname = new_request;
3535 }
3536
3537 static inline void
3538 request_dump (dump_type type)
3539 {
3540   int section;
3541   char * cp;
3542
3543   do_dump++;
3544   section = strtoul (optarg, & cp, 0);
3545
3546   if (! *cp && section >= 0)
3547     request_dump_bynumber (section, type);
3548   else
3549     request_dump_byname (optarg, type);
3550 }
3551
3552
3553 static void
3554 parse_args (int argc, char ** argv)
3555 {
3556   int c;
3557
3558   if (argc < 2)
3559     usage (stderr);
3560
3561   while ((c = getopt_long
3562           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3563     {
3564       switch (c)
3565         {
3566         case 0:
3567           /* Long options.  */
3568           break;
3569         case 'H':
3570           usage (stdout);
3571           break;
3572
3573         case 'a':
3574           do_syms++;
3575           do_reloc++;
3576           do_unwind++;
3577           do_dynamic++;
3578           do_header++;
3579           do_sections++;
3580           do_section_groups++;
3581           do_segments++;
3582           do_version++;
3583           do_histogram++;
3584           do_arch++;
3585           do_notes++;
3586           break;
3587         case 'g':
3588           do_section_groups++;
3589           break;
3590         case 't':
3591         case 'N':
3592           do_sections++;
3593           do_section_details++;
3594           break;
3595         case 'e':
3596           do_header++;
3597           do_sections++;
3598           do_segments++;
3599           break;
3600         case 'A':
3601           do_arch++;
3602           break;
3603         case 'D':
3604           do_using_dynamic++;
3605           break;
3606         case 'r':
3607           do_reloc++;
3608           break;
3609         case 'u':
3610           do_unwind++;
3611           break;
3612         case 'h':
3613           do_header++;
3614           break;
3615         case 'l':
3616           do_segments++;
3617           break;
3618         case 's':
3619           do_syms++;
3620           break;
3621         case 'S':
3622           do_sections++;
3623           break;
3624         case 'd':
3625           do_dynamic++;
3626           break;
3627         case 'I':
3628           do_histogram++;
3629           break;
3630         case 'n':
3631           do_notes++;
3632           break;
3633         case 'c':
3634           do_archive_index++;
3635           break;
3636         case 'x':
3637           request_dump (HEX_DUMP);
3638           break;
3639         case 'p':
3640           request_dump (STRING_DUMP);
3641           break;
3642         case 'R':
3643           request_dump (RELOC_DUMP);
3644           break;
3645         case 'w':
3646           do_dump++;
3647           if (optarg == 0)
3648             {
3649               do_debugging = 1;
3650               dwarf_select_sections_all ();
3651             }
3652           else
3653             {
3654               do_debugging = 0;
3655               dwarf_select_sections_by_letters (optarg);
3656             }
3657           break;
3658         case OPTION_DEBUG_DUMP:
3659           do_dump++;
3660           if (optarg == 0)
3661             do_debugging = 1;
3662           else
3663             {
3664               do_debugging = 0;
3665               dwarf_select_sections_by_names (optarg);
3666             }
3667           break;
3668         case OPTION_DWARF_DEPTH:
3669           {
3670             char *cp;
3671
3672             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3673           }
3674           break;
3675         case OPTION_DWARF_START:
3676           {
3677             char *cp;
3678
3679             dwarf_start_die = strtoul (optarg, & cp, 0);
3680           }
3681           break;
3682         case OPTION_DWARF_CHECK:
3683           dwarf_check = 1;
3684           break;
3685         case OPTION_DYN_SYMS:
3686           do_dyn_syms++;
3687           break;
3688 #ifdef SUPPORT_DISASSEMBLY
3689         case 'i':
3690           request_dump (DISASS_DUMP);
3691           break;
3692 #endif
3693         case 'v':
3694           print_version (program_name);
3695           break;
3696         case 'V':
3697           do_version++;
3698           break;
3699         case 'W':
3700           do_wide++;
3701           break;
3702         default:
3703           /* xgettext:c-format */
3704           error (_("Invalid option '-%c'\n"), c);
3705           /* Drop through.  */
3706         case '?':
3707           usage (stderr);
3708         }
3709     }
3710
3711   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3712       && !do_segments && !do_header && !do_dump && !do_version
3713       && !do_histogram && !do_debugging && !do_arch && !do_notes
3714       && !do_section_groups && !do_archive_index
3715       && !do_dyn_syms)
3716     usage (stderr);
3717   else if (argc < 3)
3718     {
3719       warn (_("Nothing to do.\n"));
3720       usage (stderr);
3721     }
3722 }
3723
3724 static const char *
3725 get_elf_class (unsigned int elf_class)
3726 {
3727   static char buff[32];
3728
3729   switch (elf_class)
3730     {
3731     case ELFCLASSNONE: return _("none");
3732     case ELFCLASS32:   return "ELF32";
3733     case ELFCLASS64:   return "ELF64";
3734     default:
3735       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3736       return buff;
3737     }
3738 }
3739
3740 static const char *
3741 get_data_encoding (unsigned int encoding)
3742 {
3743   static char buff[32];
3744
3745   switch (encoding)
3746     {
3747     case ELFDATANONE: return _("none");
3748     case ELFDATA2LSB: return _("2's complement, little endian");
3749     case ELFDATA2MSB: return _("2's complement, big endian");
3750     default:
3751       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3752       return buff;
3753     }
3754 }
3755
3756 /* Decode the data held in 'elf_header'.  */
3757
3758 static int
3759 process_file_header (void)
3760 {
3761   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
3762       || elf_header.e_ident[EI_MAG1] != ELFMAG1
3763       || elf_header.e_ident[EI_MAG2] != ELFMAG2
3764       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3765     {
3766       error
3767         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3768       return 0;
3769     }
3770
3771   init_dwarf_regnames (elf_header.e_machine);
3772
3773   if (do_header)
3774     {
3775       int i;
3776
3777       printf (_("ELF Header:\n"));
3778       printf (_("  Magic:   "));
3779       for (i = 0; i < EI_NIDENT; i++)
3780         printf ("%2.2x ", elf_header.e_ident[i]);
3781       printf ("\n");
3782       printf (_("  Class:                             %s\n"),
3783               get_elf_class (elf_header.e_ident[EI_CLASS]));
3784       printf (_("  Data:                              %s\n"),
3785               get_data_encoding (elf_header.e_ident[EI_DATA]));
3786       printf (_("  Version:                           %d %s\n"),
3787               elf_header.e_ident[EI_VERSION],
3788               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3789                ? "(current)"
3790                : (elf_header.e_ident[EI_VERSION] != EV_NONE
3791                   ? _("<unknown: %lx>")
3792                   : "")));
3793       printf (_("  OS/ABI:                            %s\n"),
3794               get_osabi_name (elf_header.e_ident[EI_OSABI]));
3795       printf (_("  ABI Version:                       %d\n"),
3796               elf_header.e_ident[EI_ABIVERSION]);
3797       printf (_("  Type:                              %s\n"),
3798               get_file_type (elf_header.e_type));
3799       printf (_("  Machine:                           %s\n"),
3800               get_machine_name (elf_header.e_machine));
3801       printf (_("  Version:                           0x%lx\n"),
3802               (unsigned long) elf_header.e_version);
3803
3804       printf (_("  Entry point address:               "));
3805       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3806       printf (_("\n  Start of program headers:          "));
3807       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3808       printf (_(" (bytes into file)\n  Start of section headers:          "));
3809       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3810       printf (_(" (bytes into file)\n"));
3811
3812       printf (_("  Flags:                             0x%lx%s\n"),
3813               (unsigned long) elf_header.e_flags,
3814               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3815       printf (_("  Size of this header:               %ld (bytes)\n"),
3816               (long) elf_header.e_ehsize);
3817       printf (_("  Size of program headers:           %ld (bytes)\n"),
3818               (long) elf_header.e_phentsize);
3819       printf (_("  Number of program headers:         %ld"),
3820               (long) elf_header.e_phnum);
3821       if (section_headers != NULL
3822           && elf_header.e_phnum == PN_XNUM
3823           && section_headers[0].sh_info != 0)
3824         printf (" (%ld)", (long) section_headers[0].sh_info);
3825       putc ('\n', stdout);
3826       printf (_("  Size of section headers:           %ld (bytes)\n"),
3827               (long) elf_header.e_shentsize);
3828       printf (_("  Number of section headers:         %ld"),
3829               (long) elf_header.e_shnum);
3830       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
3831         printf (" (%ld)", (long) section_headers[0].sh_size);
3832       putc ('\n', stdout);
3833       printf (_("  Section header string table index: %ld"),
3834               (long) elf_header.e_shstrndx);
3835       if (section_headers != NULL
3836           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3837         printf (" (%u)", section_headers[0].sh_link);
3838       else if (elf_header.e_shstrndx != SHN_UNDEF
3839                && elf_header.e_shstrndx >= elf_header.e_shnum)
3840         printf (_(" <corrupt: out of range>"));
3841       putc ('\n', stdout);
3842     }
3843
3844   if (section_headers != NULL)
3845     {
3846       if (elf_header.e_phnum == PN_XNUM
3847           && section_headers[0].sh_info != 0)
3848         elf_header.e_phnum = section_headers[0].sh_info;
3849       if (elf_header.e_shnum == SHN_UNDEF)
3850         elf_header.e_shnum = section_headers[0].sh_size;
3851       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3852         elf_header.e_shstrndx = section_headers[0].sh_link;
3853       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3854         elf_header.e_shstrndx = SHN_UNDEF;
3855       free (section_headers);
3856       section_headers = NULL;
3857     }
3858
3859   return 1;
3860 }
3861
3862
3863 static int
3864 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3865 {
3866   Elf32_External_Phdr * phdrs;
3867   Elf32_External_Phdr * external;
3868   Elf_Internal_Phdr *   internal;
3869   unsigned int i;
3870
3871   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3872                                             elf_header.e_phentsize,
3873                                             elf_header.e_phnum,
3874                                             _("program headers"));
3875   if (!phdrs)
3876     return 0;
3877
3878   for (i = 0, internal = pheaders, external = phdrs;
3879        i < elf_header.e_phnum;
3880        i++, internal++, external++)
3881     {
3882       internal->p_type   = BYTE_GET (external->p_type);
3883       internal->p_offset = BYTE_GET (external->p_offset);
3884       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
3885       internal->p_paddr  = BYTE_GET (external->p_paddr);
3886       internal->p_filesz = BYTE_GET (external->p_filesz);
3887       internal->p_memsz  = BYTE_GET (external->p_memsz);
3888       internal->p_flags  = BYTE_GET (external->p_flags);
3889       internal->p_align  = BYTE_GET (external->p_align);
3890     }
3891
3892   free (phdrs);
3893
3894   return 1;
3895 }
3896
3897 static int
3898 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3899 {
3900   Elf64_External_Phdr * phdrs;
3901   Elf64_External_Phdr * external;
3902   Elf_Internal_Phdr *   internal;
3903   unsigned int i;
3904
3905   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3906                                             elf_header.e_phentsize,
3907                                             elf_header.e_phnum,
3908                                             _("program headers"));
3909   if (!phdrs)
3910     return 0;
3911
3912   for (i = 0, internal = pheaders, external = phdrs;
3913        i < elf_header.e_phnum;
3914        i++, internal++, external++)
3915     {
3916       internal->p_type   = BYTE_GET (external->p_type);
3917       internal->p_flags  = BYTE_GET (external->p_flags);
3918       internal->p_offset = BYTE_GET (external->p_offset);
3919       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
3920       internal->p_paddr  = BYTE_GET (external->p_paddr);
3921       internal->p_filesz = BYTE_GET (external->p_filesz);
3922       internal->p_memsz  = BYTE_GET (external->p_memsz);
3923       internal->p_align  = BYTE_GET (external->p_align);
3924     }
3925
3926   free (phdrs);
3927
3928   return 1;
3929 }
3930
3931 /* Returns 1 if the program headers were read into `program_headers'.  */
3932
3933 static int
3934 get_program_headers (FILE * file)
3935 {
3936   Elf_Internal_Phdr * phdrs;
3937
3938   /* Check cache of prior read.  */
3939   if (program_headers != NULL)
3940     return 1;
3941
3942   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3943                                          sizeof (Elf_Internal_Phdr));
3944
3945   if (phdrs == NULL)
3946     {
3947       error (_("Out of memory\n"));
3948       return 0;
3949     }
3950
3951   if (is_32bit_elf
3952       ? get_32bit_program_headers (file, phdrs)
3953       : get_64bit_program_headers (file, phdrs))
3954     {
3955       program_headers = phdrs;
3956       return 1;
3957     }
3958
3959   free (phdrs);
3960   return 0;
3961 }
3962
3963 /* Returns 1 if the program headers were loaded.  */
3964
3965 static int
3966 process_program_headers (FILE * file)
3967 {
3968   Elf_Internal_Phdr * segment;
3969   unsigned int i;
3970
3971   if (elf_header.e_phnum == 0)
3972     {
3973       /* PR binutils/12467.  */
3974       if (elf_header.e_phoff != 0)
3975         warn (_("possibly corrupt ELF header - it has a non-zero program"
3976                 " header offset, but no program headers"));
3977       else if (do_segments)
3978         printf (_("\nThere are no program headers in this file.\n"));
3979       return 0;
3980     }
3981
3982   if (do_segments && !do_header)
3983     {
3984       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3985       printf (_("Entry point "));
3986       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3987       printf (_("\nThere are %d program headers, starting at offset "),
3988               elf_header.e_phnum);
3989       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3990       printf ("\n");
3991     }
3992
3993   if (! get_program_headers (file))
3994       return 0;
3995
3996   if (do_segments)
3997     {
3998       if (elf_header.e_phnum > 1)
3999         printf (_("\nProgram Headers:\n"));
4000       else
4001         printf (_("\nProgram Headers:\n"));
4002
4003       if (is_32bit_elf)
4004         printf
4005           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4006       else if (do_wide)
4007         printf
4008           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4009       else
4010         {
4011           printf
4012             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4013           printf
4014             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4015         }
4016     }
4017
4018   dynamic_addr = 0;
4019   dynamic_size = 0;
4020
4021   for (i = 0, segment = program_headers;
4022        i < elf_header.e_phnum;
4023        i++, segment++)
4024     {
4025       if (do_segments)
4026         {
4027           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4028
4029           if (is_32bit_elf)
4030             {
4031               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4032               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4033               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4034               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4035               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4036               printf ("%c%c%c ",
4037                       (segment->p_flags & PF_R ? 'R' : ' '),
4038                       (segment->p_flags & PF_W ? 'W' : ' '),
4039                       (segment->p_flags & PF_X ? 'E' : ' '));
4040               printf ("%#lx", (unsigned long) segment->p_align);
4041             }
4042           else if (do_wide)
4043             {
4044               if ((unsigned long) segment->p_offset == segment->p_offset)
4045                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4046               else
4047                 {
4048                   print_vma (segment->p_offset, FULL_HEX);
4049                   putchar (' ');
4050                 }
4051
4052               print_vma (segment->p_vaddr, FULL_HEX);
4053               putchar (' ');
4054               print_vma (segment->p_paddr, FULL_HEX);
4055               putchar (' ');
4056
4057               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4058                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4059               else
4060                 {
4061                   print_vma (segment->p_filesz, FULL_HEX);
4062                   putchar (' ');
4063                 }
4064
4065               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4066                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4067               else
4068                 {
4069                   print_vma (segment->p_memsz, FULL_HEX);
4070                 }
4071
4072               printf (" %c%c%c ",
4073                       (segment->p_flags & PF_R ? 'R' : ' '),
4074                       (segment->p_flags & PF_W ? 'W' : ' '),
4075                       (segment->p_flags & PF_X ? 'E' : ' '));
4076
4077               if ((unsigned long) segment->p_align == segment->p_align)
4078                 printf ("%#lx", (unsigned long) segment->p_align);
4079               else
4080                 {
4081                   print_vma (segment->p_align, PREFIX_HEX);
4082                 }
4083             }
4084           else
4085             {
4086               print_vma (segment->p_offset, FULL_HEX);
4087               putchar (' ');
4088               print_vma (segment->p_vaddr, FULL_HEX);
4089               putchar (' ');
4090               print_vma (segment->p_paddr, FULL_HEX);
4091               printf ("\n                 ");
4092               print_vma (segment->p_filesz, FULL_HEX);
4093               putchar (' ');
4094               print_vma (segment->p_memsz, FULL_HEX);
4095               printf ("  %c%c%c    ",
4096                       (segment->p_flags & PF_R ? 'R' : ' '),
4097                       (segment->p_flags & PF_W ? 'W' : ' '),
4098                       (segment->p_flags & PF_X ? 'E' : ' '));
4099               print_vma (segment->p_align, HEX);
4100             }
4101         }
4102
4103       switch (segment->p_type)
4104         {
4105         case PT_DYNAMIC:
4106           if (dynamic_addr)
4107             error (_("more than one dynamic segment\n"));
4108
4109           /* By default, assume that the .dynamic section is the first
4110              section in the DYNAMIC segment.  */
4111           dynamic_addr = segment->p_offset;
4112           dynamic_size = segment->p_filesz;
4113
4114           /* Try to locate the .dynamic section. If there is
4115              a section header table, we can easily locate it.  */
4116           if (section_headers != NULL)
4117             {
4118               Elf_Internal_Shdr * sec;
4119
4120               sec = find_section (".dynamic");
4121               if (sec == NULL || sec->sh_size == 0)
4122                 {
4123                   /* A corresponding .dynamic section is expected, but on
4124                      IA-64/OpenVMS it is OK for it to be missing.  */
4125                   if (!is_ia64_vms ())
4126                     error (_("no .dynamic section in the dynamic segment\n"));
4127                   break;
4128                 }
4129
4130               if (sec->sh_type == SHT_NOBITS)
4131                 {
4132                   dynamic_size = 0;
4133                   break;
4134                 }
4135
4136               dynamic_addr = sec->sh_offset;
4137               dynamic_size = sec->sh_size;
4138
4139               if (dynamic_addr < segment->p_offset
4140                   || dynamic_addr > segment->p_offset + segment->p_filesz)
4141                 warn (_("the .dynamic section is not contained"
4142                         " within the dynamic segment\n"));
4143               else if (dynamic_addr > segment->p_offset)
4144                 warn (_("the .dynamic section is not the first section"
4145                         " in the dynamic segment.\n"));
4146             }
4147           break;
4148
4149         case PT_INTERP:
4150           if (fseek (file, archive_file_offset + (long) segment->p_offset,
4151                      SEEK_SET))
4152             error (_("Unable to find program interpreter name\n"));
4153           else
4154             {
4155               char fmt [32];
4156               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
4157
4158               if (ret >= (int) sizeof (fmt) || ret < 0)
4159                 error (_("Internal error: failed to create format string to display program interpreter\n"));
4160
4161               program_interpreter[0] = 0;
4162               if (fscanf (file, fmt, program_interpreter) <= 0)
4163                 error (_("Unable to read program interpreter name\n"));
4164
4165               if (do_segments)
4166                 printf (_("\n      [Requesting program interpreter: %s]"),
4167                     program_interpreter);
4168             }
4169           break;
4170         }
4171
4172       if (do_segments)
4173         putc ('\n', stdout);
4174     }
4175
4176   if (do_segments && section_headers != NULL && string_table != NULL)
4177     {
4178       printf (_("\n Section to Segment mapping:\n"));
4179       printf (_("  Segment Sections...\n"));
4180
4181       for (i = 0; i < elf_header.e_phnum; i++)
4182         {
4183           unsigned int j;
4184           Elf_Internal_Shdr * section;
4185
4186           segment = program_headers + i;
4187           section = section_headers + 1;
4188
4189           printf ("   %2.2d     ", i);
4190
4191           for (j = 1; j < elf_header.e_shnum; j++, section++)
4192             {
4193               if (!ELF_TBSS_SPECIAL (section, segment)
4194                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4195                 printf ("%s ", SECTION_NAME (section));
4196             }
4197
4198           putc ('\n',stdout);
4199         }
4200     }
4201
4202   return 1;
4203 }
4204
4205
4206 /* Find the file offset corresponding to VMA by using the program headers.  */
4207
4208 static long
4209 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4210 {
4211   Elf_Internal_Phdr * seg;
4212
4213   if (! get_program_headers (file))
4214     {
4215       warn (_("Cannot interpret virtual addresses without program headers.\n"));
4216       return (long) vma;
4217     }
4218
4219   for (seg = program_headers;
4220        seg < program_headers + elf_header.e_phnum;
4221        ++seg)
4222     {
4223       if (seg->p_type != PT_LOAD)
4224         continue;
4225
4226       if (vma >= (seg->p_vaddr & -seg->p_align)
4227           && vma + size <= seg->p_vaddr + seg->p_filesz)
4228         return vma - seg->p_vaddr + seg->p_offset;
4229     }
4230
4231   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4232         (unsigned long) vma);
4233   return (long) vma;
4234 }
4235
4236
4237 static int
4238 get_32bit_section_headers (FILE * file, unsigned int num)
4239 {
4240   Elf32_External_Shdr * shdrs;
4241   Elf_Internal_Shdr *   internal;
4242   unsigned int i;
4243
4244   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4245                                             elf_header.e_shentsize, num,
4246                                             _("section headers"));
4247   if (!shdrs)
4248     return 0;
4249
4250   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4251                                                    sizeof (Elf_Internal_Shdr));
4252
4253   if (section_headers == NULL)
4254     {
4255       error (_("Out of memory\n"));
4256       return 0;
4257     }
4258
4259   for (i = 0, internal = section_headers;
4260        i < num;
4261        i++, internal++)
4262     {
4263       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4264       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4265       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4266       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4267       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4268       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4269       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4270       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4271       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4272       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4273     }
4274
4275   free (shdrs);
4276
4277   return 1;
4278 }
4279
4280 static int
4281 get_64bit_section_headers (FILE * file, unsigned int num)
4282 {
4283   Elf64_External_Shdr * shdrs;
4284   Elf_Internal_Shdr *   internal;
4285   unsigned int i;
4286
4287   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4288                                             elf_header.e_shentsize, num,
4289                                             _("section headers"));
4290   if (!shdrs)
4291     return 0;
4292
4293   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4294                                                    sizeof (Elf_Internal_Shdr));
4295
4296   if (section_headers == NULL)
4297     {
4298       error (_("Out of memory\n"));
4299       return 0;
4300     }
4301
4302   for (i = 0, internal = section_headers;
4303        i < num;
4304        i++, internal++)
4305     {
4306       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
4307       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
4308       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
4309       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
4310       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
4311       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
4312       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
4313       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
4314       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
4315       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4316     }
4317
4318   free (shdrs);
4319
4320   return 1;
4321 }
4322
4323 static Elf_Internal_Sym *
4324 get_32bit_elf_symbols (FILE * file,
4325                        Elf_Internal_Shdr * section,
4326                        unsigned long * num_syms_return)
4327 {
4328   unsigned long number = 0;
4329   Elf32_External_Sym * esyms = NULL;
4330   Elf_External_Sym_Shndx * shndx = NULL;
4331   Elf_Internal_Sym * isyms = NULL;
4332   Elf_Internal_Sym * psym;
4333   unsigned int j;
4334
4335   /* Run some sanity checks first.  */
4336   if (section->sh_entsize == 0)
4337     {
4338       error (_("sh_entsize is zero\n"));
4339       goto exit_point;
4340     }
4341
4342   number = section->sh_size / section->sh_entsize;
4343
4344   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4345     {
4346       error (_("Invalid sh_entsize\n"));
4347       goto exit_point;
4348     }
4349
4350   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4351                                            section->sh_size, _("symbols"));
4352   if (esyms == NULL)
4353     goto exit_point;
4354
4355   shndx = NULL;
4356   if (symtab_shndx_hdr != NULL
4357       && (symtab_shndx_hdr->sh_link
4358           == (unsigned long) (section - section_headers)))
4359     {
4360       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4361                                                    symtab_shndx_hdr->sh_offset,
4362                                                    1, symtab_shndx_hdr->sh_size,
4363                                                    _("symbol table section indicies"));
4364       if (shndx == NULL)
4365         goto exit_point;
4366     }
4367
4368   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4369
4370   if (isyms == NULL)
4371     {
4372       error (_("Out of memory\n"));
4373       goto exit_point;
4374     }
4375
4376   for (j = 0, psym = isyms; j < number; j++, psym++)
4377     {
4378       psym->st_name  = BYTE_GET (esyms[j].st_name);
4379       psym->st_value = BYTE_GET (esyms[j].st_value);
4380       psym->st_size  = BYTE_GET (esyms[j].st_size);
4381       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4382       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4383         psym->st_shndx
4384           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4385       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4386         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4387       psym->st_info  = BYTE_GET (esyms[j].st_info);
4388       psym->st_other = BYTE_GET (esyms[j].st_other);
4389     }
4390
4391  exit_point:
4392   if (shndx != NULL)
4393     free (shndx);
4394   if (esyms != NULL)
4395     free (esyms);
4396
4397   if (num_syms_return != NULL)
4398     * num_syms_return = isyms == NULL ? 0 : number;
4399
4400   return isyms;
4401 }
4402
4403 static Elf_Internal_Sym *
4404 get_64bit_elf_symbols (FILE * file,
4405                        Elf_Internal_Shdr * section,
4406                        unsigned long * num_syms_return)
4407 {
4408   unsigned long number = 0;
4409   Elf64_External_Sym * esyms = NULL;
4410   Elf_External_Sym_Shndx * shndx = NULL;
4411   Elf_Internal_Sym * isyms = NULL;
4412   Elf_Internal_Sym * psym;
4413   unsigned int j;
4414
4415   /* Run some sanity checks first.  */
4416   if (section->sh_entsize == 0)
4417     {
4418       error (_("sh_entsize is zero\n"));
4419       goto exit_point;
4420     }
4421
4422   number = section->sh_size / section->sh_entsize;
4423
4424   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4425     {
4426       error (_("Invalid sh_entsize\n"));
4427       goto exit_point;
4428     }
4429
4430   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4431                                            section->sh_size, _("symbols"));
4432   if (!esyms)
4433     goto exit_point;
4434
4435   if (symtab_shndx_hdr != NULL
4436       && (symtab_shndx_hdr->sh_link
4437           == (unsigned long) (section - section_headers)))
4438     {
4439       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4440                                                    symtab_shndx_hdr->sh_offset,
4441                                                    1, symtab_shndx_hdr->sh_size,
4442                                                    _("symbol table section indicies"));
4443       if (shndx == NULL)
4444         goto exit_point;
4445     }
4446
4447   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4448
4449   if (isyms == NULL)
4450     {
4451       error (_("Out of memory\n"));
4452       goto exit_point;
4453     }
4454
4455   for (j = 0, psym = isyms; j < number; j++, psym++)
4456     {
4457       psym->st_name  = BYTE_GET (esyms[j].st_name);
4458       psym->st_info  = BYTE_GET (esyms[j].st_info);
4459       psym->st_other = BYTE_GET (esyms[j].st_other);
4460       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4461
4462       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4463         psym->st_shndx
4464           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4465       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4466         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4467
4468       psym->st_value = BYTE_GET (esyms[j].st_value);
4469       psym->st_size  = BYTE_GET (esyms[j].st_size);
4470     }
4471
4472  exit_point:
4473   if (shndx != NULL)
4474     free (shndx);
4475   if (esyms != NULL)
4476     free (esyms);
4477
4478   if (num_syms_return != NULL)
4479     * num_syms_return = isyms == NULL ? 0 : number;
4480
4481   return isyms;
4482 }
4483
4484 static const char *
4485 get_elf_section_flags (bfd_vma sh_flags)
4486 {
4487   static char buff[1024];
4488   char * p = buff;
4489   int field_size = is_32bit_elf ? 8 : 16;
4490   int sindex;
4491   int size = sizeof (buff) - (field_size + 4 + 1);
4492   bfd_vma os_flags = 0;
4493   bfd_vma proc_flags = 0;
4494   bfd_vma unknown_flags = 0;
4495   static const struct
4496     {
4497       const char * str;
4498       int len;
4499     }
4500   flags [] =
4501     {
4502       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
4503       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
4504       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
4505       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
4506       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
4507       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
4508       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4509       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4510       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
4511       /*  9 */ { STRING_COMMA_LEN ("TLS") },
4512       /* IA-64 specific.  */
4513       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4514       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4515       /* IA-64 OpenVMS specific.  */
4516       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4517       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4518       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4519       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4520       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4521       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4522       /* Generic.  */
4523       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4524       /* SPARC specific.  */
4525       /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4526     };
4527
4528   if (do_section_details)
4529     {
4530       sprintf (buff, "[%*.*lx]: ",
4531                field_size, field_size, (unsigned long) sh_flags);
4532       p += field_size + 4;
4533     }
4534
4535   while (sh_flags)
4536     {
4537       bfd_vma flag;
4538
4539       flag = sh_flags & - sh_flags;
4540       sh_flags &= ~ flag;
4541
4542       if (do_section_details)
4543         {
4544           switch (flag)
4545             {
4546             case SHF_WRITE:             sindex = 0; break;
4547             case SHF_ALLOC:             sindex = 1; break;
4548             case SHF_EXECINSTR:         sindex = 2; break;
4549             case SHF_MERGE:             sindex = 3; break;
4550             case SHF_STRINGS:           sindex = 4; break;
4551             case SHF_INFO_LINK:         sindex = 5; break;
4552             case SHF_LINK_ORDER:        sindex = 6; break;
4553             case SHF_OS_NONCONFORMING:  sindex = 7; break;
4554             case SHF_GROUP:             sindex = 8; break;
4555             case SHF_TLS:               sindex = 9; break;
4556             case SHF_EXCLUDE:           sindex = 18; break;
4557
4558             default:
4559               sindex = -1;
4560               switch (elf_header.e_machine)
4561                 {
4562                 case EM_IA_64:
4563                   if (flag == SHF_IA_64_SHORT)
4564                     sindex = 10;
4565                   else if (flag == SHF_IA_64_NORECOV)
4566                     sindex = 11;
4567 #ifdef BFD64
4568                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4569                     switch (flag)
4570                       {
4571                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
4572                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
4573                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
4574                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
4575                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4576                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
4577                       default:                        break;
4578                       }
4579 #endif
4580                   break;
4581
4582                 case EM_386:
4583                 case EM_486:
4584                 case EM_X86_64:
4585                 case EM_L1OM:
4586                 case EM_K1OM:
4587                 case EM_OLD_SPARCV9:
4588                 case EM_SPARC32PLUS:
4589                 case EM_SPARCV9:
4590                 case EM_SPARC:
4591                   if (flag == SHF_ORDERED)
4592                     sindex = 19;
4593                   break;
4594                 default:
4595                   break;
4596                 }
4597             }
4598
4599           if (sindex != -1)
4600             {
4601               if (p != buff + field_size + 4)
4602                 {
4603                   if (size < (10 + 2))
4604                     abort ();
4605                   size -= 2;
4606                   *p++ = ',';
4607                   *p++ = ' ';
4608                 }
4609
4610               size -= flags [sindex].len;
4611               p = stpcpy (p, flags [sindex].str);
4612             }
4613           else if (flag & SHF_MASKOS)
4614             os_flags |= flag;
4615           else if (flag & SHF_MASKPROC)
4616             proc_flags |= flag;
4617           else
4618             unknown_flags |= flag;
4619         }
4620       else
4621         {
4622           switch (flag)
4623             {
4624             case SHF_WRITE:             *p = 'W'; break;
4625             case SHF_ALLOC:             *p = 'A'; break;
4626             case SHF_EXECINSTR:         *p = 'X'; break;
4627             case SHF_MERGE:             *p = 'M'; break;
4628             case SHF_STRINGS:           *p = 'S'; break;
4629             case SHF_INFO_LINK:         *p = 'I'; break;
4630             case SHF_LINK_ORDER:        *p = 'L'; break;
4631             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
4632             case SHF_GROUP:             *p = 'G'; break;
4633             case SHF_TLS:               *p = 'T'; break;
4634             case SHF_EXCLUDE:           *p = 'E'; break;
4635
4636             default:
4637               if ((elf_header.e_machine == EM_X86_64
4638                    || elf_header.e_machine == EM_L1OM
4639                    || elf_header.e_machine == EM_K1OM)
4640                   && flag == SHF_X86_64_LARGE)
4641                 *p = 'l';
4642               else if (flag & SHF_MASKOS)
4643                 {
4644                   *p = 'o';
4645                   sh_flags &= ~ SHF_MASKOS;
4646                 }
4647               else if (flag & SHF_MASKPROC)
4648                 {
4649                   *p = 'p';
4650                   sh_flags &= ~ SHF_MASKPROC;
4651                 }
4652               else
4653                 *p = 'x';
4654               break;
4655             }
4656           p++;
4657         }
4658     }
4659
4660   if (do_section_details)
4661     {
4662       if (os_flags)
4663         {
4664           size -= 5 + field_size;
4665           if (p != buff + field_size + 4)
4666             {
4667               if (size < (2 + 1))
4668                 abort ();
4669               size -= 2;
4670               *p++ = ',';
4671               *p++ = ' ';
4672             }
4673           sprintf (p, "OS (%*.*lx)", field_size, field_size,
4674                    (unsigned long) os_flags);
4675           p += 5 + field_size;
4676         }
4677       if (proc_flags)
4678         {
4679           size -= 7 + field_size;
4680           if (p != buff + field_size + 4)
4681             {
4682               if (size < (2 + 1))
4683                 abort ();
4684               size -= 2;
4685               *p++ = ',';
4686               *p++ = ' ';
4687             }
4688           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4689                    (unsigned long) proc_flags);
4690           p += 7 + field_size;
4691         }
4692       if (unknown_flags)
4693         {
4694           size -= 10 + field_size;
4695           if (p != buff + field_size + 4)
4696             {
4697               if (size < (2 + 1))
4698                 abort ();
4699               size -= 2;
4700               *p++ = ',';
4701               *p++ = ' ';
4702             }
4703           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
4704                    (unsigned long) unknown_flags);
4705           p += 10 + field_size;
4706         }
4707     }
4708
4709   *p = '\0';
4710   return buff;
4711 }
4712
4713 static int
4714 process_section_headers (FILE * file)
4715 {
4716   Elf_Internal_Shdr * section;
4717   unsigned int i;
4718
4719   section_headers = NULL;
4720
4721   if (elf_header.e_shnum == 0)
4722     {
4723       /* PR binutils/12467.  */
4724       if (elf_header.e_shoff != 0)
4725         warn (_("possibly corrupt ELF file header - it has a non-zero"
4726                 " section header offset, but no section headers\n"));
4727       else if (do_sections)
4728         printf (_("\nThere are no sections in this file.\n"));
4729
4730       return 1;
4731     }
4732
4733   if (do_sections && !do_header)
4734     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4735             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4736
4737   if (is_32bit_elf)
4738     {
4739       if (! get_32bit_section_headers (file, elf_header.e_shnum))
4740         return 0;
4741     }
4742   else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4743     return 0;
4744
4745   /* Read in the string table, so that we have names to display.  */
4746   if (elf_header.e_shstrndx != SHN_UNDEF
4747        && elf_header.e_shstrndx < elf_header.e_shnum)
4748     {
4749       section = section_headers + elf_header.e_shstrndx;
4750
4751       if (section->sh_size != 0)
4752         {
4753           string_table = (char *) get_data (NULL, file, section->sh_offset,
4754                                             1, section->sh_size,
4755                                             _("string table"));
4756
4757           string_table_length = string_table != NULL ? section->sh_size : 0;
4758         }
4759     }
4760
4761   /* Scan the sections for the dynamic symbol table
4762      and dynamic string table and debug sections.  */
4763   dynamic_symbols = NULL;
4764   dynamic_strings = NULL;
4765   dynamic_syminfo = NULL;
4766   symtab_shndx_hdr = NULL;
4767
4768   eh_addr_size = is_32bit_elf ? 4 : 8;
4769   switch (elf_header.e_machine)
4770     {
4771     case EM_MIPS:
4772     case EM_MIPS_RS3_LE:
4773       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4774          FDE addresses.  However, the ABI also has a semi-official ILP32
4775          variant for which the normal FDE address size rules apply.
4776
4777          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4778          section, where XX is the size of longs in bits.  Unfortunately,
4779          earlier compilers provided no way of distinguishing ILP32 objects
4780          from LP64 objects, so if there's any doubt, we should assume that
4781          the official LP64 form is being used.  */
4782       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4783           && find_section (".gcc_compiled_long32") == NULL)
4784         eh_addr_size = 8;
4785       break;
4786
4787     case EM_H8_300:
4788     case EM_H8_300H:
4789       switch (elf_header.e_flags & EF_H8_MACH)
4790         {
4791         case E_H8_MACH_H8300:
4792         case E_H8_MACH_H8300HN:
4793         case E_H8_MACH_H8300SN:
4794         case E_H8_MACH_H8300SXN:
4795           eh_addr_size = 2;
4796           break;
4797         case E_H8_MACH_H8300H:
4798         case E_H8_MACH_H8300S:
4799         case E_H8_MACH_H8300SX:
4800           eh_addr_size = 4;
4801           break;
4802         }
4803       break;
4804
4805     case EM_M32C_OLD:
4806     case EM_M32C:
4807       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4808         {
4809         case EF_M32C_CPU_M16C:
4810           eh_addr_size = 2;
4811           break;
4812         }
4813       break;
4814     }
4815
4816 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4817   do                                                                        \
4818     {                                                                       \
4819       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;      \
4820       if (section->sh_entsize != expected_entsize)                          \
4821         {                                                               \
4822           error (_("Section %d has invalid sh_entsize of %" BFD_VMA_FMT "x\n"), \
4823                  i, section->sh_entsize);       \
4824           error (_("(Using the expected size of %d for the rest of this dump)\n"), \
4825                    (int) expected_entsize); \
4826           section->sh_entsize = expected_entsize;                       \
4827         } \
4828     }                                                                       \
4829   while (0)
4830
4831 #define CHECK_ENTSIZE(section, i, type)                                 \
4832   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
4833                         sizeof (Elf64_External_##type))
4834
4835   for (i = 0, section = section_headers;
4836        i < elf_header.e_shnum;
4837        i++, section++)
4838     {
4839       char * name = SECTION_NAME (section);
4840
4841       if (section->sh_type == SHT_DYNSYM)
4842         {
4843           if (dynamic_symbols != NULL)
4844             {
4845               error (_("File contains multiple dynamic symbol tables\n"));
4846               continue;
4847             }
4848
4849           CHECK_ENTSIZE (section, i, Sym);
4850           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
4851         }
4852       else if (section->sh_type == SHT_STRTAB
4853                && streq (name, ".dynstr"))
4854         {
4855           if (dynamic_strings != NULL)
4856             {
4857               error (_("File contains multiple dynamic string tables\n"));
4858               continue;
4859             }
4860
4861           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4862                                                1, section->sh_size,
4863                                                _("dynamic strings"));
4864           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
4865         }
4866       else if (section->sh_type == SHT_SYMTAB_SHNDX)
4867         {
4868           if (symtab_shndx_hdr != NULL)
4869             {
4870               error (_("File contains multiple symtab shndx tables\n"));
4871               continue;
4872             }
4873           symtab_shndx_hdr = section;
4874         }
4875       else if (section->sh_type == SHT_SYMTAB)
4876         CHECK_ENTSIZE (section, i, Sym);
4877       else if (section->sh_type == SHT_GROUP)
4878         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4879       else if (section->sh_type == SHT_REL)
4880         CHECK_ENTSIZE (section, i, Rel);
4881       else if (section->sh_type == SHT_RELA)
4882         CHECK_ENTSIZE (section, i, Rela);
4883       else if ((do_debugging || do_debug_info || do_debug_abbrevs
4884                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
4885                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
4886                 || do_debug_str || do_debug_loc || do_debug_ranges
4887                 || do_debug_addr || do_debug_cu_index)
4888                && (const_strneq (name, ".debug_")
4889                    || const_strneq (name, ".zdebug_")))
4890         {
4891           if (name[1] == 'z')
4892             name += sizeof (".zdebug_") - 1;
4893           else
4894             name += sizeof (".debug_") - 1;
4895
4896           if (do_debugging
4897               || (do_debug_info     && const_strneq (name, "info"))
4898               || (do_debug_info     && const_strneq (name, "types"))
4899               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
4900               || (do_debug_lines    && strcmp (name, "line") == 0)
4901               || (do_debug_lines    && const_strneq (name, "line."))
4902               || (do_debug_pubnames && const_strneq (name, "pubnames"))
4903               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
4904               || (do_debug_aranges  && const_strneq (name, "aranges"))
4905               || (do_debug_ranges   && const_strneq (name, "ranges"))
4906               || (do_debug_frames   && const_strneq (name, "frame"))
4907               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
4908               || (do_debug_macinfo  && const_strneq (name, "macro"))
4909               || (do_debug_str      && const_strneq (name, "str"))
4910               || (do_debug_loc      && const_strneq (name, "loc"))
4911               || (do_debug_addr     && const_strneq (name, "addr"))
4912               || (do_debug_cu_index && const_strneq (name, "cu_index"))
4913               || (do_debug_cu_index && const_strneq (name, "tu_index"))
4914               )
4915             request_dump_bynumber (i, DEBUG_DUMP);
4916         }
4917       /* Linkonce section to be combined with .debug_info at link time.  */
4918       else if ((do_debugging || do_debug_info)
4919                && const_strneq (name, ".gnu.linkonce.wi."))
4920         request_dump_bynumber (i, DEBUG_DUMP);
4921       else if (do_debug_frames && streq (name, ".eh_frame"))
4922         request_dump_bynumber (i, DEBUG_DUMP);
4923       else if (do_gdb_index && streq (name, ".gdb_index"))
4924         request_dump_bynumber (i, DEBUG_DUMP);
4925       /* Trace sections for Itanium VMS.  */
4926       else if ((do_debugging || do_trace_info || do_trace_abbrevs
4927                 || do_trace_aranges)
4928                && const_strneq (name, ".trace_"))
4929         {
4930           name += sizeof (".trace_") - 1;
4931
4932           if (do_debugging
4933               || (do_trace_info     && streq (name, "info"))
4934               || (do_trace_abbrevs  && streq (name, "abbrev"))
4935               || (do_trace_aranges  && streq (name, "aranges"))
4936               )
4937             request_dump_bynumber (i, DEBUG_DUMP);
4938         }
4939
4940     }
4941
4942   if (! do_sections)
4943     return 1;
4944
4945   if (elf_header.e_shnum > 1)
4946     printf (_("\nSection Headers:\n"));
4947   else
4948     printf (_("\nSection Header:\n"));
4949
4950   if (is_32bit_elf)
4951     {
4952       if (do_section_details)
4953         {
4954           printf (_("  [Nr] Name\n"));
4955           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
4956         }
4957       else
4958         printf
4959           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
4960     }
4961   else if (do_wide)
4962     {
4963       if (do_section_details)
4964         {
4965           printf (_("  [Nr] Name\n"));
4966           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
4967         }
4968       else
4969         printf
4970           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
4971     }
4972   else
4973     {
4974       if (do_section_details)
4975         {
4976           printf (_("  [Nr] Name\n"));
4977           printf (_("       Type              Address          Offset            Link\n"));
4978           printf (_("       Size              EntSize          Info              Align\n"));
4979         }
4980       else
4981         {
4982           printf (_("  [Nr] Name              Type             Address           Offset\n"));
4983           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
4984         }
4985     }
4986
4987   if (do_section_details)
4988     printf (_("       Flags\n"));
4989
4990   for (i = 0, section = section_headers;
4991        i < elf_header.e_shnum;
4992        i++, section++)
4993     {
4994       printf ("  [%2u] ", i);
4995       if (do_section_details)
4996         {
4997           print_symbol (INT_MAX, SECTION_NAME (section));
4998           printf ("\n      ");
4999         }
5000       else
5001         {
5002           print_symbol (-17, SECTION_NAME (section));
5003         }
5004
5005       printf (do_wide ? " %-15s " : " %-15.15s ",
5006               get_section_type_name (section->sh_type));
5007
5008       if (is_32bit_elf)
5009         {
5010           const char * link_too_big = NULL;
5011
5012           print_vma (section->sh_addr, LONG_HEX);
5013
5014           printf ( " %6.6lx %6.6lx %2.2lx",
5015                    (unsigned long) section->sh_offset,
5016                    (unsigned long) section->sh_size,
5017                    (unsigned long) section->sh_entsize);
5018
5019           if (do_section_details)
5020             fputs ("  ", stdout);
5021           else
5022             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5023
5024           if (section->sh_link >= elf_header.e_shnum)
5025             {
5026               link_too_big = "";
5027               /* The sh_link value is out of range.  Normally this indicates
5028                  an error but it can have special values in Solaris binaries.  */
5029               switch (elf_header.e_machine)
5030                 {
5031                 case EM_386:
5032                 case EM_486:
5033                 case EM_X86_64:
5034                 case EM_L1OM:
5035                 case EM_K1OM:
5036                 case EM_OLD_SPARCV9:
5037                 case EM_SPARC32PLUS:
5038                 case EM_SPARCV9:
5039                 case EM_SPARC:
5040                   if (section->sh_link == (SHN_BEFORE & 0xffff))
5041                     link_too_big = "BEFORE";
5042                   else if (section->sh_link == (SHN_AFTER & 0xffff))
5043                     link_too_big = "AFTER";
5044                   break;
5045                 default:
5046                   break;
5047                 }
5048             }
5049
5050           if (do_section_details)
5051             {
5052               if (link_too_big != NULL && * link_too_big)
5053                 printf ("<%s> ", link_too_big);
5054               else
5055                 printf ("%2u ", section->sh_link);
5056               printf ("%3u %2lu\n", section->sh_info,
5057                       (unsigned long) section->sh_addralign);
5058             }
5059           else
5060             printf ("%2u %3u %2lu\n",
5061                     section->sh_link,
5062                     section->sh_info,
5063                     (unsigned long) section->sh_addralign);
5064
5065           if (link_too_big && ! * link_too_big)
5066             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5067                   i, section->sh_link);
5068         }
5069       else if (do_wide)
5070         {
5071           print_vma (section->sh_addr, LONG_HEX);
5072
5073           if ((long) section->sh_offset == section->sh_offset)
5074             printf (" %6.6lx", (unsigned long) section->sh_offset);
5075           else
5076             {
5077               putchar (' ');
5078               print_vma (section->sh_offset, LONG_HEX);
5079             }
5080
5081           if ((unsigned long) section->sh_size == section->sh_size)
5082             printf (" %6.6lx", (unsigned long) section->sh_size);
5083           else
5084             {
5085               putchar (' ');
5086               print_vma (section->sh_size, LONG_HEX);
5087             }
5088
5089           if ((unsigned long) section->sh_entsize == section->sh_entsize)
5090             printf (" %2.2lx", (unsigned long) section->sh_entsize);
5091           else
5092             {
5093               putchar (' ');
5094               print_vma (section->sh_entsize, LONG_HEX);
5095             }
5096
5097           if (do_section_details)
5098             fputs ("  ", stdout);
5099           else
5100             printf (" %3s ", get_elf_section_flags (section->sh_flags));
5101
5102           printf ("%2u %3u ", section->sh_link, section->sh_info);
5103
5104           if ((unsigned long) section->sh_addralign == section->sh_addralign)
5105             printf ("%2lu\n", (unsigned long) section->sh_addralign);
5106           else
5107             {
5108               print_vma (section->sh_addralign, DEC);
5109               putchar ('\n');
5110             }
5111         }
5112       else if (do_section_details)
5113         {
5114           printf ("       %-15.15s  ",
5115                   get_section_type_name (section->sh_type));
5116           print_vma (section->sh_addr, LONG_HEX);
5117           if ((long) section->sh_offset == section->sh_offset)
5118             printf ("  %16.16lx", (unsigned long) section->sh_offset);
5119           else
5120             {
5121               printf ("  ");
5122               print_vma (section->sh_offset, LONG_HEX);
5123             }
5124           printf ("  %u\n       ", section->sh_link);
5125           print_vma (section->sh_size, LONG_HEX);
5126           putchar (' ');
5127           print_vma (section->sh_entsize, LONG_HEX);
5128
5129           printf ("  %-16u  %lu\n",
5130                   section->sh_info,
5131                   (unsigned long) section->sh_addralign);
5132         }
5133       else
5134         {
5135           putchar (' ');
5136           print_vma (section->sh_addr, LONG_HEX);
5137           if ((long) section->sh_offset == section->sh_offset)
5138             printf ("  %8.8lx", (unsigned long) section->sh_offset);
5139           else
5140             {
5141               printf ("  ");
5142               print_vma (section->sh_offset, LONG_HEX);
5143             }
5144           printf ("\n       ");
5145           print_vma (section->sh_size, LONG_HEX);
5146           printf ("  ");
5147           print_vma (section->sh_entsize, LONG_HEX);
5148
5149           printf (" %3s ", get_elf_section_flags (section->sh_flags));
5150
5151           printf ("     %2u   %3u     %lu\n",
5152                   section->sh_link,
5153                   section->sh_info,
5154                   (unsigned long) section->sh_addralign);
5155         }
5156
5157       if (do_section_details)
5158         printf ("       %s\n", get_elf_section_flags (section->sh_flags));
5159     }
5160
5161   if (!do_section_details)
5162     {
5163       if (elf_header.e_machine == EM_X86_64
5164           || elf_header.e_machine == EM_L1OM
5165           || elf_header.e_machine == EM_K1OM)
5166         printf (_("Key to Flags:\n\
5167   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5168   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5169   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5170       else
5171         printf (_("Key to Flags:\n\
5172   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5173   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5174   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5175     }
5176
5177   return 1;
5178 }
5179
5180 static const char *
5181 get_group_flags (unsigned int flags)
5182 {
5183   static char buff[32];
5184   switch (flags)
5185     {
5186     case 0:
5187       return "";
5188
5189     case GRP_COMDAT:
5190       return "COMDAT ";
5191
5192    default:
5193       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5194       break;
5195     }
5196   return buff;
5197 }
5198
5199 static int
5200 process_section_groups (FILE * file)
5201 {
5202   Elf_Internal_Shdr * section;
5203   unsigned int i;
5204   struct group * group;
5205   Elf_Internal_Shdr * symtab_sec;
5206   Elf_Internal_Shdr * strtab_sec;
5207   Elf_Internal_Sym * symtab;
5208   unsigned long num_syms;
5209   char * strtab;
5210   size_t strtab_size;
5211
5212   /* Don't process section groups unless needed.  */
5213   if (!do_unwind && !do_section_groups)
5214     return 1;
5215
5216   if (elf_header.e_shnum == 0)
5217     {
5218       if (do_section_groups)
5219         printf (_("\nThere are no sections to group in this file.\n"));
5220
5221       return 1;
5222     }
5223
5224   if (section_headers == NULL)
5225     {
5226       error (_("Section headers are not available!\n"));
5227       /* PR 13622: This can happen with a corrupt ELF header.  */
5228       return 0;
5229     }
5230
5231   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5232                                                      sizeof (struct group *));
5233
5234   if (section_headers_groups == NULL)
5235     {
5236       error (_("Out of memory\n"));
5237       return 0;
5238     }
5239
5240   /* Scan the sections for the group section.  */
5241   group_count = 0;
5242   for (i = 0, section = section_headers;
5243        i < elf_header.e_shnum;
5244        i++, section++)
5245     if (section->sh_type == SHT_GROUP)
5246       group_count++;
5247
5248   if (group_count == 0)
5249     {
5250       if (do_section_groups)
5251         printf (_("\nThere are no section groups in this file.\n"));
5252
5253       return 1;
5254     }
5255
5256   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5257
5258   if (section_groups == NULL)
5259     {
5260       error (_("Out of memory\n"));
5261       return 0;
5262     }
5263
5264   symtab_sec = NULL;
5265   strtab_sec = NULL;
5266   symtab = NULL;
5267   num_syms = 0;
5268   strtab = NULL;
5269   strtab_size = 0;
5270   for (i = 0, section = section_headers, group = section_groups;
5271        i < elf_header.e_shnum;
5272        i++, section++)
5273     {
5274       if (section->sh_type == SHT_GROUP)
5275         {
5276           char * name = SECTION_NAME (section);
5277           char * group_name;
5278           unsigned char * start;
5279           unsigned char * indices;
5280           unsigned int entry, j, size;
5281           Elf_Internal_Shdr * sec;
5282           Elf_Internal_Sym * sym;
5283
5284           /* Get the symbol table.  */
5285           if (section->sh_link >= elf_header.e_shnum
5286               || ((sec = section_headers + section->sh_link)->sh_type
5287                   != SHT_SYMTAB))
5288             {
5289               error (_("Bad sh_link in group section `%s'\n"), name);
5290               continue;
5291             }
5292
5293           if (symtab_sec != sec)
5294             {
5295               symtab_sec = sec;
5296               if (symtab)
5297                 free (symtab);
5298               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5299             }
5300
5301           if (symtab == NULL)
5302             {
5303               error (_("Corrupt header in group section `%s'\n"), name);
5304               continue;
5305             }
5306
5307           if (section->sh_info >= num_syms)
5308             {
5309               error (_("Bad sh_info in group section `%s'\n"), name);
5310               continue;
5311             }
5312
5313           sym = symtab + section->sh_info;
5314
5315           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5316             {
5317               if (sym->st_shndx == 0
5318                   || sym->st_shndx >= elf_header.e_shnum)
5319                 {
5320                   error (_("Bad sh_info in group section `%s'\n"), name);
5321                   continue;
5322                 }
5323
5324               group_name = SECTION_NAME (section_headers + sym->st_shndx);
5325               strtab_sec = NULL;
5326               if (strtab)
5327                 free (strtab);
5328               strtab = NULL;
5329               strtab_size = 0;
5330             }
5331           else
5332             {
5333               /* Get the string table.  */
5334               if (symtab_sec->sh_link >= elf_header.e_shnum)
5335                 {
5336                   strtab_sec = NULL;
5337                   if (strtab)
5338                     free (strtab);
5339                   strtab = NULL;
5340                   strtab_size = 0;
5341                 }
5342               else if (strtab_sec
5343                        != (sec = section_headers + symtab_sec->sh_link))
5344                 {
5345                   strtab_sec = sec;
5346                   if (strtab)
5347                     free (strtab);
5348                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5349                                               1, strtab_sec->sh_size,
5350                                               _("string table"));
5351                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5352                 }
5353               group_name = sym->st_name < strtab_size
5354                 ? strtab + sym->st_name : _("<corrupt>");
5355             }
5356
5357           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5358                                               1, section->sh_size,
5359                                               _("section data"));
5360           if (start == NULL)
5361             continue;
5362
5363           indices = start;
5364           size = (section->sh_size / section->sh_entsize) - 1;
5365           entry = byte_get (indices, 4);
5366           indices += 4;
5367
5368           if (do_section_groups)
5369             {
5370               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5371                       get_group_flags (entry), i, name, group_name, size);
5372
5373               printf (_("   [Index]    Name\n"));
5374             }
5375
5376           group->group_index = i;
5377
5378           for (j = 0; j < size; j++)
5379             {
5380               struct group_list * g;
5381
5382               entry = byte_get (indices, 4);
5383               indices += 4;
5384
5385               if (entry >= elf_header.e_shnum)
5386                 {
5387                   error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5388                          entry, i, elf_header.e_shnum - 1);
5389                   continue;
5390                 }
5391
5392               if (section_headers_groups [entry] != NULL)
5393                 {
5394                   if (entry)
5395                     {
5396                       error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5397                              entry, i,
5398                              section_headers_groups [entry]->group_index);
5399                       continue;
5400                     }
5401                   else
5402                     {
5403                       /* Intel C/C++ compiler may put section 0 in a
5404                          section group. We just warn it the first time
5405                          and ignore it afterwards.  */
5406                       static int warned = 0;
5407                       if (!warned)
5408                         {
5409                           error (_("section 0 in group section [%5u]\n"),
5410                                  section_headers_groups [entry]->group_index);
5411                           warned++;
5412                         }
5413                     }
5414                 }
5415
5416               section_headers_groups [entry] = group;
5417
5418               if (do_section_groups)
5419                 {
5420                   sec = section_headers + entry;
5421                   printf ("   [%5u]   %s\n", entry, SECTION_NAME (sec));
5422                 }
5423
5424               g = (struct group_list *) xmalloc (sizeof (struct group_list));
5425               g->section_index = entry;
5426               g->next = group->root;
5427               group->root = g;
5428             }
5429
5430           if (start)
5431             free (start);
5432
5433           group++;
5434         }
5435     }
5436
5437   if (symtab)
5438     free (symtab);
5439   if (strtab)
5440     free (strtab);
5441   return 1;
5442 }
5443
5444 /* Data used to display dynamic fixups.  */
5445
5446 struct ia64_vms_dynfixup
5447 {
5448   bfd_vma needed_ident;         /* Library ident number.  */
5449   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
5450   bfd_vma fixup_needed;         /* Index of the library.  */
5451   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
5452   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
5453 };
5454
5455 /* Data used to display dynamic relocations.  */
5456
5457 struct ia64_vms_dynimgrela
5458 {
5459   bfd_vma img_rela_cnt;         /* Number of relocations.  */
5460   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
5461 };
5462
5463 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5464    library).  */
5465
5466 static void
5467 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5468                               const char *strtab, unsigned int strtab_sz)
5469 {
5470   Elf64_External_VMS_IMAGE_FIXUP *imfs;
5471   long i;
5472   const char *lib_name;
5473
5474   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5475                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
5476                    _("dynamic section image fixups"));
5477   if (!imfs)
5478     return;
5479
5480   if (fixup->needed < strtab_sz)
5481     lib_name = strtab + fixup->needed;
5482   else
5483     {
5484       warn ("corrupt library name index of 0x%lx found in dynamic entry",
5485             (unsigned long) fixup->needed);
5486       lib_name = "???";
5487     }
5488   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5489           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5490   printf
5491     (_("Seg Offset           Type                             SymVec DataType\n"));
5492
5493   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5494     {
5495       unsigned int type;
5496       const char *rtype;
5497
5498       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5499       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5500       type = BYTE_GET (imfs [i].type);
5501       rtype = elf_ia64_reloc_type (type);
5502       if (rtype == NULL)
5503         printf (" 0x%08x                       ", type);
5504       else
5505         printf (" %-32s ", rtype);
5506       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5507       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5508     }
5509
5510   free (imfs);
5511 }
5512
5513 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
5514
5515 static void
5516 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5517 {
5518   Elf64_External_VMS_IMAGE_RELA *imrs;
5519   long i;
5520
5521   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5522                    1, imgrela->img_rela_cnt * sizeof (*imrs),
5523                    _("dynamic section image relocations"));
5524   if (!imrs)
5525     return;
5526
5527   printf (_("\nImage relocs\n"));
5528   printf
5529     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
5530
5531   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5532     {
5533       unsigned int type;
5534       const char *rtype;
5535
5536       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5537       printf ("%08" BFD_VMA_FMT "x ",
5538               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5539       type = BYTE_GET (imrs [i].type);
5540       rtype = elf_ia64_reloc_type (type);
5541       if (rtype == NULL)
5542         printf ("0x%08x                      ", type);
5543       else
5544         printf ("%-31s ", rtype);
5545       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5546       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5547       printf ("%08" BFD_VMA_FMT "x\n",
5548               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5549     }
5550
5551   free (imrs);
5552 }
5553
5554 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
5555
5556 static int
5557 process_ia64_vms_dynamic_relocs (FILE *file)
5558 {
5559   struct ia64_vms_dynfixup fixup;
5560   struct ia64_vms_dynimgrela imgrela;
5561   Elf_Internal_Dyn *entry;
5562   int res = 0;
5563   bfd_vma strtab_off = 0;
5564   bfd_vma strtab_sz = 0;
5565   char *strtab = NULL;
5566
5567   memset (&fixup, 0, sizeof (fixup));
5568   memset (&imgrela, 0, sizeof (imgrela));
5569
5570   /* Note: the order of the entries is specified by the OpenVMS specs.  */
5571   for (entry = dynamic_section;
5572        entry < dynamic_section + dynamic_nent;
5573        entry++)
5574     {
5575       switch (entry->d_tag)
5576         {
5577         case DT_IA_64_VMS_STRTAB_OFFSET:
5578           strtab_off = entry->d_un.d_val;
5579           break;
5580         case DT_STRSZ:
5581           strtab_sz = entry->d_un.d_val;
5582           if (strtab == NULL)
5583             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5584                                1, strtab_sz, _("dynamic string section"));
5585           break;
5586
5587         case DT_IA_64_VMS_NEEDED_IDENT:
5588           fixup.needed_ident = entry->d_un.d_val;
5589           break;
5590         case DT_NEEDED:
5591           fixup.needed = entry->d_un.d_val;
5592           break;
5593         case DT_IA_64_VMS_FIXUP_NEEDED:
5594           fixup.fixup_needed = entry->d_un.d_val;
5595           break;
5596         case DT_IA_64_VMS_FIXUP_RELA_CNT:
5597           fixup.fixup_rela_cnt = entry->d_un.d_val;
5598           break;
5599         case DT_IA_64_VMS_FIXUP_RELA_OFF:
5600           fixup.fixup_rela_off = entry->d_un.d_val;
5601           res++;
5602           dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5603           break;
5604
5605         case DT_IA_64_VMS_IMG_RELA_CNT:
5606           imgrela.img_rela_cnt = entry->d_un.d_val;
5607           break;
5608         case DT_IA_64_VMS_IMG_RELA_OFF:
5609           imgrela.img_rela_off = entry->d_un.d_val;
5610           res++;
5611           dump_ia64_vms_dynamic_relocs (file, &imgrela);
5612           break;
5613
5614         default:
5615           break;
5616         }
5617     }
5618
5619   if (strtab != NULL)
5620     free (strtab);
5621
5622   return res;
5623 }
5624
5625 static struct
5626 {
5627   const char * name;
5628   int reloc;
5629   int size;
5630   int rela;
5631 } dynamic_relocations [] =
5632 {
5633     { "REL", DT_REL, DT_RELSZ, FALSE },
5634     { "RELA", DT_RELA, DT_RELASZ, TRUE },
5635     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5636 };
5637
5638 /* Process the reloc section.  */
5639
5640 static int
5641 process_relocs (FILE * file)
5642 {
5643   unsigned long rel_size;
5644   unsigned long rel_offset;
5645
5646
5647   if (!do_reloc)
5648     return 1;
5649
5650   if (do_using_dynamic)
5651     {
5652       int is_rela;
5653       const char * name;
5654       int has_dynamic_reloc;
5655       unsigned int i;
5656
5657       has_dynamic_reloc = 0;
5658
5659       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5660         {
5661           is_rela = dynamic_relocations [i].rela;
5662           name = dynamic_relocations [i].name;
5663           rel_size = dynamic_info [dynamic_relocations [i].size];
5664           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5665
5666           has_dynamic_reloc |= rel_size;
5667
5668           if (is_rela == UNKNOWN)
5669             {
5670               if (dynamic_relocations [i].reloc == DT_JMPREL)
5671                 switch (dynamic_info[DT_PLTREL])
5672                   {
5673                   case DT_REL:
5674                     is_rela = FALSE;
5675                     break;
5676                   case DT_RELA:
5677                     is_rela = TRUE;
5678                     break;
5679                   }
5680             }
5681
5682           if (rel_size)
5683             {
5684               printf
5685                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5686                  name, rel_offset, rel_size);
5687
5688               dump_relocations (file,
5689                                 offset_from_vma (file, rel_offset, rel_size),
5690                                 rel_size,
5691                                 dynamic_symbols, num_dynamic_syms,
5692                                 dynamic_strings, dynamic_strings_length, is_rela);
5693             }
5694         }
5695
5696       if (is_ia64_vms ())
5697         has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5698
5699       if (! has_dynamic_reloc)
5700         printf (_("\nThere are no dynamic relocations in this file.\n"));
5701     }
5702   else
5703     {
5704       Elf_Internal_Shdr * section;
5705       unsigned long i;
5706       int found = 0;
5707
5708       for (i = 0, section = section_headers;
5709            i < elf_header.e_shnum;
5710            i++, section++)
5711         {
5712           if (   section->sh_type != SHT_RELA
5713               && section->sh_type != SHT_REL)
5714             continue;
5715
5716           rel_offset = section->sh_offset;
5717           rel_size   = section->sh_size;
5718
5719           if (rel_size)
5720             {
5721               Elf_Internal_Shdr * strsec;
5722               int is_rela;
5723
5724               printf (_("\nRelocation section "));
5725
5726               if (string_table == NULL)
5727                 printf ("%d", section->sh_name);
5728               else
5729                 printf ("'%s'", SECTION_NAME (section));
5730
5731               printf (_(" at offset 0x%lx contains %lu entries:\n"),
5732                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5733
5734               is_rela = section->sh_type == SHT_RELA;
5735
5736               if (section->sh_link != 0
5737                   && section->sh_link < elf_header.e_shnum)
5738                 {
5739                   Elf_Internal_Shdr * symsec;
5740                   Elf_Internal_Sym *  symtab;
5741                   unsigned long nsyms;
5742                   unsigned long strtablen = 0;
5743                   char * strtab = NULL;
5744
5745                   symsec = section_headers + section->sh_link;
5746                   if (symsec->sh_type != SHT_SYMTAB
5747                       && symsec->sh_type != SHT_DYNSYM)
5748                     continue;
5749
5750                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
5751
5752                   if (symtab == NULL)
5753                     continue;
5754
5755                   if (symsec->sh_link != 0
5756                       && symsec->sh_link < elf_header.e_shnum)
5757                     {
5758                       strsec = section_headers + symsec->sh_link;
5759
5760                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5761                                                   1, strsec->sh_size,
5762                                                   _("string table"));
5763                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
5764                     }
5765
5766                   dump_relocations (file, rel_offset, rel_size,
5767                                     symtab, nsyms, strtab, strtablen, is_rela);
5768                   if (strtab)
5769                     free (strtab);
5770                   free (symtab);
5771                 }
5772               else
5773                 dump_relocations (file, rel_offset, rel_size,
5774                                   NULL, 0, NULL, 0, is_rela);
5775
5776               found = 1;
5777             }
5778         }
5779
5780       if (! found)
5781         printf (_("\nThere are no relocations in this file.\n"));
5782     }
5783
5784   return 1;
5785 }
5786
5787 /* Process the unwind section.  */
5788
5789 #include "unwind-ia64.h"
5790
5791 /* An absolute address consists of a section and an offset.  If the
5792    section is NULL, the offset itself is the address, otherwise, the
5793    address equals to LOAD_ADDRESS(section) + offset.  */
5794
5795 struct absaddr
5796   {
5797     unsigned short section;
5798     bfd_vma offset;
5799   };
5800
5801 #define ABSADDR(a) \
5802   ((a).section \
5803    ? section_headers [(a).section].sh_addr + (a).offset \
5804    : (a).offset)
5805
5806 struct ia64_unw_table_entry
5807   {
5808     struct absaddr start;
5809     struct absaddr end;
5810     struct absaddr info;
5811   };
5812
5813 struct ia64_unw_aux_info
5814   {
5815
5816     struct ia64_unw_table_entry *table; /* Unwind table.  */
5817     unsigned long table_len;    /* Length of unwind table.  */
5818     unsigned char * info;       /* Unwind info.  */
5819     unsigned long info_size;    /* Size of unwind info.  */
5820     bfd_vma info_addr;          /* starting address of unwind info.  */
5821     bfd_vma seg_base;           /* Starting address of segment.  */
5822     Elf_Internal_Sym * symtab;  /* The symbol table.  */
5823     unsigned long nsyms;        /* Number of symbols.  */
5824     char * strtab;              /* The string table.  */
5825     unsigned long strtab_size;  /* Size of string table.  */
5826   };
5827
5828 static void
5829 find_symbol_for_address (Elf_Internal_Sym * symtab,
5830                          unsigned long nsyms,
5831                          const char * strtab,
5832                          unsigned long strtab_size,
5833                          struct absaddr addr,
5834                          const char ** symname,
5835                          bfd_vma * offset)
5836 {
5837   bfd_vma dist = 0x100000;
5838   Elf_Internal_Sym * sym;
5839   Elf_Internal_Sym * best = NULL;
5840   unsigned long i;
5841
5842   REMOVE_ARCH_BITS (addr.offset);
5843
5844   for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
5845     {
5846       bfd_vma value = sym->st_value;
5847
5848       REMOVE_ARCH_BITS (value);
5849
5850       if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5851           && sym->st_name != 0
5852           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
5853           && addr.offset >= value
5854           && addr.offset - value < dist)
5855         {
5856           best = sym;
5857           dist = addr.offset - value;
5858           if (!dist)
5859             break;
5860         }
5861     }
5862
5863   if (best)
5864     {
5865       *symname = (best->st_name >= strtab_size
5866                   ? _("<corrupt>") : strtab + best->st_name);
5867       *offset = dist;
5868       return;
5869     }
5870
5871   *symname = NULL;
5872   *offset = addr.offset;
5873 }
5874
5875 static void
5876 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
5877 {
5878   struct ia64_unw_table_entry * tp;
5879   int in_body;
5880
5881   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5882     {
5883       bfd_vma stamp;
5884       bfd_vma offset;
5885       const unsigned char * dp;
5886       const unsigned char * head;
5887       const char * procname;
5888
5889       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5890                                aux->strtab_size, tp->start, &procname, &offset);
5891
5892       fputs ("\n<", stdout);
5893
5894       if (procname)
5895         {
5896           fputs (procname, stdout);
5897
5898           if (offset)
5899             printf ("+%lx", (unsigned long) offset);
5900         }
5901
5902       fputs (">: [", stdout);
5903       print_vma (tp->start.offset, PREFIX_HEX);
5904       fputc ('-', stdout);
5905       print_vma (tp->end.offset, PREFIX_HEX);
5906       printf ("], info at +0x%lx\n",
5907               (unsigned long) (tp->info.offset - aux->seg_base));
5908
5909       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5910       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5911
5912       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5913               (unsigned) UNW_VER (stamp),
5914               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5915               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5916               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5917               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5918
5919       if (UNW_VER (stamp) != 1)
5920         {
5921           printf (_("\tUnknown version.\n"));
5922           continue;
5923         }
5924
5925       in_body = 0;
5926       for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5927         dp = unw_decode (dp, in_body, & in_body);
5928     }
5929 }
5930
5931 static int
5932 slurp_ia64_unwind_table (FILE * file,
5933                          struct ia64_unw_aux_info * aux,
5934                          Elf_Internal_Shdr * sec)
5935 {
5936   unsigned long size, nrelas, i;
5937   Elf_Internal_Phdr * seg;
5938   struct ia64_unw_table_entry * tep;
5939   Elf_Internal_Shdr * relsec;
5940   Elf_Internal_Rela * rela;
5941   Elf_Internal_Rela * rp;
5942   unsigned char * table;
5943   unsigned char * tp;
5944   Elf_Internal_Sym * sym;
5945   const char * relname;
5946
5947   /* First, find the starting address of the segment that includes
5948      this section: */
5949
5950   if (elf_header.e_phnum)
5951     {
5952       if (! get_program_headers (file))
5953           return 0;
5954
5955       for (seg = program_headers;
5956            seg < program_headers + elf_header.e_phnum;
5957            ++seg)
5958         {
5959           if (seg->p_type != PT_LOAD)
5960             continue;
5961
5962           if (sec->sh_addr >= seg->p_vaddr
5963               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5964             {
5965               aux->seg_base = seg->p_vaddr;
5966               break;
5967             }
5968         }
5969     }
5970
5971   /* Second, build the unwind table from the contents of the unwind section:  */
5972   size = sec->sh_size;
5973   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5974                                       _("unwind table"));
5975   if (!table)
5976     return 0;
5977
5978   aux->table = (struct ia64_unw_table_entry *)
5979       xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5980   tep = aux->table;
5981   for (tp = table; tp < table + size; ++tep)
5982     {
5983       tep->start.section = SHN_UNDEF;
5984       tep->end.section   = SHN_UNDEF;
5985       tep->info.section  = SHN_UNDEF;
5986       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5987       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5988       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5989       tep->start.offset += aux->seg_base;
5990       tep->end.offset   += aux->seg_base;
5991       tep->info.offset  += aux->seg_base;
5992     }
5993   free (table);
5994
5995   /* Third, apply any relocations to the unwind table:  */
5996   for (relsec = section_headers;
5997        relsec < section_headers + elf_header.e_shnum;
5998        ++relsec)
5999     {
6000       if (relsec->sh_type != SHT_RELA
6001           || relsec->sh_info >= elf_header.e_shnum
6002           || section_headers + relsec->sh_info != sec)
6003         continue;
6004
6005       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6006                               & rela, & nrelas))
6007         return 0;
6008
6009       for (rp = rela; rp < rela + nrelas; ++rp)
6010         {
6011           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6012           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6013
6014           if (! const_strneq (relname, "R_IA64_SEGREL"))
6015             {
6016               warn (_("Skipping unexpected relocation type %s\n"), relname);
6017               continue;
6018             }
6019
6020           i = rp->r_offset / (3 * eh_addr_size);
6021
6022           switch (rp->r_offset/eh_addr_size % 3)
6023             {
6024             case 0:
6025               aux->table[i].start.section = sym->st_shndx;
6026               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
6027               break;
6028             case 1:
6029               aux->table[i].end.section   = sym->st_shndx;
6030               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
6031               break;
6032             case 2:
6033               aux->table[i].info.section  = sym->st_shndx;
6034               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
6035               break;
6036             default:
6037               break;
6038             }
6039         }
6040
6041       free (rela);
6042     }
6043
6044   aux->table_len = size / (3 * eh_addr_size);
6045   return 1;
6046 }
6047
6048 static void
6049 ia64_process_unwind (FILE * file)
6050 {
6051   Elf_Internal_Shdr * sec;
6052   Elf_Internal_Shdr * unwsec = NULL;
6053   Elf_Internal_Shdr * strsec;
6054   unsigned long i, unwcount = 0, unwstart = 0;
6055   struct ia64_unw_aux_info aux;
6056
6057   memset (& aux, 0, sizeof (aux));
6058
6059   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6060     {
6061       if (sec->sh_type == SHT_SYMTAB
6062           && sec->sh_link < elf_header.e_shnum)
6063         {
6064           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6065
6066           strsec = section_headers + sec->sh_link;
6067           assert (aux.strtab == NULL);
6068           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6069                                           1, strsec->sh_size,
6070                                           _("string table"));
6071           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6072         }
6073       else if (sec->sh_type == SHT_IA_64_UNWIND)
6074         unwcount++;
6075     }
6076
6077   if (!unwcount)
6078     printf (_("\nThere are no unwind sections in this file.\n"));
6079
6080   while (unwcount-- > 0)
6081     {
6082       char * suffix;
6083       size_t len, len2;
6084
6085       for (i = unwstart, sec = section_headers + unwstart;
6086            i < elf_header.e_shnum; ++i, ++sec)
6087         if (sec->sh_type == SHT_IA_64_UNWIND)
6088           {
6089             unwsec = sec;
6090             break;
6091           }
6092
6093       unwstart = i + 1;
6094       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6095
6096       if ((unwsec->sh_flags & SHF_GROUP) != 0)
6097         {
6098           /* We need to find which section group it is in.  */
6099           struct group_list * g = section_headers_groups [i]->root;
6100
6101           for (; g != NULL; g = g->next)
6102             {
6103               sec = section_headers + g->section_index;
6104
6105               if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6106                 break;
6107             }
6108
6109           if (g == NULL)
6110             i = elf_header.e_shnum;
6111         }
6112       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6113         {
6114           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
6115           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6116           suffix = SECTION_NAME (unwsec) + len;
6117           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6118                ++i, ++sec)
6119             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6120                 && streq (SECTION_NAME (sec) + len2, suffix))
6121               break;
6122         }
6123       else
6124         {
6125           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6126              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
6127           len = sizeof (ELF_STRING_ia64_unwind) - 1;
6128           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6129           suffix = "";
6130           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6131             suffix = SECTION_NAME (unwsec) + len;
6132           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6133                ++i, ++sec)
6134             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6135                 && streq (SECTION_NAME (sec) + len2, suffix))
6136               break;
6137         }
6138
6139       if (i == elf_header.e_shnum)
6140         {
6141           printf (_("\nCould not find unwind info section for "));
6142
6143           if (string_table == NULL)
6144             printf ("%d", unwsec->sh_name);
6145           else
6146             printf (_("'%s'"), SECTION_NAME (unwsec));
6147         }
6148       else
6149         {
6150           aux.info_addr = sec->sh_addr;
6151           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6152                                                  sec->sh_size,
6153                                                  _("unwind info"));
6154           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6155
6156           printf (_("\nUnwind section "));
6157
6158           if (string_table == NULL)
6159             printf ("%d", unwsec->sh_name);
6160           else
6161             printf (_("'%s'"), SECTION_NAME (unwsec));
6162
6163           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6164                   (unsigned long) unwsec->sh_offset,
6165                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6166
6167           (void) slurp_ia64_unwind_table (file, & aux, unwsec);
6168
6169           if (aux.table_len > 0)
6170             dump_ia64_unwind (& aux);
6171
6172           if (aux.table)
6173             free ((char *) aux.table);
6174           if (aux.info)
6175             free ((char *) aux.info);
6176           aux.table = NULL;
6177           aux.info = NULL;
6178         }
6179     }
6180
6181   if (aux.symtab)
6182     free (aux.symtab);
6183   if (aux.strtab)
6184     free ((char *) aux.strtab);
6185 }
6186
6187 struct hppa_unw_table_entry
6188   {
6189     struct absaddr start;
6190     struct absaddr end;
6191     unsigned int Cannot_unwind:1;                       /* 0 */
6192     unsigned int Millicode:1;                   /* 1 */
6193     unsigned int Millicode_save_sr0:1;          /* 2 */
6194     unsigned int Region_description:2;          /* 3..4 */
6195     unsigned int reserved1:1;                   /* 5 */
6196     unsigned int Entry_SR:1;                    /* 6 */
6197     unsigned int Entry_FR:4;     /* number saved */     /* 7..10 */
6198     unsigned int Entry_GR:5;     /* number saved */     /* 11..15 */
6199     unsigned int Args_stored:1;                 /* 16 */
6200     unsigned int Variable_Frame:1;                      /* 17 */
6201     unsigned int Separate_Package_Body:1;               /* 18 */
6202     unsigned int Frame_Extension_Millicode:1;   /* 19 */
6203     unsigned int Stack_Overflow_Check:1;                /* 20 */
6204     unsigned int Two_Instruction_SP_Increment:1;        /* 21 */
6205     unsigned int Ada_Region:1;                  /* 22 */
6206     unsigned int cxx_info:1;                    /* 23 */
6207     unsigned int cxx_try_catch:1;                       /* 24 */
6208     unsigned int sched_entry_seq:1;                     /* 25 */
6209     unsigned int reserved2:1;                   /* 26 */
6210     unsigned int Save_SP:1;                             /* 27 */
6211     unsigned int Save_RP:1;                             /* 28 */
6212     unsigned int Save_MRP_in_frame:1;           /* 29 */
6213     unsigned int extn_ptr_defined:1;            /* 30 */
6214     unsigned int Cleanup_defined:1;                     /* 31 */
6215
6216     unsigned int MPE_XL_interrupt_marker:1;             /* 0 */
6217     unsigned int HP_UX_interrupt_marker:1;              /* 1 */
6218     unsigned int Large_frame:1;                 /* 2 */
6219     unsigned int Pseudo_SP_Set:1;                       /* 3 */
6220     unsigned int reserved4:1;                   /* 4 */
6221     unsigned int Total_frame_size:27;           /* 5..31 */
6222   };
6223
6224 struct hppa_unw_aux_info
6225   {
6226     struct hppa_unw_table_entry *table; /* Unwind table.  */
6227     unsigned long table_len;    /* Length of unwind table.  */
6228     bfd_vma seg_base;           /* Starting address of segment.  */
6229     Elf_Internal_Sym * symtab;  /* The symbol table.  */
6230     unsigned long nsyms;        /* Number of symbols.  */
6231     char * strtab;              /* The string table.  */
6232     unsigned long strtab_size;  /* Size of string table.  */
6233   };
6234
6235 static void
6236 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
6237 {
6238   struct hppa_unw_table_entry * tp;
6239
6240   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6241     {
6242       bfd_vma offset;
6243       const char * procname;
6244
6245       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6246                                aux->strtab_size, tp->start, &procname,
6247                                &offset);
6248
6249       fputs ("\n<", stdout);
6250
6251       if (procname)
6252         {
6253           fputs (procname, stdout);
6254
6255           if (offset)
6256             printf ("+%lx", (unsigned long) offset);
6257         }
6258
6259       fputs (">: [", stdout);
6260       print_vma (tp->start.offset, PREFIX_HEX);
6261       fputc ('-', stdout);
6262       print_vma (tp->end.offset, PREFIX_HEX);
6263       printf ("]\n\t");
6264
6265 #define PF(_m) if (tp->_m) printf (#_m " ");
6266 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6267       PF(Cannot_unwind);
6268       PF(Millicode);
6269       PF(Millicode_save_sr0);
6270       /* PV(Region_description);  */
6271       PF(Entry_SR);
6272       PV(Entry_FR);
6273       PV(Entry_GR);
6274       PF(Args_stored);
6275       PF(Variable_Frame);
6276       PF(Separate_Package_Body);
6277       PF(Frame_Extension_Millicode);
6278       PF(Stack_Overflow_Check);
6279       PF(Two_Instruction_SP_Increment);
6280       PF(Ada_Region);
6281       PF(cxx_info);
6282       PF(cxx_try_catch);
6283       PF(sched_entry_seq);
6284       PF(Save_SP);
6285       PF(Save_RP);
6286       PF(Save_MRP_in_frame);
6287       PF(extn_ptr_defined);
6288       PF(Cleanup_defined);
6289       PF(MPE_XL_interrupt_marker);
6290       PF(HP_UX_interrupt_marker);
6291       PF(Large_frame);
6292       PF(Pseudo_SP_Set);
6293       PV(Total_frame_size);
6294 #undef PF
6295 #undef PV
6296     }
6297
6298   printf ("\n");
6299 }
6300
6301 static int
6302 slurp_hppa_unwind_table (FILE * file,
6303                          struct hppa_unw_aux_info * aux,
6304                          Elf_Internal_Shdr * sec)
6305 {
6306   unsigned long size, unw_ent_size, nentries, nrelas, i;
6307   Elf_Internal_Phdr * seg;
6308   struct hppa_unw_table_entry * tep;
6309   Elf_Internal_Shdr * relsec;
6310   Elf_Internal_Rela * rela;
6311   Elf_Internal_Rela * rp;
6312   unsigned char * table;
6313   unsigned char * tp;
6314   Elf_Internal_Sym * sym;
6315   const char * relname;
6316
6317   /* First, find the starting address of the segment that includes
6318      this section.  */
6319
6320   if (elf_header.e_phnum)
6321     {
6322       if (! get_program_headers (file))
6323         return 0;
6324
6325       for (seg = program_headers;
6326            seg < program_headers + elf_header.e_phnum;
6327            ++seg)
6328         {
6329           if (seg->p_type != PT_LOAD)
6330             continue;
6331
6332           if (sec->sh_addr >= seg->p_vaddr
6333               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6334             {
6335               aux->seg_base = seg->p_vaddr;
6336               break;
6337             }
6338         }
6339     }
6340
6341   /* Second, build the unwind table from the contents of the unwind
6342      section.  */
6343   size = sec->sh_size;
6344   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6345                                       _("unwind table"));
6346   if (!table)
6347     return 0;
6348
6349   unw_ent_size = 16;
6350   nentries = size / unw_ent_size;
6351   size = unw_ent_size * nentries;
6352
6353   tep = aux->table = (struct hppa_unw_table_entry *)
6354       xcmalloc (nentries, sizeof (aux->table[0]));
6355
6356   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6357     {
6358       unsigned int tmp1, tmp2;
6359
6360       tep->start.section = SHN_UNDEF;
6361       tep->end.section   = SHN_UNDEF;
6362
6363       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6364       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6365       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6366       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6367
6368       tep->start.offset += aux->seg_base;
6369       tep->end.offset   += aux->seg_base;
6370
6371       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6372       tep->Millicode = (tmp1 >> 30) & 0x1;
6373       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6374       tep->Region_description = (tmp1 >> 27) & 0x3;
6375       tep->reserved1 = (tmp1 >> 26) & 0x1;
6376       tep->Entry_SR = (tmp1 >> 25) & 0x1;
6377       tep->Entry_FR = (tmp1 >> 21) & 0xf;
6378       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6379       tep->Args_stored = (tmp1 >> 15) & 0x1;
6380       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6381       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6382       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6383       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6384       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6385       tep->Ada_Region = (tmp1 >> 9) & 0x1;
6386       tep->cxx_info = (tmp1 >> 8) & 0x1;
6387       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6388       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6389       tep->reserved2 = (tmp1 >> 5) & 0x1;
6390       tep->Save_SP = (tmp1 >> 4) & 0x1;
6391       tep->Save_RP = (tmp1 >> 3) & 0x1;
6392       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6393       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6394       tep->Cleanup_defined = tmp1 & 0x1;
6395
6396       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6397       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6398       tep->Large_frame = (tmp2 >> 29) & 0x1;
6399       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6400       tep->reserved4 = (tmp2 >> 27) & 0x1;
6401       tep->Total_frame_size = tmp2 & 0x7ffffff;
6402     }
6403   free (table);
6404
6405   /* Third, apply any relocations to the unwind table.  */
6406   for (relsec = section_headers;
6407        relsec < section_headers + elf_header.e_shnum;
6408        ++relsec)
6409     {
6410       if (relsec->sh_type != SHT_RELA
6411           || relsec->sh_info >= elf_header.e_shnum
6412           || section_headers + relsec->sh_info != sec)
6413         continue;
6414
6415       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6416                               & rela, & nrelas))
6417         return 0;
6418
6419       for (rp = rela; rp < rela + nrelas; ++rp)
6420         {
6421           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6422           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6423
6424           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
6425           if (! const_strneq (relname, "R_PARISC_SEGREL"))
6426             {
6427               warn (_("Skipping unexpected relocation type %s\n"), relname);
6428               continue;
6429             }
6430
6431           i = rp->r_offset / unw_ent_size;
6432
6433           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6434             {
6435             case 0:
6436               aux->table[i].start.section = sym->st_shndx;
6437               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
6438               break;
6439             case 1:
6440               aux->table[i].end.section   = sym->st_shndx;
6441               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
6442               break;
6443             default:
6444               break;
6445             }
6446         }
6447
6448       free (rela);
6449     }
6450
6451   aux->table_len = nentries;
6452
6453   return 1;
6454 }
6455
6456 static void
6457 hppa_process_unwind (FILE * file)
6458 {
6459   struct hppa_unw_aux_info aux;
6460   Elf_Internal_Shdr * unwsec = NULL;
6461   Elf_Internal_Shdr * strsec;
6462   Elf_Internal_Shdr * sec;
6463   unsigned long i;
6464
6465   if (string_table == NULL)
6466     return;
6467
6468   memset (& aux, 0, sizeof (aux));
6469
6470   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6471     {
6472       if (sec->sh_type == SHT_SYMTAB
6473           && sec->sh_link < elf_header.e_shnum)
6474         {
6475           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6476
6477           strsec = section_headers + sec->sh_link;
6478           assert (aux.strtab == NULL);
6479           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6480                                           1, strsec->sh_size,
6481                                           _("string table"));
6482           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6483         }
6484       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6485         unwsec = sec;
6486     }
6487
6488   if (!unwsec)
6489     printf (_("\nThere are no unwind sections in this file.\n"));
6490
6491   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6492     {
6493       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6494         {
6495           printf (_("\nUnwind section "));
6496           printf (_("'%s'"), SECTION_NAME (sec));
6497
6498           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6499                   (unsigned long) sec->sh_offset,
6500                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6501
6502           slurp_hppa_unwind_table (file, &aux, sec);
6503           if (aux.table_len > 0)
6504             dump_hppa_unwind (&aux);
6505
6506           if (aux.table)
6507             free ((char *) aux.table);
6508           aux.table = NULL;
6509         }
6510     }
6511
6512   if (aux.symtab)
6513     free (aux.symtab);
6514   if (aux.strtab)
6515     free ((char *) aux.strtab);
6516 }
6517
6518 struct arm_section
6519 {
6520   unsigned char *      data;            /* The unwind data.  */
6521   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
6522   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
6523   unsigned long        nrelas;          /* The number of relocations.  */
6524   unsigned int         rel_type;        /* REL or RELA ?  */
6525   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
6526 };
6527
6528 struct arm_unw_aux_info
6529 {
6530   FILE *              file;             /* The file containing the unwind sections.  */
6531   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
6532   unsigned long       nsyms;            /* Number of symbols.  */
6533   char *              strtab;           /* The file's string table.  */
6534   unsigned long       strtab_size;      /* Size of string table.  */
6535 };
6536
6537 static const char *
6538 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6539                         bfd_vma fn, struct absaddr addr)
6540 {
6541   const char *procname;
6542   bfd_vma sym_offset;
6543
6544   if (addr.section == SHN_UNDEF)
6545     addr.offset = fn;
6546
6547   find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6548                            aux->strtab_size, addr, &procname,
6549                            &sym_offset);
6550
6551   print_vma (fn, PREFIX_HEX);
6552
6553   if (procname)
6554     {
6555       fputs (" <", stdout);
6556       fputs (procname, stdout);
6557
6558       if (sym_offset)
6559         printf ("+0x%lx", (unsigned long) sym_offset);
6560       fputc ('>', stdout);
6561     }
6562
6563   return procname;
6564 }
6565
6566 static void
6567 arm_free_section (struct arm_section *arm_sec)
6568 {
6569   if (arm_sec->data != NULL)
6570     free (arm_sec->data);
6571
6572   if (arm_sec->rela != NULL)
6573     free (arm_sec->rela);
6574 }
6575
6576 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6577       cached section and install SEC instead.
6578    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6579       and return its valued in * WORDP, relocating if necessary.
6580    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6581       relocation's offset in ADDR.
6582    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6583       into the string table of the symbol associated with the reloc.  If no
6584       reloc was applied store -1 there.
6585    5) Return TRUE upon success, FALSE otherwise.  */
6586
6587 static bfd_boolean
6588 get_unwind_section_word (struct arm_unw_aux_info *  aux,
6589                          struct arm_section *       arm_sec,
6590                          Elf_Internal_Shdr *        sec,
6591                          bfd_vma                    word_offset,
6592                          unsigned int *             wordp,
6593                          struct absaddr *           addr,
6594                          bfd_vma *                  sym_name)
6595 {
6596   Elf_Internal_Rela *rp;
6597   Elf_Internal_Sym *sym;
6598   const char * relname;
6599   unsigned int word;
6600   bfd_boolean wrapped;
6601
6602   addr->section = SHN_UNDEF;
6603   addr->offset = 0;
6604
6605   if (sym_name != NULL)
6606     *sym_name = (bfd_vma) -1;
6607
6608   /* If necessary, update the section cache.  */
6609   if (sec != arm_sec->sec)
6610     {
6611       Elf_Internal_Shdr *relsec;
6612
6613       arm_free_section (arm_sec);
6614
6615       arm_sec->sec = sec;
6616       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6617                                 sec->sh_size, _("unwind data"));
6618       arm_sec->rela = NULL;
6619       arm_sec->nrelas = 0;
6620
6621       for (relsec = section_headers;
6622            relsec < section_headers + elf_header.e_shnum;
6623            ++relsec)
6624         {
6625           if (relsec->sh_info >= elf_header.e_shnum
6626               || section_headers + relsec->sh_info != sec)
6627             continue;
6628
6629           arm_sec->rel_type = relsec->sh_type;
6630           if (relsec->sh_type == SHT_REL)
6631             {
6632               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6633                                      relsec->sh_size,
6634                                      & arm_sec->rela, & arm_sec->nrelas))
6635                 return FALSE;
6636               break;
6637             }
6638           else if (relsec->sh_type == SHT_RELA)
6639             {
6640               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6641                                       relsec->sh_size,
6642                                       & arm_sec->rela, & arm_sec->nrelas))
6643                 return FALSE;
6644               break;
6645             }
6646           else
6647             warn (_("unexpected relocation type (%d) for section %d"),
6648                   relsec->sh_type, relsec->sh_info);
6649         }
6650
6651       arm_sec->next_rela = arm_sec->rela;
6652     }
6653
6654   /* If there is no unwind data we can do nothing.  */
6655   if (arm_sec->data == NULL)
6656     return FALSE;
6657
6658   /* Get the word at the required offset.  */
6659   word = byte_get (arm_sec->data + word_offset, 4);
6660
6661   /* Look through the relocs to find the one that applies to the provided offset.  */
6662   wrapped = FALSE;
6663   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6664     {
6665       bfd_vma prelval, offset;
6666
6667       if (rp->r_offset > word_offset && !wrapped)
6668         {
6669           rp = arm_sec->rela;
6670           wrapped = TRUE;
6671         }
6672       if (rp->r_offset > word_offset)
6673         break;
6674
6675       if (rp->r_offset & 3)
6676         {
6677           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6678                 (unsigned long) rp->r_offset);
6679           continue;
6680         }
6681
6682       if (rp->r_offset < word_offset)
6683         continue;
6684
6685       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6686
6687       if (arm_sec->rel_type == SHT_REL)
6688         {
6689           offset = word & 0x7fffffff;
6690           if (offset & 0x40000000)
6691             offset |= ~ (bfd_vma) 0x7fffffff;
6692         }
6693       else if (arm_sec->rel_type == SHT_RELA)
6694         offset = rp->r_addend;
6695       else
6696         abort ();
6697
6698       offset += sym->st_value;
6699       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6700
6701       /* Check that we are processing the expected reloc type.  */
6702       if (elf_header.e_machine == EM_ARM)
6703         {
6704           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6705
6706           if (streq (relname, "R_ARM_NONE"))
6707               continue;
6708
6709           if (! streq (relname, "R_ARM_PREL31"))
6710             {
6711               warn (_("Skipping unexpected relocation type %s\n"), relname);
6712               continue;
6713             }
6714         }
6715       else if (elf_header.e_machine == EM_TI_C6000)
6716         {
6717           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6718
6719           if (streq (relname, "R_C6000_NONE"))
6720             continue;
6721
6722           if (! streq (relname, "R_C6000_PREL31"))
6723             {
6724               warn (_("Skipping unexpected relocation type %s\n"), relname);
6725               continue;
6726             }
6727
6728           prelval >>= 1;
6729         }
6730       else
6731         /* This function currently only supports ARM and TI unwinders.  */
6732         abort ();
6733
6734       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6735       addr->section = sym->st_shndx;
6736       addr->offset = offset;
6737       if (sym_name)
6738         * sym_name = sym->st_name;
6739       break;
6740     }
6741
6742   *wordp = word;
6743   arm_sec->next_rela = rp;
6744
6745   return TRUE;
6746 }
6747
6748 static const char *tic6x_unwind_regnames[16] =
6749 {
6750   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6751   "A14", "A13", "A12", "A11", "A10",
6752   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6753 };
6754
6755 static void
6756 decode_tic6x_unwind_regmask (unsigned int mask)
6757 {
6758   int i;
6759
6760   for (i = 12; mask; mask >>= 1, i--)
6761     {
6762       if (mask & 1)
6763         {
6764           fputs (tic6x_unwind_regnames[i], stdout);
6765           if (mask > 1)
6766             fputs (", ", stdout);
6767         }
6768     }
6769 }
6770
6771 #define ADVANCE                                                 \
6772   if (remaining == 0 && more_words)                             \
6773     {                                                           \
6774       data_offset += 4;                                         \
6775       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
6776                                      data_offset, & word, & addr, NULL))        \
6777         return;                                                 \
6778       remaining = 4;                                            \
6779       more_words--;                                             \
6780     }                                                           \
6781
6782 #define GET_OP(OP)                      \
6783   ADVANCE;                              \
6784   if (remaining)                        \
6785     {                                   \
6786       remaining--;                      \
6787       (OP) = word >> 24;                \
6788       word <<= 8;                       \
6789     }                                   \
6790   else                                  \
6791     {                                   \
6792       printf (_("[Truncated opcode]\n"));       \
6793       return;                           \
6794     }                                   \
6795   printf ("0x%02x ", OP)
6796
6797 static void
6798 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6799                             unsigned int word, unsigned int remaining,
6800                             unsigned int more_words,
6801                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6802                             struct arm_section *data_arm_sec)
6803 {
6804   struct absaddr addr;
6805
6806   /* Decode the unwinding instructions.  */
6807   while (1)
6808     {
6809       unsigned int op, op2;
6810
6811       ADVANCE;
6812       if (remaining == 0)
6813         break;
6814       remaining--;
6815       op = word >> 24;
6816       word <<= 8;
6817
6818       printf ("  0x%02x ", op);
6819
6820       if ((op & 0xc0) == 0x00)
6821         {
6822           int offset = ((op & 0x3f) << 2) + 4;
6823
6824           printf ("     vsp = vsp + %d", offset);
6825         }
6826       else if ((op & 0xc0) == 0x40)
6827         {
6828           int offset = ((op & 0x3f) << 2) + 4;
6829
6830           printf ("     vsp = vsp - %d", offset);
6831         }
6832       else if ((op & 0xf0) == 0x80)
6833         {
6834           GET_OP (op2);
6835           if (op == 0x80 && op2 == 0)
6836             printf (_("Refuse to unwind"));
6837           else
6838             {
6839               unsigned int mask = ((op & 0x0f) << 8) | op2;
6840               int first = 1;
6841               int i;
6842
6843               printf ("pop {");
6844               for (i = 0; i < 12; i++)
6845                 if (mask & (1 << i))
6846                   {
6847                     if (first)
6848                       first = 0;
6849                     else
6850                       printf (", ");
6851                     printf ("r%d", 4 + i);
6852                   }
6853               printf ("}");
6854             }
6855         }
6856       else if ((op & 0xf0) == 0x90)
6857         {
6858           if (op == 0x9d || op == 0x9f)
6859             printf (_("     [Reserved]"));
6860           else
6861             printf ("     vsp = r%d", op & 0x0f);
6862         }
6863       else if ((op & 0xf0) == 0xa0)
6864         {
6865           int end = 4 + (op & 0x07);
6866           int first = 1;
6867           int i;
6868
6869           printf ("     pop {");
6870           for (i = 4; i <= end; i++)
6871             {
6872               if (first)
6873                 first = 0;
6874               else
6875                 printf (", ");
6876               printf ("r%d", i);
6877             }
6878           if (op & 0x08)
6879             {
6880               if (!first)
6881                 printf (", ");
6882               printf ("r14");
6883             }
6884           printf ("}");
6885         }
6886       else if (op == 0xb0)
6887         printf (_("     finish"));
6888       else if (op == 0xb1)
6889         {
6890           GET_OP (op2);
6891           if (op2 == 0 || (op2 & 0xf0) != 0)
6892             printf (_("[Spare]"));
6893           else
6894             {
6895               unsigned int mask = op2 & 0x0f;
6896               int first = 1;
6897               int i;
6898
6899               printf ("pop {");
6900               for (i = 0; i < 12; i++)
6901                 if (mask & (1 << i))
6902                   {
6903                     if (first)
6904                       first = 0;
6905                     else
6906                       printf (", ");
6907                     printf ("r%d", i);
6908                   }
6909               printf ("}");
6910             }
6911         }
6912       else if (op == 0xb2)
6913         {
6914           unsigned char buf[9];
6915           unsigned int i, len;
6916           unsigned long offset;
6917
6918           for (i = 0; i < sizeof (buf); i++)
6919             {
6920               GET_OP (buf[i]);
6921               if ((buf[i] & 0x80) == 0)
6922                 break;
6923             }
6924           assert (i < sizeof (buf));
6925           offset = read_uleb128 (buf, &len, buf + i + 1);
6926           assert (len == i + 1);
6927           offset = offset * 4 + 0x204;
6928           printf ("vsp = vsp + %ld", offset);
6929         }
6930       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
6931         {
6932           unsigned int first, last;
6933
6934           GET_OP (op2);
6935           first = op2 >> 4;
6936           last = op2 & 0x0f;
6937           if (op == 0xc8)
6938             first = first + 16;
6939           printf ("pop {D%d", first);
6940           if (last)
6941             printf ("-D%d", first + last);
6942           printf ("}");
6943         }
6944       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6945         {
6946           unsigned int count = op & 0x07;
6947
6948           printf ("pop {D8");
6949           if (count)
6950             printf ("-D%d", 8 + count);
6951           printf ("}");
6952         }
6953       else if (op >= 0xc0 && op <= 0xc5)
6954         {
6955           unsigned int count = op & 0x07;
6956
6957           printf ("     pop {wR10");
6958           if (count)
6959             printf ("-wR%d", 10 + count);
6960           printf ("}");
6961         }
6962       else if (op == 0xc6)
6963         {
6964           unsigned int first, last;
6965
6966           GET_OP (op2);
6967           first = op2 >> 4;
6968           last = op2 & 0x0f;
6969           printf ("pop {wR%d", first);
6970           if (last)
6971             printf ("-wR%d", first + last);
6972           printf ("}");
6973         }
6974       else if (op == 0xc7)
6975         {
6976           GET_OP (op2);
6977           if (op2 == 0 || (op2 & 0xf0) != 0)
6978             printf (_("[Spare]"));
6979           else
6980             {
6981               unsigned int mask = op2 & 0x0f;
6982               int first = 1;
6983               int i;
6984
6985               printf ("pop {");
6986               for (i = 0; i < 4; i++)
6987                 if (mask & (1 << i))
6988                   {
6989                     if (first)
6990                       first = 0;
6991                     else
6992                       printf (", ");
6993                     printf ("wCGR%d", i);
6994                   }
6995               printf ("}");
6996             }
6997         }
6998       else
6999         printf (_("     [unsupported opcode]"));
7000       printf ("\n");
7001     }
7002 }
7003
7004 static void
7005 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7006                             unsigned int word, unsigned int remaining,
7007                             unsigned int more_words,
7008                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7009                             struct arm_section *data_arm_sec)
7010 {
7011   struct absaddr addr;
7012
7013   /* Decode the unwinding instructions.  */
7014   while (1)
7015     {
7016       unsigned int op, op2;
7017
7018       ADVANCE;
7019       if (remaining == 0)
7020         break;
7021       remaining--;
7022       op = word >> 24;
7023       word <<= 8;
7024
7025       printf ("  0x%02x ", op);
7026
7027       if ((op & 0xc0) == 0x00)
7028         {
7029           int offset = ((op & 0x3f) << 3) + 8;
7030           printf ("     sp = sp + %d", offset);
7031         }
7032       else if ((op & 0xc0) == 0x80)
7033         {
7034           GET_OP (op2);
7035           if (op == 0x80 && op2 == 0)
7036             printf (_("Refuse to unwind"));
7037           else
7038             {
7039               unsigned int mask = ((op & 0x1f) << 8) | op2;
7040               if (op & 0x20)
7041                 printf ("pop compact {");
7042               else
7043                 printf ("pop {");
7044
7045               decode_tic6x_unwind_regmask (mask);
7046               printf("}");
7047             }
7048         }
7049       else if ((op & 0xf0) == 0xc0)
7050         {
7051           unsigned int reg;
7052           unsigned int nregs;
7053           unsigned int i;
7054           const char *name;
7055           struct
7056           {
7057               unsigned int offset;
7058               unsigned int reg;
7059           } regpos[16];
7060
7061           /* Scan entire instruction first so that GET_OP output is not
7062              interleaved with disassembly.  */
7063           nregs = 0;
7064           for (i = 0; nregs < (op & 0xf); i++)
7065             {
7066               GET_OP (op2);
7067               reg = op2 >> 4;
7068               if (reg != 0xf)
7069                 {
7070                   regpos[nregs].offset = i * 2;
7071                   regpos[nregs].reg = reg;
7072                   nregs++;
7073                 }
7074
7075               reg = op2 & 0xf;
7076               if (reg != 0xf)
7077                 {
7078                   regpos[nregs].offset = i * 2 + 1;
7079                   regpos[nregs].reg = reg;
7080                   nregs++;
7081                 }
7082             }
7083
7084           printf (_("pop frame {"));
7085           reg = nregs - 1;
7086           for (i = i * 2; i > 0; i--)
7087             {
7088               if (regpos[reg].offset == i - 1)
7089                 {
7090                   name = tic6x_unwind_regnames[regpos[reg].reg];
7091                   if (reg > 0)
7092                     reg--;
7093                 }
7094               else
7095                 name = _("[pad]");
7096
7097               fputs (name, stdout);
7098               if (i > 1)
7099                 printf (", ");
7100             }
7101
7102           printf ("}");
7103         }
7104       else if (op == 0xd0)
7105         printf ("     MOV FP, SP");
7106       else if (op == 0xd1)
7107         printf ("     __c6xabi_pop_rts");
7108       else if (op == 0xd2)
7109         {
7110           unsigned char buf[9];
7111           unsigned int i, len;
7112           unsigned long offset;
7113
7114           for (i = 0; i < sizeof (buf); i++)
7115             {
7116               GET_OP (buf[i]);
7117               if ((buf[i] & 0x80) == 0)
7118                 break;
7119             }
7120           assert (i < sizeof (buf));
7121           offset = read_uleb128 (buf, &len, buf + i + 1);
7122           assert (len == i + 1);
7123           offset = offset * 8 + 0x408;
7124           printf (_("sp = sp + %ld"), offset);
7125         }
7126       else if ((op & 0xf0) == 0xe0)
7127         {
7128           if ((op & 0x0f) == 7)
7129             printf ("     RETURN");
7130           else
7131             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7132         }
7133       else
7134         {
7135           printf (_("     [unsupported opcode]"));
7136         }
7137       putchar ('\n');
7138     }
7139 }
7140
7141 static bfd_vma
7142 arm_expand_prel31 (bfd_vma word, bfd_vma where)
7143 {
7144   bfd_vma offset;
7145
7146   offset = word & 0x7fffffff;
7147   if (offset & 0x40000000)
7148     offset |= ~ (bfd_vma) 0x7fffffff;
7149
7150   if (elf_header.e_machine == EM_TI_C6000)
7151     offset <<= 1;
7152
7153   return offset + where;
7154 }
7155
7156 static void
7157 decode_arm_unwind (struct arm_unw_aux_info *  aux,
7158                    unsigned int               word,
7159                    unsigned int               remaining,
7160                    bfd_vma                    data_offset,
7161                    Elf_Internal_Shdr *        data_sec,
7162                    struct arm_section *       data_arm_sec)
7163 {
7164   int per_index;
7165   unsigned int more_words = 0;
7166   struct absaddr addr;
7167   bfd_vma sym_name = (bfd_vma) -1;
7168
7169   if (remaining == 0)
7170     {
7171       /* Fetch the first word.
7172          Note - when decoding an object file the address extracted
7173          here will always be 0.  So we also pass in the sym_name
7174          parameter so that we can find the symbol associated with
7175          the personality routine.  */
7176       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7177                                      & word, & addr, & sym_name))
7178         return;
7179
7180       remaining = 4;
7181     }
7182
7183   if ((word & 0x80000000) == 0)
7184     {
7185       /* Expand prel31 for personality routine.  */
7186       bfd_vma fn;
7187       const char *procname;
7188
7189       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
7190       printf (_("  Personality routine: "));
7191       if (fn == 0
7192           && addr.section == SHN_UNDEF && addr.offset == 0
7193           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7194         {
7195           procname = aux->strtab + sym_name;
7196           print_vma (fn, PREFIX_HEX);
7197           if (procname)
7198             {
7199               fputs (" <", stdout);
7200               fputs (procname, stdout);
7201               fputc ('>', stdout);
7202             }
7203         }
7204       else
7205         procname = arm_print_vma_and_name (aux, fn, addr);
7206       fputc ('\n', stdout);
7207
7208       /* The GCC personality routines use the standard compact
7209          encoding, starting with one byte giving the number of
7210          words.  */
7211       if (procname != NULL
7212           && (const_strneq (procname, "__gcc_personality_v0")
7213               || const_strneq (procname, "__gxx_personality_v0")
7214               || const_strneq (procname, "__gcj_personality_v0")
7215               || const_strneq (procname, "__gnu_objc_personality_v0")))
7216         {
7217           remaining = 0;
7218           more_words = 1;
7219           ADVANCE;
7220           if (!remaining)
7221             {
7222               printf (_("  [Truncated data]\n"));
7223               return;
7224             }
7225           more_words = word >> 24;
7226           word <<= 8;
7227           remaining--;
7228           per_index = -1;
7229         }
7230       else
7231         return;
7232     }
7233   else
7234     {
7235       /* ARM EHABI Section 6.3:
7236
7237          An exception-handling table entry for the compact model looks like:
7238
7239            31 30-28 27-24 23-0
7240            -- ----- ----- ----
7241             1   0   index Data for personalityRoutine[index]    */
7242
7243       if (elf_header.e_machine == EM_ARM
7244           && (word & 0x70000000))
7245         warn (_("Corrupt ARM compact model table entry: %x \n"), word);
7246
7247       per_index = (word >> 24) & 0x7f;
7248       printf (_("  Compact model index: %d\n"), per_index);
7249       if (per_index == 0)
7250         {
7251           more_words = 0;
7252           word <<= 8;
7253           remaining--;
7254         }
7255       else if (per_index < 3)
7256         {
7257           more_words = (word >> 16) & 0xff;
7258           word <<= 16;
7259           remaining -= 2;
7260         }
7261     }
7262
7263   switch (elf_header.e_machine)
7264     {
7265     case EM_ARM:
7266       if (per_index < 3)
7267         {
7268           decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7269                                       data_offset, data_sec, data_arm_sec);
7270         }
7271       else
7272         {
7273           warn (_("Unknown ARM compact model index encountered\n"));
7274           printf (_("  [reserved]\n"));
7275         }
7276       break;
7277
7278     case EM_TI_C6000:
7279       if (per_index < 3)
7280         {
7281           decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
7282                                         data_offset, data_sec, data_arm_sec);
7283         }
7284       else if (per_index < 5)
7285         {
7286           if (((word >> 17) & 0x7f) == 0x7f)
7287             printf (_("  Restore stack from frame pointer\n"));
7288           else
7289             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
7290           printf (_("  Registers restored: "));
7291           if (per_index == 4)
7292             printf (" (compact) ");
7293           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7294           putchar ('\n');
7295           printf (_("  Return register: %s\n"),
7296                   tic6x_unwind_regnames[word & 0xf]);
7297         }
7298       else
7299         printf (_("  [reserved (%d)]\n"), per_index);
7300       break;
7301
7302     default:
7303       error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7304              elf_header.e_machine);
7305     }
7306
7307   /* Decode the descriptors.  Not implemented.  */
7308 }
7309
7310 static void
7311 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7312 {
7313   struct arm_section exidx_arm_sec, extab_arm_sec;
7314   unsigned int i, exidx_len;
7315
7316   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7317   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7318   exidx_len = exidx_sec->sh_size / 8;
7319
7320   for (i = 0; i < exidx_len; i++)
7321     {
7322       unsigned int exidx_fn, exidx_entry;
7323       struct absaddr fn_addr, entry_addr;
7324       bfd_vma fn;
7325
7326       fputc ('\n', stdout);
7327
7328       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7329                                      8 * i, & exidx_fn, & fn_addr, NULL)
7330           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7331                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
7332         {
7333           arm_free_section (& exidx_arm_sec);
7334           arm_free_section (& extab_arm_sec);
7335           return;
7336         }
7337
7338       /* ARM EHABI, Section 5:
7339          An index table entry consists of 2 words.
7340          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
7341       if (exidx_fn & 0x80000000)
7342         warn (_("corrupt index table entry: %x\n"), exidx_fn);
7343
7344       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
7345
7346       arm_print_vma_and_name (aux, fn, fn_addr);
7347       fputs (": ", stdout);
7348
7349       if (exidx_entry == 1)
7350         {
7351           print_vma (exidx_entry, PREFIX_HEX);
7352           fputs (" [cantunwind]\n", stdout);
7353         }
7354       else if (exidx_entry & 0x80000000)
7355         {
7356           print_vma (exidx_entry, PREFIX_HEX);
7357           fputc ('\n', stdout);
7358           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7359         }
7360       else
7361         {
7362           bfd_vma table, table_offset = 0;
7363           Elf_Internal_Shdr *table_sec;
7364
7365           fputs ("@", stdout);
7366           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
7367           print_vma (table, PREFIX_HEX);
7368           printf ("\n");
7369
7370           /* Locate the matching .ARM.extab.  */
7371           if (entry_addr.section != SHN_UNDEF
7372               && entry_addr.section < elf_header.e_shnum)
7373             {
7374               table_sec = section_headers + entry_addr.section;
7375               table_offset = entry_addr.offset;
7376             }
7377           else
7378             {
7379               table_sec = find_section_by_address (table);
7380               if (table_sec != NULL)
7381                 table_offset = table - table_sec->sh_addr;
7382             }
7383           if (table_sec == NULL)
7384             {
7385               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7386                     (unsigned long) table);
7387               continue;
7388             }
7389           decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7390                              &extab_arm_sec);
7391         }
7392     }
7393
7394   printf ("\n");
7395
7396   arm_free_section (&exidx_arm_sec);
7397   arm_free_section (&extab_arm_sec);
7398 }
7399
7400 /* Used for both ARM and C6X unwinding tables.  */
7401
7402 static void
7403 arm_process_unwind (FILE *file)
7404 {
7405   struct arm_unw_aux_info aux;
7406   Elf_Internal_Shdr *unwsec = NULL;
7407   Elf_Internal_Shdr *strsec;
7408   Elf_Internal_Shdr *sec;
7409   unsigned long i;
7410   unsigned int sec_type;
7411
7412   switch (elf_header.e_machine)
7413     {
7414     case EM_ARM:
7415       sec_type = SHT_ARM_EXIDX;
7416       break;
7417
7418     case EM_TI_C6000:
7419       sec_type = SHT_C6000_UNWIND;
7420       break;
7421
7422     default:
7423       error (_("Unsupported architecture type %d encountered when processing unwind table"),
7424              elf_header.e_machine);
7425       return;
7426     }
7427
7428   if (string_table == NULL)
7429     return;
7430
7431   memset (& aux, 0, sizeof (aux));
7432   aux.file = file;
7433
7434   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7435     {
7436       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7437         {
7438           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7439
7440           strsec = section_headers + sec->sh_link;
7441           assert (aux.strtab == NULL);
7442           aux.strtab = get_data (NULL, file, strsec->sh_offset,
7443                                  1, strsec->sh_size, _("string table"));
7444           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7445         }
7446       else if (sec->sh_type == sec_type)
7447         unwsec = sec;
7448     }
7449
7450   if (unwsec == NULL)
7451     printf (_("\nThere are no unwind sections in this file.\n"));
7452   else
7453     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7454       {
7455         if (sec->sh_type == sec_type)
7456           {
7457             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7458                     SECTION_NAME (sec),
7459                     (unsigned long) sec->sh_offset,
7460                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7461
7462             dump_arm_unwind (&aux, sec);
7463           }
7464       }
7465
7466   if (aux.symtab)
7467     free (aux.symtab);
7468   if (aux.strtab)
7469     free ((char *) aux.strtab);
7470 }
7471
7472 static void
7473 process_unwind (FILE * file)
7474 {
7475   struct unwind_handler
7476   {
7477     int machtype;
7478     void (* handler)(FILE *);
7479   } handlers[] =
7480   {
7481     { EM_ARM, arm_process_unwind },
7482     { EM_IA_64, ia64_process_unwind },
7483     { EM_PARISC, hppa_process_unwind },
7484     { EM_TI_C6000, arm_process_unwind },
7485     { 0, 0 }
7486   };
7487   int i;
7488
7489   if (!do_unwind)
7490     return;
7491
7492   for (i = 0; handlers[i].handler != NULL; i++)
7493     if (elf_header.e_machine == handlers[i].machtype)
7494       return handlers[i].handler (file);
7495
7496   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7497           get_machine_name (elf_header.e_machine));
7498 }
7499
7500 static void
7501 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
7502 {
7503   switch (entry->d_tag)
7504     {
7505     case DT_MIPS_FLAGS:
7506       if (entry->d_un.d_val == 0)
7507         printf (_("NONE"));
7508       else
7509         {
7510           static const char * opts[] =
7511           {
7512             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7513             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7514             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7515             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7516             "RLD_ORDER_SAFE"
7517           };
7518           unsigned int cnt;
7519           int first = 1;
7520
7521           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
7522             if (entry->d_un.d_val & (1 << cnt))
7523               {
7524                 printf ("%s%s", first ? "" : " ", opts[cnt]);
7525                 first = 0;
7526               }
7527         }
7528       break;
7529
7530     case DT_MIPS_IVERSION:
7531       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7532         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
7533       else
7534         printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
7535       break;
7536
7537     case DT_MIPS_TIME_STAMP:
7538       {
7539         char timebuf[20];
7540         struct tm * tmp;
7541
7542         time_t atime = entry->d_un.d_val;
7543         tmp = gmtime (&atime);
7544         snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7545                   tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7546                   tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7547         printf (_("Time Stamp: %s"), timebuf);
7548       }
7549       break;
7550
7551     case DT_MIPS_RLD_VERSION:
7552     case DT_MIPS_LOCAL_GOTNO:
7553     case DT_MIPS_CONFLICTNO:
7554     case DT_MIPS_LIBLISTNO:
7555     case DT_MIPS_SYMTABNO:
7556     case DT_MIPS_UNREFEXTNO:
7557     case DT_MIPS_HIPAGENO:
7558     case DT_MIPS_DELTA_CLASS_NO:
7559     case DT_MIPS_DELTA_INSTANCE_NO:
7560     case DT_MIPS_DELTA_RELOC_NO:
7561     case DT_MIPS_DELTA_SYM_NO:
7562     case DT_MIPS_DELTA_CLASSSYM_NO:
7563     case DT_MIPS_COMPACT_SIZE:
7564       print_vma (entry->d_un.d_ptr, DEC);
7565       break;
7566
7567     default:
7568       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7569     }
7570     putchar ('\n');
7571 }
7572
7573 static void
7574 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
7575 {
7576   switch (entry->d_tag)
7577     {
7578     case DT_HP_DLD_FLAGS:
7579       {
7580         static struct
7581         {
7582           long int bit;
7583           const char * str;
7584         }
7585         flags[] =
7586         {
7587           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7588           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7589           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7590           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7591           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7592           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7593           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7594           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7595           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7596           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
7597           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7598           { DT_HP_GST, "HP_GST" },
7599           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7600           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7601           { DT_HP_NODELETE, "HP_NODELETE" },
7602           { DT_HP_GROUP, "HP_GROUP" },
7603           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
7604         };
7605         int first = 1;
7606         size_t cnt;
7607         bfd_vma val = entry->d_un.d_val;
7608
7609         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
7610           if (val & flags[cnt].bit)
7611             {
7612               if (! first)
7613                 putchar (' ');
7614               fputs (flags[cnt].str, stdout);
7615               first = 0;
7616               val ^= flags[cnt].bit;
7617             }
7618
7619         if (val != 0 || first)
7620           {
7621             if (! first)
7622               putchar (' ');
7623             print_vma (val, HEX);
7624           }
7625       }
7626       break;
7627
7628     default:
7629       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7630       break;
7631     }
7632   putchar ('\n');
7633 }
7634
7635 #ifdef BFD64
7636
7637 /* VMS vs Unix time offset and factor.  */
7638
7639 #define VMS_EPOCH_OFFSET 35067168000000000LL
7640 #define VMS_GRANULARITY_FACTOR 10000000
7641
7642 /* Display a VMS time in a human readable format.  */
7643
7644 static void
7645 print_vms_time (bfd_int64_t vmstime)
7646 {
7647   struct tm *tm;
7648   time_t unxtime;
7649
7650   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7651   tm = gmtime (&unxtime);
7652   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7653           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7654           tm->tm_hour, tm->tm_min, tm->tm_sec);
7655 }
7656 #endif /* BFD64 */
7657
7658 static void
7659 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
7660 {
7661   switch (entry->d_tag)
7662     {
7663     case DT_IA_64_PLT_RESERVE:
7664       /* First 3 slots reserved.  */
7665       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7666       printf (" -- ");
7667       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
7668       break;
7669
7670     case DT_IA_64_VMS_LINKTIME:
7671 #ifdef BFD64
7672       print_vms_time (entry->d_un.d_val);
7673 #endif
7674       break;
7675
7676     case DT_IA_64_VMS_LNKFLAGS:
7677       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7678       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7679         printf (" CALL_DEBUG");
7680       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7681         printf (" NOP0BUFS");
7682       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7683         printf (" P0IMAGE");
7684       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7685         printf (" MKTHREADS");
7686       if (entry->d_un.d_val & VMS_LF_UPCALLS)
7687         printf (" UPCALLS");
7688       if (entry->d_un.d_val & VMS_LF_IMGSTA)
7689         printf (" IMGSTA");
7690       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7691         printf (" INITIALIZE");
7692       if (entry->d_un.d_val & VMS_LF_MAIN)
7693         printf (" MAIN");
7694       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7695         printf (" EXE_INIT");
7696       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7697         printf (" TBK_IN_IMG");
7698       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7699         printf (" DBG_IN_IMG");
7700       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7701         printf (" TBK_IN_DSF");
7702       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7703         printf (" DBG_IN_DSF");
7704       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7705         printf (" SIGNATURES");
7706       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7707         printf (" REL_SEG_OFF");
7708       break;
7709
7710     default:
7711       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7712       break;
7713     }
7714   putchar ('\n');
7715 }
7716
7717 static int
7718 get_32bit_dynamic_section (FILE * file)
7719 {
7720   Elf32_External_Dyn * edyn;
7721   Elf32_External_Dyn * ext;
7722   Elf_Internal_Dyn * entry;
7723
7724   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7725                                           dynamic_size, _("dynamic section"));
7726   if (!edyn)
7727     return 0;
7728
7729 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7730    might not have the luxury of section headers.  Look for the DT_NULL
7731    terminator to determine the number of entries.  */
7732   for (ext = edyn, dynamic_nent = 0;
7733        (char *) ext < (char *) edyn + dynamic_size;
7734        ext++)
7735     {
7736       dynamic_nent++;
7737       if (BYTE_GET (ext->d_tag) == DT_NULL)
7738         break;
7739     }
7740
7741   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7742                                                   sizeof (* entry));
7743   if (dynamic_section == NULL)
7744     {
7745       error (_("Out of memory\n"));
7746       free (edyn);
7747       return 0;
7748     }
7749
7750   for (ext = edyn, entry = dynamic_section;
7751        entry < dynamic_section + dynamic_nent;
7752        ext++, entry++)
7753     {
7754       entry->d_tag      = BYTE_GET (ext->d_tag);
7755       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7756     }
7757
7758   free (edyn);
7759
7760   return 1;
7761 }
7762
7763 static int
7764 get_64bit_dynamic_section (FILE * file)
7765 {
7766   Elf64_External_Dyn * edyn;
7767   Elf64_External_Dyn * ext;
7768   Elf_Internal_Dyn * entry;
7769
7770   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7771                                           dynamic_size, _("dynamic section"));
7772   if (!edyn)
7773     return 0;
7774
7775 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7776    might not have the luxury of section headers.  Look for the DT_NULL
7777    terminator to determine the number of entries.  */
7778   for (ext = edyn, dynamic_nent = 0;
7779        (char *) ext < (char *) edyn + dynamic_size;
7780        ext++)
7781     {
7782       dynamic_nent++;
7783       if (BYTE_GET (ext->d_tag) == DT_NULL)
7784         break;
7785     }
7786
7787   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7788                                                   sizeof (* entry));
7789   if (dynamic_section == NULL)
7790     {
7791       error (_("Out of memory\n"));
7792       free (edyn);
7793       return 0;
7794     }
7795
7796   for (ext = edyn, entry = dynamic_section;
7797        entry < dynamic_section + dynamic_nent;
7798        ext++, entry++)
7799     {
7800       entry->d_tag      = BYTE_GET (ext->d_tag);
7801       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7802     }
7803
7804   free (edyn);
7805
7806   return 1;
7807 }
7808
7809 static void
7810 print_dynamic_flags (bfd_vma flags)
7811 {
7812   int first = 1;
7813
7814   while (flags)
7815     {
7816       bfd_vma flag;
7817
7818       flag = flags & - flags;
7819       flags &= ~ flag;
7820
7821       if (first)
7822         first = 0;
7823       else
7824         putc (' ', stdout);
7825
7826       switch (flag)
7827         {
7828         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
7829         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
7830         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
7831         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
7832         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
7833         default:                fputs (_("unknown"), stdout); break;
7834         }
7835     }
7836   puts ("");
7837 }
7838
7839 /* Parse and display the contents of the dynamic section.  */
7840
7841 static int
7842 process_dynamic_section (FILE * file)
7843 {
7844   Elf_Internal_Dyn * entry;
7845
7846   if (dynamic_size == 0)
7847     {
7848       if (do_dynamic)
7849         printf (_("\nThere is no dynamic section in this file.\n"));
7850
7851       return 1;
7852     }
7853
7854   if (is_32bit_elf)
7855     {
7856       if (! get_32bit_dynamic_section (file))
7857         return 0;
7858     }
7859   else if (! get_64bit_dynamic_section (file))
7860     return 0;
7861
7862   /* Find the appropriate symbol table.  */
7863   if (dynamic_symbols == NULL)
7864     {
7865       for (entry = dynamic_section;
7866            entry < dynamic_section + dynamic_nent;
7867            ++entry)
7868         {
7869           Elf_Internal_Shdr section;
7870
7871           if (entry->d_tag != DT_SYMTAB)
7872             continue;
7873
7874           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7875
7876           /* Since we do not know how big the symbol table is,
7877              we default to reading in the entire file (!) and
7878              processing that.  This is overkill, I know, but it
7879              should work.  */
7880           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
7881
7882           if (archive_file_offset != 0)
7883             section.sh_size = archive_file_size - section.sh_offset;
7884           else
7885             {
7886               if (fseek (file, 0, SEEK_END))
7887                 error (_("Unable to seek to end of file!\n"));
7888
7889               section.sh_size = ftell (file) - section.sh_offset;
7890             }
7891
7892           if (is_32bit_elf)
7893             section.sh_entsize = sizeof (Elf32_External_Sym);
7894           else
7895             section.sh_entsize = sizeof (Elf64_External_Sym);
7896
7897           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
7898           if (num_dynamic_syms < 1)
7899             {
7900               error (_("Unable to determine the number of symbols to load\n"));
7901               continue;
7902             }
7903         }
7904     }
7905
7906   /* Similarly find a string table.  */
7907   if (dynamic_strings == NULL)
7908     {
7909       for (entry = dynamic_section;
7910            entry < dynamic_section + dynamic_nent;
7911            ++entry)
7912         {
7913           unsigned long offset;
7914           long str_tab_len;
7915
7916           if (entry->d_tag != DT_STRTAB)
7917             continue;
7918
7919           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7920
7921           /* Since we do not know how big the string table is,
7922              we default to reading in the entire file (!) and
7923              processing that.  This is overkill, I know, but it
7924              should work.  */
7925
7926           offset = offset_from_vma (file, entry->d_un.d_val, 0);
7927
7928           if (archive_file_offset != 0)
7929             str_tab_len = archive_file_size - offset;
7930           else
7931             {
7932               if (fseek (file, 0, SEEK_END))
7933                 error (_("Unable to seek to end of file\n"));
7934               str_tab_len = ftell (file) - offset;
7935             }
7936
7937           if (str_tab_len < 1)
7938             {
7939               error
7940                 (_("Unable to determine the length of the dynamic string table\n"));
7941               continue;
7942             }
7943
7944           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7945                                                str_tab_len,
7946                                                _("dynamic string table"));
7947           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
7948           break;
7949         }
7950     }
7951
7952   /* And find the syminfo section if available.  */
7953   if (dynamic_syminfo == NULL)
7954     {
7955       unsigned long syminsz = 0;
7956
7957       for (entry = dynamic_section;
7958            entry < dynamic_section + dynamic_nent;
7959            ++entry)
7960         {
7961           if (entry->d_tag == DT_SYMINENT)
7962             {
7963               /* Note: these braces are necessary to avoid a syntax
7964                  error from the SunOS4 C compiler.  */
7965               assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7966             }
7967           else if (entry->d_tag == DT_SYMINSZ)
7968             syminsz = entry->d_un.d_val;
7969           else if (entry->d_tag == DT_SYMINFO)
7970             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7971                                                       syminsz);
7972         }
7973
7974       if (dynamic_syminfo_offset != 0 && syminsz != 0)
7975         {
7976           Elf_External_Syminfo * extsyminfo;
7977           Elf_External_Syminfo * extsym;
7978           Elf_Internal_Syminfo * syminfo;
7979
7980           /* There is a syminfo section.  Read the data.  */
7981           extsyminfo = (Elf_External_Syminfo *)
7982               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7983                         _("symbol information"));
7984           if (!extsyminfo)
7985             return 0;
7986
7987           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
7988           if (dynamic_syminfo == NULL)
7989             {
7990               error (_("Out of memory\n"));
7991               return 0;
7992             }
7993
7994           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
7995           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7996                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7997                ++syminfo, ++extsym)
7998             {
7999               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8000               syminfo->si_flags = BYTE_GET (extsym->si_flags);
8001             }
8002
8003           free (extsyminfo);
8004         }
8005     }
8006
8007   if (do_dynamic && dynamic_addr)
8008     printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
8009             dynamic_addr, dynamic_nent);
8010   if (do_dynamic)
8011     printf (_("  Tag        Type                         Name/Value\n"));
8012
8013   for (entry = dynamic_section;
8014        entry < dynamic_section + dynamic_nent;
8015        entry++)
8016     {
8017       if (do_dynamic)
8018         {
8019           const char * dtype;
8020
8021           putchar (' ');
8022           print_vma (entry->d_tag, FULL_HEX);
8023           dtype = get_dynamic_type (entry->d_tag);
8024           printf (" (%s)%*s", dtype,
8025                   ((is_32bit_elf ? 27 : 19)
8026                    - (int) strlen (dtype)),
8027                   " ");
8028         }
8029
8030       switch (entry->d_tag)
8031         {
8032         case DT_FLAGS:
8033           if (do_dynamic)
8034             print_dynamic_flags (entry->d_un.d_val);
8035           break;
8036
8037         case DT_AUXILIARY:
8038         case DT_FILTER:
8039         case DT_CONFIG:
8040         case DT_DEPAUDIT:
8041         case DT_AUDIT:
8042           if (do_dynamic)
8043             {
8044               switch (entry->d_tag)
8045                 {
8046                 case DT_AUXILIARY:
8047                   printf (_("Auxiliary library"));
8048                   break;
8049
8050                 case DT_FILTER:
8051                   printf (_("Filter library"));
8052                   break;
8053
8054                 case DT_CONFIG:
8055                   printf (_("Configuration file"));
8056                   break;
8057
8058                 case DT_DEPAUDIT:
8059                   printf (_("Dependency audit library"));
8060                   break;
8061
8062                 case DT_AUDIT:
8063                   printf (_("Audit library"));
8064                   break;
8065                 }
8066
8067               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8068                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
8069               else
8070                 {
8071                   printf (": ");
8072                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8073                   putchar ('\n');
8074                 }
8075             }
8076           break;
8077
8078         case DT_FEATURE:
8079           if (do_dynamic)
8080             {
8081               printf (_("Flags:"));
8082
8083               if (entry->d_un.d_val == 0)
8084                 printf (_(" None\n"));
8085               else
8086                 {
8087                   unsigned long int val = entry->d_un.d_val;
8088
8089                   if (val & DTF_1_PARINIT)
8090                     {
8091                       printf (" PARINIT");
8092                       val ^= DTF_1_PARINIT;
8093                     }
8094                   if (val & DTF_1_CONFEXP)
8095                     {
8096                       printf (" CONFEXP");
8097                       val ^= DTF_1_CONFEXP;
8098                     }
8099                   if (val != 0)
8100                     printf (" %lx", val);
8101                   puts ("");
8102                 }
8103             }
8104           break;
8105
8106         case DT_POSFLAG_1:
8107           if (do_dynamic)
8108             {
8109               printf (_("Flags:"));
8110
8111               if (entry->d_un.d_val == 0)
8112                 printf (_(" None\n"));
8113               else
8114                 {
8115                   unsigned long int val = entry->d_un.d_val;
8116
8117                   if (val & DF_P1_LAZYLOAD)
8118                     {
8119                       printf (" LAZYLOAD");
8120                       val ^= DF_P1_LAZYLOAD;
8121                     }
8122                   if (val & DF_P1_GROUPPERM)
8123                     {
8124                       printf (" GROUPPERM");
8125                       val ^= DF_P1_GROUPPERM;
8126                     }
8127                   if (val != 0)
8128                     printf (" %lx", val);
8129                   puts ("");
8130                 }
8131             }
8132           break;
8133
8134         case DT_FLAGS_1:
8135           if (do_dynamic)
8136             {
8137               printf (_("Flags:"));
8138               if (entry->d_un.d_val == 0)
8139                 printf (_(" None\n"));
8140               else
8141                 {
8142                   unsigned long int val = entry->d_un.d_val;
8143
8144                   if (val & DF_1_NOW)
8145                     {
8146                       printf (" NOW");
8147                       val ^= DF_1_NOW;
8148                     }
8149                   if (val & DF_1_GLOBAL)
8150                     {
8151                       printf (" GLOBAL");
8152                       val ^= DF_1_GLOBAL;
8153                     }
8154                   if (val & DF_1_GROUP)
8155                     {
8156                       printf (" GROUP");
8157                       val ^= DF_1_GROUP;
8158                     }
8159                   if (val & DF_1_NODELETE)
8160                     {
8161                       printf (" NODELETE");
8162                       val ^= DF_1_NODELETE;
8163                     }
8164                   if (val & DF_1_LOADFLTR)
8165                     {
8166                       printf (" LOADFLTR");
8167                       val ^= DF_1_LOADFLTR;
8168                     }
8169                   if (val & DF_1_INITFIRST)
8170                     {
8171                       printf (" INITFIRST");
8172                       val ^= DF_1_INITFIRST;
8173                     }
8174                   if (val & DF_1_NOOPEN)
8175                     {
8176                       printf (" NOOPEN");
8177                       val ^= DF_1_NOOPEN;
8178                     }
8179                   if (val & DF_1_ORIGIN)
8180                     {
8181                       printf (" ORIGIN");
8182                       val ^= DF_1_ORIGIN;
8183                     }
8184                   if (val & DF_1_DIRECT)
8185                     {
8186                       printf (" DIRECT");
8187                       val ^= DF_1_DIRECT;
8188                     }
8189                   if (val & DF_1_TRANS)
8190                     {
8191                       printf (" TRANS");
8192                       val ^= DF_1_TRANS;
8193                     }
8194                   if (val & DF_1_INTERPOSE)
8195                     {
8196                       printf (" INTERPOSE");
8197                       val ^= DF_1_INTERPOSE;
8198                     }
8199                   if (val & DF_1_NODEFLIB)
8200                     {
8201                       printf (" NODEFLIB");
8202                       val ^= DF_1_NODEFLIB;
8203                     }
8204                   if (val & DF_1_NODUMP)
8205                     {
8206                       printf (" NODUMP");
8207                       val ^= DF_1_NODUMP;
8208                     }
8209                   if (val & DF_1_CONFALT)
8210                     {
8211                       printf (" CONFALT");
8212                       val ^= DF_1_CONFALT;
8213                     }
8214                   if (val & DF_1_ENDFILTEE)
8215                     {
8216                       printf (" ENDFILTEE");
8217                       val ^= DF_1_ENDFILTEE;
8218                     }
8219                   if (val & DF_1_DISPRELDNE)
8220                     {
8221                       printf (" DISPRELDNE");
8222                       val ^= DF_1_DISPRELDNE;
8223                     }
8224                   if (val & DF_1_DISPRELPND)
8225                     {
8226                       printf (" DISPRELPND");
8227                       val ^= DF_1_DISPRELPND;
8228                     }
8229                   if (val & DF_1_NODIRECT)
8230                     {
8231                       printf (" NODIRECT");
8232                       val ^= DF_1_NODIRECT;
8233                     }
8234                   if (val & DF_1_IGNMULDEF)
8235                     {
8236                       printf (" IGNMULDEF");
8237                       val ^= DF_1_IGNMULDEF;
8238                     }
8239                   if (val & DF_1_NOKSYMS)
8240                     {
8241                       printf (" NOKSYMS");
8242                       val ^= DF_1_NOKSYMS;
8243                     }
8244                   if (val & DF_1_NOHDR)
8245                     {
8246                       printf (" NOHDR");
8247                       val ^= DF_1_NOHDR;
8248                     }
8249                   if (val & DF_1_EDITED)
8250                     {
8251                       printf (" EDITED");
8252                       val ^= DF_1_EDITED;
8253                     }
8254                   if (val & DF_1_NORELOC)
8255                     {
8256                       printf (" NORELOC");
8257                       val ^= DF_1_NORELOC;
8258                     }
8259                   if (val & DF_1_SYMINTPOSE)
8260                     {
8261                       printf (" SYMINTPOSE");
8262                       val ^= DF_1_SYMINTPOSE;
8263                     }
8264                   if (val & DF_1_GLOBAUDIT)
8265                     {
8266                       printf (" GLOBAUDIT");
8267                       val ^= DF_1_GLOBAUDIT;
8268                     }
8269                   if (val & DF_1_SINGLETON)
8270                     {
8271                       printf (" SINGLETON");
8272                       val ^= DF_1_SINGLETON;
8273                     }
8274                   if (val != 0)
8275                     printf (" %lx", val);
8276                   puts ("");
8277                 }
8278             }
8279           break;
8280
8281         case DT_PLTREL:
8282           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8283           if (do_dynamic)
8284             puts (get_dynamic_type (entry->d_un.d_val));
8285           break;
8286
8287         case DT_NULL    :
8288         case DT_NEEDED  :
8289         case DT_PLTGOT  :
8290         case DT_HASH    :
8291         case DT_STRTAB  :
8292         case DT_SYMTAB  :
8293         case DT_RELA    :
8294         case DT_INIT    :
8295         case DT_FINI    :
8296         case DT_SONAME  :
8297         case DT_RPATH   :
8298         case DT_SYMBOLIC:
8299         case DT_REL     :
8300         case DT_DEBUG   :
8301         case DT_TEXTREL :
8302         case DT_JMPREL  :
8303         case DT_RUNPATH :
8304           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8305
8306           if (do_dynamic)
8307             {
8308               char * name;
8309
8310               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8311                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8312               else
8313                 name = NULL;
8314
8315               if (name)
8316                 {
8317                   switch (entry->d_tag)
8318                     {
8319                     case DT_NEEDED:
8320                       printf (_("Shared library: [%s]"), name);
8321
8322                       if (streq (name, program_interpreter))
8323                         printf (_(" program interpreter"));
8324                       break;
8325
8326                     case DT_SONAME:
8327                       printf (_("Library soname: [%s]"), name);
8328                       break;
8329
8330                     case DT_RPATH:
8331                       printf (_("Library rpath: [%s]"), name);
8332                       break;
8333
8334                     case DT_RUNPATH:
8335                       printf (_("Library runpath: [%s]"), name);
8336                       break;
8337
8338                     default:
8339                       print_vma (entry->d_un.d_val, PREFIX_HEX);
8340                       break;
8341                     }
8342                 }
8343               else
8344                 print_vma (entry->d_un.d_val, PREFIX_HEX);
8345
8346               putchar ('\n');
8347             }
8348           break;
8349
8350         case DT_PLTRELSZ:
8351         case DT_RELASZ  :
8352         case DT_STRSZ   :
8353         case DT_RELSZ   :
8354         case DT_RELAENT :
8355         case DT_SYMENT  :
8356         case DT_RELENT  :
8357           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8358         case DT_PLTPADSZ:
8359         case DT_MOVEENT :
8360         case DT_MOVESZ  :
8361         case DT_INIT_ARRAYSZ:
8362         case DT_FINI_ARRAYSZ:
8363         case DT_GNU_CONFLICTSZ:
8364         case DT_GNU_LIBLISTSZ:
8365           if (do_dynamic)
8366             {
8367               print_vma (entry->d_un.d_val, UNSIGNED);
8368               printf (_(" (bytes)\n"));
8369             }
8370           break;
8371
8372         case DT_VERDEFNUM:
8373         case DT_VERNEEDNUM:
8374         case DT_RELACOUNT:
8375         case DT_RELCOUNT:
8376           if (do_dynamic)
8377             {
8378               print_vma (entry->d_un.d_val, UNSIGNED);
8379               putchar ('\n');
8380             }
8381           break;
8382
8383         case DT_SYMINSZ:
8384         case DT_SYMINENT:
8385         case DT_SYMINFO:
8386         case DT_USED:
8387         case DT_INIT_ARRAY:
8388         case DT_FINI_ARRAY:
8389           if (do_dynamic)
8390             {
8391               if (entry->d_tag == DT_USED
8392                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
8393                 {
8394                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8395
8396                   if (*name)
8397                     {
8398                       printf (_("Not needed object: [%s]\n"), name);
8399                       break;
8400                     }
8401                 }
8402
8403               print_vma (entry->d_un.d_val, PREFIX_HEX);
8404               putchar ('\n');
8405             }
8406           break;
8407
8408         case DT_BIND_NOW:
8409           /* The value of this entry is ignored.  */
8410           if (do_dynamic)
8411             putchar ('\n');
8412           break;
8413
8414         case DT_GNU_PRELINKED:
8415           if (do_dynamic)
8416             {
8417               struct tm * tmp;
8418               time_t atime = entry->d_un.d_val;
8419
8420               tmp = gmtime (&atime);
8421               printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8422                       tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8423                       tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8424
8425             }
8426           break;
8427
8428         case DT_GNU_HASH:
8429           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8430           if (do_dynamic)
8431             {
8432               print_vma (entry->d_un.d_val, PREFIX_HEX);
8433               putchar ('\n');
8434             }
8435           break;
8436
8437         default:
8438           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
8439             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
8440               entry->d_un.d_val;
8441
8442           if (do_dynamic)
8443             {
8444               switch (elf_header.e_machine)
8445                 {
8446                 case EM_MIPS:
8447                 case EM_MIPS_RS3_LE:
8448                   dynamic_section_mips_val (entry);
8449                   break;
8450                 case EM_PARISC:
8451                   dynamic_section_parisc_val (entry);
8452                   break;
8453                 case EM_IA_64:
8454                   dynamic_section_ia64_val (entry);
8455                   break;
8456                 default:
8457                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8458                   putchar ('\n');
8459                 }
8460             }
8461           break;
8462         }
8463     }
8464
8465   return 1;
8466 }
8467
8468 static char *
8469 get_ver_flags (unsigned int flags)
8470 {
8471   static char buff[32];
8472
8473   buff[0] = 0;
8474
8475   if (flags == 0)
8476     return _("none");
8477
8478   if (flags & VER_FLG_BASE)
8479     strcat (buff, "BASE ");
8480
8481   if (flags & VER_FLG_WEAK)
8482     {
8483       if (flags & VER_FLG_BASE)
8484         strcat (buff, "| ");
8485
8486       strcat (buff, "WEAK ");
8487     }
8488
8489   if (flags & VER_FLG_INFO)
8490     {
8491       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8492         strcat (buff, "| ");
8493
8494       strcat (buff, "INFO ");
8495     }
8496
8497   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
8498     strcat (buff, _("| <unknown>"));
8499
8500   return buff;
8501 }
8502
8503 /* Display the contents of the version sections.  */
8504
8505 static int
8506 process_version_sections (FILE * file)
8507 {
8508   Elf_Internal_Shdr * section;
8509   unsigned i;
8510   int found = 0;
8511
8512   if (! do_version)
8513     return 1;
8514
8515   for (i = 0, section = section_headers;
8516        i < elf_header.e_shnum;
8517        i++, section++)
8518     {
8519       switch (section->sh_type)
8520         {
8521         case SHT_GNU_verdef:
8522           {
8523             Elf_External_Verdef * edefs;
8524             unsigned int idx;
8525             unsigned int cnt;
8526             char * endbuf;
8527
8528             found = 1;
8529
8530             printf
8531               (_("\nVersion definition section '%s' contains %u entries:\n"),
8532                SECTION_NAME (section), section->sh_info);
8533
8534             printf (_("  Addr: 0x"));
8535             printf_vma (section->sh_addr);
8536             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8537                     (unsigned long) section->sh_offset, section->sh_link,
8538                     section->sh_link < elf_header.e_shnum
8539                     ? SECTION_NAME (section_headers + section->sh_link)
8540                     : _("<corrupt>"));
8541
8542             edefs = (Elf_External_Verdef *)
8543                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8544                           _("version definition section"));
8545             if (!edefs)
8546               break;
8547             endbuf = (char *) edefs + section->sh_size;
8548
8549             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8550               {
8551                 char * vstart;
8552                 Elf_External_Verdef * edef;
8553                 Elf_Internal_Verdef ent;
8554                 Elf_External_Verdaux * eaux;
8555                 Elf_Internal_Verdaux aux;
8556                 int j;
8557                 int isum;
8558
8559                 /* Check for very large indicies.  */
8560                 if (idx > (size_t) (endbuf - (char *) edefs))
8561                   break;
8562
8563                 vstart = ((char *) edefs) + idx;
8564                 if (vstart + sizeof (*edef) > endbuf)
8565                   break;
8566
8567                 edef = (Elf_External_Verdef *) vstart;
8568
8569                 ent.vd_version = BYTE_GET (edef->vd_version);
8570                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
8571                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
8572                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
8573                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
8574                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
8575                 ent.vd_next    = BYTE_GET (edef->vd_next);
8576
8577                 printf (_("  %#06x: Rev: %d  Flags: %s"),
8578                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8579
8580                 printf (_("  Index: %d  Cnt: %d  "),
8581                         ent.vd_ndx, ent.vd_cnt);
8582
8583                 /* Check for overflow.  */
8584                 if (ent.vd_aux > (size_t) (endbuf - vstart))
8585                   break;
8586
8587                 vstart += ent.vd_aux;
8588
8589                 eaux = (Elf_External_Verdaux *) vstart;
8590
8591                 aux.vda_name = BYTE_GET (eaux->vda_name);
8592                 aux.vda_next = BYTE_GET (eaux->vda_next);
8593
8594                 if (VALID_DYNAMIC_NAME (aux.vda_name))
8595                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
8596                 else
8597                   printf (_("Name index: %ld\n"), aux.vda_name);
8598
8599                 isum = idx + ent.vd_aux;
8600
8601                 for (j = 1; j < ent.vd_cnt; j++)
8602                   {
8603                     /* Check for overflow.  */
8604                     if (aux.vda_next > (size_t) (endbuf - vstart))
8605                       break;
8606
8607                     isum   += aux.vda_next;
8608                     vstart += aux.vda_next;
8609
8610                     eaux = (Elf_External_Verdaux *) vstart;
8611                     if (vstart + sizeof (*eaux) > endbuf)
8612                       break;
8613
8614                     aux.vda_name = BYTE_GET (eaux->vda_name);
8615                     aux.vda_next = BYTE_GET (eaux->vda_next);
8616
8617                     if (VALID_DYNAMIC_NAME (aux.vda_name))
8618                       printf (_("  %#06x: Parent %d: %s\n"),
8619                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
8620                     else
8621                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
8622                               isum, j, aux.vda_name);
8623                   }
8624
8625                 if (j < ent.vd_cnt)
8626                   printf (_("  Version def aux past end of section\n"));
8627
8628                 idx += ent.vd_next;
8629               }
8630
8631             if (cnt < section->sh_info)
8632               printf (_("  Version definition past end of section\n"));
8633
8634             free (edefs);
8635           }
8636           break;
8637
8638         case SHT_GNU_verneed:
8639           {
8640             Elf_External_Verneed * eneed;
8641             unsigned int idx;
8642             unsigned int cnt;
8643             char * endbuf;
8644
8645             found = 1;
8646
8647             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8648                     SECTION_NAME (section), section->sh_info);
8649
8650             printf (_(" Addr: 0x"));
8651             printf_vma (section->sh_addr);
8652             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8653                     (unsigned long) section->sh_offset, section->sh_link,
8654                     section->sh_link < elf_header.e_shnum
8655                     ? SECTION_NAME (section_headers + section->sh_link)
8656                     : _("<corrupt>"));
8657
8658             eneed = (Elf_External_Verneed *) get_data (NULL, file,
8659                                                        section->sh_offset, 1,
8660                                                        section->sh_size,
8661                                                        _("Version Needs section"));
8662             if (!eneed)
8663               break;
8664             endbuf = (char *) eneed + section->sh_size;
8665
8666             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8667               {
8668                 Elf_External_Verneed * entry;
8669                 Elf_Internal_Verneed ent;
8670                 int j;
8671                 int isum;
8672                 char * vstart;
8673
8674                 if (idx > (size_t) (endbuf - (char *) eneed))
8675                   break;
8676
8677                 vstart = ((char *) eneed) + idx;
8678                 if (vstart + sizeof (*entry) > endbuf)
8679                   break;
8680
8681                 entry = (Elf_External_Verneed *) vstart;
8682
8683                 ent.vn_version = BYTE_GET (entry->vn_version);
8684                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
8685                 ent.vn_file    = BYTE_GET (entry->vn_file);
8686                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
8687                 ent.vn_next    = BYTE_GET (entry->vn_next);
8688
8689                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
8690
8691                 if (VALID_DYNAMIC_NAME (ent.vn_file))
8692                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
8693                 else
8694                   printf (_("  File: %lx"), ent.vn_file);
8695
8696                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
8697
8698                 /* Check for overflow.  */
8699                 if (ent.vn_aux > (size_t) (endbuf - vstart))
8700                   break;
8701
8702                 vstart += ent.vn_aux;
8703
8704                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8705                   {
8706                     Elf_External_Vernaux * eaux;
8707                     Elf_Internal_Vernaux aux;
8708
8709                     if (vstart + sizeof (*eaux) > endbuf)
8710                       break;
8711                     eaux = (Elf_External_Vernaux *) vstart;
8712
8713                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
8714                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
8715                     aux.vna_other = BYTE_GET (eaux->vna_other);
8716                     aux.vna_name  = BYTE_GET (eaux->vna_name);
8717                     aux.vna_next  = BYTE_GET (eaux->vna_next);
8718
8719                     if (VALID_DYNAMIC_NAME (aux.vna_name))
8720                       printf (_("  %#06x:   Name: %s"),
8721                               isum, GET_DYNAMIC_NAME (aux.vna_name));
8722                     else
8723                       printf (_("  %#06x:   Name index: %lx"),
8724                               isum, aux.vna_name);
8725
8726                     printf (_("  Flags: %s  Version: %d\n"),
8727                             get_ver_flags (aux.vna_flags), aux.vna_other);
8728
8729                     /* Check for overflow.  */
8730                     if (aux.vna_next > (size_t) (endbuf - vstart))
8731                       break;
8732
8733                     isum   += aux.vna_next;
8734                     vstart += aux.vna_next;
8735                   }
8736
8737                 if (j < ent.vn_cnt)
8738                   warn (_("Missing Version Needs auxillary information\n"));
8739
8740                 idx += ent.vn_next;
8741               }
8742
8743             if (cnt < section->sh_info)
8744               warn (_("Missing Version Needs information\n"));
8745
8746             free (eneed);
8747           }
8748           break;
8749
8750         case SHT_GNU_versym:
8751           {
8752             Elf_Internal_Shdr * link_section;
8753             int total;
8754             int cnt;
8755             unsigned char * edata;
8756             unsigned short * data;
8757             char * strtab;
8758             Elf_Internal_Sym * symbols;
8759             Elf_Internal_Shdr * string_sec;
8760             unsigned long num_syms;
8761             long off;
8762
8763             if (section->sh_link >= elf_header.e_shnum)
8764               break;
8765
8766             link_section = section_headers + section->sh_link;
8767             total = section->sh_size / sizeof (Elf_External_Versym);
8768
8769             if (link_section->sh_link >= elf_header.e_shnum)
8770               break;
8771
8772             found = 1;
8773
8774             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
8775             if (symbols == NULL)
8776               break;
8777
8778             string_sec = section_headers + link_section->sh_link;
8779
8780             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8781                                         string_sec->sh_size,
8782                                         _("version string table"));
8783             if (!strtab)
8784               {
8785                 free (symbols);
8786                 break;
8787               }
8788
8789             printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8790                     SECTION_NAME (section), total);
8791
8792             printf (_(" Addr: "));
8793             printf_vma (section->sh_addr);
8794             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8795                     (unsigned long) section->sh_offset, section->sh_link,
8796                     SECTION_NAME (link_section));
8797
8798             off = offset_from_vma (file,
8799                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8800                                    total * sizeof (short));
8801             edata = (unsigned char *) get_data (NULL, file, off, total,
8802                                                 sizeof (short),
8803                                                 _("version symbol data"));
8804             if (!edata)
8805               {
8806                 free (strtab);
8807                 free (symbols);
8808                 break;
8809               }
8810
8811             data = (short unsigned int *) cmalloc (total, sizeof (short));
8812
8813             for (cnt = total; cnt --;)
8814               data[cnt] = byte_get (edata + cnt * sizeof (short),
8815                                     sizeof (short));
8816
8817             free (edata);
8818
8819             for (cnt = 0; cnt < total; cnt += 4)
8820               {
8821                 int j, nn;
8822                 int check_def, check_need;
8823                 char * name;
8824
8825                 printf ("  %03x:", cnt);
8826
8827                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
8828                   switch (data[cnt + j])
8829                     {
8830                     case 0:
8831                       fputs (_("   0 (*local*)    "), stdout);
8832                       break;
8833
8834                     case 1:
8835                       fputs (_("   1 (*global*)   "), stdout);
8836                       break;
8837
8838                     default:
8839                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8840                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
8841
8842                       /* If this index value is greater than the size of the symbols
8843                          array, break to avoid an out-of-bounds read.  */
8844                       if ((unsigned long)(cnt + j) >= num_syms)
8845                         {
8846                           warn (_("invalid index into symbol array\n"));
8847                           break;
8848                         }
8849
8850                       check_def = 1;
8851                       check_need = 1;
8852                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8853                           || section_headers[symbols[cnt + j].st_shndx].sh_type
8854                              != SHT_NOBITS)
8855                         {
8856                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
8857                             check_def = 0;
8858                           else
8859                             check_need = 0;
8860                         }
8861
8862                       if (check_need
8863                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
8864                         {
8865                           Elf_Internal_Verneed ivn;
8866                           unsigned long offset;
8867
8868                           offset = offset_from_vma
8869                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8870                              sizeof (Elf_External_Verneed));
8871
8872                           do
8873                             {
8874                               Elf_Internal_Vernaux ivna;
8875                               Elf_External_Verneed evn;
8876                               Elf_External_Vernaux evna;
8877                               unsigned long a_off;
8878
8879                               if (get_data (&evn, file, offset, sizeof (evn), 1,
8880                                             _("version need")) == NULL)
8881                                 break;
8882
8883                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
8884                               ivn.vn_next = BYTE_GET (evn.vn_next);
8885
8886                               a_off = offset + ivn.vn_aux;
8887
8888                               do
8889                                 {
8890                                   if (get_data (&evna, file, a_off, sizeof (evna),
8891                                                 1, _("version need aux (2)")) == NULL)
8892                                     {
8893                                       ivna.vna_next  = 0;
8894                                       ivna.vna_other = 0;
8895                                     }
8896                                   else
8897                                     {
8898                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
8899                                       ivna.vna_other = BYTE_GET (evna.vna_other);
8900                                     }
8901
8902                                   a_off += ivna.vna_next;
8903                                 }
8904                               while (ivna.vna_other != data[cnt + j]
8905                                      && ivna.vna_next != 0);
8906
8907                               if (ivna.vna_other == data[cnt + j])
8908                                 {
8909                                   ivna.vna_name = BYTE_GET (evna.vna_name);
8910
8911                                   if (ivna.vna_name >= string_sec->sh_size)
8912                                     name = _("*invalid*");
8913                                   else
8914                                     name = strtab + ivna.vna_name;
8915                                   nn += printf ("(%s%-*s",
8916                                                 name,
8917                                                 12 - (int) strlen (name),
8918                                                 ")");
8919                                   check_def = 0;
8920                                   break;
8921                                 }
8922
8923                               offset += ivn.vn_next;
8924                             }
8925                           while (ivn.vn_next);
8926                         }
8927
8928                       if (check_def && data[cnt + j] != 0x8001
8929                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8930                         {
8931                           Elf_Internal_Verdef ivd;
8932                           Elf_External_Verdef evd;
8933                           unsigned long offset;
8934
8935                           offset = offset_from_vma
8936                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8937                              sizeof evd);
8938
8939                           do
8940                             {
8941                               if (get_data (&evd, file, offset, sizeof (evd), 1,
8942                                             _("version def")) == NULL)
8943                                 {
8944                                   ivd.vd_next = 0;
8945                                   ivd.vd_ndx  = 0;
8946                                 }
8947                               else
8948                                 {
8949                                   ivd.vd_next = BYTE_GET (evd.vd_next);
8950                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
8951                                 }
8952
8953                               offset += ivd.vd_next;
8954                             }
8955                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
8956                                  && ivd.vd_next != 0);
8957
8958                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
8959                             {
8960                               Elf_External_Verdaux evda;
8961                               Elf_Internal_Verdaux ivda;
8962
8963                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
8964
8965                               if (get_data (&evda, file,
8966                                             offset - ivd.vd_next + ivd.vd_aux,
8967                                             sizeof (evda), 1,
8968                                             _("version def aux")) == NULL)
8969                                 break;
8970
8971                               ivda.vda_name = BYTE_GET (evda.vda_name);
8972
8973                               if (ivda.vda_name >= string_sec->sh_size)
8974                                 name = _("*invalid*");
8975                               else
8976                                 name = strtab + ivda.vda_name;
8977                               nn += printf ("(%s%-*s",
8978                                             name,
8979                                             12 - (int) strlen (name),
8980                                             ")");
8981                             }
8982                         }
8983
8984                       if (nn < 18)
8985                         printf ("%*c", 18 - nn, ' ');
8986                     }
8987
8988                 putchar ('\n');
8989               }
8990
8991             free (data);
8992             free (strtab);
8993             free (symbols);
8994           }
8995           break;
8996
8997         default:
8998           break;
8999         }
9000     }
9001
9002   if (! found)
9003     printf (_("\nNo version information found in this file.\n"));
9004
9005   return 1;
9006 }
9007
9008 static const char *
9009 get_symbol_binding (unsigned int binding)
9010 {
9011   static char buff[32];
9012
9013   switch (binding)
9014     {
9015     case STB_LOCAL:     return "LOCAL";
9016     case STB_GLOBAL:    return "GLOBAL";
9017     case STB_WEAK:      return "WEAK";
9018     default:
9019       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
9020         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9021                   binding);
9022       else if (binding >= STB_LOOS && binding <= STB_HIOS)
9023         {
9024           if (binding == STB_GNU_UNIQUE
9025               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9026                   /* GNU is still using the default value 0.  */
9027                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9028             return "UNIQUE";
9029           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9030         }
9031       else
9032         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
9033       return buff;
9034     }
9035 }
9036
9037 static const char *
9038 get_symbol_type (unsigned int type)
9039 {
9040   static char buff[32];
9041
9042   switch (type)
9043     {
9044     case STT_NOTYPE:    return "NOTYPE";
9045     case STT_OBJECT:    return "OBJECT";
9046     case STT_FUNC:      return "FUNC";
9047     case STT_SECTION:   return "SECTION";
9048     case STT_FILE:      return "FILE";
9049     case STT_COMMON:    return "COMMON";
9050     case STT_TLS:       return "TLS";
9051     case STT_RELC:      return "RELC";
9052     case STT_SRELC:     return "SRELC";
9053     default:
9054       if (type >= STT_LOPROC && type <= STT_HIPROC)
9055         {
9056           if (elf_header.e_machine == EM_ARM)
9057             {
9058               if (type == STT_ARM_TFUNC)
9059                 return "THUMB_FUNC";
9060               if (type == STT_ARM_16BIT)
9061                 return "THUMB_LABEL";
9062             }
9063
9064           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
9065             return "REGISTER";
9066
9067           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9068             return "PARISC_MILLI";
9069
9070           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
9071         }
9072       else if (type >= STT_LOOS && type <= STT_HIOS)
9073         {
9074           if (elf_header.e_machine == EM_PARISC)
9075             {
9076               if (type == STT_HP_OPAQUE)
9077                 return "HP_OPAQUE";
9078               if (type == STT_HP_STUB)
9079                 return "HP_STUB";
9080             }
9081
9082           if (type == STT_GNU_IFUNC
9083               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9084                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9085                   /* GNU is still using the default value 0.  */
9086                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9087             return "IFUNC";
9088
9089           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
9090         }
9091       else
9092         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
9093       return buff;
9094     }
9095 }
9096
9097 static const char *
9098 get_symbol_visibility (unsigned int visibility)
9099 {
9100   switch (visibility)
9101     {
9102     case STV_DEFAULT:   return "DEFAULT";
9103     case STV_INTERNAL:  return "INTERNAL";
9104     case STV_HIDDEN:    return "HIDDEN";
9105     case STV_PROTECTED: return "PROTECTED";
9106     default: abort ();
9107     }
9108 }
9109
9110 static const char *
9111 get_mips_symbol_other (unsigned int other)
9112 {
9113   switch (other)
9114     {
9115     case STO_OPTIONAL:
9116       return "OPTIONAL";
9117     case STO_MIPS_PLT:
9118       return "MIPS PLT";
9119     case STO_MIPS_PIC:
9120       return "MIPS PIC";
9121     case STO_MICROMIPS:
9122       return "MICROMIPS";
9123     case STO_MICROMIPS | STO_MIPS_PIC:
9124       return "MICROMIPS, MIPS PIC";
9125     case STO_MIPS16:
9126       return "MIPS16";
9127     default:
9128       return NULL;
9129     }
9130 }
9131
9132 static const char *
9133 get_ia64_symbol_other (unsigned int other)
9134 {
9135   if (is_ia64_vms ())
9136     {
9137       static char res[32];
9138
9139       res[0] = 0;
9140
9141       /* Function types is for images and .STB files only.  */
9142       switch (elf_header.e_type)
9143         {
9144         case ET_DYN:
9145         case ET_EXEC:
9146           switch (VMS_ST_FUNC_TYPE (other))
9147             {
9148             case VMS_SFT_CODE_ADDR:
9149               strcat (res, " CA");
9150               break;
9151             case VMS_SFT_SYMV_IDX:
9152               strcat (res, " VEC");
9153               break;
9154             case VMS_SFT_FD:
9155               strcat (res, " FD");
9156               break;
9157             case VMS_SFT_RESERVE:
9158               strcat (res, " RSV");
9159               break;
9160             default:
9161               abort ();
9162             }
9163           break;
9164         default:
9165           break;
9166         }
9167       switch (VMS_ST_LINKAGE (other))
9168         {
9169         case VMS_STL_IGNORE:
9170           strcat (res, " IGN");
9171           break;
9172         case VMS_STL_RESERVE:
9173           strcat (res, " RSV");
9174           break;
9175         case VMS_STL_STD:
9176           strcat (res, " STD");
9177           break;
9178         case VMS_STL_LNK:
9179           strcat (res, " LNK");
9180           break;
9181         default:
9182           abort ();
9183         }
9184
9185       if (res[0] != 0)
9186         return res + 1;
9187       else
9188         return res;
9189     }
9190   return NULL;
9191 }
9192
9193 static const char *
9194 get_symbol_other (unsigned int other)
9195 {
9196   const char * result = NULL;
9197   static char buff [32];
9198
9199   if (other == 0)
9200     return "";
9201
9202   switch (elf_header.e_machine)
9203     {
9204     case EM_MIPS:
9205       result = get_mips_symbol_other (other);
9206       break;
9207     case EM_IA_64:
9208       result = get_ia64_symbol_other (other);
9209       break;
9210     default:
9211       break;
9212     }
9213
9214   if (result)
9215     return result;
9216
9217   snprintf (buff, sizeof buff, _("<other>: %x"), other);
9218   return buff;
9219 }
9220
9221 static const char *
9222 get_symbol_index_type (unsigned int type)
9223 {
9224   static char buff[32];
9225
9226   switch (type)
9227     {
9228     case SHN_UNDEF:     return "UND";
9229     case SHN_ABS:       return "ABS";
9230     case SHN_COMMON:    return "COM";
9231     default:
9232       if (type == SHN_IA_64_ANSI_COMMON
9233           && elf_header.e_machine == EM_IA_64
9234           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9235         return "ANSI_COM";
9236       else if ((elf_header.e_machine == EM_X86_64
9237                 || elf_header.e_machine == EM_L1OM
9238                 || elf_header.e_machine == EM_K1OM)
9239                && type == SHN_X86_64_LCOMMON)
9240         return "LARGE_COM";
9241       else if ((type == SHN_MIPS_SCOMMON
9242                 && elf_header.e_machine == EM_MIPS)
9243                || (type == SHN_TIC6X_SCOMMON
9244                    && elf_header.e_machine == EM_TI_C6000))
9245         return "SCOM";
9246       else if (type == SHN_MIPS_SUNDEFINED
9247                && elf_header.e_machine == EM_MIPS)
9248         return "SUND";
9249       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
9250         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
9251       else if (type >= SHN_LOOS && type <= SHN_HIOS)
9252         sprintf (buff, "OS [0x%04x]", type & 0xffff);
9253       else if (type >= SHN_LORESERVE)
9254         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
9255       else if (type >= elf_header.e_shnum)
9256         sprintf (buff, "bad section index[%3d]", type);
9257       else
9258         sprintf (buff, "%3d", type);
9259       break;
9260     }
9261
9262   return buff;
9263 }
9264
9265 static bfd_vma *
9266 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
9267 {
9268   unsigned char * e_data;
9269   bfd_vma * i_data;
9270
9271   e_data = (unsigned char *) cmalloc (number, ent_size);
9272
9273   if (e_data == NULL)
9274     {
9275       error (_("Out of memory\n"));
9276       return NULL;
9277     }
9278
9279   if (fread (e_data, ent_size, number, file) != number)
9280     {
9281       error (_("Unable to read in dynamic data\n"));
9282       return NULL;
9283     }
9284
9285   i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
9286
9287   if (i_data == NULL)
9288     {
9289       error (_("Out of memory\n"));
9290       free (e_data);
9291       return NULL;
9292     }
9293
9294   while (number--)
9295     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
9296
9297   free (e_data);
9298
9299   return i_data;
9300 }
9301
9302 static void
9303 print_dynamic_symbol (bfd_vma si, unsigned long hn)
9304 {
9305   Elf_Internal_Sym * psym;
9306   int n;
9307
9308   psym = dynamic_symbols + si;
9309
9310   n = print_vma (si, DEC_5);
9311   if (n < 5)
9312     fputs ("     " + n, stdout);
9313   printf (" %3lu: ", hn);
9314   print_vma (psym->st_value, LONG_HEX);
9315   putchar (' ');
9316   print_vma (psym->st_size, DEC_5);
9317
9318   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9319   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9320   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9321   /* Check to see if any other bits in the st_other field are set.
9322      Note - displaying this information disrupts the layout of the
9323      table being generated, but for the moment this case is very
9324      rare.  */
9325   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9326     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9327   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9328   if (VALID_DYNAMIC_NAME (psym->st_name))
9329     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9330   else
9331     printf (_(" <corrupt: %14ld>"), psym->st_name);
9332   putchar ('\n');
9333 }
9334
9335 /* Dump the symbol table.  */
9336 static int
9337 process_symbol_table (FILE * file)
9338 {
9339   Elf_Internal_Shdr * section;
9340   bfd_vma nbuckets = 0;
9341   bfd_vma nchains = 0;
9342   bfd_vma * buckets = NULL;
9343   bfd_vma * chains = NULL;
9344   bfd_vma ngnubuckets = 0;
9345   bfd_vma * gnubuckets = NULL;
9346   bfd_vma * gnuchains = NULL;
9347   bfd_vma gnusymidx = 0;
9348
9349   if (!do_syms && !do_dyn_syms && !do_histogram)
9350     return 1;
9351
9352   if (dynamic_info[DT_HASH]
9353       && (do_histogram
9354           || (do_using_dynamic
9355               && !do_dyn_syms
9356               && dynamic_strings != NULL)))
9357     {
9358       unsigned char nb[8];
9359       unsigned char nc[8];
9360       int hash_ent_size = 4;
9361
9362       if ((elf_header.e_machine == EM_ALPHA
9363            || elf_header.e_machine == EM_S390
9364            || elf_header.e_machine == EM_S390_OLD)
9365           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9366         hash_ent_size = 8;
9367
9368       if (fseek (file,
9369                  (archive_file_offset
9370                   + offset_from_vma (file, dynamic_info[DT_HASH],
9371                                      sizeof nb + sizeof nc)),
9372                  SEEK_SET))
9373         {
9374           error (_("Unable to seek to start of dynamic information\n"));
9375           goto no_hash;
9376         }
9377
9378       if (fread (nb, hash_ent_size, 1, file) != 1)
9379         {
9380           error (_("Failed to read in number of buckets\n"));
9381           goto no_hash;
9382         }
9383
9384       if (fread (nc, hash_ent_size, 1, file) != 1)
9385         {
9386           error (_("Failed to read in number of chains\n"));
9387           goto no_hash;
9388         }
9389
9390       nbuckets = byte_get (nb, hash_ent_size);
9391       nchains  = byte_get (nc, hash_ent_size);
9392
9393       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9394       chains  = get_dynamic_data (file, nchains, hash_ent_size);
9395
9396     no_hash:
9397       if (buckets == NULL || chains == NULL)
9398         {
9399           if (do_using_dynamic)
9400             return 0;
9401           free (buckets);
9402           free (chains);
9403           buckets = NULL;
9404           chains = NULL;
9405           nbuckets = 0;
9406           nchains = 0;
9407         }
9408     }
9409
9410   if (dynamic_info_DT_GNU_HASH
9411       && (do_histogram
9412           || (do_using_dynamic
9413               && !do_dyn_syms
9414               && dynamic_strings != NULL)))
9415     {
9416       unsigned char nb[16];
9417       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9418       bfd_vma buckets_vma;
9419
9420       if (fseek (file,
9421                  (archive_file_offset
9422                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9423                                      sizeof nb)),
9424                  SEEK_SET))
9425         {
9426           error (_("Unable to seek to start of dynamic information\n"));
9427           goto no_gnu_hash;
9428         }
9429
9430       if (fread (nb, 16, 1, file) != 1)
9431         {
9432           error (_("Failed to read in number of buckets\n"));
9433           goto no_gnu_hash;
9434         }
9435
9436       ngnubuckets = byte_get (nb, 4);
9437       gnusymidx = byte_get (nb + 4, 4);
9438       bitmaskwords = byte_get (nb + 8, 4);
9439       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
9440       if (is_32bit_elf)
9441         buckets_vma += bitmaskwords * 4;
9442       else
9443         buckets_vma += bitmaskwords * 8;
9444
9445       if (fseek (file,
9446                  (archive_file_offset
9447                   + offset_from_vma (file, buckets_vma, 4)),
9448                  SEEK_SET))
9449         {
9450           error (_("Unable to seek to start of dynamic information\n"));
9451           goto no_gnu_hash;
9452         }
9453
9454       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
9455
9456       if (gnubuckets == NULL)
9457         goto no_gnu_hash;
9458
9459       for (i = 0; i < ngnubuckets; i++)
9460         if (gnubuckets[i] != 0)
9461           {
9462             if (gnubuckets[i] < gnusymidx)
9463               return 0;
9464
9465             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9466               maxchain = gnubuckets[i];
9467           }
9468
9469       if (maxchain == 0xffffffff)
9470         goto no_gnu_hash;
9471
9472       maxchain -= gnusymidx;
9473
9474       if (fseek (file,
9475                  (archive_file_offset
9476                   + offset_from_vma (file, buckets_vma
9477                                            + 4 * (ngnubuckets + maxchain), 4)),
9478                  SEEK_SET))
9479         {
9480           error (_("Unable to seek to start of dynamic information\n"));
9481           goto no_gnu_hash;
9482         }
9483
9484       do
9485         {
9486           if (fread (nb, 4, 1, file) != 1)
9487             {
9488               error (_("Failed to determine last chain length\n"));
9489               goto no_gnu_hash;
9490             }
9491
9492           if (maxchain + 1 == 0)
9493             goto no_gnu_hash;
9494
9495           ++maxchain;
9496         }
9497       while ((byte_get (nb, 4) & 1) == 0);
9498
9499       if (fseek (file,
9500                  (archive_file_offset
9501                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9502                  SEEK_SET))
9503         {
9504           error (_("Unable to seek to start of dynamic information\n"));
9505           goto no_gnu_hash;
9506         }
9507
9508       gnuchains = get_dynamic_data (file, maxchain, 4);
9509
9510     no_gnu_hash:
9511       if (gnuchains == NULL)
9512         {
9513           free (gnubuckets);
9514           gnubuckets = NULL;
9515           ngnubuckets = 0;
9516           if (do_using_dynamic)
9517             return 0;
9518         }
9519     }
9520
9521   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9522       && do_syms
9523       && do_using_dynamic
9524       && dynamic_strings != NULL)
9525     {
9526       unsigned long hn;
9527
9528       if (dynamic_info[DT_HASH])
9529         {
9530           bfd_vma si;
9531
9532           printf (_("\nSymbol table for image:\n"));
9533           if (is_32bit_elf)
9534             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9535           else
9536             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9537
9538           for (hn = 0; hn < nbuckets; hn++)
9539             {
9540               if (! buckets[hn])
9541                 continue;
9542
9543               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9544                 print_dynamic_symbol (si, hn);
9545             }
9546         }
9547
9548       if (dynamic_info_DT_GNU_HASH)
9549         {
9550           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9551           if (is_32bit_elf)
9552             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9553           else
9554             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9555
9556           for (hn = 0; hn < ngnubuckets; ++hn)
9557             if (gnubuckets[hn] != 0)
9558               {
9559                 bfd_vma si = gnubuckets[hn];
9560                 bfd_vma off = si - gnusymidx;
9561
9562                 do
9563                   {
9564                     print_dynamic_symbol (si, hn);
9565                     si++;
9566                   }
9567                 while ((gnuchains[off++] & 1) == 0);
9568               }
9569         }
9570     }
9571   else if (do_dyn_syms || (do_syms && !do_using_dynamic))
9572     {
9573       unsigned int i;
9574
9575       for (i = 0, section = section_headers;
9576            i < elf_header.e_shnum;
9577            i++, section++)
9578         {
9579           unsigned int si;
9580           char * strtab = NULL;
9581           unsigned long int strtab_size = 0;
9582           Elf_Internal_Sym * symtab;
9583           Elf_Internal_Sym * psym;
9584           unsigned long num_syms;
9585
9586           if ((section->sh_type != SHT_SYMTAB
9587                && section->sh_type != SHT_DYNSYM)
9588               || (!do_syms
9589                   && section->sh_type == SHT_SYMTAB))
9590             continue;
9591
9592           if (section->sh_entsize == 0)
9593             {
9594               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9595                       SECTION_NAME (section));
9596               continue;
9597             }
9598
9599           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9600                   SECTION_NAME (section),
9601                   (unsigned long) (section->sh_size / section->sh_entsize));
9602
9603           if (is_32bit_elf)
9604             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
9605           else
9606             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
9607
9608           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
9609           if (symtab == NULL)
9610             continue;
9611
9612           if (section->sh_link == elf_header.e_shstrndx)
9613             {
9614               strtab = string_table;
9615               strtab_size = string_table_length;
9616             }
9617           else if (section->sh_link < elf_header.e_shnum)
9618             {
9619               Elf_Internal_Shdr * string_sec;
9620
9621               string_sec = section_headers + section->sh_link;
9622
9623               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9624                                           1, string_sec->sh_size,
9625                                           _("string table"));
9626               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
9627             }
9628
9629           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
9630             {
9631               printf ("%6d: ", si);
9632               print_vma (psym->st_value, LONG_HEX);
9633               putchar (' ');
9634               print_vma (psym->st_size, DEC_5);
9635               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9636               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9637               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9638               /* Check to see if any other bits in the st_other field are set.
9639                  Note - displaying this information disrupts the layout of the
9640                  table being generated, but for the moment this case is very rare.  */
9641               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9642                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9643               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
9644               print_symbol (25, psym->st_name < strtab_size
9645                             ? strtab + psym->st_name : _("<corrupt>"));
9646
9647               if (section->sh_type == SHT_DYNSYM
9648                   && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9649                 {
9650                   unsigned char data[2];
9651                   unsigned short vers_data;
9652                   unsigned long offset;
9653                   int is_nobits;
9654                   int check_def;
9655
9656                   offset = offset_from_vma
9657                     (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9658                      sizeof data + si * sizeof (vers_data));
9659
9660                   if (get_data (&data, file, offset + si * sizeof (vers_data),
9661                                 sizeof (data), 1, _("version data")) == NULL)
9662                     break;
9663
9664                   vers_data = byte_get (data, 2);
9665
9666                   is_nobits = (psym->st_shndx < elf_header.e_shnum
9667                                && section_headers[psym->st_shndx].sh_type
9668                                   == SHT_NOBITS);
9669
9670                   check_def = (psym->st_shndx != SHN_UNDEF);
9671
9672                   if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
9673                     {
9674                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
9675                           && (is_nobits || ! check_def))
9676                         {
9677                           Elf_External_Verneed evn;
9678                           Elf_Internal_Verneed ivn;
9679                           Elf_Internal_Vernaux ivna;
9680
9681                           /* We must test both.  */
9682                           offset = offset_from_vma
9683                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9684                              sizeof evn);
9685
9686                           do
9687                             {
9688                               unsigned long vna_off;
9689
9690                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9691                                             _("version need")) == NULL)
9692                                 {
9693                                   ivna.vna_next = 0;
9694                                   ivna.vna_other = 0;
9695                                   ivna.vna_name = 0;
9696                                   break;
9697                                 }
9698
9699                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9700                               ivn.vn_next = BYTE_GET (evn.vn_next);
9701
9702                               vna_off = offset + ivn.vn_aux;
9703
9704                               do
9705                                 {
9706                                   Elf_External_Vernaux evna;
9707
9708                                   if (get_data (&evna, file, vna_off,
9709                                                 sizeof (evna), 1,
9710                                                 _("version need aux (3)")) == NULL)
9711                                     {
9712                                       ivna.vna_next = 0;
9713                                       ivna.vna_other = 0;
9714                                       ivna.vna_name = 0;
9715                                     }
9716                                   else
9717                                     {
9718                                       ivna.vna_other = BYTE_GET (evna.vna_other);
9719                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
9720                                       ivna.vna_name  = BYTE_GET (evna.vna_name);
9721                                     }
9722
9723                                   vna_off += ivna.vna_next;
9724                                 }
9725                               while (ivna.vna_other != vers_data
9726                                      && ivna.vna_next != 0);
9727
9728                               if (ivna.vna_other == vers_data)
9729                                 break;
9730
9731                               offset += ivn.vn_next;
9732                             }
9733                           while (ivn.vn_next != 0);
9734
9735                           if (ivna.vna_other == vers_data)
9736                             {
9737                               printf ("@%s (%d)",
9738                                       ivna.vna_name < strtab_size
9739                                       ? strtab + ivna.vna_name : _("<corrupt>"),
9740                                       ivna.vna_other);
9741                               check_def = 0;
9742                             }
9743                           else if (! is_nobits)
9744                             error (_("bad dynamic symbol\n"));
9745                           else
9746                             check_def = 1;
9747                         }
9748
9749                       if (check_def)
9750                         {
9751                           if (vers_data != 0x8001
9752                               && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9753                             {
9754                               Elf_Internal_Verdef ivd;
9755                               Elf_Internal_Verdaux ivda;
9756                               Elf_External_Verdaux evda;
9757                               unsigned long off;
9758
9759                               off = offset_from_vma
9760                                 (file,
9761                                  version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9762                                  sizeof (Elf_External_Verdef));
9763
9764                               do
9765                                 {
9766                                   Elf_External_Verdef evd;
9767
9768                                   if (get_data (&evd, file, off, sizeof (evd),
9769                                                 1, _("version def")) == NULL)
9770                                     {
9771                                       ivd.vd_ndx = 0;
9772                                       ivd.vd_aux = 0;
9773                                       ivd.vd_next = 0;
9774                                     }
9775                                   else
9776                                     {
9777                                       ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9778                                       ivd.vd_aux = BYTE_GET (evd.vd_aux);
9779                                       ivd.vd_next = BYTE_GET (evd.vd_next);
9780                                     }
9781
9782                                   off += ivd.vd_next;
9783                                 }
9784                               while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
9785                                      && ivd.vd_next != 0);
9786
9787                               off -= ivd.vd_next;
9788                               off += ivd.vd_aux;
9789
9790                               if (get_data (&evda, file, off, sizeof (evda),
9791                                             1, _("version def aux")) == NULL)
9792                                 break;
9793
9794                               ivda.vda_name = BYTE_GET (evda.vda_name);
9795
9796                               if (psym->st_name != ivda.vda_name)
9797                                 printf ((vers_data & VERSYM_HIDDEN)
9798                                         ? "@%s" : "@@%s",
9799                                         ivda.vda_name < strtab_size
9800                                         ? strtab + ivda.vda_name : _("<corrupt>"));
9801                             }
9802                         }
9803                     }
9804                 }
9805
9806               putchar ('\n');
9807             }
9808
9809           free (symtab);
9810           if (strtab != string_table)
9811             free (strtab);
9812         }
9813     }
9814   else if (do_syms)
9815     printf
9816       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9817
9818   if (do_histogram && buckets != NULL)
9819     {
9820       unsigned long * lengths;
9821       unsigned long * counts;
9822       unsigned long hn;
9823       bfd_vma si;
9824       unsigned long maxlength = 0;
9825       unsigned long nzero_counts = 0;
9826       unsigned long nsyms = 0;
9827
9828       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9829               (unsigned long) nbuckets);
9830       printf (_(" Length  Number     %% of total  Coverage\n"));
9831
9832       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
9833       if (lengths == NULL)
9834         {
9835           error (_("Out of memory\n"));
9836           return 0;
9837         }
9838       for (hn = 0; hn < nbuckets; ++hn)
9839         {
9840           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
9841             {
9842               ++nsyms;
9843               if (maxlength < ++lengths[hn])
9844                 ++maxlength;
9845             }
9846         }
9847
9848       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9849       if (counts == NULL)
9850         {
9851           error (_("Out of memory\n"));
9852           return 0;
9853         }
9854
9855       for (hn = 0; hn < nbuckets; ++hn)
9856         ++counts[lengths[hn]];
9857
9858       if (nbuckets > 0)
9859         {
9860           unsigned long i;
9861           printf ("      0  %-10lu (%5.1f%%)\n",
9862                   counts[0], (counts[0] * 100.0) / nbuckets);
9863           for (i = 1; i <= maxlength; ++i)
9864             {
9865               nzero_counts += counts[i] * i;
9866               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
9867                       i, counts[i], (counts[i] * 100.0) / nbuckets,
9868                       (nzero_counts * 100.0) / nsyms);
9869             }
9870         }
9871
9872       free (counts);
9873       free (lengths);
9874     }
9875
9876   if (buckets != NULL)
9877     {
9878       free (buckets);
9879       free (chains);
9880     }
9881
9882   if (do_histogram && gnubuckets != NULL)
9883     {
9884       unsigned long * lengths;
9885       unsigned long * counts;
9886       unsigned long hn;
9887       unsigned long maxlength = 0;
9888       unsigned long nzero_counts = 0;
9889       unsigned long nsyms = 0;
9890
9891       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
9892       if (lengths == NULL)
9893         {
9894           error (_("Out of memory\n"));
9895           return 0;
9896         }
9897
9898       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9899               (unsigned long) ngnubuckets);
9900       printf (_(" Length  Number     %% of total  Coverage\n"));
9901
9902       for (hn = 0; hn < ngnubuckets; ++hn)
9903         if (gnubuckets[hn] != 0)
9904           {
9905             bfd_vma off, length = 1;
9906
9907             for (off = gnubuckets[hn] - gnusymidx;
9908                  (gnuchains[off] & 1) == 0; ++off)
9909               ++length;
9910             lengths[hn] = length;
9911             if (length > maxlength)
9912               maxlength = length;
9913             nsyms += length;
9914           }
9915
9916       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9917       if (counts == NULL)
9918         {
9919           error (_("Out of memory\n"));
9920           return 0;
9921         }
9922
9923       for (hn = 0; hn < ngnubuckets; ++hn)
9924         ++counts[lengths[hn]];
9925
9926       if (ngnubuckets > 0)
9927         {
9928           unsigned long j;
9929           printf ("      0  %-10lu (%5.1f%%)\n",
9930                   counts[0], (counts[0] * 100.0) / ngnubuckets);
9931           for (j = 1; j <= maxlength; ++j)
9932             {
9933               nzero_counts += counts[j] * j;
9934               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
9935                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9936                       (nzero_counts * 100.0) / nsyms);
9937             }
9938         }
9939
9940       free (counts);
9941       free (lengths);
9942       free (gnubuckets);
9943       free (gnuchains);
9944     }
9945
9946   return 1;
9947 }
9948
9949 static int
9950 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
9951 {
9952   unsigned int i;
9953
9954   if (dynamic_syminfo == NULL
9955       || !do_dynamic)
9956     /* No syminfo, this is ok.  */
9957     return 1;
9958
9959   /* There better should be a dynamic symbol section.  */
9960   if (dynamic_symbols == NULL || dynamic_strings == NULL)
9961     return 0;
9962
9963   if (dynamic_addr)
9964     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9965             dynamic_syminfo_offset, dynamic_syminfo_nent);
9966
9967   printf (_(" Num: Name                           BoundTo     Flags\n"));
9968   for (i = 0; i < dynamic_syminfo_nent; ++i)
9969     {
9970       unsigned short int flags = dynamic_syminfo[i].si_flags;
9971
9972       printf ("%4d: ", i);
9973       if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9974         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9975       else
9976         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
9977       putchar (' ');
9978
9979       switch (dynamic_syminfo[i].si_boundto)
9980         {
9981         case SYMINFO_BT_SELF:
9982           fputs ("SELF       ", stdout);
9983           break;
9984         case SYMINFO_BT_PARENT:
9985           fputs ("PARENT     ", stdout);
9986           break;
9987         default:
9988           if (dynamic_syminfo[i].si_boundto > 0
9989               && dynamic_syminfo[i].si_boundto < dynamic_nent
9990               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
9991             {
9992               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
9993               putchar (' ' );
9994             }
9995           else
9996             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9997           break;
9998         }
9999
10000       if (flags & SYMINFO_FLG_DIRECT)
10001         printf (" DIRECT");
10002       if (flags & SYMINFO_FLG_PASSTHRU)
10003         printf (" PASSTHRU");
10004       if (flags & SYMINFO_FLG_COPY)
10005         printf (" COPY");
10006       if (flags & SYMINFO_FLG_LAZYLOAD)
10007         printf (" LAZYLOAD");
10008
10009       puts ("");
10010     }
10011
10012   return 1;
10013 }
10014
10015 /* Check to see if the given reloc needs to be handled in a target specific
10016    manner.  If so then process the reloc and return TRUE otherwise return
10017    FALSE.  */
10018
10019 static bfd_boolean
10020 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10021                                 unsigned char *     start,
10022                                 Elf_Internal_Sym *  symtab)
10023 {
10024   unsigned int reloc_type = get_reloc_type (reloc->r_info);
10025
10026   switch (elf_header.e_machine)
10027     {
10028     case EM_MSP430:
10029     case EM_MSP430_OLD:
10030       {
10031         static Elf_Internal_Sym * saved_sym = NULL;
10032
10033         switch (reloc_type)
10034           {
10035           case 10: /* R_MSP430_SYM_DIFF */
10036             if (uses_msp430x_relocs ())
10037               break;
10038           case 21: /* R_MSP430X_SYM_DIFF */
10039             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10040             return TRUE;
10041
10042           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10043           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10044             goto handle_sym_diff;
10045
10046           case 5: /* R_MSP430_16_BYTE */
10047           case 9: /* R_MSP430_8 */
10048             if (uses_msp430x_relocs ())
10049               break;
10050             goto handle_sym_diff;
10051
10052           case 2: /* R_MSP430_ABS16 */
10053           case 15: /* R_MSP430X_ABS16 */
10054             if (! uses_msp430x_relocs ())
10055               break;
10056             goto handle_sym_diff;
10057
10058           handle_sym_diff:
10059             if (saved_sym != NULL)
10060               {
10061                 bfd_vma value;
10062
10063                 value = reloc->r_addend
10064                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10065                      - saved_sym->st_value);
10066
10067                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10068
10069                 saved_sym = NULL;
10070                 return TRUE;
10071               }
10072             break;
10073
10074           default:
10075             if (saved_sym != NULL)
10076               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc"));
10077             break;
10078           }
10079         break;
10080       }
10081
10082     case EM_MN10300:
10083     case EM_CYGNUS_MN10300:
10084       {
10085         static Elf_Internal_Sym * saved_sym = NULL;
10086
10087         switch (reloc_type)
10088           {
10089           case 34: /* R_MN10300_ALIGN */
10090             return TRUE;
10091           case 33: /* R_MN10300_SYM_DIFF */
10092             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10093             return TRUE;
10094           case 1: /* R_MN10300_32 */
10095           case 2: /* R_MN10300_16 */
10096             if (saved_sym != NULL)
10097               {
10098                 bfd_vma value;
10099
10100                 value = reloc->r_addend
10101                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10102                      - saved_sym->st_value);
10103
10104                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10105
10106                 saved_sym = NULL;
10107                 return TRUE;
10108               }
10109             break;
10110           default:
10111             if (saved_sym != NULL)
10112               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10113             break;
10114           }
10115         break;
10116       }
10117     }
10118
10119   return FALSE;
10120 }
10121
10122 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10123    DWARF debug sections.  This is a target specific test.  Note - we do not
10124    go through the whole including-target-headers-multiple-times route, (as
10125    we have already done with <elf/h8.h>) because this would become very
10126    messy and even then this function would have to contain target specific
10127    information (the names of the relocs instead of their numeric values).
10128    FIXME: This is not the correct way to solve this problem.  The proper way
10129    is to have target specific reloc sizing and typing functions created by
10130    the reloc-macros.h header, in the same way that it already creates the
10131    reloc naming functions.  */
10132
10133 static bfd_boolean
10134 is_32bit_abs_reloc (unsigned int reloc_type)
10135 {
10136   switch (elf_header.e_machine)
10137     {
10138     case EM_386:
10139     case EM_486:
10140       return reloc_type == 1; /* R_386_32.  */
10141     case EM_68K:
10142       return reloc_type == 1; /* R_68K_32.  */
10143     case EM_860:
10144       return reloc_type == 1; /* R_860_32.  */
10145     case EM_960:
10146       return reloc_type == 2; /* R_960_32.  */
10147     case EM_AARCH64:
10148       return reloc_type == 258; /* R_AARCH64_ABS32 */
10149     case EM_ALPHA:
10150       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
10151     case EM_ARC:
10152       return reloc_type == 1; /* R_ARC_32.  */
10153     case EM_ARM:
10154       return reloc_type == 2; /* R_ARM_ABS32 */
10155     case EM_AVR_OLD:
10156     case EM_AVR:
10157       return reloc_type == 1;
10158     case EM_ADAPTEVA_EPIPHANY:
10159       return reloc_type == 3;
10160     case EM_BLACKFIN:
10161       return reloc_type == 0x12; /* R_byte4_data.  */
10162     case EM_CRIS:
10163       return reloc_type == 3; /* R_CRIS_32.  */
10164     case EM_CR16:
10165       return reloc_type == 3; /* R_CR16_NUM32.  */
10166     case EM_CRX:
10167       return reloc_type == 15; /* R_CRX_NUM32.  */
10168     case EM_CYGNUS_FRV:
10169       return reloc_type == 1;
10170     case EM_CYGNUS_D10V:
10171     case EM_D10V:
10172       return reloc_type == 6; /* R_D10V_32.  */
10173     case EM_CYGNUS_D30V:
10174     case EM_D30V:
10175       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
10176     case EM_DLX:
10177       return reloc_type == 3; /* R_DLX_RELOC_32.  */
10178     case EM_CYGNUS_FR30:
10179     case EM_FR30:
10180       return reloc_type == 3; /* R_FR30_32.  */
10181     case EM_H8S:
10182     case EM_H8_300:
10183     case EM_H8_300H:
10184       return reloc_type == 1; /* R_H8_DIR32.  */
10185     case EM_IA_64:
10186       return reloc_type == 0x65; /* R_IA64_SECREL32LSB.  */
10187     case EM_IP2K_OLD:
10188     case EM_IP2K:
10189       return reloc_type == 2; /* R_IP2K_32.  */
10190     case EM_IQ2000:
10191       return reloc_type == 2; /* R_IQ2000_32.  */
10192     case EM_LATTICEMICO32:
10193       return reloc_type == 3; /* R_LM32_32.  */
10194     case EM_M32C_OLD:
10195     case EM_M32C:
10196       return reloc_type == 3; /* R_M32C_32.  */
10197     case EM_M32R:
10198       return reloc_type == 34; /* R_M32R_32_RELA.  */
10199     case EM_MCORE:
10200       return reloc_type == 1; /* R_MCORE_ADDR32.  */
10201     case EM_CYGNUS_MEP:
10202       return reloc_type == 4; /* R_MEP_32.  */
10203     case EM_METAG:
10204       return reloc_type == 2; /* R_METAG_ADDR32.  */
10205     case EM_MICROBLAZE:
10206       return reloc_type == 1; /* R_MICROBLAZE_32.  */
10207     case EM_MIPS:
10208       return reloc_type == 2; /* R_MIPS_32.  */
10209     case EM_MMIX:
10210       return reloc_type == 4; /* R_MMIX_32.  */
10211     case EM_CYGNUS_MN10200:
10212     case EM_MN10200:
10213       return reloc_type == 1; /* R_MN10200_32.  */
10214     case EM_CYGNUS_MN10300:
10215     case EM_MN10300:
10216       return reloc_type == 1; /* R_MN10300_32.  */
10217     case EM_MOXIE:
10218       return reloc_type == 1; /* R_MOXIE_32.  */
10219     case EM_MSP430_OLD:
10220     case EM_MSP430:
10221       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
10222     case EM_MT:
10223       return reloc_type == 2; /* R_MT_32.  */
10224     case EM_ALTERA_NIOS2:
10225       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
10226     case EM_NIOS32:
10227       return reloc_type == 1; /* R_NIOS_32.  */
10228     case EM_OPENRISC:
10229     case EM_OR32:
10230       return reloc_type == 1; /* R_OR32_32.  */
10231     case EM_PARISC:
10232       return (reloc_type == 1 /* R_PARISC_DIR32.  */
10233               || reloc_type == 41); /* R_PARISC_SECREL32.  */
10234     case EM_PJ:
10235     case EM_PJ_OLD:
10236       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
10237     case EM_PPC64:
10238       return reloc_type == 1; /* R_PPC64_ADDR32.  */
10239     case EM_PPC:
10240       return reloc_type == 1; /* R_PPC_ADDR32.  */
10241     case EM_RL78:
10242       return reloc_type == 1; /* R_RL78_DIR32.  */
10243     case EM_RX:
10244       return reloc_type == 1; /* R_RX_DIR32.  */
10245     case EM_S370:
10246       return reloc_type == 1; /* R_I370_ADDR31.  */
10247     case EM_S390_OLD:
10248     case EM_S390:
10249       return reloc_type == 4; /* R_S390_32.  */
10250     case EM_SCORE:
10251       return reloc_type == 8; /* R_SCORE_ABS32.  */
10252     case EM_SH:
10253       return reloc_type == 1; /* R_SH_DIR32.  */
10254     case EM_SPARC32PLUS:
10255     case EM_SPARCV9:
10256     case EM_SPARC:
10257       return reloc_type == 3 /* R_SPARC_32.  */
10258         || reloc_type == 23; /* R_SPARC_UA32.  */
10259     case EM_SPU:
10260       return reloc_type == 6; /* R_SPU_ADDR32 */
10261     case EM_TI_C6000:
10262       return reloc_type == 1; /* R_C6000_ABS32.  */
10263     case EM_TILEGX:
10264       return reloc_type == 2; /* R_TILEGX_32.  */
10265     case EM_TILEPRO:
10266       return reloc_type == 1; /* R_TILEPRO_32.  */
10267     case EM_CYGNUS_V850:
10268     case EM_V850:
10269       return reloc_type == 6; /* R_V850_ABS32.  */
10270     case EM_V800:
10271       return reloc_type == 0x33; /* R_V810_WORD.  */
10272     case EM_VAX:
10273       return reloc_type == 1; /* R_VAX_32.  */
10274     case EM_X86_64:
10275     case EM_L1OM:
10276     case EM_K1OM:
10277       return reloc_type == 10; /* R_X86_64_32.  */
10278     case EM_XC16X:
10279     case EM_C166:
10280       return reloc_type == 3; /* R_XC16C_ABS_32.  */
10281     case EM_XGATE:
10282       return reloc_type == 4; /* R_XGATE_32.  */
10283     case EM_XSTORMY16:
10284       return reloc_type == 1; /* R_XSTROMY16_32.  */
10285     case EM_XTENSA_OLD:
10286     case EM_XTENSA:
10287       return reloc_type == 1; /* R_XTENSA_32.  */
10288     default:
10289       error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10290              elf_header.e_machine);
10291       abort ();
10292     }
10293 }
10294
10295 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10296    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
10297
10298 static bfd_boolean
10299 is_32bit_pcrel_reloc (unsigned int reloc_type)
10300 {
10301   switch (elf_header.e_machine)
10302     {
10303     case EM_386:
10304     case EM_486:
10305       return reloc_type == 2;  /* R_386_PC32.  */
10306     case EM_68K:
10307       return reloc_type == 4;  /* R_68K_PC32.  */
10308     case EM_AARCH64:
10309       return reloc_type == 261; /* R_AARCH64_PREL32 */
10310     case EM_ADAPTEVA_EPIPHANY:
10311       return reloc_type == 6;
10312     case EM_ALPHA:
10313       return reloc_type == 10; /* R_ALPHA_SREL32.  */
10314     case EM_ARM:
10315       return reloc_type == 3;  /* R_ARM_REL32 */
10316     case EM_MICROBLAZE:
10317       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
10318     case EM_PARISC:
10319       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
10320     case EM_PPC:
10321       return reloc_type == 26; /* R_PPC_REL32.  */
10322     case EM_PPC64:
10323       return reloc_type == 26; /* R_PPC64_REL32.  */
10324     case EM_S390_OLD:
10325     case EM_S390:
10326       return reloc_type == 5;  /* R_390_PC32.  */
10327     case EM_SH:
10328       return reloc_type == 2;  /* R_SH_REL32.  */
10329     case EM_SPARC32PLUS:
10330     case EM_SPARCV9:
10331     case EM_SPARC:
10332       return reloc_type == 6;  /* R_SPARC_DISP32.  */
10333     case EM_SPU:
10334       return reloc_type == 13; /* R_SPU_REL32.  */
10335     case EM_TILEGX:
10336       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
10337     case EM_TILEPRO:
10338       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
10339     case EM_X86_64:
10340     case EM_L1OM:
10341     case EM_K1OM:
10342       return reloc_type == 2;  /* R_X86_64_PC32.  */
10343     case EM_XTENSA_OLD:
10344     case EM_XTENSA:
10345       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
10346     default:
10347       /* Do not abort or issue an error message here.  Not all targets use
10348          pc-relative 32-bit relocs in their DWARF debug information and we
10349          have already tested for target coverage in is_32bit_abs_reloc.  A
10350          more helpful warning message will be generated by apply_relocations
10351          anyway, so just return.  */
10352       return FALSE;
10353     }
10354 }
10355
10356 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10357    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
10358
10359 static bfd_boolean
10360 is_64bit_abs_reloc (unsigned int reloc_type)
10361 {
10362   switch (elf_header.e_machine)
10363     {
10364     case EM_AARCH64:
10365       return reloc_type == 257; /* R_AARCH64_ABS64.  */
10366     case EM_ALPHA:
10367       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
10368     case EM_IA_64:
10369       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
10370     case EM_PARISC:
10371       return reloc_type == 80; /* R_PARISC_DIR64.  */
10372     case EM_PPC64:
10373       return reloc_type == 38; /* R_PPC64_ADDR64.  */
10374     case EM_SPARC32PLUS:
10375     case EM_SPARCV9:
10376     case EM_SPARC:
10377       return reloc_type == 54; /* R_SPARC_UA64.  */
10378     case EM_X86_64:
10379     case EM_L1OM:
10380     case EM_K1OM:
10381       return reloc_type == 1; /* R_X86_64_64.  */
10382     case EM_S390_OLD:
10383     case EM_S390:
10384       return reloc_type == 22;  /* R_S390_64.  */
10385     case EM_TILEGX:
10386       return reloc_type == 1; /* R_TILEGX_64.  */
10387     case EM_MIPS:
10388       return reloc_type == 18;  /* R_MIPS_64.  */
10389     default:
10390       return FALSE;
10391     }
10392 }
10393
10394 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10395    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
10396
10397 static bfd_boolean
10398 is_64bit_pcrel_reloc (unsigned int reloc_type)
10399 {
10400   switch (elf_header.e_machine)
10401     {
10402     case EM_AARCH64:
10403       return reloc_type == 260; /* R_AARCH64_PREL64.  */
10404     case EM_ALPHA:
10405       return reloc_type == 11; /* R_ALPHA_SREL64.  */
10406     case EM_IA_64:
10407       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
10408     case EM_PARISC:
10409       return reloc_type == 72; /* R_PARISC_PCREL64.  */
10410     case EM_PPC64:
10411       return reloc_type == 44; /* R_PPC64_REL64.  */
10412     case EM_SPARC32PLUS:
10413     case EM_SPARCV9:
10414     case EM_SPARC:
10415       return reloc_type == 46; /* R_SPARC_DISP64.  */
10416     case EM_X86_64:
10417     case EM_L1OM:
10418     case EM_K1OM:
10419       return reloc_type == 24; /* R_X86_64_PC64.  */
10420     case EM_S390_OLD:
10421     case EM_S390:
10422       return reloc_type == 23;  /* R_S390_PC64.  */
10423     case EM_TILEGX:
10424       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
10425     default:
10426       return FALSE;
10427     }
10428 }
10429
10430 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10431    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
10432
10433 static bfd_boolean
10434 is_24bit_abs_reloc (unsigned int reloc_type)
10435 {
10436   switch (elf_header.e_machine)
10437     {
10438     case EM_CYGNUS_MN10200:
10439     case EM_MN10200:
10440       return reloc_type == 4; /* R_MN10200_24.  */
10441     default:
10442       return FALSE;
10443     }
10444 }
10445
10446 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10447    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
10448
10449 static bfd_boolean
10450 is_16bit_abs_reloc (unsigned int reloc_type)
10451 {
10452   switch (elf_header.e_machine)
10453     {
10454     case EM_AVR_OLD:
10455     case EM_AVR:
10456       return reloc_type == 4; /* R_AVR_16.  */
10457     case EM_ADAPTEVA_EPIPHANY:
10458       return reloc_type == 5;
10459     case EM_CYGNUS_D10V:
10460     case EM_D10V:
10461       return reloc_type == 3; /* R_D10V_16.  */
10462     case EM_H8S:
10463     case EM_H8_300:
10464     case EM_H8_300H:
10465       return reloc_type == R_H8_DIR16;
10466     case EM_IP2K_OLD:
10467     case EM_IP2K:
10468       return reloc_type == 1; /* R_IP2K_16.  */
10469     case EM_M32C_OLD:
10470     case EM_M32C:
10471       return reloc_type == 1; /* R_M32C_16 */
10472     case EM_MSP430:
10473       if (uses_msp430x_relocs ())
10474         return reloc_type == 2; /* R_MSP430_ABS16.  */
10475     case EM_MSP430_OLD:
10476       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
10477     case EM_ALTERA_NIOS2:
10478       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
10479     case EM_NIOS32:
10480       return reloc_type == 9; /* R_NIOS_16.  */
10481     case EM_TI_C6000:
10482       return reloc_type == 2; /* R_C6000_ABS16.  */
10483     case EM_XC16X:
10484     case EM_C166:
10485       return reloc_type == 2; /* R_XC16C_ABS_16.  */
10486     case EM_CYGNUS_MN10200:
10487     case EM_MN10200:
10488       return reloc_type == 2; /* R_MN10200_16.  */
10489     case EM_CYGNUS_MN10300:
10490     case EM_MN10300:
10491       return reloc_type == 2; /* R_MN10300_16.  */
10492     case EM_XGATE:
10493       return reloc_type == 3; /* R_XGATE_16.  */
10494     default:
10495       return FALSE;
10496     }
10497 }
10498
10499 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10500    relocation entries (possibly formerly used for SHT_GROUP sections).  */
10501
10502 static bfd_boolean
10503 is_none_reloc (unsigned int reloc_type)
10504 {
10505   switch (elf_header.e_machine)
10506     {
10507     case EM_68K:     /* R_68K_NONE.  */
10508     case EM_386:     /* R_386_NONE.  */
10509     case EM_SPARC32PLUS:
10510     case EM_SPARCV9:
10511     case EM_SPARC:   /* R_SPARC_NONE.  */
10512     case EM_MIPS:    /* R_MIPS_NONE.  */
10513     case EM_PARISC:  /* R_PARISC_NONE.  */
10514     case EM_ALPHA:   /* R_ALPHA_NONE.  */
10515     case EM_ADAPTEVA_EPIPHANY:
10516     case EM_PPC:     /* R_PPC_NONE.  */
10517     case EM_PPC64:   /* R_PPC64_NONE.  */
10518     case EM_ARM:     /* R_ARM_NONE.  */
10519     case EM_IA_64:   /* R_IA64_NONE.  */
10520     case EM_SH:      /* R_SH_NONE.  */
10521     case EM_S390_OLD:
10522     case EM_S390:    /* R_390_NONE.  */
10523     case EM_CRIS:    /* R_CRIS_NONE.  */
10524     case EM_X86_64:  /* R_X86_64_NONE.  */
10525     case EM_L1OM:    /* R_X86_64_NONE.  */
10526     case EM_K1OM:    /* R_X86_64_NONE.  */
10527     case EM_MN10300: /* R_MN10300_NONE.  */
10528     case EM_MOXIE:   /* R_MOXIE_NONE.  */
10529     case EM_M32R:    /* R_M32R_NONE.  */
10530     case EM_TI_C6000:/* R_C6000_NONE.  */
10531     case EM_TILEGX:  /* R_TILEGX_NONE.  */
10532     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
10533     case EM_XC16X:
10534     case EM_C166:    /* R_XC16X_NONE.  */
10535     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
10536     case EM_NIOS32:  /* R_NIOS_NONE.  */
10537       return reloc_type == 0;
10538     case EM_AARCH64:
10539       return reloc_type == 0 || reloc_type == 256;
10540     case EM_XTENSA_OLD:
10541     case EM_XTENSA:
10542       return (reloc_type == 0      /* R_XTENSA_NONE.  */
10543               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
10544               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
10545               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
10546     case EM_METAG:
10547       return reloc_type == 3; /* R_METAG_NONE.  */
10548     }
10549   return FALSE;
10550 }
10551
10552 /* Apply relocations to a section.
10553    Note: So far support has been added only for those relocations
10554    which can be found in debug sections.
10555    FIXME: Add support for more relocations ?  */
10556
10557 static void
10558 apply_relocations (void * file,
10559                    Elf_Internal_Shdr * section,
10560                    unsigned char * start)
10561 {
10562   Elf_Internal_Shdr * relsec;
10563   unsigned char * end = start + section->sh_size;
10564
10565   if (elf_header.e_type != ET_REL)
10566     return;
10567
10568   /* Find the reloc section associated with the section.  */
10569   for (relsec = section_headers;
10570        relsec < section_headers + elf_header.e_shnum;
10571        ++relsec)
10572     {
10573       bfd_boolean is_rela;
10574       unsigned long num_relocs;
10575       Elf_Internal_Rela * relocs;
10576       Elf_Internal_Rela * rp;
10577       Elf_Internal_Shdr * symsec;
10578       Elf_Internal_Sym * symtab;
10579       unsigned long num_syms;
10580       Elf_Internal_Sym * sym;
10581
10582       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10583           || relsec->sh_info >= elf_header.e_shnum
10584           || section_headers + relsec->sh_info != section
10585           || relsec->sh_size == 0
10586           || relsec->sh_link >= elf_header.e_shnum)
10587         continue;
10588
10589       is_rela = relsec->sh_type == SHT_RELA;
10590
10591       if (is_rela)
10592         {
10593           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10594                                   relsec->sh_size, & relocs, & num_relocs))
10595             return;
10596         }
10597       else
10598         {
10599           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10600                                  relsec->sh_size, & relocs, & num_relocs))
10601             return;
10602         }
10603
10604       /* SH uses RELA but uses in place value instead of the addend field.  */
10605       if (elf_header.e_machine == EM_SH)
10606         is_rela = FALSE;
10607
10608       symsec = section_headers + relsec->sh_link;
10609       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
10610
10611       for (rp = relocs; rp < relocs + num_relocs; ++rp)
10612         {
10613           bfd_vma         addend;
10614           unsigned int    reloc_type;
10615           unsigned int    reloc_size;
10616           unsigned char * rloc;
10617           unsigned long   sym_index;
10618
10619           reloc_type = get_reloc_type (rp->r_info);
10620
10621           if (target_specific_reloc_handling (rp, start, symtab))
10622             continue;
10623           else if (is_none_reloc (reloc_type))
10624             continue;
10625           else if (is_32bit_abs_reloc (reloc_type)
10626                    || is_32bit_pcrel_reloc (reloc_type))
10627             reloc_size = 4;
10628           else if (is_64bit_abs_reloc (reloc_type)
10629                    || is_64bit_pcrel_reloc (reloc_type))
10630             reloc_size = 8;
10631           else if (is_24bit_abs_reloc (reloc_type))
10632             reloc_size = 3;
10633           else if (is_16bit_abs_reloc (reloc_type))
10634             reloc_size = 2;
10635           else
10636             {
10637               warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10638                     reloc_type, SECTION_NAME (section));
10639               continue;
10640             }
10641
10642           rloc = start + rp->r_offset;
10643           if ((rloc + reloc_size) > end || (rloc < start))
10644             {
10645               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10646                     (unsigned long) rp->r_offset,
10647                     SECTION_NAME (section));
10648               continue;
10649             }
10650
10651           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10652           if (sym_index >= num_syms)
10653             {
10654               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10655                     sym_index, SECTION_NAME (section));
10656               continue;
10657             }
10658           sym = symtab + sym_index;
10659
10660           /* If the reloc has a symbol associated with it,
10661              make sure that it is of an appropriate type.
10662
10663              Relocations against symbols without type can happen.
10664              Gcc -feliminate-dwarf2-dups may generate symbols
10665              without type for debug info.
10666
10667              Icc generates relocations against function symbols
10668              instead of local labels.
10669
10670              Relocations against object symbols can happen, eg when
10671              referencing a global array.  For an example of this see
10672              the _clz.o binary in libgcc.a.  */
10673           if (sym != symtab
10674               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
10675             {
10676               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10677                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
10678                     (long int)(rp - relocs),
10679                     SECTION_NAME (relsec));
10680               continue;
10681             }
10682
10683           addend = 0;
10684           if (is_rela)
10685             addend += rp->r_addend;
10686           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10687              partial_inplace.  */
10688           if (!is_rela
10689               || (elf_header.e_machine == EM_XTENSA
10690                   && reloc_type == 1)
10691               || ((elf_header.e_machine == EM_PJ
10692                    || elf_header.e_machine == EM_PJ_OLD)
10693                   && reloc_type == 1)
10694               || ((elf_header.e_machine == EM_D30V
10695                    || elf_header.e_machine == EM_CYGNUS_D30V)
10696                   && reloc_type == 12))
10697             addend += byte_get (rloc, reloc_size);
10698
10699           if (is_32bit_pcrel_reloc (reloc_type)
10700               || is_64bit_pcrel_reloc (reloc_type))
10701             {
10702               /* On HPPA, all pc-relative relocations are biased by 8.  */
10703               if (elf_header.e_machine == EM_PARISC)
10704                 addend -= 8;
10705               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
10706                         reloc_size);
10707             }
10708           else
10709             byte_put (rloc, addend + sym->st_value, reloc_size);
10710         }
10711
10712       free (symtab);
10713       free (relocs);
10714       break;
10715     }
10716 }
10717
10718 #ifdef SUPPORT_DISASSEMBLY
10719 static int
10720 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10721 {
10722   printf (_("\nAssembly dump of section %s\n"),
10723           SECTION_NAME (section));
10724
10725   /* XXX -- to be done --- XXX */
10726
10727   return 1;
10728 }
10729 #endif
10730
10731 /* Reads in the contents of SECTION from FILE, returning a pointer
10732    to a malloc'ed buffer or NULL if something went wrong.  */
10733
10734 static char *
10735 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10736 {
10737   bfd_size_type num_bytes;
10738
10739   num_bytes = section->sh_size;
10740
10741   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10742     {
10743       printf (_("\nSection '%s' has no data to dump.\n"),
10744               SECTION_NAME (section));
10745       return NULL;
10746     }
10747
10748   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10749                              _("section contents"));
10750 }
10751
10752
10753 static void
10754 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10755 {
10756   Elf_Internal_Shdr * relsec;
10757   bfd_size_type num_bytes;
10758   char * data;
10759   char * end;
10760   char * start;
10761   char * name = SECTION_NAME (section);
10762   bfd_boolean some_strings_shown;
10763
10764   start = get_section_contents (section, file);
10765   if (start == NULL)
10766     return;
10767
10768   printf (_("\nString dump of section '%s':\n"), name);
10769
10770   /* If the section being dumped has relocations against it the user might
10771      be expecting these relocations to have been applied.  Check for this
10772      case and issue a warning message in order to avoid confusion.
10773      FIXME: Maybe we ought to have an option that dumps a section with
10774      relocs applied ?  */
10775   for (relsec = section_headers;
10776        relsec < section_headers + elf_header.e_shnum;
10777        ++relsec)
10778     {
10779       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10780           || relsec->sh_info >= elf_header.e_shnum
10781           || section_headers + relsec->sh_info != section
10782           || relsec->sh_size == 0
10783           || relsec->sh_link >= elf_header.e_shnum)
10784         continue;
10785
10786       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10787       break;
10788     }
10789
10790   num_bytes = section->sh_size;
10791   data = start;
10792   end  = start + num_bytes;
10793   some_strings_shown = FALSE;
10794
10795   while (data < end)
10796     {
10797       while (!ISPRINT (* data))
10798         if (++ data >= end)
10799           break;
10800
10801       if (data < end)
10802         {
10803 #ifndef __MSVCRT__
10804           /* PR 11128: Use two separate invocations in order to work
10805              around bugs in the Solaris 8 implementation of printf.  */
10806           printf ("  [%6tx]  ", data - start);
10807           printf ("%s\n", data);
10808 #else
10809           printf ("  [%6Ix]  %s\n", (size_t) (data - start), data);
10810 #endif
10811           data += strlen (data);
10812           some_strings_shown = TRUE;
10813         }
10814     }
10815
10816   if (! some_strings_shown)
10817     printf (_("  No strings found in this section."));
10818
10819   free (start);
10820
10821   putchar ('\n');
10822 }
10823
10824 static void
10825 dump_section_as_bytes (Elf_Internal_Shdr * section,
10826                        FILE * file,
10827                        bfd_boolean relocate)
10828 {
10829   Elf_Internal_Shdr * relsec;
10830   bfd_size_type bytes;
10831   bfd_vma addr;
10832   unsigned char * data;
10833   unsigned char * start;
10834
10835   start = (unsigned char *) get_section_contents (section, file);
10836   if (start == NULL)
10837     return;
10838
10839   printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10840
10841   if (relocate)
10842     {
10843       apply_relocations (file, section, start);
10844     }
10845   else
10846     {
10847       /* If the section being dumped has relocations against it the user might
10848          be expecting these relocations to have been applied.  Check for this
10849          case and issue a warning message in order to avoid confusion.
10850          FIXME: Maybe we ought to have an option that dumps a section with
10851          relocs applied ?  */
10852       for (relsec = section_headers;
10853            relsec < section_headers + elf_header.e_shnum;
10854            ++relsec)
10855         {
10856           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10857               || relsec->sh_info >= elf_header.e_shnum
10858               || section_headers + relsec->sh_info != section
10859               || relsec->sh_size == 0
10860               || relsec->sh_link >= elf_header.e_shnum)
10861             continue;
10862
10863           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10864           break;
10865         }
10866     }
10867
10868   addr = section->sh_addr;
10869   bytes = section->sh_size;
10870   data = start;
10871
10872   while (bytes)
10873     {
10874       int j;
10875       int k;
10876       int lbytes;
10877
10878       lbytes = (bytes > 16 ? 16 : bytes);
10879
10880       printf ("  0x%8.8lx ", (unsigned long) addr);
10881
10882       for (j = 0; j < 16; j++)
10883         {
10884           if (j < lbytes)
10885             printf ("%2.2x", data[j]);
10886           else
10887             printf ("  ");
10888
10889           if ((j & 3) == 3)
10890             printf (" ");
10891         }
10892
10893       for (j = 0; j < lbytes; j++)
10894         {
10895           k = data[j];
10896           if (k >= ' ' && k < 0x7f)
10897             printf ("%c", k);
10898           else
10899             printf (".");
10900         }
10901
10902       putchar ('\n');
10903
10904       data  += lbytes;
10905       addr  += lbytes;
10906       bytes -= lbytes;
10907     }
10908
10909   free (start);
10910
10911   putchar ('\n');
10912 }
10913
10914 /* Uncompresses a section that was compressed using zlib, in place.  */
10915
10916 static int
10917 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10918                              dwarf_size_type *size ATTRIBUTE_UNUSED)
10919 {
10920 #ifndef HAVE_ZLIB_H
10921   return FALSE;
10922 #else
10923   dwarf_size_type compressed_size = *size;
10924   unsigned char * compressed_buffer = *buffer;
10925   dwarf_size_type uncompressed_size;
10926   unsigned char * uncompressed_buffer;
10927   z_stream strm;
10928   int rc;
10929   dwarf_size_type header_size = 12;
10930
10931   /* Read the zlib header.  In this case, it should be "ZLIB" followed
10932      by the uncompressed section size, 8 bytes in big-endian order.  */
10933   if (compressed_size < header_size
10934       || ! streq ((char *) compressed_buffer, "ZLIB"))
10935     return 0;
10936
10937   uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10938   uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10939   uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10940   uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10941   uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10942   uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10943   uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10944   uncompressed_size += compressed_buffer[11];
10945
10946   /* It is possible the section consists of several compressed
10947      buffers concatenated together, so we uncompress in a loop.  */
10948   strm.zalloc = NULL;
10949   strm.zfree = NULL;
10950   strm.opaque = NULL;
10951   strm.avail_in = compressed_size - header_size;
10952   strm.next_in = (Bytef *) compressed_buffer + header_size;
10953   strm.avail_out = uncompressed_size;
10954   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
10955
10956   rc = inflateInit (& strm);
10957   while (strm.avail_in > 0)
10958     {
10959       if (rc != Z_OK)
10960         goto fail;
10961       strm.next_out = ((Bytef *) uncompressed_buffer
10962                        + (uncompressed_size - strm.avail_out));
10963       rc = inflate (&strm, Z_FINISH);
10964       if (rc != Z_STREAM_END)
10965         goto fail;
10966       rc = inflateReset (& strm);
10967     }
10968   rc = inflateEnd (& strm);
10969   if (rc != Z_OK
10970       || strm.avail_out != 0)
10971     goto fail;
10972
10973   free (compressed_buffer);
10974   *buffer = uncompressed_buffer;
10975   *size = uncompressed_size;
10976   return 1;
10977
10978  fail:
10979   free (uncompressed_buffer);
10980   /* Indicate decompression failure.  */
10981   *buffer = NULL;
10982   return 0;
10983 #endif  /* HAVE_ZLIB_H */
10984 }
10985
10986 static int
10987 load_specific_debug_section (enum dwarf_section_display_enum debug,
10988                              Elf_Internal_Shdr * sec, void * file)
10989 {
10990   struct dwarf_section * section = &debug_displays [debug].section;
10991   char buf [64];
10992
10993   /* If it is already loaded, do nothing.  */
10994   if (section->start != NULL)
10995     return 1;
10996
10997   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10998   section->address = sec->sh_addr;
10999   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11000                                                sec->sh_offset, 1,
11001                                                sec->sh_size, buf);
11002   if (section->start == NULL)
11003     section->size = 0;
11004   else
11005     {
11006       section->size = sec->sh_size;
11007       if (uncompress_section_contents (&section->start, &section->size))
11008         sec->sh_size = section->size;
11009     }
11010
11011   if (section->start == NULL)
11012     return 0;
11013
11014   if (debug_displays [debug].relocate)
11015     apply_relocations ((FILE *) file, sec, section->start);
11016
11017   return 1;
11018 }
11019
11020 /* If this is not NULL, load_debug_section will only look for sections
11021    within the list of sections given here.  */
11022 unsigned int *section_subset = NULL;
11023
11024 int
11025 load_debug_section (enum dwarf_section_display_enum debug, void * file)
11026 {
11027   struct dwarf_section * section = &debug_displays [debug].section;
11028   Elf_Internal_Shdr * sec;
11029
11030   /* Locate the debug section.  */
11031   sec = find_section_in_set (section->uncompressed_name, section_subset);
11032   if (sec != NULL)
11033     section->name = section->uncompressed_name;
11034   else
11035     {
11036       sec = find_section_in_set (section->compressed_name, section_subset);
11037       if (sec != NULL)
11038         section->name = section->compressed_name;
11039     }
11040   if (sec == NULL)
11041     return 0;
11042
11043   /* If we're loading from a subset of sections, and we've loaded
11044      a section matching this name before, it's likely that it's a
11045      different one.  */
11046   if (section_subset != NULL)
11047     free_debug_section (debug);
11048
11049   return load_specific_debug_section (debug, sec, (FILE *) file);
11050 }
11051
11052 void
11053 free_debug_section (enum dwarf_section_display_enum debug)
11054 {
11055   struct dwarf_section * section = &debug_displays [debug].section;
11056
11057   if (section->start == NULL)
11058     return;
11059
11060   free ((char *) section->start);
11061   section->start = NULL;
11062   section->address = 0;
11063   section->size = 0;
11064 }
11065
11066 static int
11067 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
11068 {
11069   char * name = SECTION_NAME (section);
11070   bfd_size_type length;
11071   int result = 1;
11072   int i;
11073
11074   length = section->sh_size;
11075   if (length == 0)
11076     {
11077       printf (_("\nSection '%s' has no debugging data.\n"), name);
11078       return 0;
11079     }
11080   if (section->sh_type == SHT_NOBITS)
11081     {
11082       /* There is no point in dumping the contents of a debugging section
11083          which has the NOBITS type - the bits in the file will be random.
11084          This can happen when a file containing a .eh_frame section is
11085          stripped with the --only-keep-debug command line option.  */
11086       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
11087       return 0;
11088     }
11089
11090   if (const_strneq (name, ".gnu.linkonce.wi."))
11091     name = ".debug_info";
11092
11093   /* See if we know how to display the contents of this section.  */
11094   for (i = 0; i < max; i++)
11095     if (streq (debug_displays[i].section.uncompressed_name, name)
11096         || (i == line && const_strneq (name, ".debug_line."))
11097         || streq (debug_displays[i].section.compressed_name, name))
11098       {
11099         struct dwarf_section * sec = &debug_displays [i].section;
11100         int secondary = (section != find_section (name));
11101
11102         if (secondary)
11103           free_debug_section ((enum dwarf_section_display_enum) i);
11104
11105         if (i == line && const_strneq (name, ".debug_line."))
11106           sec->name = name;
11107         else if (streq (sec->uncompressed_name, name))
11108           sec->name = sec->uncompressed_name;
11109         else
11110           sec->name = sec->compressed_name;
11111         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
11112                                          section, file))
11113           {
11114             /* If this debug section is part of a CU/TU set in a .dwp file,
11115                restrict load_debug_section to the sections in that set.  */
11116             section_subset = find_cu_tu_set (file, shndx);
11117
11118             result &= debug_displays[i].display (sec, file);
11119
11120             section_subset = NULL;
11121
11122             if (secondary || (i != info && i != abbrev))
11123               free_debug_section ((enum dwarf_section_display_enum) i);
11124           }
11125
11126         break;
11127       }
11128
11129   if (i == max)
11130     {
11131       printf (_("Unrecognized debug section: %s\n"), name);
11132       result = 0;
11133     }
11134
11135   return result;
11136 }
11137
11138 /* Set DUMP_SECTS for all sections where dumps were requested
11139    based on section name.  */
11140
11141 static void
11142 initialise_dumps_byname (void)
11143 {
11144   struct dump_list_entry * cur;
11145
11146   for (cur = dump_sects_byname; cur; cur = cur->next)
11147     {
11148       unsigned int i;
11149       int any;
11150
11151       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11152         if (streq (SECTION_NAME (section_headers + i), cur->name))
11153           {
11154             request_dump_bynumber (i, cur->type);
11155             any = 1;
11156           }
11157
11158       if (!any)
11159         warn (_("Section '%s' was not dumped because it does not exist!\n"),
11160               cur->name);
11161     }
11162 }
11163
11164 static void
11165 process_section_contents (FILE * file)
11166 {
11167   Elf_Internal_Shdr * section;
11168   unsigned int i;
11169
11170   if (! do_dump)
11171     return;
11172
11173   initialise_dumps_byname ();
11174
11175   for (i = 0, section = section_headers;
11176        i < elf_header.e_shnum && i < num_dump_sects;
11177        i++, section++)
11178     {
11179 #ifdef SUPPORT_DISASSEMBLY
11180       if (dump_sects[i] & DISASS_DUMP)
11181         disassemble_section (section, file);
11182 #endif
11183       if (dump_sects[i] & HEX_DUMP)
11184         dump_section_as_bytes (section, file, FALSE);
11185
11186       if (dump_sects[i] & RELOC_DUMP)
11187         dump_section_as_bytes (section, file, TRUE);
11188
11189       if (dump_sects[i] & STRING_DUMP)
11190         dump_section_as_strings (section, file);
11191
11192       if (dump_sects[i] & DEBUG_DUMP)
11193         display_debug_section (i, section, file);
11194     }
11195
11196   /* Check to see if the user requested a
11197      dump of a section that does not exist.  */
11198   while (i++ < num_dump_sects)
11199     if (dump_sects[i])
11200       warn (_("Section %d was not dumped because it does not exist!\n"), i);
11201 }
11202
11203 static void
11204 process_mips_fpe_exception (int mask)
11205 {
11206   if (mask)
11207     {
11208       int first = 1;
11209       if (mask & OEX_FPU_INEX)
11210         fputs ("INEX", stdout), first = 0;
11211       if (mask & OEX_FPU_UFLO)
11212         printf ("%sUFLO", first ? "" : "|"), first = 0;
11213       if (mask & OEX_FPU_OFLO)
11214         printf ("%sOFLO", first ? "" : "|"), first = 0;
11215       if (mask & OEX_FPU_DIV0)
11216         printf ("%sDIV0", first ? "" : "|"), first = 0;
11217       if (mask & OEX_FPU_INVAL)
11218         printf ("%sINVAL", first ? "" : "|");
11219     }
11220   else
11221     fputs ("0", stdout);
11222 }
11223
11224 /* Display's the value of TAG at location P.  If TAG is
11225    greater than 0 it is assumed to be an unknown tag, and
11226    a message is printed to this effect.  Otherwise it is
11227    assumed that a message has already been printed.
11228
11229    If the bottom bit of TAG is set it assumed to have a
11230    string value, otherwise it is assumed to have an integer
11231    value.
11232
11233    Returns an updated P pointing to the first unread byte
11234    beyond the end of TAG's value.
11235
11236    Reads at or beyond END will not be made.  */
11237
11238 static unsigned char *
11239 display_tag_value (int tag,
11240                    unsigned char * p,
11241                    const unsigned char * const end)
11242 {
11243   unsigned long val;
11244
11245   if (tag > 0)
11246     printf ("  Tag_unknown_%d: ", tag);
11247
11248   if (p >= end)
11249     {
11250       warn (_("corrupt tag\n"));
11251     }
11252   else if (tag & 1)
11253     {
11254       /* FIXME: we could read beyond END here.  */
11255       printf ("\"%s\"\n", p);
11256       p += strlen ((char *) p) + 1;
11257     }
11258   else
11259     {
11260       unsigned int len;
11261
11262       val = read_uleb128 (p, &len, end);
11263       p += len;
11264       printf ("%ld (0x%lx)\n", val, val);
11265     }
11266
11267   return p;
11268 }
11269
11270 /* ARM EABI attributes section.  */
11271 typedef struct
11272 {
11273   int tag;
11274   const char * name;
11275   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
11276   int type;
11277   const char ** table;
11278 } arm_attr_public_tag;
11279
11280 static const char * arm_attr_tag_CPU_arch[] =
11281   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11282    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11283 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11284 static const char * arm_attr_tag_THUMB_ISA_use[] =
11285   {"No", "Thumb-1", "Thumb-2"};
11286 static const char * arm_attr_tag_FP_arch[] =
11287   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11288    "FP for ARMv8"};
11289 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
11290 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
11291   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11292 static const char * arm_attr_tag_PCS_config[] =
11293   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11294    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11295 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11296   {"V6", "SB", "TLS", "Unused"};
11297 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11298   {"Absolute", "PC-relative", "SB-relative", "None"};
11299 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11300   {"Absolute", "PC-relative", "None"};
11301 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11302   {"None", "direct", "GOT-indirect"};
11303 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11304   {"None", "??? 1", "2", "??? 3", "4"};
11305 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11306 static const char * arm_attr_tag_ABI_FP_denormal[] =
11307   {"Unused", "Needed", "Sign only"};
11308 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11309 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11310 static const char * arm_attr_tag_ABI_FP_number_model[] =
11311   {"Unused", "Finite", "RTABI", "IEEE 754"};
11312 static const char * arm_attr_tag_ABI_enum_size[] =
11313   {"Unused", "small", "int", "forced to int"};
11314 static const char * arm_attr_tag_ABI_HardFP_use[] =
11315   {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11316 static const char * arm_attr_tag_ABI_VFP_args[] =
11317   {"AAPCS", "VFP registers", "custom"};
11318 static const char * arm_attr_tag_ABI_WMMX_args[] =
11319   {"AAPCS", "WMMX registers", "custom"};
11320 static const char * arm_attr_tag_ABI_optimization_goals[] =
11321   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11322     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11323 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11324   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11325     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11326 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
11327 static const char * arm_attr_tag_FP_HP_extension[] =
11328   {"Not Allowed", "Allowed"};
11329 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
11330   {"None", "IEEE 754", "Alternative Format"};
11331 static const char * arm_attr_tag_MPextension_use[] =
11332   {"Not Allowed", "Allowed"};
11333 static const char * arm_attr_tag_DIV_use[] =
11334   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11335     "Allowed in v7-A with integer division extension"};
11336 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11337 static const char * arm_attr_tag_Virtualization_use[] =
11338   {"Not Allowed", "TrustZone", "Virtualization Extensions",
11339     "TrustZone and Virtualization Extensions"};
11340 static const char * arm_attr_tag_MPextension_use_legacy[] =
11341   {"Not Allowed", "Allowed"};
11342
11343 #define LOOKUP(id, name) \
11344   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11345 static arm_attr_public_tag arm_attr_public_tags[] =
11346 {
11347   {4, "CPU_raw_name", 1, NULL},
11348   {5, "CPU_name", 1, NULL},
11349   LOOKUP(6, CPU_arch),
11350   {7, "CPU_arch_profile", 0, NULL},
11351   LOOKUP(8, ARM_ISA_use),
11352   LOOKUP(9, THUMB_ISA_use),
11353   LOOKUP(10, FP_arch),
11354   LOOKUP(11, WMMX_arch),
11355   LOOKUP(12, Advanced_SIMD_arch),
11356   LOOKUP(13, PCS_config),
11357   LOOKUP(14, ABI_PCS_R9_use),
11358   LOOKUP(15, ABI_PCS_RW_data),
11359   LOOKUP(16, ABI_PCS_RO_data),
11360   LOOKUP(17, ABI_PCS_GOT_use),
11361   LOOKUP(18, ABI_PCS_wchar_t),
11362   LOOKUP(19, ABI_FP_rounding),
11363   LOOKUP(20, ABI_FP_denormal),
11364   LOOKUP(21, ABI_FP_exceptions),
11365   LOOKUP(22, ABI_FP_user_exceptions),
11366   LOOKUP(23, ABI_FP_number_model),
11367   {24, "ABI_align_needed", 0, NULL},
11368   {25, "ABI_align_preserved", 0, NULL},
11369   LOOKUP(26, ABI_enum_size),
11370   LOOKUP(27, ABI_HardFP_use),
11371   LOOKUP(28, ABI_VFP_args),
11372   LOOKUP(29, ABI_WMMX_args),
11373   LOOKUP(30, ABI_optimization_goals),
11374   LOOKUP(31, ABI_FP_optimization_goals),
11375   {32, "compatibility", 0, NULL},
11376   LOOKUP(34, CPU_unaligned_access),
11377   LOOKUP(36, FP_HP_extension),
11378   LOOKUP(38, ABI_FP_16bit_format),
11379   LOOKUP(42, MPextension_use),
11380   LOOKUP(44, DIV_use),
11381   {64, "nodefaults", 0, NULL},
11382   {65, "also_compatible_with", 0, NULL},
11383   LOOKUP(66, T2EE_use),
11384   {67, "conformance", 1, NULL},
11385   LOOKUP(68, Virtualization_use),
11386   LOOKUP(70, MPextension_use_legacy)
11387 };
11388 #undef LOOKUP
11389
11390 static unsigned char *
11391 display_arm_attribute (unsigned char * p,
11392                        const unsigned char * const end)
11393 {
11394   int tag;
11395   unsigned int len;
11396   int val;
11397   arm_attr_public_tag * attr;
11398   unsigned i;
11399   int type;
11400
11401   tag = read_uleb128 (p, &len, end);
11402   p += len;
11403   attr = NULL;
11404   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11405     {
11406       if (arm_attr_public_tags[i].tag == tag)
11407         {
11408           attr = &arm_attr_public_tags[i];
11409           break;
11410         }
11411     }
11412
11413   if (attr)
11414     {
11415       printf ("  Tag_%s: ", attr->name);
11416       switch (attr->type)
11417         {
11418         case 0:
11419           switch (tag)
11420             {
11421             case 7: /* Tag_CPU_arch_profile.  */
11422               val = read_uleb128 (p, &len, end);
11423               p += len;
11424               switch (val)
11425                 {
11426                 case 0: printf (_("None\n")); break;
11427                 case 'A': printf (_("Application\n")); break;
11428                 case 'R': printf (_("Realtime\n")); break;
11429                 case 'M': printf (_("Microcontroller\n")); break;
11430                 case 'S': printf (_("Application or Realtime\n")); break;
11431                 default: printf ("??? (%d)\n", val); break;
11432                 }
11433               break;
11434
11435             case 24: /* Tag_align_needed.  */
11436               val = read_uleb128 (p, &len, end);
11437               p += len;
11438               switch (val)
11439                 {
11440                 case 0: printf (_("None\n")); break;
11441                 case 1: printf (_("8-byte\n")); break;
11442                 case 2: printf (_("4-byte\n")); break;
11443                 case 3: printf ("??? 3\n"); break;
11444                 default:
11445                   if (val <= 12)
11446                     printf (_("8-byte and up to %d-byte extended\n"),
11447                             1 << val);
11448                   else
11449                     printf ("??? (%d)\n", val);
11450                   break;
11451                 }
11452               break;
11453
11454             case 25: /* Tag_align_preserved.  */
11455               val = read_uleb128 (p, &len, end);
11456               p += len;
11457               switch (val)
11458                 {
11459                 case 0: printf (_("None\n")); break;
11460                 case 1: printf (_("8-byte, except leaf SP\n")); break;
11461                 case 2: printf (_("8-byte\n")); break;
11462                 case 3: printf ("??? 3\n"); break;
11463                 default:
11464                   if (val <= 12)
11465                     printf (_("8-byte and up to %d-byte extended\n"),
11466                             1 << val);
11467                   else
11468                     printf ("??? (%d)\n", val);
11469                   break;
11470                 }
11471               break;
11472
11473             case 32: /* Tag_compatibility.  */
11474               val = read_uleb128 (p, &len, end);
11475               p += len;
11476               printf (_("flag = %d, vendor = %s\n"), val, p);
11477               p += strlen ((char *) p) + 1;
11478               break;
11479
11480             case 64: /* Tag_nodefaults.  */
11481               p++;
11482               printf (_("True\n"));
11483               break;
11484
11485             case 65: /* Tag_also_compatible_with.  */
11486               val = read_uleb128 (p, &len, end);
11487               p += len;
11488               if (val == 6 /* Tag_CPU_arch.  */)
11489                 {
11490                   val = read_uleb128 (p, &len, end);
11491                   p += len;
11492                   if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
11493                     printf ("??? (%d)\n", val);
11494                   else
11495                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11496                 }
11497               else
11498                 printf ("???\n");
11499               while (*(p++) != '\0' /* NUL terminator.  */);
11500               break;
11501
11502             default:
11503               abort ();
11504             }
11505           return p;
11506
11507         case 1:
11508           return display_tag_value (-1, p, end);
11509         case 2:
11510           return display_tag_value (0, p, end);
11511
11512         default:
11513           assert (attr->type & 0x80);
11514           val = read_uleb128 (p, &len, end);
11515           p += len;
11516           type = attr->type & 0x7f;
11517           if (val >= type)
11518             printf ("??? (%d)\n", val);
11519           else
11520             printf ("%s\n", attr->table[val]);
11521           return p;
11522         }
11523     }
11524
11525   return display_tag_value (tag, p, end);
11526 }
11527
11528 static unsigned char *
11529 display_gnu_attribute (unsigned char * p,
11530                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
11531                        const unsigned char * const end)
11532 {
11533   int tag;
11534   unsigned int len;
11535   int val;
11536
11537   tag = read_uleb128 (p, &len, end);
11538   p += len;
11539
11540   /* Tag_compatibility is the only generic GNU attribute defined at
11541      present.  */
11542   if (tag == 32)
11543     {
11544       val = read_uleb128 (p, &len, end);
11545       p += len;
11546       if (p == end)
11547         {
11548           printf (_("flag = %d, vendor = <corrupt>\n"), val);
11549           warn (_("corrupt vendor attribute\n"));
11550         }
11551       else
11552         {
11553           printf (_("flag = %d, vendor = %s\n"), val, p);
11554           p += strlen ((char *) p) + 1;
11555         }
11556       return p;
11557     }
11558
11559   if ((tag & 2) == 0 && display_proc_gnu_attribute)
11560     return display_proc_gnu_attribute (p, tag, end);
11561
11562   return display_tag_value (tag, p, end);
11563 }
11564
11565 static unsigned char *
11566 display_power_gnu_attribute (unsigned char * p,
11567                              int tag,
11568                              const unsigned char * const end)
11569 {
11570   unsigned int len;
11571   int val;
11572
11573   if (tag == Tag_GNU_Power_ABI_FP)
11574     {
11575       val = read_uleb128 (p, &len, end);
11576       p += len;
11577       printf ("  Tag_GNU_Power_ABI_FP: ");
11578
11579       switch (val)
11580         {
11581         case 0:
11582           printf (_("Hard or soft float\n"));
11583           break;
11584         case 1:
11585           printf (_("Hard float\n"));
11586           break;
11587         case 2:
11588           printf (_("Soft float\n"));
11589           break;
11590         case 3:
11591           printf (_("Single-precision hard float\n"));
11592           break;
11593         default:
11594           printf ("??? (%d)\n", val);
11595           break;
11596         }
11597       return p;
11598    }
11599
11600   if (tag == Tag_GNU_Power_ABI_Vector)
11601     {
11602       val = read_uleb128 (p, &len, end);
11603       p += len;
11604       printf ("  Tag_GNU_Power_ABI_Vector: ");
11605       switch (val)
11606         {
11607         case 0:
11608           printf (_("Any\n"));
11609           break;
11610         case 1:
11611           printf (_("Generic\n"));
11612           break;
11613         case 2:
11614           printf ("AltiVec\n");
11615           break;
11616         case 3:
11617           printf ("SPE\n");
11618           break;
11619         default:
11620           printf ("??? (%d)\n", val);
11621           break;
11622         }
11623       return p;
11624    }
11625
11626   if (tag == Tag_GNU_Power_ABI_Struct_Return)
11627     {
11628       if (p == end)
11629         {
11630           warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
11631           return p;
11632         }
11633
11634       val = read_uleb128 (p, &len, end);
11635       p += len;
11636       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
11637       switch (val)
11638        {
11639        case 0:
11640          printf (_("Any\n"));
11641          break;
11642        case 1:
11643          printf ("r3/r4\n");
11644          break;
11645        case 2:
11646          printf (_("Memory\n"));
11647          break;
11648        default:
11649          printf ("??? (%d)\n", val);
11650          break;
11651        }
11652       return p;
11653     }
11654
11655   return display_tag_value (tag & 1, p, end);
11656 }
11657
11658 static void
11659 display_sparc_hwcaps (int mask)
11660 {
11661   if (mask)
11662     {
11663       int first = 1;
11664       if (mask & ELF_SPARC_HWCAP_MUL32)
11665         fputs ("mul32", stdout), first = 0;
11666       if (mask & ELF_SPARC_HWCAP_DIV32)
11667         printf ("%sdiv32", first ? "" : "|"), first = 0;
11668       if (mask & ELF_SPARC_HWCAP_FSMULD)
11669         printf ("%sfsmuld", first ? "" : "|"), first = 0;
11670       if (mask & ELF_SPARC_HWCAP_V8PLUS)
11671         printf ("%sv8plus", first ? "" : "|"), first = 0;
11672       if (mask & ELF_SPARC_HWCAP_POPC)
11673         printf ("%spopc", first ? "" : "|"), first = 0;
11674       if (mask & ELF_SPARC_HWCAP_VIS)
11675         printf ("%svis", first ? "" : "|"), first = 0;
11676       if (mask & ELF_SPARC_HWCAP_VIS2)
11677         printf ("%svis2", first ? "" : "|"), first = 0;
11678       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11679         printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11680       if (mask & ELF_SPARC_HWCAP_FMAF)
11681         printf ("%sfmaf", first ? "" : "|"), first = 0;
11682       if (mask & ELF_SPARC_HWCAP_VIS3)
11683         printf ("%svis3", first ? "" : "|"), first = 0;
11684       if (mask & ELF_SPARC_HWCAP_HPC)
11685         printf ("%shpc", first ? "" : "|"), first = 0;
11686       if (mask & ELF_SPARC_HWCAP_RANDOM)
11687         printf ("%srandom", first ? "" : "|"), first = 0;
11688       if (mask & ELF_SPARC_HWCAP_TRANS)
11689         printf ("%strans", first ? "" : "|"), first = 0;
11690       if (mask & ELF_SPARC_HWCAP_FJFMAU)
11691         printf ("%sfjfmau", first ? "" : "|"), first = 0;
11692       if (mask & ELF_SPARC_HWCAP_IMA)
11693         printf ("%sima", first ? "" : "|"), first = 0;
11694       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11695         printf ("%scspare", first ? "" : "|"), first = 0;
11696     }
11697   else
11698     fputc('0', stdout);
11699   fputc('\n', stdout);
11700 }
11701
11702 static unsigned char *
11703 display_sparc_gnu_attribute (unsigned char * p,
11704                              int tag,
11705                              const unsigned char * const end)
11706 {
11707   if (tag == Tag_GNU_Sparc_HWCAPS)
11708     {
11709       unsigned int len;
11710       int val;
11711
11712       val = read_uleb128 (p, &len, end);
11713       p += len;
11714       printf ("  Tag_GNU_Sparc_HWCAPS: ");
11715       display_sparc_hwcaps (val);
11716       return p;
11717    }
11718
11719   return display_tag_value (tag, p, end);
11720 }
11721
11722 static unsigned char *
11723 display_mips_gnu_attribute (unsigned char * p,
11724                             int tag,
11725                             const unsigned char * const end)
11726 {
11727   if (tag == Tag_GNU_MIPS_ABI_FP)
11728     {
11729       unsigned int len;
11730       int val;
11731
11732       val = read_uleb128 (p, &len, end);
11733       p += len;
11734       printf ("  Tag_GNU_MIPS_ABI_FP: ");
11735
11736       switch (val)
11737         {
11738         case 0:
11739           printf (_("Hard or soft float\n"));
11740           break;
11741         case 1:
11742           printf (_("Hard float (double precision)\n"));
11743           break;
11744         case 2:
11745           printf (_("Hard float (single precision)\n"));
11746           break;
11747         case 3:
11748           printf (_("Soft float\n"));
11749           break;
11750         case 4:
11751           printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
11752           break;
11753         default:
11754           printf ("??? (%d)\n", val);
11755           break;
11756         }
11757       return p;
11758    }
11759
11760   return display_tag_value (tag & 1, p, end);
11761 }
11762
11763 static unsigned char *
11764 display_tic6x_attribute (unsigned char * p,
11765                          const unsigned char * const end)
11766 {
11767   int tag;
11768   unsigned int len;
11769   int val;
11770
11771   tag = read_uleb128 (p, &len, end);
11772   p += len;
11773
11774   switch (tag)
11775     {
11776     case Tag_ISA:
11777       val = read_uleb128 (p, &len, end);
11778       p += len;
11779       printf ("  Tag_ISA: ");
11780
11781       switch (val)
11782         {
11783         case C6XABI_Tag_ISA_none:
11784           printf (_("None\n"));
11785           break;
11786         case C6XABI_Tag_ISA_C62X:
11787           printf ("C62x\n");
11788           break;
11789         case C6XABI_Tag_ISA_C67X:
11790           printf ("C67x\n");
11791           break;
11792         case C6XABI_Tag_ISA_C67XP:
11793           printf ("C67x+\n");
11794           break;
11795         case C6XABI_Tag_ISA_C64X:
11796           printf ("C64x\n");
11797           break;
11798         case C6XABI_Tag_ISA_C64XP:
11799           printf ("C64x+\n");
11800           break;
11801         case C6XABI_Tag_ISA_C674X:
11802           printf ("C674x\n");
11803           break;
11804         default:
11805           printf ("??? (%d)\n", val);
11806           break;
11807         }
11808       return p;
11809
11810     case Tag_ABI_wchar_t:
11811       val = read_uleb128 (p, &len, end);
11812       p += len;
11813       printf ("  Tag_ABI_wchar_t: ");
11814       switch (val)
11815         {
11816         case 0:
11817           printf (_("Not used\n"));
11818           break;
11819         case 1:
11820           printf (_("2 bytes\n"));
11821           break;
11822         case 2:
11823           printf (_("4 bytes\n"));
11824           break;
11825         default:
11826           printf ("??? (%d)\n", val);
11827           break;
11828         }
11829       return p;
11830
11831     case Tag_ABI_stack_align_needed:
11832       val = read_uleb128 (p, &len, end);
11833       p += len;
11834       printf ("  Tag_ABI_stack_align_needed: ");
11835       switch (val)
11836         {
11837         case 0:
11838           printf (_("8-byte\n"));
11839           break;
11840         case 1:
11841           printf (_("16-byte\n"));
11842           break;
11843         default:
11844           printf ("??? (%d)\n", val);
11845           break;
11846         }
11847       return p;
11848
11849     case Tag_ABI_stack_align_preserved:
11850       val = read_uleb128 (p, &len, end);
11851       p += len;
11852       printf ("  Tag_ABI_stack_align_preserved: ");
11853       switch (val)
11854         {
11855         case 0:
11856           printf (_("8-byte\n"));
11857           break;
11858         case 1:
11859           printf (_("16-byte\n"));
11860           break;
11861         default:
11862           printf ("??? (%d)\n", val);
11863           break;
11864         }
11865       return p;
11866
11867     case Tag_ABI_DSBT:
11868       val = read_uleb128 (p, &len, end);
11869       p += len;
11870       printf ("  Tag_ABI_DSBT: ");
11871       switch (val)
11872         {
11873         case 0:
11874           printf (_("DSBT addressing not used\n"));
11875           break;
11876         case 1:
11877           printf (_("DSBT addressing used\n"));
11878           break;
11879         default:
11880           printf ("??? (%d)\n", val);
11881           break;
11882         }
11883       return p;
11884
11885     case Tag_ABI_PID:
11886       val = read_uleb128 (p, &len, end);
11887       p += len;
11888       printf ("  Tag_ABI_PID: ");
11889       switch (val)
11890         {
11891         case 0:
11892           printf (_("Data addressing position-dependent\n"));
11893           break;
11894         case 1:
11895           printf (_("Data addressing position-independent, GOT near DP\n"));
11896           break;
11897         case 2:
11898           printf (_("Data addressing position-independent, GOT far from DP\n"));
11899           break;
11900         default:
11901           printf ("??? (%d)\n", val);
11902           break;
11903         }
11904       return p;
11905
11906     case Tag_ABI_PIC:
11907       val = read_uleb128 (p, &len, end);
11908       p += len;
11909       printf ("  Tag_ABI_PIC: ");
11910       switch (val)
11911         {
11912         case 0:
11913           printf (_("Code addressing position-dependent\n"));
11914           break;
11915         case 1:
11916           printf (_("Code addressing position-independent\n"));
11917           break;
11918         default:
11919           printf ("??? (%d)\n", val);
11920           break;
11921         }
11922       return p;
11923
11924     case Tag_ABI_array_object_alignment:
11925       val = read_uleb128 (p, &len, end);
11926       p += len;
11927       printf ("  Tag_ABI_array_object_alignment: ");
11928       switch (val)
11929         {
11930         case 0:
11931           printf (_("8-byte\n"));
11932           break;
11933         case 1:
11934           printf (_("4-byte\n"));
11935           break;
11936         case 2:
11937           printf (_("16-byte\n"));
11938           break;
11939         default:
11940           printf ("??? (%d)\n", val);
11941           break;
11942         }
11943       return p;
11944
11945     case Tag_ABI_array_object_align_expected:
11946       val = read_uleb128 (p, &len, end);
11947       p += len;
11948       printf ("  Tag_ABI_array_object_align_expected: ");
11949       switch (val)
11950         {
11951         case 0:
11952           printf (_("8-byte\n"));
11953           break;
11954         case 1:
11955           printf (_("4-byte\n"));
11956           break;
11957         case 2:
11958           printf (_("16-byte\n"));
11959           break;
11960         default:
11961           printf ("??? (%d)\n", val);
11962           break;
11963         }
11964       return p;
11965
11966     case Tag_ABI_compatibility:
11967       val = read_uleb128 (p, &len, end);
11968       p += len;
11969       printf ("  Tag_ABI_compatibility: ");
11970       printf (_("flag = %d, vendor = %s\n"), val, p);
11971       p += strlen ((char *) p) + 1;
11972       return p;
11973
11974     case Tag_ABI_conformance:
11975       printf ("  Tag_ABI_conformance: ");
11976       printf ("\"%s\"\n", p);
11977       p += strlen ((char *) p) + 1;
11978       return p;
11979     }
11980
11981   return display_tag_value (tag, p, end);
11982 }
11983
11984 static void
11985 display_raw_attribute (unsigned char * p, unsigned char * end)
11986 {
11987   unsigned long addr = 0;
11988   size_t bytes = end - p;
11989
11990   while (bytes)
11991     {
11992       int j;
11993       int k;
11994       int lbytes = (bytes > 16 ? 16 : bytes);
11995
11996       printf ("  0x%8.8lx ", addr);
11997
11998       for (j = 0; j < 16; j++)
11999         {
12000           if (j < lbytes)
12001             printf ("%2.2x", p[j]);
12002           else
12003             printf ("  ");
12004
12005           if ((j & 3) == 3)
12006             printf (" ");
12007         }
12008
12009       for (j = 0; j < lbytes; j++)
12010         {
12011           k = p[j];
12012           if (k >= ' ' && k < 0x7f)
12013             printf ("%c", k);
12014           else
12015             printf (".");
12016         }
12017
12018       putchar ('\n');
12019
12020       p  += lbytes;
12021       bytes -= lbytes;
12022       addr += lbytes;
12023     }
12024
12025   putchar ('\n');
12026 }
12027
12028 static unsigned char *
12029 display_msp430x_attribute (unsigned char * p,
12030                            const unsigned char * const end)
12031 {
12032   unsigned int len;
12033   int val;
12034   int tag;
12035
12036   tag = read_uleb128 (p, & len, end);
12037   p += len;
12038
12039   switch (tag)
12040     {
12041     case OFBA_MSPABI_Tag_ISA:
12042       val = read_uleb128 (p, &len, end);
12043       p += len;
12044       printf ("  Tag_ISA: ");
12045       switch (val)
12046         {
12047         case 0: printf (_("None\n")); break;
12048         case 1: printf (_("MSP430\n")); break;
12049         case 2: printf (_("MSP430X\n")); break;
12050         default: printf ("??? (%d)\n", val); break;
12051         }
12052       break;
12053
12054     case OFBA_MSPABI_Tag_Code_Model:
12055       val = read_uleb128 (p, &len, end);
12056       p += len;
12057       printf ("  Tag_Code_Model: ");
12058       switch (val)
12059         {
12060         case 0: printf (_("None\n")); break;
12061         case 1: printf (_("Small\n")); break;
12062         case 2: printf (_("Large\n")); break;
12063         default: printf ("??? (%d)\n", val); break;
12064         }
12065       break;
12066
12067     case OFBA_MSPABI_Tag_Data_Model:
12068       val = read_uleb128 (p, &len, end);
12069       p += len;
12070       printf ("  Tag_Data_Model: ");
12071       switch (val)
12072         {
12073         case 0: printf (_("None\n")); break;
12074         case 1: printf (_("Small\n")); break;
12075         case 2: printf (_("Large\n")); break;
12076         case 3: printf (_("Restricted Large\n")); break;
12077         default: printf ("??? (%d)\n", val); break;
12078         }
12079       break;
12080
12081     default:
12082       printf (_("  <unknown tag %d>: "), tag);
12083
12084       if (tag & 1)
12085         {
12086           printf ("\"%s\"\n", p);
12087           p += strlen ((char *) p) + 1;
12088         }
12089       else
12090         {
12091           val = read_uleb128 (p, &len, end);
12092           p += len;
12093           printf ("%d (0x%x)\n", val, val);
12094         }
12095       break;
12096    }
12097
12098   return p;
12099 }
12100
12101 static int
12102 process_attributes (FILE * file,
12103                     const char * public_name,
12104                     unsigned int proc_type,
12105                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
12106                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
12107 {
12108   Elf_Internal_Shdr * sect;
12109   unsigned char * contents;
12110   unsigned char * p;
12111   unsigned char * end;
12112   bfd_vma section_len;
12113   bfd_vma len;
12114   unsigned i;
12115
12116   /* Find the section header so that we get the size.  */
12117   for (i = 0, sect = section_headers;
12118        i < elf_header.e_shnum;
12119        i++, sect++)
12120     {
12121       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
12122         continue;
12123
12124       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
12125                                              sect->sh_size, _("attributes"));
12126       if (contents == NULL)
12127         continue;
12128
12129       p = contents;
12130       if (*p == 'A')
12131         {
12132           len = sect->sh_size - 1;
12133           p++;
12134
12135           while (len > 0)
12136             {
12137               int namelen;
12138               bfd_boolean public_section;
12139               bfd_boolean gnu_section;
12140
12141               section_len = byte_get (p, 4);
12142               p += 4;
12143
12144               if (section_len > len)
12145                 {
12146                   printf (_("ERROR: Bad section length (%d > %d)\n"),
12147                           (int) section_len, (int) len);
12148                   section_len = len;
12149                 }
12150
12151               len -= section_len;
12152               printf (_("Attribute Section: %s\n"), p);
12153
12154               if (public_name && streq ((char *) p, public_name))
12155                 public_section = TRUE;
12156               else
12157                 public_section = FALSE;
12158
12159               if (streq ((char *) p, "gnu"))
12160                 gnu_section = TRUE;
12161               else
12162                 gnu_section = FALSE;
12163
12164               namelen = strlen ((char *) p) + 1;
12165               p += namelen;
12166               section_len -= namelen + 4;
12167
12168               while (section_len > 0)
12169                 {
12170                   int tag = *(p++);
12171                   int val;
12172                   bfd_vma size;
12173
12174                   size = byte_get (p, 4);
12175                   if (size > section_len)
12176                     {
12177                       printf (_("ERROR: Bad subsection length (%d > %d)\n"),
12178                               (int) size, (int) section_len);
12179                       size = section_len;
12180                     }
12181
12182                   section_len -= size;
12183                   end = p + size - 1;
12184                   p += 4;
12185
12186                   switch (tag)
12187                     {
12188                     case 1:
12189                       printf (_("File Attributes\n"));
12190                       break;
12191                     case 2:
12192                       printf (_("Section Attributes:"));
12193                       goto do_numlist;
12194                     case 3:
12195                       printf (_("Symbol Attributes:"));
12196                     do_numlist:
12197                       for (;;)
12198                         {
12199                           unsigned int j;
12200
12201                           val = read_uleb128 (p, &j, end);
12202                           p += j;
12203                           if (val == 0)
12204                             break;
12205                           printf (" %d", val);
12206                         }
12207                       printf ("\n");
12208                       break;
12209                     default:
12210                       printf (_("Unknown tag: %d\n"), tag);
12211                       public_section = FALSE;
12212                       break;
12213                     }
12214
12215                   if (public_section)
12216                     {
12217                       while (p < end)
12218                         p = display_pub_attribute (p, end);
12219                     }
12220                   else if (gnu_section)
12221                     {
12222                       while (p < end)
12223                         p = display_gnu_attribute (p,
12224                                                    display_proc_gnu_attribute,
12225                                                    end);
12226                     }
12227                   else
12228                     {
12229                       printf (_("  Unknown section contexts\n"));
12230                       display_raw_attribute (p, end);
12231                       p = end;
12232                     }
12233                 }
12234             }
12235         }
12236       else
12237         printf (_("Unknown format '%c'\n"), *p);
12238
12239       free (contents);
12240     }
12241   return 1;
12242 }
12243
12244 static int
12245 process_arm_specific (FILE * file)
12246 {
12247   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
12248                              display_arm_attribute, NULL);
12249 }
12250
12251 static int
12252 process_power_specific (FILE * file)
12253 {
12254   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12255                              display_power_gnu_attribute);
12256 }
12257
12258 static int
12259 process_sparc_specific (FILE * file)
12260 {
12261   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12262                              display_sparc_gnu_attribute);
12263 }
12264
12265 static int
12266 process_tic6x_specific (FILE * file)
12267 {
12268   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
12269                              display_tic6x_attribute, NULL);
12270 }
12271
12272 static int
12273 process_msp430x_specific (FILE * file)
12274 {
12275   return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
12276                              display_msp430x_attribute, NULL);
12277 }
12278
12279 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12280    Print the Address, Access and Initial fields of an entry at VMA ADDR
12281    and return the VMA of the next entry.  */
12282
12283 static bfd_vma
12284 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12285 {
12286   printf ("  ");
12287   print_vma (addr, LONG_HEX);
12288   printf (" ");
12289   if (addr < pltgot + 0xfff0)
12290     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
12291   else
12292     printf ("%10s", "");
12293   printf (" ");
12294   if (data == NULL)
12295     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12296   else
12297     {
12298       bfd_vma entry;
12299
12300       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12301       print_vma (entry, LONG_HEX);
12302     }
12303   return addr + (is_32bit_elf ? 4 : 8);
12304 }
12305
12306 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12307    PLTGOT.  Print the Address and Initial fields of an entry at VMA
12308    ADDR and return the VMA of the next entry.  */
12309
12310 static bfd_vma
12311 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12312 {
12313   printf ("  ");
12314   print_vma (addr, LONG_HEX);
12315   printf (" ");
12316   if (data == NULL)
12317     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12318   else
12319     {
12320       bfd_vma entry;
12321
12322       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12323       print_vma (entry, LONG_HEX);
12324     }
12325   return addr + (is_32bit_elf ? 4 : 8);
12326 }
12327
12328 static int
12329 process_mips_specific (FILE * file)
12330 {
12331   Elf_Internal_Dyn * entry;
12332   size_t liblist_offset = 0;
12333   size_t liblistno = 0;
12334   size_t conflictsno = 0;
12335   size_t options_offset = 0;
12336   size_t conflicts_offset = 0;
12337   size_t pltrelsz = 0;
12338   size_t pltrel = 0;
12339   bfd_vma pltgot = 0;
12340   bfd_vma mips_pltgot = 0;
12341   bfd_vma jmprel = 0;
12342   bfd_vma local_gotno = 0;
12343   bfd_vma gotsym = 0;
12344   bfd_vma symtabno = 0;
12345
12346   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12347                       display_mips_gnu_attribute);
12348
12349   /* We have a lot of special sections.  Thanks SGI!  */
12350   if (dynamic_section == NULL)
12351     /* No information available.  */
12352     return 0;
12353
12354   for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
12355     switch (entry->d_tag)
12356       {
12357       case DT_MIPS_LIBLIST:
12358         liblist_offset
12359           = offset_from_vma (file, entry->d_un.d_val,
12360                              liblistno * sizeof (Elf32_External_Lib));
12361         break;
12362       case DT_MIPS_LIBLISTNO:
12363         liblistno = entry->d_un.d_val;
12364         break;
12365       case DT_MIPS_OPTIONS:
12366         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
12367         break;
12368       case DT_MIPS_CONFLICT:
12369         conflicts_offset
12370           = offset_from_vma (file, entry->d_un.d_val,
12371                              conflictsno * sizeof (Elf32_External_Conflict));
12372         break;
12373       case DT_MIPS_CONFLICTNO:
12374         conflictsno = entry->d_un.d_val;
12375         break;
12376       case DT_PLTGOT:
12377         pltgot = entry->d_un.d_ptr;
12378         break;
12379       case DT_MIPS_LOCAL_GOTNO:
12380         local_gotno = entry->d_un.d_val;
12381         break;
12382       case DT_MIPS_GOTSYM:
12383         gotsym = entry->d_un.d_val;
12384         break;
12385       case DT_MIPS_SYMTABNO:
12386         symtabno = entry->d_un.d_val;
12387         break;
12388       case DT_MIPS_PLTGOT:
12389         mips_pltgot = entry->d_un.d_ptr;
12390         break;
12391       case DT_PLTREL:
12392         pltrel = entry->d_un.d_val;
12393         break;
12394       case DT_PLTRELSZ:
12395         pltrelsz = entry->d_un.d_val;
12396         break;
12397       case DT_JMPREL:
12398         jmprel = entry->d_un.d_ptr;
12399         break;
12400       default:
12401         break;
12402       }
12403
12404   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
12405     {
12406       Elf32_External_Lib * elib;
12407       size_t cnt;
12408
12409       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
12410                                               liblistno,
12411                                               sizeof (Elf32_External_Lib),
12412                                               _("liblist section data"));
12413       if (elib)
12414         {
12415           printf (_("\nSection '.liblist' contains %lu entries:\n"),
12416                   (unsigned long) liblistno);
12417           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
12418                  stdout);
12419
12420           for (cnt = 0; cnt < liblistno; ++cnt)
12421             {
12422               Elf32_Lib liblist;
12423               time_t atime;
12424               char timebuf[20];
12425               struct tm * tmp;
12426
12427               liblist.l_name = BYTE_GET (elib[cnt].l_name);
12428               atime = BYTE_GET (elib[cnt].l_time_stamp);
12429               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12430               liblist.l_version = BYTE_GET (elib[cnt].l_version);
12431               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12432
12433               tmp = gmtime (&atime);
12434               snprintf (timebuf, sizeof (timebuf),
12435                         "%04u-%02u-%02uT%02u:%02u:%02u",
12436                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12437                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12438
12439               printf ("%3lu: ", (unsigned long) cnt);
12440               if (VALID_DYNAMIC_NAME (liblist.l_name))
12441                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
12442               else
12443                 printf (_("<corrupt: %9ld>"), liblist.l_name);
12444               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
12445                       liblist.l_version);
12446
12447               if (liblist.l_flags == 0)
12448                 puts (_(" NONE"));
12449               else
12450                 {
12451                   static const struct
12452                   {
12453                     const char * name;
12454                     int bit;
12455                   }
12456                   l_flags_vals[] =
12457                   {
12458                     { " EXACT_MATCH", LL_EXACT_MATCH },
12459                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
12460                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
12461                     { " EXPORTS", LL_EXPORTS },
12462                     { " DELAY_LOAD", LL_DELAY_LOAD },
12463                     { " DELTA", LL_DELTA }
12464                   };
12465                   int flags = liblist.l_flags;
12466                   size_t fcnt;
12467
12468                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
12469                     if ((flags & l_flags_vals[fcnt].bit) != 0)
12470                       {
12471                         fputs (l_flags_vals[fcnt].name, stdout);
12472                         flags ^= l_flags_vals[fcnt].bit;
12473                       }
12474                   if (flags != 0)
12475                     printf (" %#x", (unsigned int) flags);
12476
12477                   puts ("");
12478                 }
12479             }
12480
12481           free (elib);
12482         }
12483     }
12484
12485   if (options_offset != 0)
12486     {
12487       Elf_External_Options * eopt;
12488       Elf_Internal_Shdr * sect = section_headers;
12489       Elf_Internal_Options * iopt;
12490       Elf_Internal_Options * option;
12491       size_t offset;
12492       int cnt;
12493
12494       /* Find the section header so that we get the size.  */
12495       while (sect->sh_type != SHT_MIPS_OPTIONS)
12496         ++sect;
12497
12498       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
12499                                                 sect->sh_size, _("options"));
12500       if (eopt)
12501         {
12502           iopt = (Elf_Internal_Options *)
12503               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
12504           if (iopt == NULL)
12505             {
12506               error (_("Out of memory\n"));
12507               return 0;
12508             }
12509
12510           offset = cnt = 0;
12511           option = iopt;
12512
12513           while (offset < sect->sh_size)
12514             {
12515               Elf_External_Options * eoption;
12516
12517               eoption = (Elf_External_Options *) ((char *) eopt + offset);
12518
12519               option->kind = BYTE_GET (eoption->kind);
12520               option->size = BYTE_GET (eoption->size);
12521               option->section = BYTE_GET (eoption->section);
12522               option->info = BYTE_GET (eoption->info);
12523
12524               offset += option->size;
12525
12526               ++option;
12527               ++cnt;
12528             }
12529
12530           printf (_("\nSection '%s' contains %d entries:\n"),
12531                   SECTION_NAME (sect), cnt);
12532
12533           option = iopt;
12534
12535           while (cnt-- > 0)
12536             {
12537               size_t len;
12538
12539               switch (option->kind)
12540                 {
12541                 case ODK_NULL:
12542                   /* This shouldn't happen.  */
12543                   printf (" NULL       %d %lx", option->section, option->info);
12544                   break;
12545                 case ODK_REGINFO:
12546                   printf (" REGINFO    ");
12547                   if (elf_header.e_machine == EM_MIPS)
12548                     {
12549                       /* 32bit form.  */
12550                       Elf32_External_RegInfo * ereg;
12551                       Elf32_RegInfo reginfo;
12552
12553                       ereg = (Elf32_External_RegInfo *) (option + 1);
12554                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12555                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12556                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12557                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12558                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12559                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12560
12561                       printf ("GPR %08lx  GP 0x%lx\n",
12562                               reginfo.ri_gprmask,
12563                               (unsigned long) reginfo.ri_gp_value);
12564                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
12565                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12566                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12567                     }
12568                   else
12569                     {
12570                       /* 64 bit form.  */
12571                       Elf64_External_RegInfo * ereg;
12572                       Elf64_Internal_RegInfo reginfo;
12573
12574                       ereg = (Elf64_External_RegInfo *) (option + 1);
12575                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
12576                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12577                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12578                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12579                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12580                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
12581
12582                       printf ("GPR %08lx  GP 0x",
12583                               reginfo.ri_gprmask);
12584                       printf_vma (reginfo.ri_gp_value);
12585                       printf ("\n");
12586
12587                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
12588                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12589                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12590                     }
12591                   ++option;
12592                   continue;
12593                 case ODK_EXCEPTIONS:
12594                   fputs (" EXCEPTIONS fpe_min(", stdout);
12595                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12596                   fputs (") fpe_max(", stdout);
12597                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12598                   fputs (")", stdout);
12599
12600                   if (option->info & OEX_PAGE0)
12601                     fputs (" PAGE0", stdout);
12602                   if (option->info & OEX_SMM)
12603                     fputs (" SMM", stdout);
12604                   if (option->info & OEX_FPDBUG)
12605                     fputs (" FPDBUG", stdout);
12606                   if (option->info & OEX_DISMISS)
12607                     fputs (" DISMISS", stdout);
12608                   break;
12609                 case ODK_PAD:
12610                   fputs (" PAD       ", stdout);
12611                   if (option->info & OPAD_PREFIX)
12612                     fputs (" PREFIX", stdout);
12613                   if (option->info & OPAD_POSTFIX)
12614                     fputs (" POSTFIX", stdout);
12615                   if (option->info & OPAD_SYMBOL)
12616                     fputs (" SYMBOL", stdout);
12617                   break;
12618                 case ODK_HWPATCH:
12619                   fputs (" HWPATCH   ", stdout);
12620                   if (option->info & OHW_R4KEOP)
12621                     fputs (" R4KEOP", stdout);
12622                   if (option->info & OHW_R8KPFETCH)
12623                     fputs (" R8KPFETCH", stdout);
12624                   if (option->info & OHW_R5KEOP)
12625                     fputs (" R5KEOP", stdout);
12626                   if (option->info & OHW_R5KCVTL)
12627                     fputs (" R5KCVTL", stdout);
12628                   break;
12629                 case ODK_FILL:
12630                   fputs (" FILL       ", stdout);
12631                   /* XXX Print content of info word?  */
12632                   break;
12633                 case ODK_TAGS:
12634                   fputs (" TAGS       ", stdout);
12635                   /* XXX Print content of info word?  */
12636                   break;
12637                 case ODK_HWAND:
12638                   fputs (" HWAND     ", stdout);
12639                   if (option->info & OHWA0_R4KEOP_CHECKED)
12640                     fputs (" R4KEOP_CHECKED", stdout);
12641                   if (option->info & OHWA0_R4KEOP_CLEAN)
12642                     fputs (" R4KEOP_CLEAN", stdout);
12643                   break;
12644                 case ODK_HWOR:
12645                   fputs (" HWOR      ", stdout);
12646                   if (option->info & OHWA0_R4KEOP_CHECKED)
12647                     fputs (" R4KEOP_CHECKED", stdout);
12648                   if (option->info & OHWA0_R4KEOP_CLEAN)
12649                     fputs (" R4KEOP_CLEAN", stdout);
12650                   break;
12651                 case ODK_GP_GROUP:
12652                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
12653                           option->info & OGP_GROUP,
12654                           (option->info & OGP_SELF) >> 16);
12655                   break;
12656                 case ODK_IDENT:
12657                   printf (" IDENT     %#06lx  self-contained %#06lx",
12658                           option->info & OGP_GROUP,
12659                           (option->info & OGP_SELF) >> 16);
12660                   break;
12661                 default:
12662                   /* This shouldn't happen.  */
12663                   printf (" %3d ???     %d %lx",
12664                           option->kind, option->section, option->info);
12665                   break;
12666                 }
12667
12668               len = sizeof (* eopt);
12669               while (len < option->size)
12670                 if (((char *) option)[len] >= ' '
12671                     && ((char *) option)[len] < 0x7f)
12672                   printf ("%c", ((char *) option)[len++]);
12673                 else
12674                   printf ("\\%03o", ((char *) option)[len++]);
12675
12676               fputs ("\n", stdout);
12677               ++option;
12678             }
12679
12680           free (eopt);
12681         }
12682     }
12683
12684   if (conflicts_offset != 0 && conflictsno != 0)
12685     {
12686       Elf32_Conflict * iconf;
12687       size_t cnt;
12688
12689       if (dynamic_symbols == NULL)
12690         {
12691           error (_("conflict list found without a dynamic symbol table\n"));
12692           return 0;
12693         }
12694
12695       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
12696       if (iconf == NULL)
12697         {
12698           error (_("Out of memory\n"));
12699           return 0;
12700         }
12701
12702       if (is_32bit_elf)
12703         {
12704           Elf32_External_Conflict * econf32;
12705
12706           econf32 = (Elf32_External_Conflict *)
12707               get_data (NULL, file, conflicts_offset, conflictsno,
12708                         sizeof (* econf32), _("conflict"));
12709           if (!econf32)
12710             return 0;
12711
12712           for (cnt = 0; cnt < conflictsno; ++cnt)
12713             iconf[cnt] = BYTE_GET (econf32[cnt]);
12714
12715           free (econf32);
12716         }
12717       else
12718         {
12719           Elf64_External_Conflict * econf64;
12720
12721           econf64 = (Elf64_External_Conflict *)
12722               get_data (NULL, file, conflicts_offset, conflictsno,
12723                         sizeof (* econf64), _("conflict"));
12724           if (!econf64)
12725             return 0;
12726
12727           for (cnt = 0; cnt < conflictsno; ++cnt)
12728             iconf[cnt] = BYTE_GET (econf64[cnt]);
12729
12730           free (econf64);
12731         }
12732
12733       printf (_("\nSection '.conflict' contains %lu entries:\n"),
12734               (unsigned long) conflictsno);
12735       puts (_("  Num:    Index       Value  Name"));
12736
12737       for (cnt = 0; cnt < conflictsno; ++cnt)
12738         {
12739           Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
12740
12741           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
12742           print_vma (psym->st_value, FULL_HEX);
12743           putchar (' ');
12744           if (VALID_DYNAMIC_NAME (psym->st_name))
12745             print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
12746           else
12747             printf (_("<corrupt: %14ld>"), psym->st_name);
12748           putchar ('\n');
12749         }
12750
12751       free (iconf);
12752     }
12753
12754   if (pltgot != 0 && local_gotno != 0)
12755     {
12756       bfd_vma ent, local_end, global_end;
12757       size_t i, offset;
12758       unsigned char * data;
12759       int addr_size;
12760
12761       ent = pltgot;
12762       addr_size = (is_32bit_elf ? 4 : 8);
12763       local_end = pltgot + local_gotno * addr_size;
12764       global_end = local_end + (symtabno - gotsym) * addr_size;
12765
12766       offset = offset_from_vma (file, pltgot, global_end - pltgot);
12767       data = (unsigned char *) get_data (NULL, file, offset,
12768                                          global_end - pltgot, 1,
12769                                          _("Global Offset Table data"));
12770       if (data == NULL)
12771         return 0;
12772
12773       printf (_("\nPrimary GOT:\n"));
12774       printf (_(" Canonical gp value: "));
12775       print_vma (pltgot + 0x7ff0, LONG_HEX);
12776       printf ("\n\n");
12777
12778       printf (_(" Reserved entries:\n"));
12779       printf (_("  %*s %10s %*s Purpose\n"),
12780               addr_size * 2, _("Address"), _("Access"),
12781               addr_size * 2, _("Initial"));
12782       ent = print_mips_got_entry (data, pltgot, ent);
12783       printf (_(" Lazy resolver\n"));
12784       if (data
12785           && (byte_get (data + ent - pltgot, addr_size)
12786               >> (addr_size * 8 - 1)) != 0)
12787         {
12788           ent = print_mips_got_entry (data, pltgot, ent);
12789           printf (_(" Module pointer (GNU extension)\n"));
12790         }
12791       printf ("\n");
12792
12793       if (ent < local_end)
12794         {
12795           printf (_(" Local entries:\n"));
12796           printf ("  %*s %10s %*s\n",
12797                   addr_size * 2, _("Address"), _("Access"),
12798                   addr_size * 2, _("Initial"));
12799           while (ent < local_end)
12800             {
12801               ent = print_mips_got_entry (data, pltgot, ent);
12802               printf ("\n");
12803             }
12804           printf ("\n");
12805         }
12806
12807       if (gotsym < symtabno)
12808         {
12809           int sym_width;
12810
12811           printf (_(" Global entries:\n"));
12812           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
12813                   addr_size * 2, _("Address"),
12814                   _("Access"),
12815                   addr_size * 2, _("Initial"),
12816                   addr_size * 2, _("Sym.Val."),
12817                   _("Type"),
12818                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
12819                   _("Ndx"), _("Name"));
12820
12821           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12822           for (i = gotsym; i < symtabno; i++)
12823             {
12824               Elf_Internal_Sym * psym;
12825
12826               psym = dynamic_symbols + i;
12827               ent = print_mips_got_entry (data, pltgot, ent);
12828               printf (" ");
12829               print_vma (psym->st_value, LONG_HEX);
12830               printf (" %-7s %3s ",
12831                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12832                       get_symbol_index_type (psym->st_shndx));
12833               if (VALID_DYNAMIC_NAME (psym->st_name))
12834                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12835               else
12836                 printf (_("<corrupt: %14ld>"), psym->st_name);
12837               printf ("\n");
12838             }
12839           printf ("\n");
12840         }
12841
12842       if (data)
12843         free (data);
12844     }
12845
12846   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12847     {
12848       bfd_vma ent, end;
12849       size_t offset, rel_offset;
12850       unsigned long count, i;
12851       unsigned char * data;
12852       int addr_size, sym_width;
12853       Elf_Internal_Rela * rels;
12854
12855       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12856       if (pltrel == DT_RELA)
12857         {
12858           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12859             return 0;
12860         }
12861       else
12862         {
12863           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12864             return 0;
12865         }
12866
12867       ent = mips_pltgot;
12868       addr_size = (is_32bit_elf ? 4 : 8);
12869       end = mips_pltgot + (2 + count) * addr_size;
12870
12871       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
12872       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
12873                                          1, _("Procedure Linkage Table data"));
12874       if (data == NULL)
12875         return 0;
12876
12877       printf ("\nPLT GOT:\n\n");
12878       printf (_(" Reserved entries:\n"));
12879       printf (_("  %*s %*s Purpose\n"),
12880               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
12881       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12882       printf (_(" PLT lazy resolver\n"));
12883       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12884       printf (_(" Module pointer\n"));
12885       printf ("\n");
12886
12887       printf (_(" Entries:\n"));
12888       printf ("  %*s %*s %*s %-7s %3s %s\n",
12889               addr_size * 2, _("Address"),
12890               addr_size * 2, _("Initial"),
12891               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12892       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12893       for (i = 0; i < count; i++)
12894         {
12895           Elf_Internal_Sym * psym;
12896
12897           psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
12898           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12899           printf (" ");
12900           print_vma (psym->st_value, LONG_HEX);
12901           printf (" %-7s %3s ",
12902                   get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12903                   get_symbol_index_type (psym->st_shndx));
12904           if (VALID_DYNAMIC_NAME (psym->st_name))
12905             print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12906           else
12907             printf (_("<corrupt: %14ld>"), psym->st_name);
12908           printf ("\n");
12909         }
12910       printf ("\n");
12911
12912       if (data)
12913         free (data);
12914       free (rels);
12915     }
12916
12917   return 1;
12918 }
12919
12920 static int
12921 process_gnu_liblist (FILE * file)
12922 {
12923   Elf_Internal_Shdr * section;
12924   Elf_Internal_Shdr * string_sec;
12925   Elf32_External_Lib * elib;
12926   char * strtab;
12927   size_t strtab_size;
12928   size_t cnt;
12929   unsigned i;
12930
12931   if (! do_arch)
12932     return 0;
12933
12934   for (i = 0, section = section_headers;
12935        i < elf_header.e_shnum;
12936        i++, section++)
12937     {
12938       switch (section->sh_type)
12939         {
12940         case SHT_GNU_LIBLIST:
12941           if (section->sh_link >= elf_header.e_shnum)
12942             break;
12943
12944           elib = (Elf32_External_Lib *)
12945               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
12946                         _("liblist section data"));
12947
12948           if (elib == NULL)
12949             break;
12950           string_sec = section_headers + section->sh_link;
12951
12952           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12953                                       string_sec->sh_size,
12954                                       _("liblist string table"));
12955           if (strtab == NULL
12956               || section->sh_entsize != sizeof (Elf32_External_Lib))
12957             {
12958               free (elib);
12959               free (strtab);
12960               break;
12961             }
12962           strtab_size = string_sec->sh_size;
12963
12964           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12965                   SECTION_NAME (section),
12966                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
12967
12968           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
12969
12970           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12971                ++cnt)
12972             {
12973               Elf32_Lib liblist;
12974               time_t atime;
12975               char timebuf[20];
12976               struct tm * tmp;
12977
12978               liblist.l_name = BYTE_GET (elib[cnt].l_name);
12979               atime = BYTE_GET (elib[cnt].l_time_stamp);
12980               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12981               liblist.l_version = BYTE_GET (elib[cnt].l_version);
12982               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12983
12984               tmp = gmtime (&atime);
12985               snprintf (timebuf, sizeof (timebuf),
12986                         "%04u-%02u-%02uT%02u:%02u:%02u",
12987                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12988                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12989
12990               printf ("%3lu: ", (unsigned long) cnt);
12991               if (do_wide)
12992                 printf ("%-20s", liblist.l_name < strtab_size
12993                         ? strtab + liblist.l_name : _("<corrupt>"));
12994               else
12995                 printf ("%-20.20s", liblist.l_name < strtab_size
12996                         ? strtab + liblist.l_name : _("<corrupt>"));
12997               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12998                       liblist.l_version, liblist.l_flags);
12999             }
13000
13001           free (elib);
13002           free (strtab);
13003         }
13004     }
13005
13006   return 1;
13007 }
13008
13009 static const char *
13010 get_note_type (unsigned e_type)
13011 {
13012   static char buff[64];
13013
13014   if (elf_header.e_type == ET_CORE)
13015     switch (e_type)
13016       {
13017       case NT_AUXV:
13018         return _("NT_AUXV (auxiliary vector)");
13019       case NT_PRSTATUS:
13020         return _("NT_PRSTATUS (prstatus structure)");
13021       case NT_FPREGSET:
13022         return _("NT_FPREGSET (floating point registers)");
13023       case NT_PRPSINFO:
13024         return _("NT_PRPSINFO (prpsinfo structure)");
13025       case NT_TASKSTRUCT:
13026         return _("NT_TASKSTRUCT (task structure)");
13027       case NT_PRXFPREG:
13028         return _("NT_PRXFPREG (user_xfpregs structure)");
13029       case NT_PPC_VMX:
13030         return _("NT_PPC_VMX (ppc Altivec registers)");
13031       case NT_PPC_VSX:
13032         return _("NT_PPC_VSX (ppc VSX registers)");
13033       case NT_386_TLS:
13034         return _("NT_386_TLS (x86 TLS information)");
13035       case NT_386_IOPERM:
13036         return _("NT_386_IOPERM (x86 I/O permissions)");
13037       case NT_X86_XSTATE:
13038         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
13039       case NT_S390_HIGH_GPRS:
13040         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
13041       case NT_S390_TIMER:
13042         return _("NT_S390_TIMER (s390 timer register)");
13043       case NT_S390_TODCMP:
13044         return _("NT_S390_TODCMP (s390 TOD comparator register)");
13045       case NT_S390_TODPREG:
13046         return _("NT_S390_TODPREG (s390 TOD programmable register)");
13047       case NT_S390_CTRS:
13048         return _("NT_S390_CTRS (s390 control registers)");
13049       case NT_S390_PREFIX:
13050         return _("NT_S390_PREFIX (s390 prefix register)");
13051       case NT_S390_LAST_BREAK:
13052         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
13053       case NT_S390_SYSTEM_CALL:
13054         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
13055       case NT_S390_TDB:
13056         return _("NT_S390_TDB (s390 transaction diagnostic block)");
13057       case NT_ARM_VFP:
13058         return _("NT_ARM_VFP (arm VFP registers)");
13059       case NT_ARM_TLS:
13060         return _("NT_ARM_TLS (AArch TLS registers)");
13061       case NT_ARM_HW_BREAK:
13062         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
13063       case NT_ARM_HW_WATCH:
13064         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
13065       case NT_PSTATUS:
13066         return _("NT_PSTATUS (pstatus structure)");
13067       case NT_FPREGS:
13068         return _("NT_FPREGS (floating point registers)");
13069       case NT_PSINFO:
13070         return _("NT_PSINFO (psinfo structure)");
13071       case NT_LWPSTATUS:
13072         return _("NT_LWPSTATUS (lwpstatus_t structure)");
13073       case NT_LWPSINFO:
13074         return _("NT_LWPSINFO (lwpsinfo_t structure)");
13075       case NT_WIN32PSTATUS:
13076         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
13077       case NT_SIGINFO:
13078         return _("NT_SIGINFO (siginfo_t data)");
13079       case NT_FILE:
13080         return _("NT_FILE (mapped files)");
13081       default:
13082         break;
13083       }
13084   else
13085     switch (e_type)
13086       {
13087       case NT_VERSION:
13088         return _("NT_VERSION (version)");
13089       case NT_ARCH:
13090         return _("NT_ARCH (architecture)");
13091       default:
13092         break;
13093       }
13094
13095   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13096   return buff;
13097 }
13098
13099 static int
13100 print_core_note (Elf_Internal_Note *pnote)
13101 {
13102   unsigned int addr_size = is_32bit_elf ? 4 : 8;
13103   bfd_vma count, page_size;
13104   unsigned char *descdata, *filenames, *descend;
13105
13106   if (pnote->type != NT_FILE)
13107     return 1;
13108
13109 #ifndef BFD64
13110   if (!is_32bit_elf)
13111     {
13112       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
13113       /* Still "successful".  */
13114       return 1;
13115     }
13116 #endif
13117
13118   if (pnote->descsz < 2 * addr_size)
13119     {
13120       printf (_("    Malformed note - too short for header\n"));
13121       return 0;
13122     }
13123
13124   descdata = (unsigned char *) pnote->descdata;
13125   descend = descdata + pnote->descsz;
13126
13127   if (descdata[pnote->descsz - 1] != '\0')
13128     {
13129       printf (_("    Malformed note - does not end with \\0\n"));
13130       return 0;
13131     }
13132
13133   count = byte_get (descdata, addr_size);
13134   descdata += addr_size;
13135
13136   page_size = byte_get (descdata, addr_size);
13137   descdata += addr_size;
13138
13139   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
13140     {
13141       printf (_("    Malformed note - too short for supplied file count\n"));
13142       return 0;
13143     }
13144
13145   printf (_("    Page size: "));
13146   print_vma (page_size, DEC);
13147   printf ("\n");
13148
13149   printf (_("    %*s%*s%*s\n"),
13150           (int) (2 + 2 * addr_size), _("Start"),
13151           (int) (4 + 2 * addr_size), _("End"),
13152           (int) (4 + 2 * addr_size), _("Page Offset"));
13153   filenames = descdata + count * 3 * addr_size;
13154   while (--count > 0)
13155     {
13156       bfd_vma start, end, file_ofs;
13157
13158       if (filenames == descend)
13159         {
13160           printf (_("    Malformed note - filenames end too early\n"));
13161           return 0;
13162         }
13163
13164       start = byte_get (descdata, addr_size);
13165       descdata += addr_size;
13166       end = byte_get (descdata, addr_size);
13167       descdata += addr_size;
13168       file_ofs = byte_get (descdata, addr_size);
13169       descdata += addr_size;
13170
13171       printf ("    ");
13172       print_vma (start, FULL_HEX);
13173       printf ("  ");
13174       print_vma (end, FULL_HEX);
13175       printf ("  ");
13176       print_vma (file_ofs, FULL_HEX);
13177       printf ("\n        %s\n", filenames);
13178
13179       filenames += 1 + strlen ((char *) filenames);
13180     }
13181
13182   return 1;
13183 }
13184
13185 static const char *
13186 get_gnu_elf_note_type (unsigned e_type)
13187 {
13188   static char buff[64];
13189
13190   switch (e_type)
13191     {
13192     case NT_GNU_ABI_TAG:
13193       return _("NT_GNU_ABI_TAG (ABI version tag)");
13194     case NT_GNU_HWCAP:
13195       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
13196     case NT_GNU_BUILD_ID:
13197       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
13198     case NT_GNU_GOLD_VERSION:
13199       return _("NT_GNU_GOLD_VERSION (gold version)");
13200     default:
13201       break;
13202     }
13203
13204   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13205   return buff;
13206 }
13207
13208 static int
13209 print_gnu_note (Elf_Internal_Note *pnote)
13210 {
13211   switch (pnote->type)
13212     {
13213     case NT_GNU_BUILD_ID:
13214       {
13215         unsigned long i;
13216
13217         printf (_("    Build ID: "));
13218         for (i = 0; i < pnote->descsz; ++i)
13219           printf ("%02x", pnote->descdata[i] & 0xff);
13220         printf ("\n");
13221       }
13222       break;
13223
13224     case NT_GNU_ABI_TAG:
13225       {
13226         unsigned long os, major, minor, subminor;
13227         const char *osname;
13228
13229         os = byte_get ((unsigned char *) pnote->descdata, 4);
13230         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
13231         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
13232         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
13233
13234         switch (os)
13235           {
13236           case GNU_ABI_TAG_LINUX:
13237             osname = "Linux";
13238             break;
13239           case GNU_ABI_TAG_HURD:
13240             osname = "Hurd";
13241             break;
13242           case GNU_ABI_TAG_SOLARIS:
13243             osname = "Solaris";
13244             break;
13245           case GNU_ABI_TAG_FREEBSD:
13246             osname = "FreeBSD";
13247             break;
13248           case GNU_ABI_TAG_NETBSD:
13249             osname = "NetBSD";
13250             break;
13251           default:
13252             osname = "Unknown";
13253             break;
13254           }
13255
13256         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
13257                 major, minor, subminor);
13258       }
13259       break;
13260     }
13261
13262   return 1;
13263 }
13264
13265 static const char *
13266 get_netbsd_elfcore_note_type (unsigned e_type)
13267 {
13268   static char buff[64];
13269
13270   if (e_type == NT_NETBSDCORE_PROCINFO)
13271     {
13272       /* NetBSD core "procinfo" structure.  */
13273       return _("NetBSD procinfo structure");
13274     }
13275
13276   /* As of Jan 2002 there are no other machine-independent notes
13277      defined for NetBSD core files.  If the note type is less
13278      than the start of the machine-dependent note types, we don't
13279      understand it.  */
13280
13281   if (e_type < NT_NETBSDCORE_FIRSTMACH)
13282     {
13283       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13284       return buff;
13285     }
13286
13287   switch (elf_header.e_machine)
13288     {
13289     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13290        and PT_GETFPREGS == mach+2.  */
13291
13292     case EM_OLD_ALPHA:
13293     case EM_ALPHA:
13294     case EM_SPARC:
13295     case EM_SPARC32PLUS:
13296     case EM_SPARCV9:
13297       switch (e_type)
13298         {
13299         case NT_NETBSDCORE_FIRSTMACH + 0:
13300           return _("PT_GETREGS (reg structure)");
13301         case NT_NETBSDCORE_FIRSTMACH + 2:
13302           return _("PT_GETFPREGS (fpreg structure)");
13303         default:
13304           break;
13305         }
13306       break;
13307
13308     /* On all other arch's, PT_GETREGS == mach+1 and
13309        PT_GETFPREGS == mach+3.  */
13310     default:
13311       switch (e_type)
13312         {
13313         case NT_NETBSDCORE_FIRSTMACH + 1:
13314           return _("PT_GETREGS (reg structure)");
13315         case NT_NETBSDCORE_FIRSTMACH + 3:
13316           return _("PT_GETFPREGS (fpreg structure)");
13317         default:
13318           break;
13319         }
13320     }
13321
13322   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
13323             e_type - NT_NETBSDCORE_FIRSTMACH);
13324   return buff;
13325 }
13326
13327 static const char *
13328 get_stapsdt_note_type (unsigned e_type)
13329 {
13330   static char buff[64];
13331
13332   switch (e_type)
13333     {
13334     case NT_STAPSDT:
13335       return _("NT_STAPSDT (SystemTap probe descriptors)");
13336
13337     default:
13338       break;
13339     }
13340
13341   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13342   return buff;
13343 }
13344
13345 static int
13346 print_stapsdt_note (Elf_Internal_Note *pnote)
13347 {
13348   int addr_size = is_32bit_elf ? 4 : 8;
13349   char *data = pnote->descdata;
13350   char *data_end = pnote->descdata + pnote->descsz;
13351   bfd_vma pc, base_addr, semaphore;
13352   char *provider, *probe, *arg_fmt;
13353
13354   pc = byte_get ((unsigned char *) data, addr_size);
13355   data += addr_size;
13356   base_addr = byte_get ((unsigned char *) data, addr_size);
13357   data += addr_size;
13358   semaphore = byte_get ((unsigned char *) data, addr_size);
13359   data += addr_size;
13360
13361   provider = data;
13362   data += strlen (data) + 1;
13363   probe = data;
13364   data += strlen (data) + 1;
13365   arg_fmt = data;
13366   data += strlen (data) + 1;
13367
13368   printf (_("    Provider: %s\n"), provider);
13369   printf (_("    Name: %s\n"), probe);
13370   printf (_("    Location: "));
13371   print_vma (pc, FULL_HEX);
13372   printf (_(", Base: "));
13373   print_vma (base_addr, FULL_HEX);
13374   printf (_(", Semaphore: "));
13375   print_vma (semaphore, FULL_HEX);
13376   printf ("\n");
13377   printf (_("    Arguments: %s\n"), arg_fmt);
13378
13379   return data == data_end;
13380 }
13381
13382 static const char *
13383 get_ia64_vms_note_type (unsigned e_type)
13384 {
13385   static char buff[64];
13386
13387   switch (e_type)
13388     {
13389     case NT_VMS_MHD:
13390       return _("NT_VMS_MHD (module header)");
13391     case NT_VMS_LNM:
13392       return _("NT_VMS_LNM (language name)");
13393     case NT_VMS_SRC:
13394       return _("NT_VMS_SRC (source files)");
13395     case NT_VMS_TITLE:
13396       return "NT_VMS_TITLE";
13397     case NT_VMS_EIDC:
13398       return _("NT_VMS_EIDC (consistency check)");
13399     case NT_VMS_FPMODE:
13400       return _("NT_VMS_FPMODE (FP mode)");
13401     case NT_VMS_LINKTIME:
13402       return "NT_VMS_LINKTIME";
13403     case NT_VMS_IMGNAM:
13404       return _("NT_VMS_IMGNAM (image name)");
13405     case NT_VMS_IMGID:
13406       return _("NT_VMS_IMGID (image id)");
13407     case NT_VMS_LINKID:
13408       return _("NT_VMS_LINKID (link id)");
13409     case NT_VMS_IMGBID:
13410       return _("NT_VMS_IMGBID (build id)");
13411     case NT_VMS_GSTNAM:
13412       return _("NT_VMS_GSTNAM (sym table name)");
13413     case NT_VMS_ORIG_DYN:
13414       return "NT_VMS_ORIG_DYN";
13415     case NT_VMS_PATCHTIME:
13416       return "NT_VMS_PATCHTIME";
13417     default:
13418       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13419       return buff;
13420     }
13421 }
13422
13423 static int
13424 print_ia64_vms_note (Elf_Internal_Note * pnote)
13425 {
13426   switch (pnote->type)
13427     {
13428     case NT_VMS_MHD:
13429       if (pnote->descsz > 36)
13430         {
13431           size_t l = strlen (pnote->descdata + 34);
13432           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
13433           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
13434           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
13435           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
13436         }
13437       else
13438         printf (_("    Invalid size\n"));
13439       break;
13440     case NT_VMS_LNM:
13441       printf (_("   Language: %s\n"), pnote->descdata);
13442       break;
13443 #ifdef BFD64
13444     case NT_VMS_FPMODE:
13445       printf (_("   Floating Point mode: "));
13446       printf ("0x%016" BFD_VMA_FMT "x\n",
13447               (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
13448       break;
13449     case NT_VMS_LINKTIME:
13450       printf (_("   Link time: "));
13451       print_vms_time
13452         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13453       printf ("\n");
13454       break;
13455     case NT_VMS_PATCHTIME:
13456       printf (_("   Patch time: "));
13457       print_vms_time
13458         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13459       printf ("\n");
13460       break;
13461     case NT_VMS_ORIG_DYN:
13462       printf (_("   Major id: %u,  minor id: %u\n"),
13463               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
13464               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
13465       printf (_("   Last modified  : "));
13466       print_vms_time
13467         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
13468       printf (_("\n   Link flags  : "));
13469       printf ("0x%016" BFD_VMA_FMT "x\n",
13470               (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
13471       printf (_("   Header flags: 0x%08x\n"),
13472               (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
13473       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
13474       break;
13475 #endif
13476     case NT_VMS_IMGNAM:
13477       printf (_("    Image name: %s\n"), pnote->descdata);
13478       break;
13479     case NT_VMS_GSTNAM:
13480       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
13481       break;
13482     case NT_VMS_IMGID:
13483       printf (_("    Image id: %s\n"), pnote->descdata);
13484       break;
13485     case NT_VMS_LINKID:
13486       printf (_("    Linker id: %s\n"), pnote->descdata);
13487       break;
13488     default:
13489       break;
13490     }
13491   return 1;
13492 }
13493
13494 /* Note that by the ELF standard, the name field is already null byte
13495    terminated, and namesz includes the terminating null byte.
13496    I.E. the value of namesz for the name "FSF" is 4.
13497
13498    If the value of namesz is zero, there is no name present.  */
13499 static int
13500 process_note (Elf_Internal_Note * pnote)
13501 {
13502   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
13503   const char * nt;
13504
13505   if (pnote->namesz == 0)
13506     /* If there is no note name, then use the default set of
13507        note type strings.  */
13508     nt = get_note_type (pnote->type);
13509
13510   else if (const_strneq (pnote->namedata, "GNU"))
13511     /* GNU-specific object file notes.  */
13512     nt = get_gnu_elf_note_type (pnote->type);
13513
13514   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
13515     /* NetBSD-specific core file notes.  */
13516     nt = get_netbsd_elfcore_note_type (pnote->type);
13517
13518   else if (strneq (pnote->namedata, "SPU/", 4))
13519     {
13520       /* SPU-specific core file notes.  */
13521       nt = pnote->namedata + 4;
13522       name = "SPU";
13523     }
13524
13525   else if (const_strneq (pnote->namedata, "IPF/VMS"))
13526     /* VMS/ia64-specific file notes.  */
13527     nt = get_ia64_vms_note_type (pnote->type);
13528
13529   else if (const_strneq (pnote->namedata, "stapsdt"))
13530     nt = get_stapsdt_note_type (pnote->type);
13531
13532   else
13533     /* Don't recognize this note name; just use the default set of
13534        note type strings.  */
13535     nt = get_note_type (pnote->type);
13536
13537   printf ("  %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
13538
13539   if (const_strneq (pnote->namedata, "IPF/VMS"))
13540     return print_ia64_vms_note (pnote);
13541   else if (const_strneq (pnote->namedata, "GNU"))
13542     return print_gnu_note (pnote);
13543   else if (const_strneq (pnote->namedata, "stapsdt"))
13544     return print_stapsdt_note (pnote);
13545   else if (const_strneq (pnote->namedata, "CORE"))
13546     return print_core_note (pnote);
13547   else
13548     return 1;
13549 }
13550
13551
13552 static int
13553 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
13554 {
13555   Elf_External_Note * pnotes;
13556   Elf_External_Note * external;
13557   int res = 1;
13558
13559   if (length <= 0)
13560     return 0;
13561
13562   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
13563                                            _("notes"));
13564   if (pnotes == NULL)
13565     return 0;
13566
13567   external = pnotes;
13568
13569   printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
13570           (unsigned long) offset, (unsigned long) length);
13571   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
13572
13573   while ((char *) external < (char *) pnotes + length)
13574     {
13575       Elf_Internal_Note inote;
13576       size_t min_notesz;
13577       char *next;
13578       char * temp = NULL;
13579       size_t data_remaining = ((char *) pnotes + length) - (char *) external;
13580
13581       if (!is_ia64_vms ())
13582         {
13583           /* PR binutils/15191
13584              Make sure that there is enough data to read.  */
13585           min_notesz = offsetof (Elf_External_Note, name);
13586           if (data_remaining < min_notesz)
13587             {
13588               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13589                     (int) data_remaining);
13590               break;
13591             }
13592           inote.type     = BYTE_GET (external->type);
13593           inote.namesz   = BYTE_GET (external->namesz);
13594           inote.namedata = external->name;
13595           inote.descsz   = BYTE_GET (external->descsz);
13596           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
13597           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
13598           next = inote.descdata + align_power (inote.descsz, 2);
13599         }
13600       else
13601         {
13602           Elf64_External_VMS_Note *vms_external;
13603
13604           /* PR binutils/15191
13605              Make sure that there is enough data to read.  */
13606           min_notesz = offsetof (Elf64_External_VMS_Note, name);
13607           if (data_remaining < min_notesz)
13608             {
13609               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13610                     (int) data_remaining);
13611               break;
13612             }
13613
13614           vms_external = (Elf64_External_VMS_Note *) external;
13615           inote.type     = BYTE_GET (vms_external->type);
13616           inote.namesz   = BYTE_GET (vms_external->namesz);
13617           inote.namedata = vms_external->name;
13618           inote.descsz   = BYTE_GET (vms_external->descsz);
13619           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
13620           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
13621           next = inote.descdata + align_power (inote.descsz, 3);
13622         }
13623
13624       if (inote.descdata < (char *) external + min_notesz
13625           || next < (char *) external + min_notesz
13626           || data_remaining < (size_t)(next - (char *) external))
13627         {
13628           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
13629                 (unsigned long) ((char *) external - (char *) pnotes));
13630           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
13631                 inote.type, inote.namesz, inote.descsz);
13632           break;
13633         }
13634
13635       external = (Elf_External_Note *) next;
13636
13637       /* Verify that name is null terminated.  It appears that at least
13638          one version of Linux (RedHat 6.0) generates corefiles that don't
13639          comply with the ELF spec by failing to include the null byte in
13640          namesz.  */
13641       if (inote.namedata[inote.namesz - 1] != '\0')
13642         {
13643           temp = (char *) malloc (inote.namesz + 1);
13644
13645           if (temp == NULL)
13646             {
13647               error (_("Out of memory\n"));
13648               res = 0;
13649               break;
13650             }
13651
13652           strncpy (temp, inote.namedata, inote.namesz);
13653           temp[inote.namesz] = 0;
13654
13655           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
13656           inote.namedata = temp;
13657         }
13658
13659       res &= process_note (& inote);
13660
13661       if (temp != NULL)
13662         {
13663           free (temp);
13664           temp = NULL;
13665         }
13666     }
13667
13668   free (pnotes);
13669
13670   return res;
13671 }
13672
13673 static int
13674 process_corefile_note_segments (FILE * file)
13675 {
13676   Elf_Internal_Phdr * segment;
13677   unsigned int i;
13678   int res = 1;
13679
13680   if (! get_program_headers (file))
13681       return 0;
13682
13683   for (i = 0, segment = program_headers;
13684        i < elf_header.e_phnum;
13685        i++, segment++)
13686     {
13687       if (segment->p_type == PT_NOTE)
13688         res &= process_corefile_note_segment (file,
13689                                               (bfd_vma) segment->p_offset,
13690                                               (bfd_vma) segment->p_filesz);
13691     }
13692
13693   return res;
13694 }
13695
13696 static int
13697 process_note_sections (FILE * file)
13698 {
13699   Elf_Internal_Shdr * section;
13700   unsigned long i;
13701   int res = 1;
13702
13703   for (i = 0, section = section_headers;
13704        i < elf_header.e_shnum && section != NULL;
13705        i++, section++)
13706     if (section->sh_type == SHT_NOTE)
13707       res &= process_corefile_note_segment (file,
13708                                             (bfd_vma) section->sh_offset,
13709                                             (bfd_vma) section->sh_size);
13710
13711   return res;
13712 }
13713
13714 static int
13715 process_notes (FILE * file)
13716 {
13717   /* If we have not been asked to display the notes then do nothing.  */
13718   if (! do_notes)
13719     return 1;
13720
13721   if (elf_header.e_type != ET_CORE)
13722     return process_note_sections (file);
13723
13724   /* No program headers means no NOTE segment.  */
13725   if (elf_header.e_phnum > 0)
13726     return process_corefile_note_segments (file);
13727
13728   printf (_("No note segments present in the core file.\n"));
13729   return 1;
13730 }
13731
13732 static int
13733 process_arch_specific (FILE * file)
13734 {
13735   if (! do_arch)
13736     return 1;
13737
13738   switch (elf_header.e_machine)
13739     {
13740     case EM_ARM:
13741       return process_arm_specific (file);
13742     case EM_MIPS:
13743     case EM_MIPS_RS3_LE:
13744       return process_mips_specific (file);
13745       break;
13746     case EM_PPC:
13747       return process_power_specific (file);
13748       break;
13749     case EM_SPARC:
13750     case EM_SPARC32PLUS:
13751     case EM_SPARCV9:
13752       return process_sparc_specific (file);
13753       break;
13754     case EM_TI_C6000:
13755       return process_tic6x_specific (file);
13756       break;
13757     case EM_MSP430:
13758       return process_msp430x_specific (file);
13759     default:
13760       break;
13761     }
13762   return 1;
13763 }
13764
13765 static int
13766 get_file_header (FILE * file)
13767 {
13768   /* Read in the identity array.  */
13769   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
13770     return 0;
13771
13772   /* Determine how to read the rest of the header.  */
13773   switch (elf_header.e_ident[EI_DATA])
13774     {
13775     default: /* fall through */
13776     case ELFDATANONE: /* fall through */
13777     case ELFDATA2LSB:
13778       byte_get = byte_get_little_endian;
13779       byte_put = byte_put_little_endian;
13780       break;
13781     case ELFDATA2MSB:
13782       byte_get = byte_get_big_endian;
13783       byte_put = byte_put_big_endian;
13784       break;
13785     }
13786
13787   /* For now we only support 32 bit and 64 bit ELF files.  */
13788   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
13789
13790   /* Read in the rest of the header.  */
13791   if (is_32bit_elf)
13792     {
13793       Elf32_External_Ehdr ehdr32;
13794
13795       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
13796         return 0;
13797
13798       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
13799       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
13800       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
13801       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
13802       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
13803       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
13804       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
13805       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
13806       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
13807       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
13808       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
13809       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
13810       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
13811     }
13812   else
13813     {
13814       Elf64_External_Ehdr ehdr64;
13815
13816       /* If we have been compiled with sizeof (bfd_vma) == 4, then
13817          we will not be able to cope with the 64bit data found in
13818          64 ELF files.  Detect this now and abort before we start
13819          overwriting things.  */
13820       if (sizeof (bfd_vma) < 8)
13821         {
13822           error (_("This instance of readelf has been built without support for a\n\
13823 64 bit data type and so it cannot read 64 bit ELF files.\n"));
13824           return 0;
13825         }
13826
13827       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
13828         return 0;
13829
13830       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
13831       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
13832       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
13833       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
13834       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
13835       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
13836       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
13837       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
13838       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
13839       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
13840       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
13841       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
13842       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
13843     }
13844
13845   if (elf_header.e_shoff)
13846     {
13847       /* There may be some extensions in the first section header.  Don't
13848          bomb if we can't read it.  */
13849       if (is_32bit_elf)
13850         get_32bit_section_headers (file, 1);
13851       else
13852         get_64bit_section_headers (file, 1);
13853     }
13854
13855   return 1;
13856 }
13857
13858 /* Process one ELF object file according to the command line options.
13859    This file may actually be stored in an archive.  The file is
13860    positioned at the start of the ELF object.  */
13861
13862 static int
13863 process_object (char * file_name, FILE * file)
13864 {
13865   unsigned int i;
13866
13867   if (! get_file_header (file))
13868     {
13869       error (_("%s: Failed to read file header\n"), file_name);
13870       return 1;
13871     }
13872
13873   /* Initialise per file variables.  */
13874   for (i = ARRAY_SIZE (version_info); i--;)
13875     version_info[i] = 0;
13876
13877   for (i = ARRAY_SIZE (dynamic_info); i--;)
13878     dynamic_info[i] = 0;
13879   dynamic_info_DT_GNU_HASH = 0;
13880
13881   /* Process the file.  */
13882   if (show_name)
13883     printf (_("\nFile: %s\n"), file_name);
13884
13885   /* Initialise the dump_sects array from the cmdline_dump_sects array.
13886      Note we do this even if cmdline_dump_sects is empty because we
13887      must make sure that the dump_sets array is zeroed out before each
13888      object file is processed.  */
13889   if (num_dump_sects > num_cmdline_dump_sects)
13890     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
13891
13892   if (num_cmdline_dump_sects > 0)
13893     {
13894       if (num_dump_sects == 0)
13895         /* A sneaky way of allocating the dump_sects array.  */
13896         request_dump_bynumber (num_cmdline_dump_sects, 0);
13897
13898       assert (num_dump_sects >= num_cmdline_dump_sects);
13899       memcpy (dump_sects, cmdline_dump_sects,
13900               num_cmdline_dump_sects * sizeof (* dump_sects));
13901     }
13902
13903   if (! process_file_header ())
13904     return 1;
13905
13906   if (! process_section_headers (file))
13907     {
13908       /* Without loaded section headers we cannot process lots of
13909          things.  */
13910       do_unwind = do_version = do_dump = do_arch = 0;
13911
13912       if (! do_using_dynamic)
13913         do_syms = do_dyn_syms = do_reloc = 0;
13914     }
13915
13916   if (! process_section_groups (file))
13917     {
13918       /* Without loaded section groups we cannot process unwind.  */
13919       do_unwind = 0;
13920     }
13921
13922   if (process_program_headers (file))
13923     process_dynamic_section (file);
13924
13925   process_relocs (file);
13926
13927   process_unwind (file);
13928
13929   process_symbol_table (file);
13930
13931   process_syminfo (file);
13932
13933   process_version_sections (file);
13934
13935   process_section_contents (file);
13936
13937   process_notes (file);
13938
13939   process_gnu_liblist (file);
13940
13941   process_arch_specific (file);
13942
13943   if (program_headers)
13944     {
13945       free (program_headers);
13946       program_headers = NULL;
13947     }
13948
13949   if (section_headers)
13950     {
13951       free (section_headers);
13952       section_headers = NULL;
13953     }
13954
13955   if (string_table)
13956     {
13957       free (string_table);
13958       string_table = NULL;
13959       string_table_length = 0;
13960     }
13961
13962   if (dynamic_strings)
13963     {
13964       free (dynamic_strings);
13965       dynamic_strings = NULL;
13966       dynamic_strings_length = 0;
13967     }
13968
13969   if (dynamic_symbols)
13970     {
13971       free (dynamic_symbols);
13972       dynamic_symbols = NULL;
13973       num_dynamic_syms = 0;
13974     }
13975
13976   if (dynamic_syminfo)
13977     {
13978       free (dynamic_syminfo);
13979       dynamic_syminfo = NULL;
13980     }
13981
13982   if (dynamic_section)
13983     {
13984       free (dynamic_section);
13985       dynamic_section = NULL;
13986     }
13987
13988   if (section_headers_groups)
13989     {
13990       free (section_headers_groups);
13991       section_headers_groups = NULL;
13992     }
13993
13994   if (section_groups)
13995     {
13996       struct group_list * g;
13997       struct group_list * next;
13998
13999       for (i = 0; i < group_count; i++)
14000         {
14001           for (g = section_groups [i].root; g != NULL; g = next)
14002             {
14003               next = g->next;
14004               free (g);
14005             }
14006         }
14007
14008       free (section_groups);
14009       section_groups = NULL;
14010     }
14011
14012   free_debug_memory ();
14013
14014   return 0;
14015 }
14016
14017 /* Process an ELF archive.
14018    On entry the file is positioned just after the ARMAG string.  */
14019
14020 static int
14021 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
14022 {
14023   struct archive_info arch;
14024   struct archive_info nested_arch;
14025   size_t got;
14026   int ret;
14027
14028   show_name = 1;
14029
14030   /* The ARCH structure is used to hold information about this archive.  */
14031   arch.file_name = NULL;
14032   arch.file = NULL;
14033   arch.index_array = NULL;
14034   arch.sym_table = NULL;
14035   arch.longnames = NULL;
14036
14037   /* The NESTED_ARCH structure is used as a single-item cache of information
14038      about a nested archive (when members of a thin archive reside within
14039      another regular archive file).  */
14040   nested_arch.file_name = NULL;
14041   nested_arch.file = NULL;
14042   nested_arch.index_array = NULL;
14043   nested_arch.sym_table = NULL;
14044   nested_arch.longnames = NULL;
14045
14046   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
14047     {
14048       ret = 1;
14049       goto out;
14050     }
14051
14052   if (do_archive_index)
14053     {
14054       if (arch.sym_table == NULL)
14055         error (_("%s: unable to dump the index as none was found\n"), file_name);
14056       else
14057         {
14058           unsigned int i, l;
14059           unsigned long current_pos;
14060
14061           printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
14062                   file_name, (long) arch.index_num, arch.sym_size);
14063           current_pos = ftell (file);
14064
14065           for (i = l = 0; i < arch.index_num; i++)
14066             {
14067               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
14068                 {
14069                   char * member_name;
14070
14071                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
14072
14073                   if (member_name != NULL)
14074                     {
14075                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
14076
14077                       if (qualified_name != NULL)
14078                         {
14079                           printf (_("Contents of binary %s at offset "), qualified_name);
14080                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
14081                           putchar ('\n');
14082                           free (qualified_name);
14083                         }
14084                     }
14085                 }
14086
14087               if (l >= arch.sym_size)
14088                 {
14089                   error (_("%s: end of the symbol table reached before the end of the index\n"),
14090                          file_name);
14091                   break;
14092                 }
14093               printf ("\t%s\n", arch.sym_table + l);
14094               l += strlen (arch.sym_table + l) + 1;
14095             }
14096
14097           if (arch.uses_64bit_indicies)
14098             l = (l + 7) & ~ 7;
14099           else
14100             l += l & 1;
14101
14102           if (l < arch.sym_size)
14103             error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
14104                    file_name, arch.sym_size - l);
14105
14106           if (fseek (file, current_pos, SEEK_SET) != 0)
14107             {
14108               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
14109               ret = 1;
14110               goto out;
14111             }
14112         }
14113
14114       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
14115           && !do_segments && !do_header && !do_dump && !do_version
14116           && !do_histogram && !do_debugging && !do_arch && !do_notes
14117           && !do_section_groups && !do_dyn_syms)
14118         {
14119           ret = 0; /* Archive index only.  */
14120           goto out;
14121         }
14122     }
14123
14124   ret = 0;
14125
14126   while (1)
14127     {
14128       char * name;
14129       size_t namelen;
14130       char * qualified_name;
14131
14132       /* Read the next archive header.  */
14133       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
14134         {
14135           error (_("%s: failed to seek to next archive header\n"), file_name);
14136           return 1;
14137         }
14138       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
14139       if (got != sizeof arch.arhdr)
14140         {
14141           if (got == 0)
14142             break;
14143           error (_("%s: failed to read archive header\n"), file_name);
14144           ret = 1;
14145           break;
14146         }
14147       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
14148         {
14149           error (_("%s: did not find a valid archive header\n"), arch.file_name);
14150           ret = 1;
14151           break;
14152         }
14153
14154       arch.next_arhdr_offset += sizeof arch.arhdr;
14155
14156       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
14157       if (archive_file_size & 01)
14158         ++archive_file_size;
14159
14160       name = get_archive_member_name (&arch, &nested_arch);
14161       if (name == NULL)
14162         {
14163           error (_("%s: bad archive file name\n"), file_name);
14164           ret = 1;
14165           break;
14166         }
14167       namelen = strlen (name);
14168
14169       qualified_name = make_qualified_name (&arch, &nested_arch, name);
14170       if (qualified_name == NULL)
14171         {
14172           error (_("%s: bad archive file name\n"), file_name);
14173           ret = 1;
14174           break;
14175         }
14176
14177       if (is_thin_archive && arch.nested_member_origin == 0)
14178         {
14179           /* This is a proxy for an external member of a thin archive.  */
14180           FILE * member_file;
14181           char * member_file_name = adjust_relative_path (file_name, name, namelen);
14182           if (member_file_name == NULL)
14183             {
14184               ret = 1;
14185               break;
14186             }
14187
14188           member_file = fopen (member_file_name, "rb");
14189           if (member_file == NULL)
14190             {
14191               error (_("Input file '%s' is not readable.\n"), member_file_name);
14192               free (member_file_name);
14193               ret = 1;
14194               break;
14195             }
14196
14197           archive_file_offset = arch.nested_member_origin;
14198
14199           ret |= process_object (qualified_name, member_file);
14200
14201           fclose (member_file);
14202           free (member_file_name);
14203         }
14204       else if (is_thin_archive)
14205         {
14206           /* PR 15140: Allow for corrupt thin archives.  */
14207           if (nested_arch.file == NULL)
14208             {
14209               error (_("%s: contains corrupt thin archive: %s\n"),
14210                      file_name, name);
14211               ret = 1;
14212               break;
14213             }
14214
14215           /* This is a proxy for a member of a nested archive.  */
14216           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
14217
14218           /* The nested archive file will have been opened and setup by
14219              get_archive_member_name.  */
14220           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
14221             {
14222               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
14223               ret = 1;
14224               break;
14225             }
14226
14227           ret |= process_object (qualified_name, nested_arch.file);
14228         }
14229       else
14230         {
14231           archive_file_offset = arch.next_arhdr_offset;
14232           arch.next_arhdr_offset += archive_file_size;
14233
14234           ret |= process_object (qualified_name, file);
14235         }
14236
14237       if (dump_sects != NULL)
14238         {
14239           free (dump_sects);
14240           dump_sects = NULL;
14241           num_dump_sects = 0;
14242         }
14243
14244       free (qualified_name);
14245     }
14246
14247  out:
14248   if (nested_arch.file != NULL)
14249     fclose (nested_arch.file);
14250   release_archive (&nested_arch);
14251   release_archive (&arch);
14252
14253   return ret;
14254 }
14255
14256 static int
14257 process_file (char * file_name)
14258 {
14259   FILE * file;
14260   struct stat statbuf;
14261   char armag[SARMAG];
14262   int ret;
14263
14264   if (stat (file_name, &statbuf) < 0)
14265     {
14266       if (errno == ENOENT)
14267         error (_("'%s': No such file\n"), file_name);
14268       else
14269         error (_("Could not locate '%s'.  System error message: %s\n"),
14270                file_name, strerror (errno));
14271       return 1;
14272     }
14273
14274   if (! S_ISREG (statbuf.st_mode))
14275     {
14276       error (_("'%s' is not an ordinary file\n"), file_name);
14277       return 1;
14278     }
14279
14280   file = fopen (file_name, "rb");
14281   if (file == NULL)
14282     {
14283       error (_("Input file '%s' is not readable.\n"), file_name);
14284       return 1;
14285     }
14286
14287   if (fread (armag, SARMAG, 1, file) != 1)
14288     {
14289       error (_("%s: Failed to read file's magic number\n"), file_name);
14290       fclose (file);
14291       return 1;
14292     }
14293
14294   if (memcmp (armag, ARMAG, SARMAG) == 0)
14295     ret = process_archive (file_name, file, FALSE);
14296   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
14297     ret = process_archive (file_name, file, TRUE);
14298   else
14299     {
14300       if (do_archive_index)
14301         error (_("File %s is not an archive so its index cannot be displayed.\n"),
14302                file_name);
14303
14304       rewind (file);
14305       archive_file_size = archive_file_offset = 0;
14306       ret = process_object (file_name, file);
14307     }
14308
14309   fclose (file);
14310
14311   return ret;
14312 }
14313
14314 #ifdef SUPPORT_DISASSEMBLY
14315 /* Needed by the i386 disassembler.  For extra credit, someone could
14316    fix this so that we insert symbolic addresses here, esp for GOT/PLT
14317    symbols.  */
14318
14319 void
14320 print_address (unsigned int addr, FILE * outfile)
14321 {
14322   fprintf (outfile,"0x%8.8x", addr);
14323 }
14324
14325 /* Needed by the i386 disassembler.  */
14326 void
14327 db_task_printsym (unsigned int addr)
14328 {
14329   print_address (addr, stderr);
14330 }
14331 #endif
14332
14333 int
14334 main (int argc, char ** argv)
14335 {
14336   int err;
14337
14338 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14339   setlocale (LC_MESSAGES, "");
14340 #endif
14341 #if defined (HAVE_SETLOCALE)
14342   setlocale (LC_CTYPE, "");
14343 #endif
14344   bindtextdomain (PACKAGE, LOCALEDIR);
14345   textdomain (PACKAGE);
14346
14347   expandargv (&argc, &argv);
14348
14349   parse_args (argc, argv);
14350
14351   if (num_dump_sects > 0)
14352     {
14353       /* Make a copy of the dump_sects array.  */
14354       cmdline_dump_sects = (dump_type *)
14355           malloc (num_dump_sects * sizeof (* dump_sects));
14356       if (cmdline_dump_sects == NULL)
14357         error (_("Out of memory allocating dump request table.\n"));
14358       else
14359         {
14360           memcpy (cmdline_dump_sects, dump_sects,
14361                   num_dump_sects * sizeof (* dump_sects));
14362           num_cmdline_dump_sects = num_dump_sects;
14363         }
14364     }
14365
14366   if (optind < (argc - 1))
14367     show_name = 1;
14368
14369   err = 0;
14370   while (optind < argc)
14371     err |= process_file (argv[optind++]);
14372
14373   if (dump_sects != NULL)
14374     free (dump_sects);
14375   if (cmdline_dump_sects != NULL)
14376     free (cmdline_dump_sects);
14377
14378   return err;
14379 }