binutils/readelf.c

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