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