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           putchar ('\n');
4742           if (is_32bit_elf || do_wide)
4743             printf ("       %-15.15s ",
4744                     get_section_type_name (section->sh_type));
4745         }
4746       else
4747         {
4748           print_symbol (-17, SECTION_NAME (section));
4749           printf (" %-15.15s ",
4750                   get_section_type_name (section->sh_type));
4751         }
4752
4753       if (is_32bit_elf)
4754         {
4755           const char * link_too_big = NULL;
4756
4757           print_vma (section->sh_addr, LONG_HEX);
4758
4759           printf ( " %6.6lx %6.6lx %2.2lx",
4760                    (unsigned long) section->sh_offset,
4761                    (unsigned long) section->sh_size,
4762                    (unsigned long) section->sh_entsize);
4763
4764           if (do_section_details)
4765             fputs ("  ", stdout);
4766           else
4767             printf (" %3s ", get_elf_section_flags (section->sh_flags));
4768
4769           if (section->sh_link >= elf_header.e_shnum)
4770             {
4771               link_too_big = "";
4772               /* The sh_link value is out of range.  Normally this indicates
4773                  an error but it can have special values in Solaris binaries.  */
4774               switch (elf_header.e_machine)
4775                 {
4776                 case EM_386:
4777                 case EM_486:
4778                 case EM_X86_64:
4779                 case EM_L1OM:
4780                 case EM_K1OM:
4781                 case EM_OLD_SPARCV9:
4782                 case EM_SPARC32PLUS:
4783                 case EM_SPARCV9:
4784                 case EM_SPARC:
4785                   if (section->sh_link == (SHN_BEFORE & 0xffff))
4786                     link_too_big = "BEFORE";
4787                   else if (section->sh_link == (SHN_AFTER & 0xffff))
4788                     link_too_big = "AFTER";
4789                   break;
4790                 default:
4791                   break;
4792                 }
4793             }
4794
4795           if (do_section_details)
4796             {
4797               if (link_too_big != NULL && * link_too_big)
4798                 printf ("<%s> ", link_too_big);
4799               else
4800                 printf ("%2u ", section->sh_link);
4801               printf ("%3u %2lu\n", section->sh_info,
4802                       (unsigned long) section->sh_addralign);
4803             }
4804           else
4805             printf ("%2u %3u %2lu\n",
4806                     section->sh_link,
4807                     section->sh_info,
4808                     (unsigned long) section->sh_addralign);
4809
4810           if (link_too_big && ! * link_too_big)
4811             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4812                   i, section->sh_link);
4813         }
4814       else if (do_wide)
4815         {
4816           print_vma (section->sh_addr, LONG_HEX);
4817
4818           if ((long) section->sh_offset == section->sh_offset)
4819             printf (" %6.6lx", (unsigned long) section->sh_offset);
4820           else
4821             {
4822               putchar (' ');
4823               print_vma (section->sh_offset, LONG_HEX);
4824             }
4825
4826           if ((unsigned long) section->sh_size == section->sh_size)
4827             printf (" %6.6lx", (unsigned long) section->sh_size);
4828           else
4829             {
4830               putchar (' ');
4831               print_vma (section->sh_size, LONG_HEX);
4832             }
4833
4834           if ((unsigned long) section->sh_entsize == section->sh_entsize)
4835             printf (" %2.2lx", (unsigned long) section->sh_entsize);
4836           else
4837             {
4838               putchar (' ');
4839               print_vma (section->sh_entsize, LONG_HEX);
4840             }
4841
4842           if (do_section_details)
4843             fputs ("  ", stdout);
4844           else
4845             printf (" %3s ", get_elf_section_flags (section->sh_flags));
4846
4847           printf ("%2u %3u ", section->sh_link, section->sh_info);
4848
4849           if ((unsigned long) section->sh_addralign == section->sh_addralign)
4850             printf ("%2lu\n", (unsigned long) section->sh_addralign);
4851           else
4852             {
4853               print_vma (section->sh_addralign, DEC);
4854               putchar ('\n');
4855             }
4856         }
4857       else if (do_section_details)
4858         {
4859           printf ("       %-15.15s  ",
4860                   get_section_type_name (section->sh_type));
4861           print_vma (section->sh_addr, LONG_HEX);
4862           if ((long) section->sh_offset == section->sh_offset)
4863             printf ("  %16.16lx", (unsigned long) section->sh_offset);
4864           else
4865             {
4866               printf ("  ");
4867               print_vma (section->sh_offset, LONG_HEX);
4868             }
4869           printf ("  %u\n       ", section->sh_link);
4870           print_vma (section->sh_size, LONG_HEX);
4871           putchar (' ');
4872           print_vma (section->sh_entsize, LONG_HEX);
4873
4874           printf ("  %-16u  %lu\n",
4875                   section->sh_info,
4876                   (unsigned long) section->sh_addralign);
4877         }
4878       else
4879         {
4880           putchar (' ');
4881           print_vma (section->sh_addr, LONG_HEX);
4882           if ((long) section->sh_offset == section->sh_offset)
4883             printf ("  %8.8lx", (unsigned long) section->sh_offset);
4884           else
4885             {
4886               printf ("  ");
4887               print_vma (section->sh_offset, LONG_HEX);
4888             }
4889           printf ("\n       ");
4890           print_vma (section->sh_size, LONG_HEX);
4891           printf ("  ");
4892           print_vma (section->sh_entsize, LONG_HEX);
4893
4894           printf (" %3s ", get_elf_section_flags (section->sh_flags));
4895
4896           printf ("     %2u   %3u     %lu\n",
4897                   section->sh_link,
4898                   section->sh_info,
4899                   (unsigned long) section->sh_addralign);
4900         }
4901
4902       if (do_section_details)
4903         printf ("       %s\n", get_elf_section_flags (section->sh_flags));
4904     }
4905
4906   if (!do_section_details)
4907     {
4908       if (elf_header.e_machine == EM_X86_64
4909           || elf_header.e_machine == EM_L1OM
4910           || elf_header.e_machine == EM_K1OM)
4911         printf (_("Key to Flags:\n\
4912   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
4913   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4914   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4915       else
4916         printf (_("Key to Flags:\n\
4917   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4918   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4919   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4920     }
4921
4922   return 1;
4923 }
4924
4925 static const char *
4926 get_group_flags (unsigned int flags)
4927 {
4928   static char buff[32];
4929   switch (flags)
4930     {
4931     case 0:
4932       return "";
4933
4934     case GRP_COMDAT:
4935       return "COMDAT ";
4936
4937    default:
4938       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
4939       break;
4940     }
4941   return buff;
4942 }
4943
4944 static int
4945 process_section_groups (FILE * file)
4946 {
4947   Elf_Internal_Shdr * section;
4948   unsigned int i;
4949   struct group * group;
4950   Elf_Internal_Shdr * symtab_sec;
4951   Elf_Internal_Shdr * strtab_sec;
4952   Elf_Internal_Sym * symtab;
4953   unsigned long num_syms;
4954   char * strtab;
4955   size_t strtab_size;
4956
4957   /* Don't process section groups unless needed.  */
4958   if (!do_unwind && !do_section_groups)
4959     return 1;
4960
4961   if (elf_header.e_shnum == 0)
4962     {
4963       if (do_section_groups)
4964         printf (_("\nThere are no sections to group in this file.\n"));
4965
4966       return 1;
4967     }
4968
4969   if (section_headers == NULL)
4970     {
4971       error (_("Section headers are not available!\n"));
4972       /* PR 13622: This can happen with a corrupt ELF header.  */
4973       return 0;
4974     }
4975
4976   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
4977                                                      sizeof (struct group *));
4978
4979   if (section_headers_groups == NULL)
4980     {
4981       error (_("Out of memory\n"));
4982       return 0;
4983     }
4984
4985   /* Scan the sections for the group section.  */
4986   group_count = 0;
4987   for (i = 0, section = section_headers;
4988        i < elf_header.e_shnum;
4989        i++, section++)
4990     if (section->sh_type == SHT_GROUP)
4991       group_count++;
4992
4993   if (group_count == 0)
4994     {
4995       if (do_section_groups)
4996         printf (_("\nThere are no section groups in this file.\n"));
4997
4998       return 1;
4999     }
5000
5001   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5002
5003   if (section_groups == NULL)
5004     {
5005       error (_("Out of memory\n"));
5006       return 0;
5007     }
5008
5009   symtab_sec = NULL;
5010   strtab_sec = NULL;
5011   symtab = NULL;
5012   num_syms = 0;
5013   strtab = NULL;
5014   strtab_size = 0;
5015   for (i = 0, section = section_headers, group = section_groups;
5016        i < elf_header.e_shnum;
5017        i++, section++)
5018     {
5019       if (section->sh_type == SHT_GROUP)
5020         {
5021           char * name = SECTION_NAME (section);
5022           char * group_name;
5023           unsigned char * start;
5024           unsigned char * indices;
5025           unsigned int entry, j, size;
5026           Elf_Internal_Shdr * sec;
5027           Elf_Internal_Sym * sym;
5028
5029           /* Get the symbol table.  */
5030           if (section->sh_link >= elf_header.e_shnum
5031               || ((sec = section_headers + section->sh_link)->sh_type
5032                   != SHT_SYMTAB))
5033             {
5034               error (_("Bad sh_link in group section `%s'\n"), name);
5035               continue;
5036             }
5037
5038           if (symtab_sec != sec)
5039             {
5040               symtab_sec = sec;
5041               if (symtab)
5042                 free (symtab);
5043               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5044             }
5045
5046           if (symtab == NULL)
5047             {
5048               error (_("Corrupt header in group section `%s'\n"), name);
5049               continue;
5050             }
5051
5052           if (section->sh_info >= num_syms)
5053             {
5054               error (_("Bad sh_info in group section `%s'\n"), name);
5055               continue;
5056             }
5057
5058           sym = symtab + section->sh_info;
5059
5060           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5061             {
5062               if (sym->st_shndx == 0
5063                   || sym->st_shndx >= elf_header.e_shnum)
5064                 {
5065                   error (_("Bad sh_info in group section `%s'\n"), name);
5066                   continue;
5067                 }
5068
5069               group_name = SECTION_NAME (section_headers + sym->st_shndx);
5070               strtab_sec = NULL;
5071               if (strtab)
5072                 free (strtab);
5073               strtab = NULL;
5074               strtab_size = 0;
5075             }
5076           else
5077             {
5078               /* Get the string table.  */
5079               if (symtab_sec->sh_link >= elf_header.e_shnum)
5080                 {
5081                   strtab_sec = NULL;
5082                   if (strtab)
5083                     free (strtab);
5084                   strtab = NULL;
5085                   strtab_size = 0;
5086                 }
5087               else if (strtab_sec
5088                        != (sec = section_headers + symtab_sec->sh_link))
5089                 {
5090                   strtab_sec = sec;
5091                   if (strtab)
5092                     free (strtab);
5093                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5094                                               1, strtab_sec->sh_size,
5095                                               _("string table"));
5096                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5097                 }
5098               group_name = sym->st_name < strtab_size
5099                 ? strtab + sym->st_name : _("<corrupt>");
5100             }
5101
5102           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5103                                               1, section->sh_size,
5104                                               _("section data"));
5105           if (start == NULL)
5106             continue;
5107
5108           indices = start;
5109           size = (section->sh_size / section->sh_entsize) - 1;
5110           entry = byte_get (indices, 4);
5111           indices += 4;
5112
5113           if (do_section_groups)
5114             {
5115               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5116                       get_group_flags (entry), i, name, group_name, size);
5117
5118               printf (_("   [Index]    Name\n"));
5119             }
5120
5121           group->group_index = i;
5122
5123           for (j = 0; j < size; j++)
5124             {
5125               struct group_list * g;
5126
5127               entry = byte_get (indices, 4);
5128               indices += 4;
5129
5130               if (entry >= elf_header.e_shnum)
5131                 {
5132                   error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5133                          entry, i, elf_header.e_shnum - 1);
5134                   continue;
5135                 }
5136
5137               if (section_headers_groups [entry] != NULL)
5138                 {
5139                   if (entry)
5140                     {
5141                       error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5142                              entry, i,
5143                              section_headers_groups [entry]->group_index);
5144                       continue;
5145                     }
5146                   else
5147                     {
5148                       /* Intel C/C++ compiler may put section 0 in a
5149                          section group. We just warn it the first time
5150                          and ignore it afterwards.  */
5151                       static int warned = 0;
5152                       if (!warned)
5153                         {
5154                           error (_("section 0 in group section [%5u]\n"),
5155                                  section_headers_groups [entry]->group_index);
5156                           warned++;
5157                         }
5158                     }
5159                 }
5160
5161               section_headers_groups [entry] = group;
5162
5163               if (do_section_groups)
5164                 {
5165                   sec = section_headers + entry;
5166                   printf ("   [%5u]   %s\n", entry, SECTION_NAME (sec));
5167                 }
5168
5169               g = (struct group_list *) xmalloc (sizeof (struct group_list));
5170               g->section_index = entry;
5171               g->next = group->root;
5172               group->root = g;
5173             }
5174
5175           if (start)
5176             free (start);
5177
5178           group++;
5179         }
5180     }
5181
5182   if (symtab)
5183     free (symtab);
5184   if (strtab)
5185     free (strtab);
5186   return 1;
5187 }
5188
5189 /* Data used to display dynamic fixups.  */
5190
5191 struct ia64_vms_dynfixup
5192 {
5193   bfd_vma needed_ident;         /* Library ident number.  */
5194   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
5195   bfd_vma fixup_needed;         /* Index of the library.  */
5196   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
5197   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
5198 };
5199
5200 /* Data used to display dynamic relocations.  */
5201
5202 struct ia64_vms_dynimgrela
5203 {
5204   bfd_vma img_rela_cnt;         /* Number of relocations.  */
5205   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
5206 };
5207
5208 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5209    library).  */
5210
5211 static void
5212 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5213                               const char *strtab, unsigned int strtab_sz)
5214 {
5215   Elf64_External_VMS_IMAGE_FIXUP *imfs;
5216   long i;
5217   const char *lib_name;
5218
5219   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5220                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
5221                    _("dynamic section image fixups"));
5222   if (!imfs)
5223     return;
5224
5225   if (fixup->needed < strtab_sz)
5226     lib_name = strtab + fixup->needed;
5227   else
5228     {
5229       warn ("corrupt library name index of 0x%lx found in dynamic entry",
5230             (unsigned long) fixup->needed);
5231       lib_name = "???";
5232     }
5233   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5234           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5235   printf
5236     (_("Seg Offset           Type                             SymVec DataType\n"));
5237
5238   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5239     {
5240       unsigned int type;
5241       const char *rtype;
5242
5243       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5244       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5245       type = BYTE_GET (imfs [i].type);
5246       rtype = elf_ia64_reloc_type (type);
5247       if (rtype == NULL)
5248         printf (" 0x%08x                       ", type);
5249       else
5250         printf (" %-32s ", rtype);
5251       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5252       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5253     }
5254
5255   free (imfs);
5256 }
5257
5258 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
5259
5260 static void
5261 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5262 {
5263   Elf64_External_VMS_IMAGE_RELA *imrs;
5264   long i;
5265
5266   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5267                    1, imgrela->img_rela_cnt * sizeof (*imrs),
5268                    _("dynamic section image relocations"));
5269   if (!imrs)
5270     return;
5271
5272   printf (_("\nImage relocs\n"));
5273   printf
5274     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
5275
5276   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5277     {
5278       unsigned int type;
5279       const char *rtype;
5280
5281       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5282       printf ("%08" BFD_VMA_FMT "x ",
5283               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5284       type = BYTE_GET (imrs [i].type);
5285       rtype = elf_ia64_reloc_type (type);
5286       if (rtype == NULL)
5287         printf ("0x%08x                      ", type);
5288       else
5289         printf ("%-31s ", rtype);
5290       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5291       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5292       printf ("%08" BFD_VMA_FMT "x\n",
5293               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5294     }
5295
5296   free (imrs);
5297 }
5298
5299 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
5300
5301 static int
5302 process_ia64_vms_dynamic_relocs (FILE *file)
5303 {
5304   struct ia64_vms_dynfixup fixup;
5305   struct ia64_vms_dynimgrela imgrela;
5306   Elf_Internal_Dyn *entry;
5307   int res = 0;
5308   bfd_vma strtab_off = 0;
5309   bfd_vma strtab_sz = 0;
5310   char *strtab = NULL;
5311
5312   memset (&fixup, 0, sizeof (fixup));
5313   memset (&imgrela, 0, sizeof (imgrela));
5314
5315   /* Note: the order of the entries is specified by the OpenVMS specs.  */
5316   for (entry = dynamic_section;
5317        entry < dynamic_section + dynamic_nent;
5318        entry++)
5319     {
5320       switch (entry->d_tag)
5321         {
5322         case DT_IA_64_VMS_STRTAB_OFFSET:
5323           strtab_off = entry->d_un.d_val;
5324           break;
5325         case DT_STRSZ:
5326           strtab_sz = entry->d_un.d_val;
5327           if (strtab == NULL)
5328             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5329                                1, strtab_sz, _("dynamic string section"));
5330           break;
5331
5332         case DT_IA_64_VMS_NEEDED_IDENT:
5333           fixup.needed_ident = entry->d_un.d_val;
5334           break;
5335         case DT_NEEDED:
5336           fixup.needed = entry->d_un.d_val;
5337           break;
5338         case DT_IA_64_VMS_FIXUP_NEEDED:
5339           fixup.fixup_needed = entry->d_un.d_val;
5340           break;
5341         case DT_IA_64_VMS_FIXUP_RELA_CNT:
5342           fixup.fixup_rela_cnt = entry->d_un.d_val;
5343           break;
5344         case DT_IA_64_VMS_FIXUP_RELA_OFF:
5345           fixup.fixup_rela_off = entry->d_un.d_val;
5346           res++;
5347           dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5348           break;
5349
5350         case DT_IA_64_VMS_IMG_RELA_CNT:
5351           imgrela.img_rela_cnt = entry->d_un.d_val;
5352           break;
5353         case DT_IA_64_VMS_IMG_RELA_OFF:
5354           imgrela.img_rela_off = entry->d_un.d_val;
5355           res++;
5356           dump_ia64_vms_dynamic_relocs (file, &imgrela);
5357           break;
5358
5359         default:
5360           break;
5361         }
5362     }
5363
5364   if (strtab != NULL)
5365     free (strtab);
5366
5367   return res;
5368 }
5369
5370 static struct
5371 {
5372   const char * name;
5373   int reloc;
5374   int size;
5375   int rela;
5376 } dynamic_relocations [] =
5377 {
5378     { "REL", DT_REL, DT_RELSZ, FALSE },
5379     { "RELA", DT_RELA, DT_RELASZ, TRUE },
5380     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5381 };
5382
5383 /* Process the reloc section.  */
5384
5385 static int
5386 process_relocs (FILE * file)
5387 {
5388   unsigned long rel_size;
5389   unsigned long rel_offset;
5390
5391
5392   if (!do_reloc)
5393     return 1;
5394
5395   if (do_using_dynamic)
5396     {
5397       int is_rela;
5398       const char * name;
5399       int has_dynamic_reloc;
5400       unsigned int i;
5401
5402       has_dynamic_reloc = 0;
5403
5404       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5405         {
5406           is_rela = dynamic_relocations [i].rela;
5407           name = dynamic_relocations [i].name;
5408           rel_size = dynamic_info [dynamic_relocations [i].size];
5409           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5410
5411           has_dynamic_reloc |= rel_size;
5412
5413           if (is_rela == UNKNOWN)
5414             {
5415               if (dynamic_relocations [i].reloc == DT_JMPREL)
5416                 switch (dynamic_info[DT_PLTREL])
5417                   {
5418                   case DT_REL:
5419                     is_rela = FALSE;
5420                     break;
5421                   case DT_RELA:
5422                     is_rela = TRUE;
5423                     break;
5424                   }
5425             }
5426
5427           if (rel_size)
5428             {
5429               printf
5430                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5431                  name, rel_offset, rel_size);
5432
5433               dump_relocations (file,
5434                                 offset_from_vma (file, rel_offset, rel_size),
5435                                 rel_size,
5436                                 dynamic_symbols, num_dynamic_syms,
5437                                 dynamic_strings, dynamic_strings_length, is_rela);
5438             }
5439         }
5440
5441       if (is_ia64_vms ())
5442         has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5443
5444       if (! has_dynamic_reloc)
5445         printf (_("\nThere are no dynamic relocations in this file.\n"));
5446     }
5447   else
5448     {
5449       Elf_Internal_Shdr * section;
5450       unsigned long i;
5451       int found = 0;
5452
5453       for (i = 0, section = section_headers;
5454            i < elf_header.e_shnum;
5455            i++, section++)
5456         {
5457           if (   section->sh_type != SHT_RELA
5458               && section->sh_type != SHT_REL)
5459             continue;
5460
5461           rel_offset = section->sh_offset;
5462           rel_size   = section->sh_size;
5463
5464           if (rel_size)
5465             {
5466               Elf_Internal_Shdr * strsec;
5467               int is_rela;
5468
5469               printf (_("\nRelocation section "));
5470
5471               if (string_table == NULL)
5472                 printf ("%d", section->sh_name);
5473               else
5474                 printf ("'%s'", SECTION_NAME (section));
5475
5476               printf (_(" at offset 0x%lx contains %lu entries:\n"),
5477                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5478
5479               is_rela = section->sh_type == SHT_RELA;
5480
5481               if (section->sh_link != 0
5482                   && section->sh_link < elf_header.e_shnum)
5483                 {
5484                   Elf_Internal_Shdr * symsec;
5485                   Elf_Internal_Sym *  symtab;
5486                   unsigned long nsyms;
5487                   unsigned long strtablen = 0;
5488                   char * strtab = NULL;
5489
5490                   symsec = section_headers + section->sh_link;
5491                   if (symsec->sh_type != SHT_SYMTAB
5492                       && symsec->sh_type != SHT_DYNSYM)
5493                     continue;
5494
5495                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
5496
5497                   if (symtab == NULL)
5498                     continue;
5499
5500                   if (symsec->sh_link != 0
5501                       && symsec->sh_link < elf_header.e_shnum)
5502                     {
5503                       strsec = section_headers + symsec->sh_link;
5504
5505                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5506                                                   1, strsec->sh_size,
5507                                                   _("string table"));
5508                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
5509                     }
5510
5511                   dump_relocations (file, rel_offset, rel_size,
5512                                     symtab, nsyms, strtab, strtablen, is_rela);
5513                   if (strtab)
5514                     free (strtab);
5515                   free (symtab);
5516                 }
5517               else
5518                 dump_relocations (file, rel_offset, rel_size,
5519                                   NULL, 0, NULL, 0, is_rela);
5520
5521               found = 1;
5522             }
5523         }
5524
5525       if (! found)
5526         printf (_("\nThere are no relocations in this file.\n"));
5527     }
5528
5529   return 1;
5530 }
5531
5532 /* Process the unwind section.  */
5533
5534 #include "unwind-ia64.h"
5535
5536 /* An absolute address consists of a section and an offset.  If the
5537    section is NULL, the offset itself is the address, otherwise, the
5538    address equals to LOAD_ADDRESS(section) + offset.  */
5539
5540 struct absaddr
5541   {
5542     unsigned short section;
5543     bfd_vma offset;
5544   };
5545
5546 #define ABSADDR(a) \
5547   ((a).section \
5548    ? section_headers [(a).section].sh_addr + (a).offset \
5549    : (a).offset)
5550
5551 struct ia64_unw_table_entry
5552   {
5553     struct absaddr start;
5554     struct absaddr end;
5555     struct absaddr info;
5556   };
5557
5558 struct ia64_unw_aux_info
5559   {
5560
5561     struct ia64_unw_table_entry *table; /* Unwind table.  */
5562     unsigned long table_len;    /* Length of unwind table.  */
5563     unsigned char * info;       /* Unwind info.  */
5564     unsigned long info_size;    /* Size of unwind info.  */
5565     bfd_vma info_addr;          /* starting address of unwind info.  */
5566     bfd_vma seg_base;           /* Starting address of segment.  */
5567     Elf_Internal_Sym * symtab;  /* The symbol table.  */
5568     unsigned long nsyms;        /* Number of symbols.  */
5569     char * strtab;              /* The string table.  */
5570     unsigned long strtab_size;  /* Size of string table.  */
5571   };
5572
5573 static void
5574 find_symbol_for_address (Elf_Internal_Sym * symtab,
5575                          unsigned long nsyms,
5576                          const char * strtab,
5577                          unsigned long strtab_size,
5578                          struct absaddr addr,
5579                          const char ** symname,
5580                          bfd_vma * offset)
5581 {
5582   bfd_vma dist = 0x100000;
5583   Elf_Internal_Sym * sym;
5584   Elf_Internal_Sym * best = NULL;
5585   unsigned long i;
5586
5587   REMOVE_ARCH_BITS (addr.offset);
5588
5589   for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
5590     {
5591       bfd_vma value = sym->st_value;
5592
5593       REMOVE_ARCH_BITS (value);
5594
5595       if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5596           && sym->st_name != 0
5597           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
5598           && addr.offset >= value
5599           && addr.offset - value < dist)
5600         {
5601           best = sym;
5602           dist = addr.offset - value;
5603           if (!dist)
5604             break;
5605         }
5606     }
5607
5608   if (best)
5609     {
5610       *symname = (best->st_name >= strtab_size
5611                   ? _("<corrupt>") : strtab + best->st_name);
5612       *offset = dist;
5613       return;
5614     }
5615
5616   *symname = NULL;
5617   *offset = addr.offset;
5618 }
5619
5620 static void
5621 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
5622 {
5623   struct ia64_unw_table_entry * tp;
5624   int in_body;
5625
5626   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5627     {
5628       bfd_vma stamp;
5629       bfd_vma offset;
5630       const unsigned char * dp;
5631       const unsigned char * head;
5632       const char * procname;
5633
5634       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5635                                aux->strtab_size, tp->start, &procname, &offset);
5636
5637       fputs ("\n<", stdout);
5638
5639       if (procname)
5640         {
5641           fputs (procname, stdout);
5642
5643           if (offset)
5644             printf ("+%lx", (unsigned long) offset);
5645         }
5646
5647       fputs (">: [", stdout);
5648       print_vma (tp->start.offset, PREFIX_HEX);
5649       fputc ('-', stdout);
5650       print_vma (tp->end.offset, PREFIX_HEX);
5651       printf ("], info at +0x%lx\n",
5652               (unsigned long) (tp->info.offset - aux->seg_base));
5653
5654       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5655       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5656
5657       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5658               (unsigned) UNW_VER (stamp),
5659               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5660               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5661               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5662               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5663
5664       if (UNW_VER (stamp) != 1)
5665         {
5666           printf (_("\tUnknown version.\n"));
5667           continue;
5668         }
5669
5670       in_body = 0;
5671       for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5672         dp = unw_decode (dp, in_body, & in_body);
5673     }
5674 }
5675
5676 static int
5677 slurp_ia64_unwind_table (FILE * file,
5678                          struct ia64_unw_aux_info * aux,
5679                          Elf_Internal_Shdr * sec)
5680 {
5681   unsigned long size, nrelas, i;
5682   Elf_Internal_Phdr * seg;
5683   struct ia64_unw_table_entry * tep;
5684   Elf_Internal_Shdr * relsec;
5685   Elf_Internal_Rela * rela;
5686   Elf_Internal_Rela * rp;
5687   unsigned char * table;
5688   unsigned char * tp;
5689   Elf_Internal_Sym * sym;
5690   const char * relname;
5691
5692   /* First, find the starting address of the segment that includes
5693      this section: */
5694
5695   if (elf_header.e_phnum)
5696     {
5697       if (! get_program_headers (file))
5698           return 0;
5699
5700       for (seg = program_headers;
5701            seg < program_headers + elf_header.e_phnum;
5702            ++seg)
5703         {
5704           if (seg->p_type != PT_LOAD)
5705             continue;
5706
5707           if (sec->sh_addr >= seg->p_vaddr
5708               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5709             {
5710               aux->seg_base = seg->p_vaddr;
5711               break;
5712             }
5713         }
5714     }
5715
5716   /* Second, build the unwind table from the contents of the unwind section:  */
5717   size = sec->sh_size;
5718   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5719                                       _("unwind table"));
5720   if (!table)
5721     return 0;
5722
5723   aux->table = (struct ia64_unw_table_entry *)
5724       xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5725   tep = aux->table;
5726   for (tp = table; tp < table + size; ++tep)
5727     {
5728       tep->start.section = SHN_UNDEF;
5729       tep->end.section   = SHN_UNDEF;
5730       tep->info.section  = SHN_UNDEF;
5731       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5732       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5733       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5734       tep->start.offset += aux->seg_base;
5735       tep->end.offset   += aux->seg_base;
5736       tep->info.offset  += aux->seg_base;
5737     }
5738   free (table);
5739
5740   /* Third, apply any relocations to the unwind table:  */
5741   for (relsec = section_headers;
5742        relsec < section_headers + elf_header.e_shnum;
5743        ++relsec)
5744     {
5745       if (relsec->sh_type != SHT_RELA
5746           || relsec->sh_info >= elf_header.e_shnum
5747           || section_headers + relsec->sh_info != sec)
5748         continue;
5749
5750       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5751                               & rela, & nrelas))
5752         return 0;
5753
5754       for (rp = rela; rp < rela + nrelas; ++rp)
5755         {
5756           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5757           sym = aux->symtab + get_reloc_symindex (rp->r_info);
5758
5759           if (! const_strneq (relname, "R_IA64_SEGREL"))
5760             {
5761               warn (_("Skipping unexpected relocation type %s\n"), relname);
5762               continue;
5763             }
5764
5765           i = rp->r_offset / (3 * eh_addr_size);
5766
5767           switch (rp->r_offset/eh_addr_size % 3)
5768             {
5769             case 0:
5770               aux->table[i].start.section = sym->st_shndx;
5771               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
5772               break;
5773             case 1:
5774               aux->table[i].end.section   = sym->st_shndx;
5775               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
5776               break;
5777             case 2:
5778               aux->table[i].info.section  = sym->st_shndx;
5779               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
5780               break;
5781             default:
5782               break;
5783             }
5784         }
5785
5786       free (rela);
5787     }
5788
5789   aux->table_len = size / (3 * eh_addr_size);
5790   return 1;
5791 }
5792
5793 static void
5794 ia64_process_unwind (FILE * file)
5795 {
5796   Elf_Internal_Shdr * sec;
5797   Elf_Internal_Shdr * unwsec = NULL;
5798   Elf_Internal_Shdr * strsec;
5799   unsigned long i, unwcount = 0, unwstart = 0;
5800   struct ia64_unw_aux_info aux;
5801
5802   memset (& aux, 0, sizeof (aux));
5803
5804   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5805     {
5806       if (sec->sh_type == SHT_SYMTAB
5807           && sec->sh_link < elf_header.e_shnum)
5808         {
5809           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
5810
5811           strsec = section_headers + sec->sh_link;
5812           assert (aux.strtab == NULL);
5813           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5814                                           1, strsec->sh_size,
5815                                           _("string table"));
5816           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5817         }
5818       else if (sec->sh_type == SHT_IA_64_UNWIND)
5819         unwcount++;
5820     }
5821
5822   if (!unwcount)
5823     printf (_("\nThere are no unwind sections in this file.\n"));
5824
5825   while (unwcount-- > 0)
5826     {
5827       char * suffix;
5828       size_t len, len2;
5829
5830       for (i = unwstart, sec = section_headers + unwstart;
5831            i < elf_header.e_shnum; ++i, ++sec)
5832         if (sec->sh_type == SHT_IA_64_UNWIND)
5833           {
5834             unwsec = sec;
5835             break;
5836           }
5837
5838       unwstart = i + 1;
5839       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5840
5841       if ((unwsec->sh_flags & SHF_GROUP) != 0)
5842         {
5843           /* We need to find which section group it is in.  */
5844           struct group_list * g = section_headers_groups [i]->root;
5845
5846           for (; g != NULL; g = g->next)
5847             {
5848               sec = section_headers + g->section_index;
5849
5850               if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
5851                 break;
5852             }
5853
5854           if (g == NULL)
5855             i = elf_header.e_shnum;
5856         }
5857       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
5858         {
5859           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
5860           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5861           suffix = SECTION_NAME (unwsec) + len;
5862           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5863                ++i, ++sec)
5864             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5865                 && streq (SECTION_NAME (sec) + len2, suffix))
5866               break;
5867         }
5868       else
5869         {
5870           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5871              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
5872           len = sizeof (ELF_STRING_ia64_unwind) - 1;
5873           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5874           suffix = "";
5875           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
5876             suffix = SECTION_NAME (unwsec) + len;
5877           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5878                ++i, ++sec)
5879             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5880                 && streq (SECTION_NAME (sec) + len2, suffix))
5881               break;
5882         }
5883
5884       if (i == elf_header.e_shnum)
5885         {
5886           printf (_("\nCould not find unwind info section for "));
5887
5888           if (string_table == NULL)
5889             printf ("%d", unwsec->sh_name);
5890           else
5891             printf (_("'%s'"), SECTION_NAME (unwsec));
5892         }
5893       else
5894         {
5895           aux.info_addr = sec->sh_addr;
5896           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
5897                                                  sec->sh_size,
5898                                                  _("unwind info"));
5899           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
5900
5901           printf (_("\nUnwind section "));
5902
5903           if (string_table == NULL)
5904             printf ("%d", unwsec->sh_name);
5905           else
5906             printf (_("'%s'"), SECTION_NAME (unwsec));
5907
5908           printf (_(" at offset 0x%lx contains %lu entries:\n"),
5909                   (unsigned long) unwsec->sh_offset,
5910                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
5911
5912           (void) slurp_ia64_unwind_table (file, & aux, unwsec);
5913
5914           if (aux.table_len > 0)
5915             dump_ia64_unwind (& aux);
5916
5917           if (aux.table)
5918             free ((char *) aux.table);
5919           if (aux.info)
5920             free ((char *) aux.info);
5921           aux.table = NULL;
5922           aux.info = NULL;
5923         }
5924     }
5925
5926   if (aux.symtab)
5927     free (aux.symtab);
5928   if (aux.strtab)
5929     free ((char *) aux.strtab);
5930 }
5931
5932 struct hppa_unw_table_entry
5933   {
5934     struct absaddr start;
5935     struct absaddr end;
5936     unsigned int Cannot_unwind:1;                       /* 0 */
5937     unsigned int Millicode:1;                   /* 1 */
5938     unsigned int Millicode_save_sr0:1;          /* 2 */
5939     unsigned int Region_description:2;          /* 3..4 */
5940     unsigned int reserved1:1;                   /* 5 */
5941     unsigned int Entry_SR:1;                    /* 6 */
5942     unsigned int Entry_FR:4;     /* number saved */     /* 7..10 */
5943     unsigned int Entry_GR:5;     /* number saved */     /* 11..15 */
5944     unsigned int Args_stored:1;                 /* 16 */
5945     unsigned int Variable_Frame:1;                      /* 17 */
5946     unsigned int Separate_Package_Body:1;               /* 18 */
5947     unsigned int Frame_Extension_Millicode:1;   /* 19 */
5948     unsigned int Stack_Overflow_Check:1;                /* 20 */
5949     unsigned int Two_Instruction_SP_Increment:1;        /* 21 */
5950     unsigned int Ada_Region:1;                  /* 22 */
5951     unsigned int cxx_info:1;                    /* 23 */
5952     unsigned int cxx_try_catch:1;                       /* 24 */
5953     unsigned int sched_entry_seq:1;                     /* 25 */
5954     unsigned int reserved2:1;                   /* 26 */
5955     unsigned int Save_SP:1;                             /* 27 */
5956     unsigned int Save_RP:1;                             /* 28 */
5957     unsigned int Save_MRP_in_frame:1;           /* 29 */
5958     unsigned int extn_ptr_defined:1;            /* 30 */
5959     unsigned int Cleanup_defined:1;                     /* 31 */
5960
5961     unsigned int MPE_XL_interrupt_marker:1;             /* 0 */
5962     unsigned int HP_UX_interrupt_marker:1;              /* 1 */
5963     unsigned int Large_frame:1;                 /* 2 */
5964     unsigned int Pseudo_SP_Set:1;                       /* 3 */
5965     unsigned int reserved4:1;                   /* 4 */
5966     unsigned int Total_frame_size:27;           /* 5..31 */
5967   };
5968
5969 struct hppa_unw_aux_info
5970   {
5971     struct hppa_unw_table_entry *table; /* Unwind table.  */
5972     unsigned long table_len;    /* Length of unwind table.  */
5973     bfd_vma seg_base;           /* Starting address of segment.  */
5974     Elf_Internal_Sym * symtab;  /* The symbol table.  */
5975     unsigned long nsyms;        /* Number of symbols.  */
5976     char * strtab;              /* The string table.  */
5977     unsigned long strtab_size;  /* Size of string table.  */
5978   };
5979
5980 static void
5981 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
5982 {
5983   struct hppa_unw_table_entry * tp;
5984
5985   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5986     {
5987       bfd_vma offset;
5988       const char * procname;
5989
5990       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5991                                aux->strtab_size, tp->start, &procname,
5992                                &offset);
5993
5994       fputs ("\n<", stdout);
5995
5996       if (procname)
5997         {
5998           fputs (procname, stdout);
5999
6000           if (offset)
6001             printf ("+%lx", (unsigned long) offset);
6002         }
6003
6004       fputs (">: [", stdout);
6005       print_vma (tp->start.offset, PREFIX_HEX);
6006       fputc ('-', stdout);
6007       print_vma (tp->end.offset, PREFIX_HEX);
6008       printf ("]\n\t");
6009
6010 #define PF(_m) if (tp->_m) printf (#_m " ");
6011 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6012       PF(Cannot_unwind);
6013       PF(Millicode);
6014       PF(Millicode_save_sr0);
6015       /* PV(Region_description);  */
6016       PF(Entry_SR);
6017       PV(Entry_FR);
6018       PV(Entry_GR);
6019       PF(Args_stored);
6020       PF(Variable_Frame);
6021       PF(Separate_Package_Body);
6022       PF(Frame_Extension_Millicode);
6023       PF(Stack_Overflow_Check);
6024       PF(Two_Instruction_SP_Increment);
6025       PF(Ada_Region);
6026       PF(cxx_info);
6027       PF(cxx_try_catch);
6028       PF(sched_entry_seq);
6029       PF(Save_SP);
6030       PF(Save_RP);
6031       PF(Save_MRP_in_frame);
6032       PF(extn_ptr_defined);
6033       PF(Cleanup_defined);
6034       PF(MPE_XL_interrupt_marker);
6035       PF(HP_UX_interrupt_marker);
6036       PF(Large_frame);
6037       PF(Pseudo_SP_Set);
6038       PV(Total_frame_size);
6039 #undef PF
6040 #undef PV
6041     }
6042
6043   printf ("\n");
6044 }
6045
6046 static int
6047 slurp_hppa_unwind_table (FILE * file,
6048                          struct hppa_unw_aux_info * aux,
6049                          Elf_Internal_Shdr * sec)
6050 {
6051   unsigned long size, unw_ent_size, nentries, nrelas, i;
6052   Elf_Internal_Phdr * seg;
6053   struct hppa_unw_table_entry * tep;
6054   Elf_Internal_Shdr * relsec;
6055   Elf_Internal_Rela * rela;
6056   Elf_Internal_Rela * rp;
6057   unsigned char * table;
6058   unsigned char * tp;
6059   Elf_Internal_Sym * sym;
6060   const char * relname;
6061
6062   /* First, find the starting address of the segment that includes
6063      this section.  */
6064
6065   if (elf_header.e_phnum)
6066     {
6067       if (! get_program_headers (file))
6068         return 0;
6069
6070       for (seg = program_headers;
6071            seg < program_headers + elf_header.e_phnum;
6072            ++seg)
6073         {
6074           if (seg->p_type != PT_LOAD)
6075             continue;
6076
6077           if (sec->sh_addr >= seg->p_vaddr
6078               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6079             {
6080               aux->seg_base = seg->p_vaddr;
6081               break;
6082             }
6083         }
6084     }
6085
6086   /* Second, build the unwind table from the contents of the unwind
6087      section.  */
6088   size = sec->sh_size;
6089   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6090                                       _("unwind table"));
6091   if (!table)
6092     return 0;
6093
6094   unw_ent_size = 16;
6095   nentries = size / unw_ent_size;
6096   size = unw_ent_size * nentries;
6097
6098   tep = aux->table = (struct hppa_unw_table_entry *)
6099       xcmalloc (nentries, sizeof (aux->table[0]));
6100
6101   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6102     {
6103       unsigned int tmp1, tmp2;
6104
6105       tep->start.section = SHN_UNDEF;
6106       tep->end.section   = SHN_UNDEF;
6107
6108       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6109       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6110       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6111       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6112
6113       tep->start.offset += aux->seg_base;
6114       tep->end.offset   += aux->seg_base;
6115
6116       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6117       tep->Millicode = (tmp1 >> 30) & 0x1;
6118       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6119       tep->Region_description = (tmp1 >> 27) & 0x3;
6120       tep->reserved1 = (tmp1 >> 26) & 0x1;
6121       tep->Entry_SR = (tmp1 >> 25) & 0x1;
6122       tep->Entry_FR = (tmp1 >> 21) & 0xf;
6123       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6124       tep->Args_stored = (tmp1 >> 15) & 0x1;
6125       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6126       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6127       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6128       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6129       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6130       tep->Ada_Region = (tmp1 >> 9) & 0x1;
6131       tep->cxx_info = (tmp1 >> 8) & 0x1;
6132       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6133       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6134       tep->reserved2 = (tmp1 >> 5) & 0x1;
6135       tep->Save_SP = (tmp1 >> 4) & 0x1;
6136       tep->Save_RP = (tmp1 >> 3) & 0x1;
6137       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6138       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6139       tep->Cleanup_defined = tmp1 & 0x1;
6140
6141       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6142       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6143       tep->Large_frame = (tmp2 >> 29) & 0x1;
6144       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6145       tep->reserved4 = (tmp2 >> 27) & 0x1;
6146       tep->Total_frame_size = tmp2 & 0x7ffffff;
6147     }
6148   free (table);
6149
6150   /* Third, apply any relocations to the unwind table.  */
6151   for (relsec = section_headers;
6152        relsec < section_headers + elf_header.e_shnum;
6153        ++relsec)
6154     {
6155       if (relsec->sh_type != SHT_RELA
6156           || relsec->sh_info >= elf_header.e_shnum
6157           || section_headers + relsec->sh_info != sec)
6158         continue;
6159
6160       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6161                               & rela, & nrelas))
6162         return 0;
6163
6164       for (rp = rela; rp < rela + nrelas; ++rp)
6165         {
6166           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6167           sym = aux->symtab + get_reloc_symindex (rp->r_info);
6168
6169           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
6170           if (! const_strneq (relname, "R_PARISC_SEGREL"))
6171             {
6172               warn (_("Skipping unexpected relocation type %s\n"), relname);
6173               continue;
6174             }
6175
6176           i = rp->r_offset / unw_ent_size;
6177
6178           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6179             {
6180             case 0:
6181               aux->table[i].start.section = sym->st_shndx;
6182               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
6183               break;
6184             case 1:
6185               aux->table[i].end.section   = sym->st_shndx;
6186               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
6187               break;
6188             default:
6189               break;
6190             }
6191         }
6192
6193       free (rela);
6194     }
6195
6196   aux->table_len = nentries;
6197
6198   return 1;
6199 }
6200
6201 static void
6202 hppa_process_unwind (FILE * file)
6203 {
6204   struct hppa_unw_aux_info aux;
6205   Elf_Internal_Shdr * unwsec = NULL;
6206   Elf_Internal_Shdr * strsec;
6207   Elf_Internal_Shdr * sec;
6208   unsigned long i;
6209
6210   if (string_table == NULL)
6211     return;
6212
6213   memset (& aux, 0, sizeof (aux));
6214
6215   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6216     {
6217       if (sec->sh_type == SHT_SYMTAB
6218           && sec->sh_link < elf_header.e_shnum)
6219         {
6220           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6221
6222           strsec = section_headers + sec->sh_link;
6223           assert (aux.strtab == NULL);
6224           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6225                                           1, strsec->sh_size,
6226                                           _("string table"));
6227           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6228         }
6229       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6230         unwsec = sec;
6231     }
6232
6233   if (!unwsec)
6234     printf (_("\nThere are no unwind sections in this file.\n"));
6235
6236   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6237     {
6238       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6239         {
6240           printf (_("\nUnwind section "));
6241           printf (_("'%s'"), SECTION_NAME (sec));
6242
6243           printf (_(" at offset 0x%lx contains %lu entries:\n"),
6244                   (unsigned long) sec->sh_offset,
6245                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6246
6247           slurp_hppa_unwind_table (file, &aux, sec);
6248           if (aux.table_len > 0)
6249             dump_hppa_unwind (&aux);
6250
6251           if (aux.table)
6252             free ((char *) aux.table);
6253           aux.table = NULL;
6254         }
6255     }
6256
6257   if (aux.symtab)
6258     free (aux.symtab);
6259   if (aux.strtab)
6260     free ((char *) aux.strtab);
6261 }
6262
6263 struct arm_section
6264 {
6265   unsigned char *      data;            /* The unwind data.  */
6266   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
6267   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
6268   unsigned long        nrelas;          /* The number of relocations.  */
6269   unsigned int         rel_type;        /* REL or RELA ?  */
6270   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
6271 };
6272
6273 struct arm_unw_aux_info
6274 {
6275   FILE *              file;             /* The file containing the unwind sections.  */
6276   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
6277   unsigned long       nsyms;            /* Number of symbols.  */
6278   char *              strtab;           /* The file's string table.  */
6279   unsigned long       strtab_size;      /* Size of string table.  */
6280 };
6281
6282 static const char *
6283 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6284                         bfd_vma fn, struct absaddr addr)
6285 {
6286   const char *procname;
6287   bfd_vma sym_offset;
6288
6289   if (addr.section == SHN_UNDEF)
6290     addr.offset = fn;
6291
6292   find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6293                            aux->strtab_size, addr, &procname,
6294                            &sym_offset);
6295
6296   print_vma (fn, PREFIX_HEX);
6297
6298   if (procname)
6299     {
6300       fputs (" <", stdout);
6301       fputs (procname, stdout);
6302
6303       if (sym_offset)
6304         printf ("+0x%lx", (unsigned long) sym_offset);
6305       fputc ('>', stdout);
6306     }
6307
6308   return procname;
6309 }
6310
6311 static void
6312 arm_free_section (struct arm_section *arm_sec)
6313 {
6314   if (arm_sec->data != NULL)
6315     free (arm_sec->data);
6316
6317   if (arm_sec->rela != NULL)
6318     free (arm_sec->rela);
6319 }
6320
6321 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6322       cached section and install SEC instead.
6323    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6324       and return its valued in * WORDP, relocating if necessary.
6325    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6326       relocation's offset in ADDR.
6327    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6328       into the string table of the symbol associated with the reloc.  If no
6329       reloc was applied store -1 there.
6330    5) Return TRUE upon success, FALSE otherwise.  */
6331
6332 static bfd_boolean
6333 get_unwind_section_word (struct arm_unw_aux_info *  aux,
6334                          struct arm_section *       arm_sec,
6335                          Elf_Internal_Shdr *        sec,
6336                          bfd_vma                    word_offset,
6337                          unsigned int *             wordp,
6338                          struct absaddr *           addr,
6339                          bfd_vma *                  sym_name)
6340 {
6341   Elf_Internal_Rela *rp;
6342   Elf_Internal_Sym *sym;
6343   const char * relname;
6344   unsigned int word;
6345   bfd_boolean wrapped;
6346
6347   addr->section = SHN_UNDEF;
6348   addr->offset = 0;
6349
6350   if (sym_name != NULL)
6351     *sym_name = (bfd_vma) -1;
6352
6353   /* If necessary, update the section cache.  */
6354   if (sec != arm_sec->sec)
6355     {
6356       Elf_Internal_Shdr *relsec;
6357
6358       arm_free_section (arm_sec);
6359
6360       arm_sec->sec = sec;
6361       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6362                                 sec->sh_size, _("unwind data"));
6363       arm_sec->rela = NULL;
6364       arm_sec->nrelas = 0;
6365
6366       for (relsec = section_headers;
6367            relsec < section_headers + elf_header.e_shnum;
6368            ++relsec)
6369         {
6370           if (relsec->sh_info >= elf_header.e_shnum
6371               || section_headers + relsec->sh_info != sec)
6372             continue;
6373
6374           arm_sec->rel_type = relsec->sh_type;
6375           if (relsec->sh_type == SHT_REL)
6376             {
6377               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6378                                      relsec->sh_size,
6379                                      & arm_sec->rela, & arm_sec->nrelas))
6380                 return FALSE;
6381               break;
6382             }
6383           else if (relsec->sh_type == SHT_RELA)
6384             {
6385               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6386                                       relsec->sh_size,
6387                                       & arm_sec->rela, & arm_sec->nrelas))
6388                 return FALSE;
6389               break;
6390             }
6391           else
6392             warn (_("unexpected relocation type (%d) for section %d"),
6393                   relsec->sh_type, relsec->sh_info);
6394         }
6395
6396       arm_sec->next_rela = arm_sec->rela;
6397     }
6398
6399   /* If there is no unwind data we can do nothing.  */
6400   if (arm_sec->data == NULL)
6401     return FALSE;
6402
6403   /* Get the word at the required offset.  */
6404   word = byte_get (arm_sec->data + word_offset, 4);
6405
6406   /* Look through the relocs to find the one that applies to the provided offset.  */
6407   wrapped = FALSE;
6408   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6409     {
6410       bfd_vma prelval, offset;
6411
6412       if (rp->r_offset > word_offset && !wrapped)
6413         {
6414           rp = arm_sec->rela;
6415           wrapped = TRUE;
6416         }
6417       if (rp->r_offset > word_offset)
6418         break;
6419
6420       if (rp->r_offset & 3)
6421         {
6422           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6423                 (unsigned long) rp->r_offset);
6424           continue;
6425         }
6426
6427       if (rp->r_offset < word_offset)
6428         continue;
6429
6430       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6431
6432       if (arm_sec->rel_type == SHT_REL)
6433         {
6434           offset = word & 0x7fffffff;
6435           if (offset & 0x40000000)
6436             offset |= ~ (bfd_vma) 0x7fffffff;
6437         }
6438       else if (arm_sec->rel_type == SHT_RELA)
6439         offset = rp->r_addend;
6440       else
6441         abort ();
6442
6443       offset += sym->st_value;
6444       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6445
6446       /* Check that we are processing the expected reloc type.  */
6447       if (elf_header.e_machine == EM_ARM)
6448         {
6449           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6450
6451           if (streq (relname, "R_ARM_NONE"))
6452               continue;
6453
6454           if (! streq (relname, "R_ARM_PREL31"))
6455             {
6456               warn (_("Skipping unexpected relocation type %s\n"), relname);
6457               continue;
6458             }
6459         }
6460       else if (elf_header.e_machine == EM_TI_C6000)
6461         {
6462           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6463
6464           if (streq (relname, "R_C6000_NONE"))
6465             continue;
6466
6467           if (! streq (relname, "R_C6000_PREL31"))
6468             {
6469               warn (_("Skipping unexpected relocation type %s\n"), relname);
6470               continue;
6471             }
6472
6473           prelval >>= 1;
6474         }
6475       else
6476         /* This function currently only supports ARM and TI unwinders.  */
6477         abort ();
6478
6479       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6480       addr->section = sym->st_shndx;
6481       addr->offset = offset;
6482       if (sym_name)
6483         * sym_name = sym->st_name;
6484       break;
6485     }
6486
6487   *wordp = word;
6488   arm_sec->next_rela = rp;
6489
6490   return TRUE;
6491 }
6492
6493 static const char *tic6x_unwind_regnames[16] =
6494 {
6495   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6496   "A14", "A13", "A12", "A11", "A10",
6497   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6498 };
6499
6500 static void
6501 decode_tic6x_unwind_regmask (unsigned int mask)
6502 {
6503   int i;
6504
6505   for (i = 12; mask; mask >>= 1, i--)
6506     {
6507       if (mask & 1)
6508         {
6509           fputs (tic6x_unwind_regnames[i], stdout);
6510           if (mask > 1)
6511             fputs (", ", stdout);
6512         }
6513     }
6514 }
6515
6516 #define ADVANCE                                                 \
6517   if (remaining == 0 && more_words)                             \
6518     {                                                           \
6519       data_offset += 4;                                         \
6520       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
6521                                      data_offset, & word, & addr, NULL))        \
6522         return;                                                 \
6523       remaining = 4;                                            \
6524       more_words--;                                             \
6525     }                                                           \
6526
6527 #define GET_OP(OP)                      \
6528   ADVANCE;                              \
6529   if (remaining)                        \
6530     {                                   \
6531       remaining--;                      \
6532       (OP) = word >> 24;                \
6533       word <<= 8;                       \
6534     }                                   \
6535   else                                  \
6536     {                                   \
6537       printf (_("[Truncated opcode]\n"));       \
6538       return;                           \
6539     }                                   \
6540   printf ("0x%02x ", OP)
6541
6542 static void
6543 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6544                             unsigned int word, unsigned int remaining,
6545                             unsigned int more_words,
6546                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6547                             struct arm_section *data_arm_sec)
6548 {
6549   struct absaddr addr;
6550
6551   /* Decode the unwinding instructions.  */
6552   while (1)
6553     {
6554       unsigned int op, op2;
6555
6556       ADVANCE;
6557       if (remaining == 0)
6558         break;
6559       remaining--;
6560       op = word >> 24;
6561       word <<= 8;
6562
6563       printf ("  0x%02x ", op);
6564
6565       if ((op & 0xc0) == 0x00)
6566         {
6567           int offset = ((op & 0x3f) << 2) + 4;
6568
6569           printf ("     vsp = vsp + %d", offset);
6570         }
6571       else if ((op & 0xc0) == 0x40)
6572         {
6573           int offset = ((op & 0x3f) << 2) + 4;
6574
6575           printf ("     vsp = vsp - %d", offset);
6576         }
6577       else if ((op & 0xf0) == 0x80)
6578         {
6579           GET_OP (op2);
6580           if (op == 0x80 && op2 == 0)
6581             printf (_("Refuse to unwind"));
6582           else
6583             {
6584               unsigned int mask = ((op & 0x0f) << 8) | op2;
6585               int first = 1;
6586               int i;
6587
6588               printf ("pop {");
6589               for (i = 0; i < 12; i++)
6590                 if (mask & (1 << i))
6591                   {
6592                     if (first)
6593                       first = 0;
6594                     else
6595                       printf (", ");
6596                     printf ("r%d", 4 + i);
6597                   }
6598               printf ("}");
6599             }
6600         }
6601       else if ((op & 0xf0) == 0x90)
6602         {
6603           if (op == 0x9d || op == 0x9f)
6604             printf (_("     [Reserved]"));
6605           else
6606             printf ("     vsp = r%d", op & 0x0f);
6607         }
6608       else if ((op & 0xf0) == 0xa0)
6609         {
6610           int end = 4 + (op & 0x07);
6611           int first = 1;
6612           int i;
6613
6614           printf ("     pop {");
6615           for (i = 4; i <= end; i++)
6616             {
6617               if (first)
6618                 first = 0;
6619               else
6620                 printf (", ");
6621               printf ("r%d", i);
6622             }
6623           if (op & 0x08)
6624             {
6625               if (!first)
6626                 printf (", ");
6627               printf ("r14");
6628             }
6629           printf ("}");
6630         }
6631       else if (op == 0xb0)
6632         printf (_("     finish"));
6633       else if (op == 0xb1)
6634         {
6635           GET_OP (op2);
6636           if (op2 == 0 || (op2 & 0xf0) != 0)
6637             printf (_("[Spare]"));
6638           else
6639             {
6640               unsigned int mask = op2 & 0x0f;
6641               int first = 1;
6642               int i;
6643
6644               printf ("pop {");
6645               for (i = 0; i < 12; i++)
6646                 if (mask & (1 << i))
6647                   {
6648                     if (first)
6649                       first = 0;
6650                     else
6651                       printf (", ");
6652                     printf ("r%d", i);
6653                   }
6654               printf ("}");
6655             }
6656         }
6657       else if (op == 0xb2)
6658         {
6659           unsigned char buf[9];
6660           unsigned int i, len;
6661           unsigned long offset;
6662
6663           for (i = 0; i < sizeof (buf); i++)
6664             {
6665               GET_OP (buf[i]);
6666               if ((buf[i] & 0x80) == 0)
6667                 break;
6668             }
6669           assert (i < sizeof (buf));
6670           offset = read_uleb128 (buf, &len);
6671           assert (len == i + 1);
6672           offset = offset * 4 + 0x204;
6673           printf ("vsp = vsp + %ld", offset);
6674         }
6675       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
6676         {
6677           unsigned int first, last;
6678
6679           GET_OP (op2);
6680           first = op2 >> 4;
6681           last = op2 & 0x0f;
6682           if (op == 0xc8)
6683             first = first + 16;
6684           printf ("pop {D%d", first);
6685           if (last)
6686             printf ("-D%d", first + last);
6687           printf ("}");
6688         }
6689       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6690         {
6691           unsigned int count = op & 0x07;
6692
6693           printf ("pop {D8");
6694           if (count)
6695             printf ("-D%d", 8 + count);
6696           printf ("}");
6697         }
6698       else if (op >= 0xc0 && op <= 0xc5)
6699         {
6700           unsigned int count = op & 0x07;
6701
6702           printf ("     pop {wR10");
6703           if (count)
6704             printf ("-wR%d", 10 + count);
6705           printf ("}");
6706         }
6707       else if (op == 0xc6)
6708         {
6709           unsigned int first, last;
6710
6711           GET_OP (op2);
6712           first = op2 >> 4;
6713           last = op2 & 0x0f;
6714           printf ("pop {wR%d", first);
6715           if (last)
6716             printf ("-wR%d", first + last);
6717           printf ("}");
6718         }
6719       else if (op == 0xc7)
6720         {
6721           GET_OP (op2);
6722           if (op2 == 0 || (op2 & 0xf0) != 0)
6723             printf (_("[Spare]"));
6724           else
6725             {
6726               unsigned int mask = op2 & 0x0f;
6727               int first = 1;
6728               int i;
6729
6730               printf ("pop {");
6731               for (i = 0; i < 4; i++)
6732                 if (mask & (1 << i))
6733                   {
6734                     if (first)
6735                       first = 0;
6736                     else
6737                       printf (", ");
6738                     printf ("wCGR%d", i);
6739                   }
6740               printf ("}");
6741             }
6742         }
6743       else
6744         printf (_("     [unsupported opcode]"));
6745       printf ("\n");
6746     }
6747 }
6748
6749 static void
6750 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6751                             unsigned int word, unsigned int remaining,
6752                             unsigned int more_words,
6753                             bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6754                             struct arm_section *data_arm_sec)
6755 {
6756   struct absaddr addr;
6757
6758   /* Decode the unwinding instructions.  */
6759   while (1)
6760     {
6761       unsigned int op, op2;
6762
6763       ADVANCE;
6764       if (remaining == 0)
6765         break;
6766       remaining--;
6767       op = word >> 24;
6768       word <<= 8;
6769
6770       printf ("  0x%02x ", op);
6771
6772       if ((op & 0xc0) == 0x00)
6773         {
6774           int offset = ((op & 0x3f) << 3) + 8;
6775           printf ("     sp = sp + %d", offset);
6776         }
6777       else if ((op & 0xc0) == 0x80)
6778         {
6779           GET_OP (op2);
6780           if (op == 0x80 && op2 == 0)
6781             printf (_("Refuse to unwind"));
6782           else
6783             {
6784               unsigned int mask = ((op & 0x1f) << 8) | op2;
6785               if (op & 0x20)
6786                 printf ("pop compact {");
6787               else
6788                 printf ("pop {");
6789
6790               decode_tic6x_unwind_regmask (mask);
6791               printf("}");
6792             }
6793         }
6794       else if ((op & 0xf0) == 0xc0)
6795         {
6796           unsigned int reg;
6797           unsigned int nregs;
6798           unsigned int i;
6799           const char *name;
6800           struct
6801           {
6802               unsigned int offset;
6803               unsigned int reg;
6804           } regpos[16];
6805
6806           /* Scan entire instruction first so that GET_OP output is not
6807              interleaved with disassembly.  */
6808           nregs = 0;
6809           for (i = 0; nregs < (op & 0xf); i++)
6810             {
6811               GET_OP (op2);
6812               reg = op2 >> 4;
6813               if (reg != 0xf)
6814                 {
6815                   regpos[nregs].offset = i * 2;
6816                   regpos[nregs].reg = reg;
6817                   nregs++;
6818                 }
6819
6820               reg = op2 & 0xf;
6821               if (reg != 0xf)
6822                 {
6823                   regpos[nregs].offset = i * 2 + 1;
6824                   regpos[nregs].reg = reg;
6825                   nregs++;
6826                 }
6827             }
6828
6829           printf (_("pop frame {"));
6830           reg = nregs - 1;
6831           for (i = i * 2; i > 0; i--)
6832             {
6833               if (regpos[reg].offset == i - 1)
6834                 {
6835                   name = tic6x_unwind_regnames[regpos[reg].reg];
6836                   if (reg > 0)
6837                     reg--;
6838                 }
6839               else
6840                 name = _("[pad]");
6841
6842               fputs (name, stdout);
6843               if (i > 1)
6844                 printf (", ");
6845             }
6846
6847           printf ("}");
6848         }
6849       else if (op == 0xd0)
6850         printf ("     MOV FP, SP");
6851       else if (op == 0xd1)
6852         printf ("     __c6xabi_pop_rts");
6853       else if (op == 0xd2)
6854         {
6855           unsigned char buf[9];
6856           unsigned int i, len;
6857           unsigned long offset;
6858
6859           for (i = 0; i < sizeof (buf); i++)
6860             {
6861               GET_OP (buf[i]);
6862               if ((buf[i] & 0x80) == 0)
6863                 break;
6864             }
6865           assert (i < sizeof (buf));
6866           offset = read_uleb128 (buf, &len);
6867           assert (len == i + 1);
6868           offset = offset * 8 + 0x408;
6869           printf (_("sp = sp + %ld"), offset);
6870         }
6871       else if ((op & 0xf0) == 0xe0)
6872         {
6873           if ((op & 0x0f) == 7)
6874             printf ("     RETURN");
6875           else
6876             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
6877         }
6878       else
6879         {
6880           printf (_("     [unsupported opcode]"));
6881         }
6882       putchar ('\n');
6883     }
6884 }
6885
6886 static bfd_vma
6887 arm_expand_prel31 (bfd_vma word, bfd_vma where)
6888 {
6889   bfd_vma offset;
6890
6891   offset = word & 0x7fffffff;
6892   if (offset & 0x40000000)
6893     offset |= ~ (bfd_vma) 0x7fffffff;
6894
6895   if (elf_header.e_machine == EM_TI_C6000)
6896     offset <<= 1;
6897
6898   return offset + where;
6899 }
6900
6901 static void
6902 decode_arm_unwind (struct arm_unw_aux_info *  aux,
6903                    unsigned int               word,
6904                    unsigned int               remaining,
6905                    bfd_vma                    data_offset,
6906                    Elf_Internal_Shdr *        data_sec,
6907                    struct arm_section *       data_arm_sec)
6908 {
6909   int per_index;
6910   unsigned int more_words = 0;
6911   struct absaddr addr;
6912   bfd_vma sym_name = (bfd_vma) -1;
6913
6914   if (remaining == 0)
6915     {
6916       /* Fetch the first word.
6917          Note - when decoding an object file the address extracted
6918          here will always be 0.  So we also pass in the sym_name
6919          parameter so that we can find the symbol associated with
6920          the personality routine.  */
6921       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
6922                                      & word, & addr, & sym_name))
6923         return;
6924
6925       remaining = 4;
6926     }
6927
6928   if ((word & 0x80000000) == 0)
6929     {
6930       /* Expand prel31 for personality routine.  */
6931       bfd_vma fn;
6932       const char *procname;
6933
6934       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
6935       printf (_("  Personality routine: "));
6936       if (fn == 0
6937           && addr.section == SHN_UNDEF && addr.offset == 0
6938           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
6939         {
6940           procname = aux->strtab + sym_name;
6941           print_vma (fn, PREFIX_HEX);
6942           if (procname)
6943             {
6944               fputs (" <", stdout);
6945               fputs (procname, stdout);
6946               fputc ('>', stdout);
6947             }
6948         }
6949       else
6950         procname = arm_print_vma_and_name (aux, fn, addr);
6951       fputc ('\n', stdout);
6952
6953       /* The GCC personality routines use the standard compact
6954          encoding, starting with one byte giving the number of
6955          words.  */
6956       if (procname != NULL
6957           && (const_strneq (procname, "__gcc_personality_v0")
6958               || const_strneq (procname, "__gxx_personality_v0")
6959               || const_strneq (procname, "__gcj_personality_v0")
6960               || const_strneq (procname, "__gnu_objc_personality_v0")))
6961         {
6962           remaining = 0;
6963           more_words = 1;
6964           ADVANCE;
6965           if (!remaining)
6966             {
6967               printf (_("  [Truncated data]\n"));
6968               return;
6969             }
6970           more_words = word >> 24;
6971           word <<= 8;
6972           remaining--;
6973           per_index = -1;
6974         }
6975       else
6976         return;
6977     }
6978   else
6979     {
6980       /* ARM EHABI Section 6.3:
6981
6982          An exception-handling table entry for the compact model looks like:
6983
6984            31 30-28 27-24 23-0
6985            -- ----- ----- ----
6986             1   0   index Data for personalityRoutine[index]    */
6987
6988       if (elf_header.e_machine == EM_ARM
6989           && (word & 0x70000000))
6990         warn (_("Corrupt ARM compact model table entry: %x \n"), word);
6991
6992       per_index = (word >> 24) & 0x7f;
6993       printf (_("  Compact model index: %d\n"), per_index);
6994       if (per_index == 0)
6995         {
6996           more_words = 0;
6997           word <<= 8;
6998           remaining--;
6999         }
7000       else if (per_index < 3)
7001         {
7002           more_words = (word >> 16) & 0xff;
7003           word <<= 16;
7004           remaining -= 2;
7005         }
7006     }
7007
7008   switch (elf_header.e_machine)
7009     {
7010     case EM_ARM:
7011       if (per_index < 3)
7012         {
7013           decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7014                                       data_offset, data_sec, data_arm_sec);
7015         }
7016       else
7017         {
7018           warn (_("Unknown ARM compact model index encountered\n"));
7019           printf (_("  [reserved]\n"));
7020         }
7021       break;
7022
7023     case EM_TI_C6000:
7024       if (per_index < 3)
7025         {
7026           decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
7027                                         data_offset, data_sec, data_arm_sec);
7028         }
7029       else if (per_index < 5)
7030         {
7031           if (((word >> 17) & 0x7f) == 0x7f)
7032             printf (_("  Restore stack from frame pointer\n"));
7033           else
7034             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
7035           printf (_("  Registers restored: "));
7036           if (per_index == 4)
7037             printf (" (compact) ");
7038           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7039           putchar ('\n');
7040           printf (_("  Return register: %s\n"),
7041                   tic6x_unwind_regnames[word & 0xf]);
7042         }
7043       else
7044         printf (_("  [reserved (%d)]\n"), per_index);
7045       break;
7046
7047     default:
7048       error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7049              elf_header.e_machine);
7050     }
7051
7052   /* Decode the descriptors.  Not implemented.  */
7053 }
7054
7055 static void
7056 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7057 {
7058   struct arm_section exidx_arm_sec, extab_arm_sec;
7059   unsigned int i, exidx_len;
7060
7061   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7062   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7063   exidx_len = exidx_sec->sh_size / 8;
7064
7065   for (i = 0; i < exidx_len; i++)
7066     {
7067       unsigned int exidx_fn, exidx_entry;
7068       struct absaddr fn_addr, entry_addr;
7069       bfd_vma fn;
7070
7071       fputc ('\n', stdout);
7072
7073       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7074                                      8 * i, & exidx_fn, & fn_addr, NULL)
7075           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7076                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
7077         {
7078           arm_free_section (& exidx_arm_sec);
7079           arm_free_section (& extab_arm_sec);
7080           return;
7081         }
7082
7083       /* ARM EHABI, Section 5:
7084          An index table entry consists of 2 words.
7085          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
7086       if (exidx_fn & 0x80000000)
7087         warn (_("corrupt index table entry: %x\n"), exidx_fn);
7088
7089       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
7090
7091       arm_print_vma_and_name (aux, fn, fn_addr);
7092       fputs (": ", stdout);
7093
7094       if (exidx_entry == 1)
7095         {
7096           print_vma (exidx_entry, PREFIX_HEX);
7097           fputs (" [cantunwind]\n", stdout);
7098         }
7099       else if (exidx_entry & 0x80000000)
7100         {
7101           print_vma (exidx_entry, PREFIX_HEX);
7102           fputc ('\n', stdout);
7103           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7104         }
7105       else
7106         {
7107           bfd_vma table, table_offset = 0;
7108           Elf_Internal_Shdr *table_sec;
7109
7110           fputs ("@", stdout);
7111           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
7112           print_vma (table, PREFIX_HEX);
7113           printf ("\n");
7114
7115           /* Locate the matching .ARM.extab.  */
7116           if (entry_addr.section != SHN_UNDEF
7117               && entry_addr.section < elf_header.e_shnum)
7118             {
7119               table_sec = section_headers + entry_addr.section;
7120               table_offset = entry_addr.offset;
7121             }
7122           else
7123             {
7124               table_sec = find_section_by_address (table);
7125               if (table_sec != NULL)
7126                 table_offset = table - table_sec->sh_addr;
7127             }
7128           if (table_sec == NULL)
7129             {
7130               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7131                     (unsigned long) table);
7132               continue;
7133             }
7134           decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7135                              &extab_arm_sec);
7136         }
7137     }
7138
7139   printf ("\n");
7140
7141   arm_free_section (&exidx_arm_sec);
7142   arm_free_section (&extab_arm_sec);
7143 }
7144
7145 /* Used for both ARM and C6X unwinding tables.  */
7146
7147 static void
7148 arm_process_unwind (FILE *file)
7149 {
7150   struct arm_unw_aux_info aux;
7151   Elf_Internal_Shdr *unwsec = NULL;
7152   Elf_Internal_Shdr *strsec;
7153   Elf_Internal_Shdr *sec;
7154   unsigned long i;
7155   unsigned int sec_type;
7156
7157   switch (elf_header.e_machine)
7158     {
7159     case EM_ARM:
7160       sec_type = SHT_ARM_EXIDX;
7161       break;
7162
7163     case EM_TI_C6000:
7164       sec_type = SHT_C6000_UNWIND;
7165       break;
7166
7167     default:
7168       error (_("Unsupported architecture type %d encountered when processing unwind table"),
7169              elf_header.e_machine);
7170       return;
7171     }
7172
7173   if (string_table == NULL)
7174     return;
7175
7176   memset (& aux, 0, sizeof (aux));
7177   aux.file = file;
7178
7179   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7180     {
7181       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7182         {
7183           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7184
7185           strsec = section_headers + sec->sh_link;
7186           assert (aux.strtab == NULL);
7187           aux.strtab = get_data (NULL, file, strsec->sh_offset,
7188                                  1, strsec->sh_size, _("string table"));
7189           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7190         }
7191       else if (sec->sh_type == sec_type)
7192         unwsec = sec;
7193     }
7194
7195   if (unwsec == NULL)
7196     printf (_("\nThere are no unwind sections in this file.\n"));
7197   else
7198     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7199       {
7200         if (sec->sh_type == sec_type)
7201           {
7202             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7203                     SECTION_NAME (sec),
7204                     (unsigned long) sec->sh_offset,
7205                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7206
7207             dump_arm_unwind (&aux, sec);
7208           }
7209       }
7210
7211   if (aux.symtab)
7212     free (aux.symtab);
7213   if (aux.strtab)
7214     free ((char *) aux.strtab);
7215 }
7216
7217 static void
7218 process_unwind (FILE * file)
7219 {
7220   struct unwind_handler
7221   {
7222     int machtype;
7223     void (* handler)(FILE *);
7224   } handlers[] =
7225   {
7226     { EM_ARM, arm_process_unwind },
7227     { EM_IA_64, ia64_process_unwind },
7228     { EM_PARISC, hppa_process_unwind },
7229     { EM_TI_C6000, arm_process_unwind },
7230     { 0, 0 }
7231   };
7232   int i;
7233
7234   if (!do_unwind)
7235     return;
7236
7237   for (i = 0; handlers[i].handler != NULL; i++)
7238     if (elf_header.e_machine == handlers[i].machtype)
7239       return handlers[i].handler (file);
7240
7241   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7242           get_machine_name (elf_header.e_machine));
7243 }
7244
7245 static void
7246 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
7247 {
7248   switch (entry->d_tag)
7249     {
7250     case DT_MIPS_FLAGS:
7251       if (entry->d_un.d_val == 0)
7252         printf (_("NONE"));
7253       else
7254         {
7255           static const char * opts[] =
7256           {
7257             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7258             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7259             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7260             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7261             "RLD_ORDER_SAFE"
7262           };
7263           unsigned int cnt;
7264           int first = 1;
7265
7266           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
7267             if (entry->d_un.d_val & (1 << cnt))
7268               {
7269                 printf ("%s%s", first ? "" : " ", opts[cnt]);
7270                 first = 0;
7271               }
7272         }
7273       break;
7274
7275     case DT_MIPS_IVERSION:
7276       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7277         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
7278       else
7279         printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
7280       break;
7281
7282     case DT_MIPS_TIME_STAMP:
7283       {
7284         char timebuf[20];
7285         struct tm * tmp;
7286
7287         time_t atime = entry->d_un.d_val;
7288         tmp = gmtime (&atime);
7289         snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7290                   tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7291                   tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7292         printf (_("Time Stamp: %s"), timebuf);
7293       }
7294       break;
7295
7296     case DT_MIPS_RLD_VERSION:
7297     case DT_MIPS_LOCAL_GOTNO:
7298     case DT_MIPS_CONFLICTNO:
7299     case DT_MIPS_LIBLISTNO:
7300     case DT_MIPS_SYMTABNO:
7301     case DT_MIPS_UNREFEXTNO:
7302     case DT_MIPS_HIPAGENO:
7303     case DT_MIPS_DELTA_CLASS_NO:
7304     case DT_MIPS_DELTA_INSTANCE_NO:
7305     case DT_MIPS_DELTA_RELOC_NO:
7306     case DT_MIPS_DELTA_SYM_NO:
7307     case DT_MIPS_DELTA_CLASSSYM_NO:
7308     case DT_MIPS_COMPACT_SIZE:
7309       print_vma (entry->d_un.d_ptr, DEC);
7310       break;
7311
7312     default:
7313       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7314     }
7315     putchar ('\n');
7316 }
7317
7318 static void
7319 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
7320 {
7321   switch (entry->d_tag)
7322     {
7323     case DT_HP_DLD_FLAGS:
7324       {
7325         static struct
7326         {
7327           long int bit;
7328           const char * str;
7329         }
7330         flags[] =
7331         {
7332           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7333           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7334           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7335           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7336           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7337           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7338           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7339           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7340           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7341           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
7342           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7343           { DT_HP_GST, "HP_GST" },
7344           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7345           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7346           { DT_HP_NODELETE, "HP_NODELETE" },
7347           { DT_HP_GROUP, "HP_GROUP" },
7348           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
7349         };
7350         int first = 1;
7351         size_t cnt;
7352         bfd_vma val = entry->d_un.d_val;
7353
7354         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
7355           if (val & flags[cnt].bit)
7356             {
7357               if (! first)
7358                 putchar (' ');
7359               fputs (flags[cnt].str, stdout);
7360               first = 0;
7361               val ^= flags[cnt].bit;
7362             }
7363
7364         if (val != 0 || first)
7365           {
7366             if (! first)
7367               putchar (' ');
7368             print_vma (val, HEX);
7369           }
7370       }
7371       break;
7372
7373     default:
7374       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7375       break;
7376     }
7377   putchar ('\n');
7378 }
7379
7380 #ifdef BFD64
7381
7382 /* VMS vs Unix time offset and factor.  */
7383
7384 #define VMS_EPOCH_OFFSET 35067168000000000LL
7385 #define VMS_GRANULARITY_FACTOR 10000000
7386
7387 /* Display a VMS time in a human readable format.  */
7388
7389 static void
7390 print_vms_time (bfd_int64_t vmstime)
7391 {
7392   struct tm *tm;
7393   time_t unxtime;
7394
7395   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7396   tm = gmtime (&unxtime);
7397   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7398           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7399           tm->tm_hour, tm->tm_min, tm->tm_sec);
7400 }
7401 #endif /* BFD64 */
7402
7403 static void
7404 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
7405 {
7406   switch (entry->d_tag)
7407     {
7408     case DT_IA_64_PLT_RESERVE:
7409       /* First 3 slots reserved.  */
7410       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7411       printf (" -- ");
7412       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
7413       break;
7414
7415     case DT_IA_64_VMS_LINKTIME:
7416 #ifdef BFD64
7417       print_vms_time (entry->d_un.d_val);
7418 #endif
7419       break;
7420
7421     case DT_IA_64_VMS_LNKFLAGS:
7422       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7423       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7424         printf (" CALL_DEBUG");
7425       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7426         printf (" NOP0BUFS");
7427       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7428         printf (" P0IMAGE");
7429       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7430         printf (" MKTHREADS");
7431       if (entry->d_un.d_val & VMS_LF_UPCALLS)
7432         printf (" UPCALLS");
7433       if (entry->d_un.d_val & VMS_LF_IMGSTA)
7434         printf (" IMGSTA");
7435       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7436         printf (" INITIALIZE");
7437       if (entry->d_un.d_val & VMS_LF_MAIN)
7438         printf (" MAIN");
7439       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7440         printf (" EXE_INIT");
7441       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7442         printf (" TBK_IN_IMG");
7443       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7444         printf (" DBG_IN_IMG");
7445       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7446         printf (" TBK_IN_DSF");
7447       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7448         printf (" DBG_IN_DSF");
7449       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7450         printf (" SIGNATURES");
7451       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7452         printf (" REL_SEG_OFF");
7453       break;
7454
7455     default:
7456       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7457       break;
7458     }
7459   putchar ('\n');
7460 }
7461
7462 static int
7463 get_32bit_dynamic_section (FILE * file)
7464 {
7465   Elf32_External_Dyn * edyn;
7466   Elf32_External_Dyn * ext;
7467   Elf_Internal_Dyn * entry;
7468
7469   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7470                                           dynamic_size, _("dynamic section"));
7471   if (!edyn)
7472     return 0;
7473
7474 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7475    might not have the luxury of section headers.  Look for the DT_NULL
7476    terminator to determine the number of entries.  */
7477   for (ext = edyn, dynamic_nent = 0;
7478        (char *) ext < (char *) edyn + dynamic_size;
7479        ext++)
7480     {
7481       dynamic_nent++;
7482       if (BYTE_GET (ext->d_tag) == DT_NULL)
7483         break;
7484     }
7485
7486   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7487                                                   sizeof (* entry));
7488   if (dynamic_section == NULL)
7489     {
7490       error (_("Out of memory\n"));
7491       free (edyn);
7492       return 0;
7493     }
7494
7495   for (ext = edyn, entry = dynamic_section;
7496        entry < dynamic_section + dynamic_nent;
7497        ext++, entry++)
7498     {
7499       entry->d_tag      = BYTE_GET (ext->d_tag);
7500       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7501     }
7502
7503   free (edyn);
7504
7505   return 1;
7506 }
7507
7508 static int
7509 get_64bit_dynamic_section (FILE * file)
7510 {
7511   Elf64_External_Dyn * edyn;
7512   Elf64_External_Dyn * ext;
7513   Elf_Internal_Dyn * entry;
7514
7515   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7516                                           dynamic_size, _("dynamic section"));
7517   if (!edyn)
7518     return 0;
7519
7520 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7521    might not have the luxury of section headers.  Look for the DT_NULL
7522    terminator to determine the number of entries.  */
7523   for (ext = edyn, dynamic_nent = 0;
7524        (char *) ext < (char *) edyn + dynamic_size;
7525        ext++)
7526     {
7527       dynamic_nent++;
7528       if (BYTE_GET (ext->d_tag) == DT_NULL)
7529         break;
7530     }
7531
7532   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7533                                                   sizeof (* entry));
7534   if (dynamic_section == NULL)
7535     {
7536       error (_("Out of memory\n"));
7537       free (edyn);
7538       return 0;
7539     }
7540
7541   for (ext = edyn, entry = dynamic_section;
7542        entry < dynamic_section + dynamic_nent;
7543        ext++, entry++)
7544     {
7545       entry->d_tag      = BYTE_GET (ext->d_tag);
7546       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7547     }
7548
7549   free (edyn);
7550
7551   return 1;
7552 }
7553
7554 static void
7555 print_dynamic_flags (bfd_vma flags)
7556 {
7557   int first = 1;
7558
7559   while (flags)
7560     {
7561       bfd_vma flag;
7562
7563       flag = flags & - flags;
7564       flags &= ~ flag;
7565
7566       if (first)
7567         first = 0;
7568       else
7569         putc (' ', stdout);
7570
7571       switch (flag)
7572         {
7573         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
7574         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
7575         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
7576         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
7577         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
7578         default:                fputs (_("unknown"), stdout); break;
7579         }
7580     }
7581   puts ("");
7582 }
7583
7584 /* Parse and display the contents of the dynamic section.  */
7585
7586 static int
7587 process_dynamic_section (FILE * file)
7588 {
7589   Elf_Internal_Dyn * entry;
7590
7591   if (dynamic_size == 0)
7592     {
7593       if (do_dynamic)
7594         printf (_("\nThere is no dynamic section in this file.\n"));
7595
7596       return 1;
7597     }
7598
7599   if (is_32bit_elf)
7600     {
7601       if (! get_32bit_dynamic_section (file))
7602         return 0;
7603     }
7604   else if (! get_64bit_dynamic_section (file))
7605     return 0;
7606
7607   /* Find the appropriate symbol table.  */
7608   if (dynamic_symbols == NULL)
7609     {
7610       for (entry = dynamic_section;
7611            entry < dynamic_section + dynamic_nent;
7612            ++entry)
7613         {
7614           Elf_Internal_Shdr section;
7615
7616           if (entry->d_tag != DT_SYMTAB)
7617             continue;
7618
7619           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7620
7621           /* Since we do not know how big the symbol table is,
7622              we default to reading in the entire file (!) and
7623              processing that.  This is overkill, I know, but it
7624              should work.  */
7625           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
7626
7627           if (archive_file_offset != 0)
7628             section.sh_size = archive_file_size - section.sh_offset;
7629           else
7630             {
7631               if (fseek (file, 0, SEEK_END))
7632                 error (_("Unable to seek to end of file!\n"));
7633
7634               section.sh_size = ftell (file) - section.sh_offset;
7635             }
7636
7637           if (is_32bit_elf)
7638             section.sh_entsize = sizeof (Elf32_External_Sym);
7639           else
7640             section.sh_entsize = sizeof (Elf64_External_Sym);
7641
7642           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
7643           if (num_dynamic_syms < 1)
7644             {
7645               error (_("Unable to determine the number of symbols to load\n"));
7646               continue;
7647             }
7648         }
7649     }
7650
7651   /* Similarly find a string table.  */
7652   if (dynamic_strings == NULL)
7653     {
7654       for (entry = dynamic_section;
7655            entry < dynamic_section + dynamic_nent;
7656            ++entry)
7657         {
7658           unsigned long offset;
7659           long str_tab_len;
7660
7661           if (entry->d_tag != DT_STRTAB)
7662             continue;
7663
7664           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7665
7666           /* Since we do not know how big the string table is,
7667              we default to reading in the entire file (!) and
7668              processing that.  This is overkill, I know, but it
7669              should work.  */
7670
7671           offset = offset_from_vma (file, entry->d_un.d_val, 0);
7672
7673           if (archive_file_offset != 0)
7674             str_tab_len = archive_file_size - offset;
7675           else
7676             {
7677               if (fseek (file, 0, SEEK_END))
7678                 error (_("Unable to seek to end of file\n"));
7679               str_tab_len = ftell (file) - offset;
7680             }
7681
7682           if (str_tab_len < 1)
7683             {
7684               error
7685                 (_("Unable to determine the length of the dynamic string table\n"));
7686               continue;
7687             }
7688
7689           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7690                                                str_tab_len,
7691                                                _("dynamic string table"));
7692           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
7693           break;
7694         }
7695     }
7696
7697   /* And find the syminfo section if available.  */
7698   if (dynamic_syminfo == NULL)
7699     {
7700       unsigned long syminsz = 0;
7701
7702       for (entry = dynamic_section;
7703            entry < dynamic_section + dynamic_nent;
7704            ++entry)
7705         {
7706           if (entry->d_tag == DT_SYMINENT)
7707             {
7708               /* Note: these braces are necessary to avoid a syntax
7709                  error from the SunOS4 C compiler.  */
7710               assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7711             }
7712           else if (entry->d_tag == DT_SYMINSZ)
7713             syminsz = entry->d_un.d_val;
7714           else if (entry->d_tag == DT_SYMINFO)
7715             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7716                                                       syminsz);
7717         }
7718
7719       if (dynamic_syminfo_offset != 0 && syminsz != 0)
7720         {
7721           Elf_External_Syminfo * extsyminfo;
7722           Elf_External_Syminfo * extsym;
7723           Elf_Internal_Syminfo * syminfo;
7724
7725           /* There is a syminfo section.  Read the data.  */
7726           extsyminfo = (Elf_External_Syminfo *)
7727               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7728                         _("symbol information"));
7729           if (!extsyminfo)
7730             return 0;
7731
7732           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
7733           if (dynamic_syminfo == NULL)
7734             {
7735               error (_("Out of memory\n"));
7736               return 0;
7737             }
7738
7739           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
7740           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7741                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7742                ++syminfo, ++extsym)
7743             {
7744               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7745               syminfo->si_flags = BYTE_GET (extsym->si_flags);
7746             }
7747
7748           free (extsyminfo);
7749         }
7750     }
7751
7752   if (do_dynamic && dynamic_addr)
7753     printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7754             dynamic_addr, dynamic_nent);
7755   if (do_dynamic)
7756     printf (_("  Tag        Type                         Name/Value\n"));
7757
7758   for (entry = dynamic_section;
7759        entry < dynamic_section + dynamic_nent;
7760        entry++)
7761     {
7762       if (do_dynamic)
7763         {
7764           const char * dtype;
7765
7766           putchar (' ');
7767           print_vma (entry->d_tag, FULL_HEX);
7768           dtype = get_dynamic_type (entry->d_tag);
7769           printf (" (%s)%*s", dtype,
7770                   ((is_32bit_elf ? 27 : 19)
7771                    - (int) strlen (dtype)),
7772                   " ");
7773         }
7774
7775       switch (entry->d_tag)
7776         {
7777         case DT_FLAGS:
7778           if (do_dynamic)
7779             print_dynamic_flags (entry->d_un.d_val);
7780           break;
7781
7782         case DT_AUXILIARY:
7783         case DT_FILTER:
7784         case DT_CONFIG:
7785         case DT_DEPAUDIT:
7786         case DT_AUDIT:
7787           if (do_dynamic)
7788             {
7789               switch (entry->d_tag)
7790                 {
7791                 case DT_AUXILIARY:
7792                   printf (_("Auxiliary library"));
7793                   break;
7794
7795                 case DT_FILTER:
7796                   printf (_("Filter library"));
7797                   break;
7798
7799                 case DT_CONFIG:
7800                   printf (_("Configuration file"));
7801                   break;
7802
7803                 case DT_DEPAUDIT:
7804                   printf (_("Dependency audit library"));
7805                   break;
7806
7807                 case DT_AUDIT:
7808                   printf (_("Audit library"));
7809                   break;
7810                 }
7811
7812               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7813                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
7814               else
7815                 {
7816                   printf (": ");
7817                   print_vma (entry->d_un.d_val, PREFIX_HEX);
7818                   putchar ('\n');
7819                 }
7820             }
7821           break;
7822
7823         case DT_FEATURE:
7824           if (do_dynamic)
7825             {
7826               printf (_("Flags:"));
7827
7828               if (entry->d_un.d_val == 0)
7829                 printf (_(" None\n"));
7830               else
7831                 {
7832                   unsigned long int val = entry->d_un.d_val;
7833
7834                   if (val & DTF_1_PARINIT)
7835                     {
7836                       printf (" PARINIT");
7837                       val ^= DTF_1_PARINIT;
7838                     }
7839                   if (val & DTF_1_CONFEXP)
7840                     {
7841                       printf (" CONFEXP");
7842                       val ^= DTF_1_CONFEXP;
7843                     }
7844                   if (val != 0)
7845                     printf (" %lx", val);
7846                   puts ("");
7847                 }
7848             }
7849           break;
7850
7851         case DT_POSFLAG_1:
7852           if (do_dynamic)
7853             {
7854               printf (_("Flags:"));
7855
7856               if (entry->d_un.d_val == 0)
7857                 printf (_(" None\n"));
7858               else
7859                 {
7860                   unsigned long int val = entry->d_un.d_val;
7861
7862                   if (val & DF_P1_LAZYLOAD)
7863                     {
7864                       printf (" LAZYLOAD");
7865                       val ^= DF_P1_LAZYLOAD;
7866                     }
7867                   if (val & DF_P1_GROUPPERM)
7868                     {
7869                       printf (" GROUPPERM");
7870                       val ^= DF_P1_GROUPPERM;
7871                     }
7872                   if (val != 0)
7873                     printf (" %lx", val);
7874                   puts ("");
7875                 }
7876             }
7877           break;
7878
7879         case DT_FLAGS_1:
7880           if (do_dynamic)
7881             {
7882               printf (_("Flags:"));
7883               if (entry->d_un.d_val == 0)
7884                 printf (_(" None\n"));
7885               else
7886                 {
7887                   unsigned long int val = entry->d_un.d_val;
7888
7889                   if (val & DF_1_NOW)
7890                     {
7891                       printf (" NOW");
7892                       val ^= DF_1_NOW;
7893                     }
7894                   if (val & DF_1_GLOBAL)
7895                     {
7896                       printf (" GLOBAL");
7897                       val ^= DF_1_GLOBAL;
7898                     }
7899                   if (val & DF_1_GROUP)
7900                     {
7901                       printf (" GROUP");
7902                       val ^= DF_1_GROUP;
7903                     }
7904                   if (val & DF_1_NODELETE)
7905                     {
7906                       printf (" NODELETE");
7907                       val ^= DF_1_NODELETE;
7908                     }
7909                   if (val & DF_1_LOADFLTR)
7910                     {
7911                       printf (" LOADFLTR");
7912                       val ^= DF_1_LOADFLTR;
7913                     }
7914                   if (val & DF_1_INITFIRST)
7915                     {
7916                       printf (" INITFIRST");
7917                       val ^= DF_1_INITFIRST;
7918                     }
7919                   if (val & DF_1_NOOPEN)
7920                     {
7921                       printf (" NOOPEN");
7922                       val ^= DF_1_NOOPEN;
7923                     }
7924                   if (val & DF_1_ORIGIN)
7925                     {
7926                       printf (" ORIGIN");
7927                       val ^= DF_1_ORIGIN;
7928                     }
7929                   if (val & DF_1_DIRECT)
7930                     {
7931                       printf (" DIRECT");
7932                       val ^= DF_1_DIRECT;
7933                     }
7934                   if (val & DF_1_TRANS)
7935                     {
7936                       printf (" TRANS");
7937                       val ^= DF_1_TRANS;
7938                     }
7939                   if (val & DF_1_INTERPOSE)
7940                     {
7941                       printf (" INTERPOSE");
7942                       val ^= DF_1_INTERPOSE;
7943                     }
7944                   if (val & DF_1_NODEFLIB)
7945                     {
7946                       printf (" NODEFLIB");
7947                       val ^= DF_1_NODEFLIB;
7948                     }
7949                   if (val & DF_1_NODUMP)
7950                     {
7951                       printf (" NODUMP");
7952                       val ^= DF_1_NODUMP;
7953                     }
7954                   if (val & DF_1_CONLFAT)
7955                     {
7956                       printf (" CONLFAT");
7957                       val ^= DF_1_CONLFAT;
7958                     }
7959                   if (val != 0)
7960                     printf (" %lx", val);
7961                   puts ("");
7962                 }
7963             }
7964           break;
7965
7966         case DT_PLTREL:
7967           dynamic_info[entry->d_tag] = entry->d_un.d_val;
7968           if (do_dynamic)
7969             puts (get_dynamic_type (entry->d_un.d_val));
7970           break;
7971
7972         case DT_NULL    :
7973         case DT_NEEDED  :
7974         case DT_PLTGOT  :
7975         case DT_HASH    :
7976         case DT_STRTAB  :
7977         case DT_SYMTAB  :
7978         case DT_RELA    :
7979         case DT_INIT    :
7980         case DT_FINI    :
7981         case DT_SONAME  :
7982         case DT_RPATH   :
7983         case DT_SYMBOLIC:
7984         case DT_REL     :
7985         case DT_DEBUG   :
7986         case DT_TEXTREL :
7987         case DT_JMPREL  :
7988         case DT_RUNPATH :
7989           dynamic_info[entry->d_tag] = entry->d_un.d_val;
7990
7991           if (do_dynamic)
7992             {
7993               char * name;
7994
7995               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7996                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
7997               else
7998                 name = NULL;
7999
8000               if (name)
8001                 {
8002                   switch (entry->d_tag)
8003                     {
8004                     case DT_NEEDED:
8005                       printf (_("Shared library: [%s]"), name);
8006
8007                       if (streq (name, program_interpreter))
8008                         printf (_(" program interpreter"));
8009                       break;
8010
8011                     case DT_SONAME:
8012                       printf (_("Library soname: [%s]"), name);
8013                       break;
8014
8015                     case DT_RPATH:
8016                       printf (_("Library rpath: [%s]"), name);
8017                       break;
8018
8019                     case DT_RUNPATH:
8020                       printf (_("Library runpath: [%s]"), name);
8021                       break;
8022
8023                     default:
8024                       print_vma (entry->d_un.d_val, PREFIX_HEX);
8025                       break;
8026                     }
8027                 }
8028               else
8029                 print_vma (entry->d_un.d_val, PREFIX_HEX);
8030
8031               putchar ('\n');
8032             }
8033           break;
8034
8035         case DT_PLTRELSZ:
8036         case DT_RELASZ  :
8037         case DT_STRSZ   :
8038         case DT_RELSZ   :
8039         case DT_RELAENT :
8040         case DT_SYMENT  :
8041         case DT_RELENT  :
8042           dynamic_info[entry->d_tag] = entry->d_un.d_val;
8043         case DT_PLTPADSZ:
8044         case DT_MOVEENT :
8045         case DT_MOVESZ  :
8046         case DT_INIT_ARRAYSZ:
8047         case DT_FINI_ARRAYSZ:
8048         case DT_GNU_CONFLICTSZ:
8049         case DT_GNU_LIBLISTSZ:
8050           if (do_dynamic)
8051             {
8052               print_vma (entry->d_un.d_val, UNSIGNED);
8053               printf (_(" (bytes)\n"));
8054             }
8055           break;
8056
8057         case DT_VERDEFNUM:
8058         case DT_VERNEEDNUM:
8059         case DT_RELACOUNT:
8060         case DT_RELCOUNT:
8061           if (do_dynamic)
8062             {
8063               print_vma (entry->d_un.d_val, UNSIGNED);
8064               putchar ('\n');
8065             }
8066           break;
8067
8068         case DT_SYMINSZ:
8069         case DT_SYMINENT:
8070         case DT_SYMINFO:
8071         case DT_USED:
8072         case DT_INIT_ARRAY:
8073         case DT_FINI_ARRAY:
8074           if (do_dynamic)
8075             {
8076               if (entry->d_tag == DT_USED
8077                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
8078                 {
8079                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8080
8081                   if (*name)
8082                     {
8083                       printf (_("Not needed object: [%s]\n"), name);
8084                       break;
8085                     }
8086                 }
8087
8088               print_vma (entry->d_un.d_val, PREFIX_HEX);
8089               putchar ('\n');
8090             }
8091           break;
8092
8093         case DT_BIND_NOW:
8094           /* The value of this entry is ignored.  */
8095           if (do_dynamic)
8096             putchar ('\n');
8097           break;
8098
8099         case DT_GNU_PRELINKED:
8100           if (do_dynamic)
8101             {
8102               struct tm * tmp;
8103               time_t atime = entry->d_un.d_val;
8104
8105               tmp = gmtime (&atime);
8106               printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8107                       tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8108                       tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8109
8110             }
8111           break;
8112
8113         case DT_GNU_HASH:
8114           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8115           if (do_dynamic)
8116             {
8117               print_vma (entry->d_un.d_val, PREFIX_HEX);
8118               putchar ('\n');
8119             }
8120           break;
8121
8122         default:
8123           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
8124             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
8125               entry->d_un.d_val;
8126
8127           if (do_dynamic)
8128             {
8129               switch (elf_header.e_machine)
8130                 {
8131                 case EM_MIPS:
8132                 case EM_MIPS_RS3_LE:
8133                   dynamic_section_mips_val (entry);
8134                   break;
8135                 case EM_PARISC:
8136                   dynamic_section_parisc_val (entry);
8137                   break;
8138                 case EM_IA_64:
8139                   dynamic_section_ia64_val (entry);
8140                   break;
8141                 default:
8142                   print_vma (entry->d_un.d_val, PREFIX_HEX);
8143                   putchar ('\n');
8144                 }
8145             }
8146           break;
8147         }
8148     }
8149
8150   return 1;
8151 }
8152
8153 static char *
8154 get_ver_flags (unsigned int flags)
8155 {
8156   static char buff[32];
8157
8158   buff[0] = 0;
8159
8160   if (flags == 0)
8161     return _("none");
8162
8163   if (flags & VER_FLG_BASE)
8164     strcat (buff, "BASE ");
8165
8166   if (flags & VER_FLG_WEAK)
8167     {
8168       if (flags & VER_FLG_BASE)
8169         strcat (buff, "| ");
8170
8171       strcat (buff, "WEAK ");
8172     }
8173
8174   if (flags & VER_FLG_INFO)
8175     {
8176       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8177         strcat (buff, "| ");
8178
8179       strcat (buff, "INFO ");
8180     }
8181
8182   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
8183     strcat (buff, _("| <unknown>"));
8184
8185   return buff;
8186 }
8187
8188 /* Display the contents of the version sections.  */
8189
8190 static int
8191 process_version_sections (FILE * file)
8192 {
8193   Elf_Internal_Shdr * section;
8194   unsigned i;
8195   int found = 0;
8196
8197   if (! do_version)
8198     return 1;
8199
8200   for (i = 0, section = section_headers;
8201        i < elf_header.e_shnum;
8202        i++, section++)
8203     {
8204       switch (section->sh_type)
8205         {
8206         case SHT_GNU_verdef:
8207           {
8208             Elf_External_Verdef * edefs;
8209             unsigned int idx;
8210             unsigned int cnt;
8211             char * endbuf;
8212
8213             found = 1;
8214
8215             printf
8216               (_("\nVersion definition section '%s' contains %u entries:\n"),
8217                SECTION_NAME (section), section->sh_info);
8218
8219             printf (_("  Addr: 0x"));
8220             printf_vma (section->sh_addr);
8221             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8222                     (unsigned long) section->sh_offset, section->sh_link,
8223                     section->sh_link < elf_header.e_shnum
8224                     ? SECTION_NAME (section_headers + section->sh_link)
8225                     : _("<corrupt>"));
8226
8227             edefs = (Elf_External_Verdef *)
8228                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8229                           _("version definition section"));
8230             if (!edefs)
8231               break;
8232             endbuf = (char *) edefs + section->sh_size;
8233
8234             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8235               {
8236                 char * vstart;
8237                 Elf_External_Verdef * edef;
8238                 Elf_Internal_Verdef ent;
8239                 Elf_External_Verdaux * eaux;
8240                 Elf_Internal_Verdaux aux;
8241                 int j;
8242                 int isum;
8243
8244                 /* Check for negative or very large indicies.  */
8245                 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
8246                   break;
8247
8248                 vstart = ((char *) edefs) + idx;
8249                 if (vstart + sizeof (*edef) > endbuf)
8250                   break;
8251
8252                 edef = (Elf_External_Verdef *) vstart;
8253
8254                 ent.vd_version = BYTE_GET (edef->vd_version);
8255                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
8256                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
8257                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
8258                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
8259                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
8260                 ent.vd_next    = BYTE_GET (edef->vd_next);
8261
8262                 printf (_("  %#06x: Rev: %d  Flags: %s"),
8263                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8264
8265                 printf (_("  Index: %d  Cnt: %d  "),
8266                         ent.vd_ndx, ent.vd_cnt);
8267
8268                 /* Check for overflow.  */
8269                 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
8270                     || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
8271                   break;
8272
8273                 vstart += ent.vd_aux;
8274
8275                 eaux = (Elf_External_Verdaux *) vstart;
8276
8277                 aux.vda_name = BYTE_GET (eaux->vda_name);
8278                 aux.vda_next = BYTE_GET (eaux->vda_next);
8279
8280                 if (VALID_DYNAMIC_NAME (aux.vda_name))
8281                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
8282                 else
8283                   printf (_("Name index: %ld\n"), aux.vda_name);
8284
8285                 isum = idx + ent.vd_aux;
8286
8287                 for (j = 1; j < ent.vd_cnt; j++)
8288                   {
8289                     /* Check for overflow.  */
8290                     if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
8291                         || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
8292                       break;
8293
8294                     isum   += aux.vda_next;
8295                     vstart += aux.vda_next;
8296
8297                     eaux = (Elf_External_Verdaux *) vstart;
8298                     if (vstart + sizeof (*eaux) > endbuf)
8299                       break;
8300
8301                     aux.vda_name = BYTE_GET (eaux->vda_name);
8302                     aux.vda_next = BYTE_GET (eaux->vda_next);
8303
8304                     if (VALID_DYNAMIC_NAME (aux.vda_name))
8305                       printf (_("  %#06x: Parent %d: %s\n"),
8306                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
8307                     else
8308                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
8309                               isum, j, aux.vda_name);
8310                   }
8311
8312                 if (j < ent.vd_cnt)
8313                   printf (_("  Version def aux past end of section\n"));
8314
8315                 idx += ent.vd_next;
8316               }
8317
8318             if (cnt < section->sh_info)
8319               printf (_("  Version definition past end of section\n"));
8320
8321             free (edefs);
8322           }
8323           break;
8324
8325         case SHT_GNU_verneed:
8326           {
8327             Elf_External_Verneed * eneed;
8328             unsigned int idx;
8329             unsigned int cnt;
8330             char * endbuf;
8331
8332             found = 1;
8333
8334             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8335                     SECTION_NAME (section), section->sh_info);
8336
8337             printf (_(" Addr: 0x"));
8338             printf_vma (section->sh_addr);
8339             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8340                     (unsigned long) section->sh_offset, section->sh_link,
8341                     section->sh_link < elf_header.e_shnum
8342                     ? SECTION_NAME (section_headers + section->sh_link)
8343                     : _("<corrupt>"));
8344
8345             eneed = (Elf_External_Verneed *) get_data (NULL, file,
8346                                                        section->sh_offset, 1,
8347                                                        section->sh_size,
8348                                                        _("Version Needs section"));
8349             if (!eneed)
8350               break;
8351             endbuf = (char *) eneed + section->sh_size;
8352
8353             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8354               {
8355                 Elf_External_Verneed * entry;
8356                 Elf_Internal_Verneed ent;
8357                 int j;
8358                 int isum;
8359                 char * vstart;
8360
8361                 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
8362                   break;
8363
8364                 vstart = ((char *) eneed) + idx;
8365                 if (vstart + sizeof (*entry) > endbuf)
8366                   break;
8367
8368                 entry = (Elf_External_Verneed *) vstart;
8369
8370                 ent.vn_version = BYTE_GET (entry->vn_version);
8371                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
8372                 ent.vn_file    = BYTE_GET (entry->vn_file);
8373                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
8374                 ent.vn_next    = BYTE_GET (entry->vn_next);
8375
8376                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
8377
8378                 if (VALID_DYNAMIC_NAME (ent.vn_file))
8379                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
8380                 else
8381                   printf (_("  File: %lx"), ent.vn_file);
8382
8383                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
8384
8385                 /* Check for overflow.  */
8386                 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
8387                     || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
8388                   break;
8389
8390                 vstart += ent.vn_aux;
8391
8392                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8393                   {
8394                     Elf_External_Vernaux * eaux;
8395                     Elf_Internal_Vernaux aux;
8396
8397                     if (vstart + sizeof (*eaux) > endbuf)
8398                       break;
8399                     eaux = (Elf_External_Vernaux *) vstart;
8400
8401                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
8402                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
8403                     aux.vna_other = BYTE_GET (eaux->vna_other);
8404                     aux.vna_name  = BYTE_GET (eaux->vna_name);
8405                     aux.vna_next  = BYTE_GET (eaux->vna_next);
8406
8407                     if (VALID_DYNAMIC_NAME (aux.vna_name))
8408                       printf (_("  %#06x:   Name: %s"),
8409                               isum, GET_DYNAMIC_NAME (aux.vna_name));
8410                     else
8411                       printf (_("  %#06x:   Name index: %lx"),
8412                               isum, aux.vna_name);
8413
8414                     printf (_("  Flags: %s  Version: %d\n"),
8415                             get_ver_flags (aux.vna_flags), aux.vna_other);
8416
8417                     /* Check for overflow.  */
8418                     if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
8419                         || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
8420                       break;
8421
8422                     isum   += aux.vna_next;
8423                     vstart += aux.vna_next;
8424                   }
8425
8426                 if (j < ent.vn_cnt)
8427                   warn (_("Missing Version Needs auxillary information\n"));
8428
8429                 idx += ent.vn_next;
8430               }
8431
8432             if (cnt < section->sh_info)
8433               warn (_("Missing Version Needs information\n"));
8434
8435             free (eneed);
8436           }
8437           break;
8438
8439         case SHT_GNU_versym:
8440           {
8441             Elf_Internal_Shdr * link_section;
8442             int total;
8443             int cnt;
8444             unsigned char * edata;
8445             unsigned short * data;
8446             char * strtab;
8447             Elf_Internal_Sym * symbols;
8448             Elf_Internal_Shdr * string_sec;
8449             unsigned long num_syms;
8450             long off;
8451
8452             if (section->sh_link >= elf_header.e_shnum)
8453               break;
8454
8455             link_section = section_headers + section->sh_link;
8456             total = section->sh_size / sizeof (Elf_External_Versym);
8457
8458             if (link_section->sh_link >= elf_header.e_shnum)
8459               break;
8460
8461             found = 1;
8462
8463             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
8464             if (symbols == NULL)
8465               break;
8466
8467             string_sec = section_headers + link_section->sh_link;
8468
8469             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8470                                         string_sec->sh_size,
8471                                         _("version string table"));
8472             if (!strtab)
8473               {
8474                 free (symbols);
8475                 break;
8476               }
8477
8478             printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8479                     SECTION_NAME (section), total);
8480
8481             printf (_(" Addr: "));
8482             printf_vma (section->sh_addr);
8483             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
8484                     (unsigned long) section->sh_offset, section->sh_link,
8485                     SECTION_NAME (link_section));
8486
8487             off = offset_from_vma (file,
8488                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8489                                    total * sizeof (short));
8490             edata = (unsigned char *) get_data (NULL, file, off, total,
8491                                                 sizeof (short),
8492                                                 _("version symbol data"));
8493             if (!edata)
8494               {
8495                 free (strtab);
8496                 free (symbols);
8497                 break;
8498               }
8499
8500             data = (short unsigned int *) cmalloc (total, sizeof (short));
8501
8502             for (cnt = total; cnt --;)
8503               data[cnt] = byte_get (edata + cnt * sizeof (short),
8504                                     sizeof (short));
8505
8506             free (edata);
8507
8508             for (cnt = 0; cnt < total; cnt += 4)
8509               {
8510                 int j, nn;
8511                 int check_def, check_need;
8512                 char * name;
8513
8514                 printf ("  %03x:", cnt);
8515
8516                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
8517                   switch (data[cnt + j])
8518                     {
8519                     case 0:
8520                       fputs (_("   0 (*local*)    "), stdout);
8521                       break;
8522
8523                     case 1:
8524                       fputs (_("   1 (*global*)   "), stdout);
8525                       break;
8526
8527                     default:
8528                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8529                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
8530
8531                       /* If this index value is greater than the size of the symbols
8532                          array, break to avoid an out-of-bounds read.  */
8533                       if ((unsigned long)(cnt + j) >= num_syms)
8534                         {
8535                           warn (_("invalid index into symbol array\n"));
8536                           break;
8537                         }
8538
8539                       check_def = 1;
8540                       check_need = 1;
8541                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8542                           || section_headers[symbols[cnt + j].st_shndx].sh_type
8543                              != SHT_NOBITS)
8544                         {
8545                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
8546                             check_def = 0;
8547                           else
8548                             check_need = 0;
8549                         }
8550
8551                       if (check_need
8552                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
8553                         {
8554                           Elf_Internal_Verneed ivn;
8555                           unsigned long offset;
8556
8557                           offset = offset_from_vma
8558                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8559                              sizeof (Elf_External_Verneed));
8560
8561                           do
8562                             {
8563                               Elf_Internal_Vernaux ivna;
8564                               Elf_External_Verneed evn;
8565                               Elf_External_Vernaux evna;
8566                               unsigned long a_off;
8567
8568                               if (get_data (&evn, file, offset, sizeof (evn), 1,
8569                                             _("version need")) == NULL)
8570                                 break;
8571
8572                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
8573                               ivn.vn_next = BYTE_GET (evn.vn_next);
8574
8575                               a_off = offset + ivn.vn_aux;
8576
8577                               do
8578                                 {
8579                                   if (get_data (&evna, file, a_off, sizeof (evna),
8580                                                 1, _("version need aux (2)")) == NULL)
8581                                     {
8582                                       ivna.vna_next  = 0;
8583                                       ivna.vna_other = 0;
8584                                     }
8585                                   else
8586                                     {
8587                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
8588                                       ivna.vna_other = BYTE_GET (evna.vna_other);
8589                                     }
8590
8591                                   a_off += ivna.vna_next;
8592                                 }
8593                               while (ivna.vna_other != data[cnt + j]
8594                                      && ivna.vna_next != 0);
8595
8596                               if (ivna.vna_other == data[cnt + j])
8597                                 {
8598                                   ivna.vna_name = BYTE_GET (evna.vna_name);
8599
8600                                   if (ivna.vna_name >= string_sec->sh_size)
8601                                     name = _("*invalid*");
8602                                   else
8603                                     name = strtab + ivna.vna_name;
8604                                   nn += printf ("(%s%-*s",
8605                                                 name,
8606                                                 12 - (int) strlen (name),
8607                                                 ")");
8608                                   check_def = 0;
8609                                   break;
8610                                 }
8611
8612                               offset += ivn.vn_next;
8613                             }
8614                           while (ivn.vn_next);
8615                         }
8616
8617                       if (check_def && data[cnt + j] != 0x8001
8618                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8619                         {
8620                           Elf_Internal_Verdef ivd;
8621                           Elf_External_Verdef evd;
8622                           unsigned long offset;
8623
8624                           offset = offset_from_vma
8625                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8626                              sizeof evd);
8627
8628                           do
8629                             {
8630                               if (get_data (&evd, file, offset, sizeof (evd), 1,
8631                                             _("version def")) == NULL)
8632                                 {
8633                                   ivd.vd_next = 0;
8634                                   ivd.vd_ndx  = 0;
8635                                 }
8636                               else
8637                                 {
8638                                   ivd.vd_next = BYTE_GET (evd.vd_next);
8639                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
8640                                 }
8641
8642                               offset += ivd.vd_next;
8643                             }
8644                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
8645                                  && ivd.vd_next != 0);
8646
8647                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
8648                             {
8649                               Elf_External_Verdaux evda;
8650                               Elf_Internal_Verdaux ivda;
8651
8652                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
8653
8654                               if (get_data (&evda, file,
8655                                             offset - ivd.vd_next + ivd.vd_aux,
8656                                             sizeof (evda), 1,
8657                                             _("version def aux")) == NULL)
8658                                 break;
8659
8660                               ivda.vda_name = BYTE_GET (evda.vda_name);
8661
8662                               if (ivda.vda_name >= string_sec->sh_size)
8663                                 name = _("*invalid*");
8664                               else
8665                                 name = strtab + ivda.vda_name;
8666                               nn += printf ("(%s%-*s",
8667                                             name,
8668                                             12 - (int) strlen (name),
8669                                             ")");
8670                             }
8671                         }
8672
8673                       if (nn < 18)
8674                         printf ("%*c", 18 - nn, ' ');
8675                     }
8676
8677                 putchar ('\n');
8678               }
8679
8680             free (data);
8681             free (strtab);
8682             free (symbols);
8683           }
8684           break;
8685
8686         default:
8687           break;
8688         }
8689     }
8690
8691   if (! found)
8692     printf (_("\nNo version information found in this file.\n"));
8693
8694   return 1;
8695 }
8696
8697 static const char *
8698 get_symbol_binding (unsigned int binding)
8699 {
8700   static char buff[32];
8701
8702   switch (binding)
8703     {
8704     case STB_LOCAL:     return "LOCAL";
8705     case STB_GLOBAL:    return "GLOBAL";
8706     case STB_WEAK:      return "WEAK";
8707     default:
8708       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
8709         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8710                   binding);
8711       else if (binding >= STB_LOOS && binding <= STB_HIOS)
8712         {
8713           if (binding == STB_GNU_UNIQUE
8714               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8715                   /* GNU is still using the default value 0.  */
8716                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8717             return "UNIQUE";
8718           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8719         }
8720       else
8721         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
8722       return buff;
8723     }
8724 }
8725
8726 static const char *
8727 get_symbol_type (unsigned int type)
8728 {
8729   static char buff[32];
8730
8731   switch (type)
8732     {
8733     case STT_NOTYPE:    return "NOTYPE";
8734     case STT_OBJECT:    return "OBJECT";
8735     case STT_FUNC:      return "FUNC";
8736     case STT_SECTION:   return "SECTION";
8737     case STT_FILE:      return "FILE";
8738     case STT_COMMON:    return "COMMON";
8739     case STT_TLS:       return "TLS";
8740     case STT_RELC:      return "RELC";
8741     case STT_SRELC:     return "SRELC";
8742     default:
8743       if (type >= STT_LOPROC && type <= STT_HIPROC)
8744         {
8745           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
8746             return "THUMB_FUNC";
8747
8748           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
8749             return "REGISTER";
8750
8751           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8752             return "PARISC_MILLI";
8753
8754           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
8755         }
8756       else if (type >= STT_LOOS && type <= STT_HIOS)
8757         {
8758           if (elf_header.e_machine == EM_PARISC)
8759             {
8760               if (type == STT_HP_OPAQUE)
8761                 return "HP_OPAQUE";
8762               if (type == STT_HP_STUB)
8763                 return "HP_STUB";
8764             }
8765
8766           if (type == STT_GNU_IFUNC
8767               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8768                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
8769                   /* GNU is still using the default value 0.  */
8770                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8771             return "IFUNC";
8772
8773           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
8774         }
8775       else
8776         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
8777       return buff;
8778     }
8779 }
8780
8781 static const char *
8782 get_symbol_visibility (unsigned int visibility)
8783 {
8784   switch (visibility)
8785     {
8786     case STV_DEFAULT:   return "DEFAULT";
8787     case STV_INTERNAL:  return "INTERNAL";
8788     case STV_HIDDEN:    return "HIDDEN";
8789     case STV_PROTECTED: return "PROTECTED";
8790     default: abort ();
8791     }
8792 }
8793
8794 static const char *
8795 get_mips_symbol_other (unsigned int other)
8796 {
8797   switch (other)
8798     {
8799     case STO_OPTIONAL:
8800       return "OPTIONAL";
8801     case STO_MIPS_PLT:
8802       return "MIPS PLT";
8803     case STO_MIPS_PIC:
8804       return "MIPS PIC";
8805     case STO_MICROMIPS:
8806       return "MICROMIPS";
8807     case STO_MICROMIPS | STO_MIPS_PIC:
8808       return "MICROMIPS, MIPS PIC";
8809     case STO_MIPS16:
8810       return "MIPS16";
8811     default:
8812       return NULL;
8813     }
8814 }
8815
8816 static const char *
8817 get_ia64_symbol_other (unsigned int other)
8818 {
8819   if (is_ia64_vms ())
8820     {
8821       static char res[32];
8822
8823       res[0] = 0;
8824
8825       /* Function types is for images and .STB files only.  */
8826       switch (elf_header.e_type)
8827         {
8828         case ET_DYN:
8829         case ET_EXEC:
8830           switch (VMS_ST_FUNC_TYPE (other))
8831             {
8832             case VMS_SFT_CODE_ADDR:
8833               strcat (res, " CA");
8834               break;
8835             case VMS_SFT_SYMV_IDX:
8836               strcat (res, " VEC");
8837               break;
8838             case VMS_SFT_FD:
8839               strcat (res, " FD");
8840               break;
8841             case VMS_SFT_RESERVE:
8842               strcat (res, " RSV");
8843               break;
8844             default:
8845               abort ();
8846             }
8847           break;
8848         default:
8849           break;
8850         }
8851       switch (VMS_ST_LINKAGE (other))
8852         {
8853         case VMS_STL_IGNORE:
8854           strcat (res, " IGN");
8855           break;
8856         case VMS_STL_RESERVE:
8857           strcat (res, " RSV");
8858           break;
8859         case VMS_STL_STD:
8860           strcat (res, " STD");
8861           break;
8862         case VMS_STL_LNK:
8863           strcat (res, " LNK");
8864           break;
8865         default:
8866           abort ();
8867         }
8868
8869       if (res[0] != 0)
8870         return res + 1;
8871       else
8872         return res;
8873     }
8874   return NULL;
8875 }
8876
8877 static const char *
8878 get_symbol_other (unsigned int other)
8879 {
8880   const char * result = NULL;
8881   static char buff [32];
8882
8883   if (other == 0)
8884     return "";
8885
8886   switch (elf_header.e_machine)
8887     {
8888     case EM_MIPS:
8889       result = get_mips_symbol_other (other);
8890       break;
8891     case EM_IA_64:
8892       result = get_ia64_symbol_other (other);
8893       break;
8894     default:
8895       break;
8896     }
8897
8898   if (result)
8899     return result;
8900
8901   snprintf (buff, sizeof buff, _("<other>: %x"), other);
8902   return buff;
8903 }
8904
8905 static const char *
8906 get_symbol_index_type (unsigned int type)
8907 {
8908   static char buff[32];
8909
8910   switch (type)
8911     {
8912     case SHN_UNDEF:     return "UND";
8913     case SHN_ABS:       return "ABS";
8914     case SHN_COMMON:    return "COM";
8915     default:
8916       if (type == SHN_IA_64_ANSI_COMMON
8917           && elf_header.e_machine == EM_IA_64
8918           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
8919         return "ANSI_COM";
8920       else if ((elf_header.e_machine == EM_X86_64
8921                 || elf_header.e_machine == EM_L1OM
8922                 || elf_header.e_machine == EM_K1OM)
8923                && type == SHN_X86_64_LCOMMON)
8924         return "LARGE_COM";
8925       else if ((type == SHN_MIPS_SCOMMON
8926                 && elf_header.e_machine == EM_MIPS)
8927                || (type == SHN_TIC6X_SCOMMON
8928                    && elf_header.e_machine == EM_TI_C6000))
8929         return "SCOM";
8930       else if (type == SHN_MIPS_SUNDEFINED
8931                && elf_header.e_machine == EM_MIPS)
8932         return "SUND";
8933       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
8934         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
8935       else if (type >= SHN_LOOS && type <= SHN_HIOS)
8936         sprintf (buff, "OS [0x%04x]", type & 0xffff);
8937       else if (type >= SHN_LORESERVE)
8938         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
8939       else
8940         sprintf (buff, "%3d", type);
8941       break;
8942     }
8943
8944   return buff;
8945 }
8946
8947 static bfd_vma *
8948 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
8949 {
8950   unsigned char * e_data;
8951   bfd_vma * i_data;
8952
8953   e_data = (unsigned char *) cmalloc (number, ent_size);
8954
8955   if (e_data == NULL)
8956     {
8957       error (_("Out of memory\n"));
8958       return NULL;
8959     }
8960
8961   if (fread (e_data, ent_size, number, file) != number)
8962     {
8963       error (_("Unable to read in dynamic data\n"));
8964       return NULL;
8965     }
8966
8967   i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
8968
8969   if (i_data == NULL)
8970     {
8971       error (_("Out of memory\n"));
8972       free (e_data);
8973       return NULL;
8974     }
8975
8976   while (number--)
8977     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
8978
8979   free (e_data);
8980
8981   return i_data;
8982 }
8983
8984 static void
8985 print_dynamic_symbol (bfd_vma si, unsigned long hn)
8986 {
8987   Elf_Internal_Sym * psym;
8988   int n;
8989
8990   psym = dynamic_symbols + si;
8991
8992   n = print_vma (si, DEC_5);
8993   if (n < 5)
8994     fputs ("     " + n, stdout);
8995   printf (" %3lu: ", hn);
8996   print_vma (psym->st_value, LONG_HEX);
8997   putchar (' ');
8998   print_vma (psym->st_size, DEC_5);
8999
9000   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9001   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9002   printf (" %-7s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9003   /* Check to see if any other bits in the st_other field are set.
9004      Note - displaying this information disrupts the layout of the
9005      table being generated, but for the moment this case is very
9006      rare.  */
9007   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9008     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9009   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9010   if (VALID_DYNAMIC_NAME (psym->st_name))
9011     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9012   else
9013     printf (_(" <corrupt: %14ld>"), psym->st_name);
9014   putchar ('\n');
9015 }
9016
9017 /* Dump the symbol table.  */
9018 static int
9019 process_symbol_table (FILE * file)
9020 {
9021   Elf_Internal_Shdr * section;
9022   bfd_vma nbuckets = 0;
9023   bfd_vma nchains = 0;
9024   bfd_vma * buckets = NULL;
9025   bfd_vma * chains = NULL;
9026   bfd_vma ngnubuckets = 0;
9027   bfd_vma * gnubuckets = NULL;
9028   bfd_vma * gnuchains = NULL;
9029   bfd_vma gnusymidx = 0;
9030
9031   if (!do_syms && !do_dyn_syms && !do_histogram)
9032     return 1;
9033
9034   if (dynamic_info[DT_HASH]
9035       && (do_histogram
9036           || (do_using_dynamic
9037               && !do_dyn_syms
9038               && dynamic_strings != NULL)))
9039     {
9040       unsigned char nb[8];
9041       unsigned char nc[8];
9042       int hash_ent_size = 4;
9043
9044       if ((elf_header.e_machine == EM_ALPHA
9045            || elf_header.e_machine == EM_S390
9046            || elf_header.e_machine == EM_S390_OLD)
9047           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9048         hash_ent_size = 8;
9049
9050       if (fseek (file,
9051                  (archive_file_offset
9052                   + offset_from_vma (file, dynamic_info[DT_HASH],
9053                                      sizeof nb + sizeof nc)),
9054                  SEEK_SET))
9055         {
9056           error (_("Unable to seek to start of dynamic information\n"));
9057           goto no_hash;
9058         }
9059
9060       if (fread (nb, hash_ent_size, 1, file) != 1)
9061         {
9062           error (_("Failed to read in number of buckets\n"));
9063           goto no_hash;
9064         }
9065
9066       if (fread (nc, hash_ent_size, 1, file) != 1)
9067         {
9068           error (_("Failed to read in number of chains\n"));
9069           goto no_hash;
9070         }
9071
9072       nbuckets = byte_get (nb, hash_ent_size);
9073       nchains  = byte_get (nc, hash_ent_size);
9074
9075       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9076       chains  = get_dynamic_data (file, nchains, hash_ent_size);
9077
9078     no_hash:
9079       if (buckets == NULL || chains == NULL)
9080         {
9081           if (do_using_dynamic)
9082             return 0;
9083           free (buckets);
9084           free (chains);
9085           buckets = NULL;
9086           chains = NULL;
9087           nbuckets = 0;
9088           nchains = 0;
9089         }
9090     }
9091
9092   if (dynamic_info_DT_GNU_HASH
9093       && (do_histogram
9094           || (do_using_dynamic
9095               && !do_dyn_syms
9096               && dynamic_strings != NULL)))
9097     {
9098       unsigned char nb[16];
9099       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9100       bfd_vma buckets_vma;
9101
9102       if (fseek (file,
9103                  (archive_file_offset
9104                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9105                                      sizeof nb)),
9106                  SEEK_SET))
9107         {
9108           error (_("Unable to seek to start of dynamic information\n"));
9109           goto no_gnu_hash;
9110         }
9111
9112       if (fread (nb, 16, 1, file) != 1)
9113         {
9114           error (_("Failed to read in number of buckets\n"));
9115           goto no_gnu_hash;
9116         }
9117
9118       ngnubuckets = byte_get (nb, 4);
9119       gnusymidx = byte_get (nb + 4, 4);
9120       bitmaskwords = byte_get (nb + 8, 4);
9121       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
9122       if (is_32bit_elf)
9123         buckets_vma += bitmaskwords * 4;
9124       else
9125         buckets_vma += bitmaskwords * 8;
9126
9127       if (fseek (file,
9128                  (archive_file_offset
9129                   + offset_from_vma (file, buckets_vma, 4)),
9130                  SEEK_SET))
9131         {
9132           error (_("Unable to seek to start of dynamic information\n"));
9133           goto no_gnu_hash;
9134         }
9135
9136       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
9137
9138       if (gnubuckets == NULL)
9139         goto no_gnu_hash;
9140
9141       for (i = 0; i < ngnubuckets; i++)
9142         if (gnubuckets[i] != 0)
9143           {
9144             if (gnubuckets[i] < gnusymidx)
9145               return 0;
9146
9147             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9148               maxchain = gnubuckets[i];
9149           }
9150
9151       if (maxchain == 0xffffffff)
9152         goto no_gnu_hash;
9153
9154       maxchain -= gnusymidx;
9155
9156       if (fseek (file,
9157                  (archive_file_offset
9158                   + offset_from_vma (file, buckets_vma
9159                                            + 4 * (ngnubuckets + maxchain), 4)),
9160                  SEEK_SET))
9161         {
9162           error (_("Unable to seek to start of dynamic information\n"));
9163           goto no_gnu_hash;
9164         }
9165
9166       do
9167         {
9168           if (fread (nb, 4, 1, file) != 1)
9169             {
9170               error (_("Failed to determine last chain length\n"));
9171               goto no_gnu_hash;
9172             }
9173
9174           if (maxchain + 1 == 0)
9175             goto no_gnu_hash;
9176
9177           ++maxchain;
9178         }
9179       while ((byte_get (nb, 4) & 1) == 0);
9180
9181       if (fseek (file,
9182                  (archive_file_offset
9183                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9184                  SEEK_SET))
9185         {
9186           error (_("Unable to seek to start of dynamic information\n"));
9187           goto no_gnu_hash;
9188         }
9189
9190       gnuchains = get_dynamic_data (file, maxchain, 4);
9191
9192     no_gnu_hash:
9193       if (gnuchains == NULL)
9194         {
9195           free (gnubuckets);
9196           gnubuckets = NULL;
9197           ngnubuckets = 0;
9198           if (do_using_dynamic)
9199             return 0;
9200         }
9201     }
9202
9203   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9204       && do_syms
9205       && do_using_dynamic
9206       && dynamic_strings != NULL)
9207     {
9208       unsigned long hn;
9209
9210       if (dynamic_info[DT_HASH])
9211         {
9212           bfd_vma si;
9213
9214           printf (_("\nSymbol table for image:\n"));
9215           if (is_32bit_elf)
9216             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9217           else
9218             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9219
9220           for (hn = 0; hn < nbuckets; hn++)
9221             {
9222               if (! buckets[hn])
9223                 continue;
9224
9225               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9226                 print_dynamic_symbol (si, hn);
9227             }
9228         }
9229
9230       if (dynamic_info_DT_GNU_HASH)
9231         {
9232           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9233           if (is_32bit_elf)
9234             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
9235           else
9236             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
9237
9238           for (hn = 0; hn < ngnubuckets; ++hn)
9239             if (gnubuckets[hn] != 0)
9240               {
9241                 bfd_vma si = gnubuckets[hn];
9242                 bfd_vma off = si - gnusymidx;
9243
9244                 do
9245                   {
9246                     print_dynamic_symbol (si, hn);
9247                     si++;
9248                   }
9249                 while ((gnuchains[off++] & 1) == 0);
9250               }
9251         }
9252     }
9253   else if (do_dyn_syms || (do_syms && !do_using_dynamic))
9254     {
9255       unsigned int i;
9256
9257       for (i = 0, section = section_headers;
9258            i < elf_header.e_shnum;
9259            i++, section++)
9260         {
9261           unsigned int si;
9262           char * strtab = NULL;
9263           unsigned long int strtab_size = 0;
9264           Elf_Internal_Sym * symtab;
9265           Elf_Internal_Sym * psym;
9266           unsigned long num_syms;
9267
9268           if ((section->sh_type != SHT_SYMTAB
9269                && section->sh_type != SHT_DYNSYM)
9270               || (!do_syms
9271                   && section->sh_type == SHT_SYMTAB))
9272             continue;
9273
9274           if (section->sh_entsize == 0)
9275             {
9276               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9277                       SECTION_NAME (section));
9278               continue;
9279             }
9280
9281           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9282                   SECTION_NAME (section),
9283                   (unsigned long) (section->sh_size / section->sh_entsize));
9284
9285           if (is_32bit_elf)
9286             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
9287           else
9288             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
9289
9290           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
9291           if (symtab == NULL)
9292             continue;
9293
9294           if (section->sh_link == elf_header.e_shstrndx)
9295             {
9296               strtab = string_table;
9297               strtab_size = string_table_length;
9298             }
9299           else if (section->sh_link < elf_header.e_shnum)
9300             {
9301               Elf_Internal_Shdr * string_sec;
9302
9303               string_sec = section_headers + section->sh_link;
9304
9305               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9306                                           1, string_sec->sh_size,
9307                                           _("string table"));
9308               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
9309             }
9310
9311           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
9312             {
9313               printf ("%6d: ", si);
9314               print_vma (psym->st_value, LONG_HEX);
9315               putchar (' ');
9316               print_vma (psym->st_size, DEC_5);
9317               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9318               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9319               printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9320               /* Check to see if any other bits in the st_other field are set.
9321                  Note - displaying this information disrupts the layout of the
9322                  table being generated, but for the moment this case is very rare.  */
9323               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9324                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9325               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
9326               print_symbol (25, psym->st_name < strtab_size
9327                             ? strtab + psym->st_name : _("<corrupt>"));
9328
9329               if (section->sh_type == SHT_DYNSYM
9330                   && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9331                 {
9332                   unsigned char data[2];
9333                   unsigned short vers_data;
9334                   unsigned long offset;
9335                   int is_nobits;
9336                   int check_def;
9337
9338                   offset = offset_from_vma
9339                     (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9340                      sizeof data + si * sizeof (vers_data));
9341
9342                   if (get_data (&data, file, offset + si * sizeof (vers_data),
9343                                 sizeof (data), 1, _("version data")) == NULL)
9344                     break;
9345
9346                   vers_data = byte_get (data, 2);
9347
9348                   is_nobits = (psym->st_shndx < elf_header.e_shnum
9349                                && section_headers[psym->st_shndx].sh_type
9350                                   == SHT_NOBITS);
9351
9352                   check_def = (psym->st_shndx != SHN_UNDEF);
9353
9354                   if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
9355                     {
9356                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
9357                           && (is_nobits || ! check_def))
9358                         {
9359                           Elf_External_Verneed evn;
9360                           Elf_Internal_Verneed ivn;
9361                           Elf_Internal_Vernaux ivna;
9362
9363                           /* We must test both.  */
9364                           offset = offset_from_vma
9365                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9366                              sizeof evn);
9367
9368                           do
9369                             {
9370                               unsigned long vna_off;
9371
9372                               if (get_data (&evn, file, offset, sizeof (evn), 1,
9373                                             _("version need")) == NULL)
9374                                 {
9375                                   ivna.vna_next = 0;
9376                                   ivna.vna_other = 0;
9377                                   ivna.vna_name = 0;
9378                                   break;
9379                                 }
9380
9381                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
9382                               ivn.vn_next = BYTE_GET (evn.vn_next);
9383
9384                               vna_off = offset + ivn.vn_aux;
9385
9386                               do
9387                                 {
9388                                   Elf_External_Vernaux evna;
9389
9390                                   if (get_data (&evna, file, vna_off,
9391                                                 sizeof (evna), 1,
9392                                                 _("version need aux (3)")) == NULL)
9393                                     {
9394                                       ivna.vna_next = 0;
9395                                       ivna.vna_other = 0;
9396                                       ivna.vna_name = 0;
9397                                     }
9398                                   else
9399                                     {
9400                                       ivna.vna_other = BYTE_GET (evna.vna_other);
9401                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
9402                                       ivna.vna_name  = BYTE_GET (evna.vna_name);
9403                                     }
9404
9405                                   vna_off += ivna.vna_next;
9406                                 }
9407                               while (ivna.vna_other != vers_data
9408                                      && ivna.vna_next != 0);
9409
9410                               if (ivna.vna_other == vers_data)
9411                                 break;
9412
9413                               offset += ivn.vn_next;
9414                             }
9415                           while (ivn.vn_next != 0);
9416
9417                           if (ivna.vna_other == vers_data)
9418                             {
9419                               printf ("@%s (%d)",
9420                                       ivna.vna_name < strtab_size
9421                                       ? strtab + ivna.vna_name : _("<corrupt>"),
9422                                       ivna.vna_other);
9423                               check_def = 0;
9424                             }
9425                           else if (! is_nobits)
9426                             error (_("bad dynamic symbol\n"));
9427                           else
9428                             check_def = 1;
9429                         }
9430
9431                       if (check_def)
9432                         {
9433                           if (vers_data != 0x8001
9434                               && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9435                             {
9436                               Elf_Internal_Verdef ivd;
9437                               Elf_Internal_Verdaux ivda;
9438                               Elf_External_Verdaux evda;
9439                               unsigned long off;
9440
9441                               off = offset_from_vma
9442                                 (file,
9443                                  version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9444                                  sizeof (Elf_External_Verdef));
9445
9446                               do
9447                                 {
9448                                   Elf_External_Verdef evd;
9449
9450                                   if (get_data (&evd, file, off, sizeof (evd),
9451                                                 1, _("version def")) == NULL)
9452                                     {
9453                                       ivd.vd_ndx = 0;
9454                                       ivd.vd_aux = 0;
9455                                       ivd.vd_next = 0;
9456                                     }
9457                                   else
9458                                     {
9459                                       ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9460                                       ivd.vd_aux = BYTE_GET (evd.vd_aux);
9461                                       ivd.vd_next = BYTE_GET (evd.vd_next);
9462                                     }
9463
9464                                   off += ivd.vd_next;
9465                                 }
9466                               while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
9467                                      && ivd.vd_next != 0);
9468
9469                               off -= ivd.vd_next;
9470                               off += ivd.vd_aux;
9471
9472                               if (get_data (&evda, file, off, sizeof (evda),
9473                                             1, _("version def aux")) == NULL)
9474                                 break;
9475
9476                               ivda.vda_name = BYTE_GET (evda.vda_name);
9477
9478                               if (psym->st_name != ivda.vda_name)
9479                                 printf ((vers_data & VERSYM_HIDDEN)
9480                                         ? "@%s" : "@@%s",
9481                                         ivda.vda_name < strtab_size
9482                                         ? strtab + ivda.vda_name : _("<corrupt>"));
9483                             }
9484                         }
9485                     }
9486                 }
9487
9488               putchar ('\n');
9489             }
9490
9491           free (symtab);
9492           if (strtab != string_table)
9493             free (strtab);
9494         }
9495     }
9496   else if (do_syms)
9497     printf
9498       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9499
9500   if (do_histogram && buckets != NULL)
9501     {
9502       unsigned long * lengths;
9503       unsigned long * counts;
9504       unsigned long hn;
9505       bfd_vma si;
9506       unsigned long maxlength = 0;
9507       unsigned long nzero_counts = 0;
9508       unsigned long nsyms = 0;
9509
9510       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9511               (unsigned long) nbuckets);
9512       printf (_(" Length  Number     %% of total  Coverage\n"));
9513
9514       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
9515       if (lengths == NULL)
9516         {
9517           error (_("Out of memory\n"));
9518           return 0;
9519         }
9520       for (hn = 0; hn < nbuckets; ++hn)
9521         {
9522           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
9523             {
9524               ++nsyms;
9525               if (maxlength < ++lengths[hn])
9526                 ++maxlength;
9527             }
9528         }
9529
9530       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9531       if (counts == NULL)
9532         {
9533           error (_("Out of memory\n"));
9534           return 0;
9535         }
9536
9537       for (hn = 0; hn < nbuckets; ++hn)
9538         ++counts[lengths[hn]];
9539
9540       if (nbuckets > 0)
9541         {
9542           unsigned long i;
9543           printf ("      0  %-10lu (%5.1f%%)\n",
9544                   counts[0], (counts[0] * 100.0) / nbuckets);
9545           for (i = 1; i <= maxlength; ++i)
9546             {
9547               nzero_counts += counts[i] * i;
9548               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
9549                       i, counts[i], (counts[i] * 100.0) / nbuckets,
9550                       (nzero_counts * 100.0) / nsyms);
9551             }
9552         }
9553
9554       free (counts);
9555       free (lengths);
9556     }
9557
9558   if (buckets != NULL)
9559     {
9560       free (buckets);
9561       free (chains);
9562     }
9563
9564   if (do_histogram && gnubuckets != NULL)
9565     {
9566       unsigned long * lengths;
9567       unsigned long * counts;
9568       unsigned long hn;
9569       unsigned long maxlength = 0;
9570       unsigned long nzero_counts = 0;
9571       unsigned long nsyms = 0;
9572
9573       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
9574       if (lengths == NULL)
9575         {
9576           error (_("Out of memory\n"));
9577           return 0;
9578         }
9579
9580       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9581               (unsigned long) ngnubuckets);
9582       printf (_(" Length  Number     %% of total  Coverage\n"));
9583
9584       for (hn = 0; hn < ngnubuckets; ++hn)
9585         if (gnubuckets[hn] != 0)
9586           {
9587             bfd_vma off, length = 1;
9588
9589             for (off = gnubuckets[hn] - gnusymidx;
9590                  (gnuchains[off] & 1) == 0; ++off)
9591               ++length;
9592             lengths[hn] = length;
9593             if (length > maxlength)
9594               maxlength = length;
9595             nsyms += length;
9596           }
9597
9598       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9599       if (counts == NULL)
9600         {
9601           error (_("Out of memory\n"));
9602           return 0;
9603         }
9604
9605       for (hn = 0; hn < ngnubuckets; ++hn)
9606         ++counts[lengths[hn]];
9607
9608       if (ngnubuckets > 0)
9609         {
9610           unsigned long j;
9611           printf ("      0  %-10lu (%5.1f%%)\n",
9612                   counts[0], (counts[0] * 100.0) / ngnubuckets);
9613           for (j = 1; j <= maxlength; ++j)
9614             {
9615               nzero_counts += counts[j] * j;
9616               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
9617                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9618                       (nzero_counts * 100.0) / nsyms);
9619             }
9620         }
9621
9622       free (counts);
9623       free (lengths);
9624       free (gnubuckets);
9625       free (gnuchains);
9626     }
9627
9628   return 1;
9629 }
9630
9631 static int
9632 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
9633 {
9634   unsigned int i;
9635
9636   if (dynamic_syminfo == NULL
9637       || !do_dynamic)
9638     /* No syminfo, this is ok.  */
9639     return 1;
9640
9641   /* There better should be a dynamic symbol section.  */
9642   if (dynamic_symbols == NULL || dynamic_strings == NULL)
9643     return 0;
9644
9645   if (dynamic_addr)
9646     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9647             dynamic_syminfo_offset, dynamic_syminfo_nent);
9648
9649   printf (_(" Num: Name                           BoundTo     Flags\n"));
9650   for (i = 0; i < dynamic_syminfo_nent; ++i)
9651     {
9652       unsigned short int flags = dynamic_syminfo[i].si_flags;
9653
9654       printf ("%4d: ", i);
9655       if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9656         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9657       else
9658         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
9659       putchar (' ');
9660
9661       switch (dynamic_syminfo[i].si_boundto)
9662         {
9663         case SYMINFO_BT_SELF:
9664           fputs ("SELF       ", stdout);
9665           break;
9666         case SYMINFO_BT_PARENT:
9667           fputs ("PARENT     ", stdout);
9668           break;
9669         default:
9670           if (dynamic_syminfo[i].si_boundto > 0
9671               && dynamic_syminfo[i].si_boundto < dynamic_nent
9672               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
9673             {
9674               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
9675               putchar (' ' );
9676             }
9677           else
9678             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9679           break;
9680         }
9681
9682       if (flags & SYMINFO_FLG_DIRECT)
9683         printf (" DIRECT");
9684       if (flags & SYMINFO_FLG_PASSTHRU)
9685         printf (" PASSTHRU");
9686       if (flags & SYMINFO_FLG_COPY)
9687         printf (" COPY");
9688       if (flags & SYMINFO_FLG_LAZYLOAD)
9689         printf (" LAZYLOAD");
9690
9691       puts ("");
9692     }
9693
9694   return 1;
9695 }
9696
9697 /* Check to see if the given reloc needs to be handled in a target specific
9698    manner.  If so then process the reloc and return TRUE otherwise return
9699    FALSE.  */
9700
9701 static bfd_boolean
9702 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9703                                 unsigned char *     start,
9704                                 Elf_Internal_Sym *  symtab)
9705 {
9706   unsigned int reloc_type = get_reloc_type (reloc->r_info);
9707
9708   switch (elf_header.e_machine)
9709     {
9710     case EM_MN10300:
9711     case EM_CYGNUS_MN10300:
9712       {
9713         static Elf_Internal_Sym * saved_sym = NULL;
9714
9715         switch (reloc_type)
9716           {
9717           case 34: /* R_MN10300_ALIGN */
9718             return TRUE;
9719           case 33: /* R_MN10300_SYM_DIFF */
9720             saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9721             return TRUE;
9722           case 1: /* R_MN10300_32 */
9723           case 2: /* R_MN10300_16 */
9724             if (saved_sym != NULL)
9725               {
9726                 bfd_vma value;
9727
9728                 value = reloc->r_addend
9729                   + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9730                      - saved_sym->st_value);
9731
9732                 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
9733
9734                 saved_sym = NULL;
9735                 return TRUE;
9736               }
9737             break;
9738           default:
9739             if (saved_sym != NULL)
9740               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9741             break;
9742           }
9743         break;
9744       }
9745     }
9746
9747   return FALSE;
9748 }
9749
9750 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9751    DWARF debug sections.  This is a target specific test.  Note - we do not
9752    go through the whole including-target-headers-multiple-times route, (as
9753    we have already done with <elf/h8.h>) because this would become very
9754    messy and even then this function would have to contain target specific
9755    information (the names of the relocs instead of their numeric values).
9756    FIXME: This is not the correct way to solve this problem.  The proper way
9757    is to have target specific reloc sizing and typing functions created by
9758    the reloc-macros.h header, in the same way that it already creates the
9759    reloc naming functions.  */
9760
9761 static bfd_boolean
9762 is_32bit_abs_reloc (unsigned int reloc_type)
9763 {
9764   switch (elf_header.e_machine)
9765     {
9766     case EM_386:
9767     case EM_486:
9768       return reloc_type == 1; /* R_386_32.  */
9769     case EM_68K:
9770       return reloc_type == 1; /* R_68K_32.  */
9771     case EM_860:
9772       return reloc_type == 1; /* R_860_32.  */
9773     case EM_960:
9774       return reloc_type == 2; /* R_960_32.  */
9775     case EM_ALPHA:
9776       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
9777     case EM_ARC:
9778       return reloc_type == 1; /* R_ARC_32.  */
9779     case EM_ARM:
9780       return reloc_type == 2; /* R_ARM_ABS32 */
9781     case EM_AVR_OLD:
9782     case EM_AVR:
9783       return reloc_type == 1;
9784     case EM_ADAPTEVA_EPIPHANY:
9785       return reloc_type == 3;
9786     case EM_BLACKFIN:
9787       return reloc_type == 0x12; /* R_byte4_data.  */
9788     case EM_CRIS:
9789       return reloc_type == 3; /* R_CRIS_32.  */
9790     case EM_CR16:
9791       return reloc_type == 3; /* R_CR16_NUM32.  */
9792     case EM_CRX:
9793       return reloc_type == 15; /* R_CRX_NUM32.  */
9794     case EM_CYGNUS_FRV:
9795       return reloc_type == 1;
9796     case EM_CYGNUS_D10V:
9797     case EM_D10V:
9798       return reloc_type == 6; /* R_D10V_32.  */
9799     case EM_CYGNUS_D30V:
9800     case EM_D30V:
9801       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
9802     case EM_DLX:
9803       return reloc_type == 3; /* R_DLX_RELOC_32.  */
9804     case EM_CYGNUS_FR30:
9805     case EM_FR30:
9806       return reloc_type == 3; /* R_FR30_32.  */
9807     case EM_H8S:
9808     case EM_H8_300:
9809     case EM_H8_300H:
9810       return reloc_type == 1; /* R_H8_DIR32.  */
9811     case EM_IA_64:
9812       return reloc_type == 0x65; /* R_IA64_SECREL32LSB.  */
9813     case EM_IP2K_OLD:
9814     case EM_IP2K:
9815       return reloc_type == 2; /* R_IP2K_32.  */
9816     case EM_IQ2000:
9817       return reloc_type == 2; /* R_IQ2000_32.  */
9818     case EM_LATTICEMICO32:
9819       return reloc_type == 3; /* R_LM32_32.  */
9820     case EM_M32C_OLD:
9821     case EM_M32C:
9822       return reloc_type == 3; /* R_M32C_32.  */
9823     case EM_M32R:
9824       return reloc_type == 34; /* R_M32R_32_RELA.  */
9825     case EM_MCORE:
9826       return reloc_type == 1; /* R_MCORE_ADDR32.  */
9827     case EM_CYGNUS_MEP:
9828       return reloc_type == 4; /* R_MEP_32.  */
9829     case EM_MICROBLAZE:
9830       return reloc_type == 1; /* R_MICROBLAZE_32.  */
9831     case EM_MIPS:
9832       return reloc_type == 2; /* R_MIPS_32.  */
9833     case EM_MMIX:
9834       return reloc_type == 4; /* R_MMIX_32.  */
9835     case EM_CYGNUS_MN10200:
9836     case EM_MN10200:
9837       return reloc_type == 1; /* R_MN10200_32.  */
9838     case EM_CYGNUS_MN10300:
9839     case EM_MN10300:
9840       return reloc_type == 1; /* R_MN10300_32.  */
9841     case EM_MOXIE:
9842       return reloc_type == 1; /* R_MOXIE_32.  */
9843     case EM_MSP430_OLD:
9844     case EM_MSP430:
9845       return reloc_type == 1; /* R_MSP43_32.  */
9846     case EM_MT:
9847       return reloc_type == 2; /* R_MT_32.  */
9848     case EM_ALTERA_NIOS2:
9849     case EM_NIOS32:
9850       return reloc_type == 1; /* R_NIOS_32.  */
9851     case EM_OPENRISC:
9852     case EM_OR32:
9853       return reloc_type == 1; /* R_OR32_32.  */
9854     case EM_PARISC:
9855       return (reloc_type == 1 /* R_PARISC_DIR32.  */
9856               || reloc_type == 41); /* R_PARISC_SECREL32.  */
9857     case EM_PJ:
9858     case EM_PJ_OLD:
9859       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
9860     case EM_PPC64:
9861       return reloc_type == 1; /* R_PPC64_ADDR32.  */
9862     case EM_PPC:
9863       return reloc_type == 1; /* R_PPC_ADDR32.  */
9864     case EM_RL78:
9865       return reloc_type == 1; /* R_RL78_DIR32.  */
9866     case EM_RX:
9867       return reloc_type == 1; /* R_RX_DIR32.  */
9868     case EM_S370:
9869       return reloc_type == 1; /* R_I370_ADDR31.  */
9870     case EM_S390_OLD:
9871     case EM_S390:
9872       return reloc_type == 4; /* R_S390_32.  */
9873     case EM_SCORE:
9874       return reloc_type == 8; /* R_SCORE_ABS32.  */
9875     case EM_SH:
9876       return reloc_type == 1; /* R_SH_DIR32.  */
9877     case EM_SPARC32PLUS:
9878     case EM_SPARCV9:
9879     case EM_SPARC:
9880       return reloc_type == 3 /* R_SPARC_32.  */
9881         || reloc_type == 23; /* R_SPARC_UA32.  */
9882     case EM_SPU:
9883       return reloc_type == 6; /* R_SPU_ADDR32 */
9884     case EM_TI_C6000:
9885       return reloc_type == 1; /* R_C6000_ABS32.  */
9886     case EM_TILEGX:
9887       return reloc_type == 2; /* R_TILEGX_32.  */
9888     case EM_TILEPRO:
9889       return reloc_type == 1; /* R_TILEPRO_32.  */
9890     case EM_CYGNUS_V850:
9891     case EM_V850:
9892       return reloc_type == 6; /* R_V850_ABS32.  */
9893     case EM_VAX:
9894       return reloc_type == 1; /* R_VAX_32.  */
9895     case EM_X86_64:
9896     case EM_L1OM:
9897     case EM_K1OM:
9898       return reloc_type == 10; /* R_X86_64_32.  */
9899     case EM_XC16X:
9900     case EM_C166:
9901       return reloc_type == 3; /* R_XC16C_ABS_32.  */
9902     case EM_XGATE:
9903       return reloc_type == 4; /* R_XGATE_32.  */
9904     case EM_XSTORMY16:
9905       return reloc_type == 1; /* R_XSTROMY16_32.  */
9906     case EM_XTENSA_OLD:
9907     case EM_XTENSA:
9908       return reloc_type == 1; /* R_XTENSA_32.  */
9909     default:
9910       error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9911              elf_header.e_machine);
9912       abort ();
9913     }
9914 }
9915
9916 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9917    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
9918
9919 static bfd_boolean
9920 is_32bit_pcrel_reloc (unsigned int reloc_type)
9921 {
9922   switch (elf_header.e_machine)
9923     {
9924     case EM_386:
9925     case EM_486:
9926       return reloc_type == 2;  /* R_386_PC32.  */
9927     case EM_68K:
9928       return reloc_type == 4;  /* R_68K_PC32.  */
9929     case EM_ADAPTEVA_EPIPHANY:
9930       return reloc_type == 6;
9931     case EM_ALPHA:
9932       return reloc_type == 10; /* R_ALPHA_SREL32.  */
9933     case EM_ARM:
9934       return reloc_type == 3;  /* R_ARM_REL32 */
9935     case EM_MICROBLAZE:
9936       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
9937     case EM_PARISC:
9938       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
9939     case EM_PPC:
9940       return reloc_type == 26; /* R_PPC_REL32.  */
9941     case EM_PPC64:
9942       return reloc_type == 26; /* R_PPC64_REL32.  */
9943     case EM_S390_OLD:
9944     case EM_S390:
9945       return reloc_type == 5;  /* R_390_PC32.  */
9946     case EM_SH:
9947       return reloc_type == 2;  /* R_SH_REL32.  */
9948     case EM_SPARC32PLUS:
9949     case EM_SPARCV9:
9950     case EM_SPARC:
9951       return reloc_type == 6;  /* R_SPARC_DISP32.  */
9952     case EM_SPU:
9953       return reloc_type == 13; /* R_SPU_REL32.  */
9954     case EM_TILEGX:
9955       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
9956     case EM_TILEPRO:
9957       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
9958     case EM_X86_64:
9959     case EM_L1OM:
9960     case EM_K1OM:
9961       return reloc_type == 2;  /* R_X86_64_PC32.  */
9962     case EM_XTENSA_OLD:
9963     case EM_XTENSA:
9964       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
9965     default:
9966       /* Do not abort or issue an error message here.  Not all targets use
9967          pc-relative 32-bit relocs in their DWARF debug information and we
9968          have already tested for target coverage in is_32bit_abs_reloc.  A
9969          more helpful warning message will be generated by apply_relocations
9970          anyway, so just return.  */
9971       return FALSE;
9972     }
9973 }
9974
9975 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9976    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
9977
9978 static bfd_boolean
9979 is_64bit_abs_reloc (unsigned int reloc_type)
9980 {
9981   switch (elf_header.e_machine)
9982     {
9983     case EM_ALPHA:
9984       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
9985     case EM_IA_64:
9986       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
9987     case EM_PARISC:
9988       return reloc_type == 80; /* R_PARISC_DIR64.  */
9989     case EM_PPC64:
9990       return reloc_type == 38; /* R_PPC64_ADDR64.  */
9991     case EM_SPARC32PLUS:
9992     case EM_SPARCV9:
9993     case EM_SPARC:
9994       return reloc_type == 54; /* R_SPARC_UA64.  */
9995     case EM_X86_64:
9996     case EM_L1OM:
9997     case EM_K1OM:
9998       return reloc_type == 1; /* R_X86_64_64.  */
9999     case EM_S390_OLD:
10000     case EM_S390:
10001       return reloc_type == 22;  /* R_S390_64.  */
10002     case EM_TILEGX:
10003       return reloc_type == 1; /* R_TILEGX_64.  */
10004     case EM_MIPS:
10005       return reloc_type == 18;  /* R_MIPS_64.  */
10006     default:
10007       return FALSE;
10008     }
10009 }
10010
10011 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10012    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
10013
10014 static bfd_boolean
10015 is_64bit_pcrel_reloc (unsigned int reloc_type)
10016 {
10017   switch (elf_header.e_machine)
10018     {
10019     case EM_ALPHA:
10020       return reloc_type == 11; /* R_ALPHA_SREL64.  */
10021     case EM_IA_64:
10022       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
10023     case EM_PARISC:
10024       return reloc_type == 72; /* R_PARISC_PCREL64.  */
10025     case EM_PPC64:
10026       return reloc_type == 44; /* R_PPC64_REL64.  */
10027     case EM_SPARC32PLUS:
10028     case EM_SPARCV9:
10029     case EM_SPARC:
10030       return reloc_type == 46; /* R_SPARC_DISP64.  */
10031     case EM_X86_64:
10032     case EM_L1OM:
10033     case EM_K1OM:
10034       return reloc_type == 24; /* R_X86_64_PC64.  */
10035     case EM_S390_OLD:
10036     case EM_S390:
10037       return reloc_type == 23;  /* R_S390_PC64.  */
10038     case EM_TILEGX:
10039       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
10040     default:
10041       return FALSE;
10042     }
10043 }
10044
10045 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10046    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
10047
10048 static bfd_boolean
10049 is_24bit_abs_reloc (unsigned int reloc_type)
10050 {
10051   switch (elf_header.e_machine)
10052     {
10053     case EM_CYGNUS_MN10200:
10054     case EM_MN10200:
10055       return reloc_type == 4; /* R_MN10200_24.  */
10056     default:
10057       return FALSE;
10058     }
10059 }
10060
10061 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10062    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
10063
10064 static bfd_boolean
10065 is_16bit_abs_reloc (unsigned int reloc_type)
10066 {
10067   switch (elf_header.e_machine)
10068     {
10069     case EM_AVR_OLD:
10070     case EM_AVR:
10071       return reloc_type == 4; /* R_AVR_16.  */
10072     case EM_ADAPTEVA_EPIPHANY:
10073       return reloc_type == 5;
10074     case EM_CYGNUS_D10V:
10075     case EM_D10V:
10076       return reloc_type == 3; /* R_D10V_16.  */
10077     case EM_H8S:
10078     case EM_H8_300:
10079     case EM_H8_300H:
10080       return reloc_type == R_H8_DIR16;
10081     case EM_IP2K_OLD:
10082     case EM_IP2K:
10083       return reloc_type == 1; /* R_IP2K_16.  */
10084     case EM_M32C_OLD:
10085     case EM_M32C:
10086       return reloc_type == 1; /* R_M32C_16 */
10087     case EM_MSP430_OLD:
10088     case EM_MSP430:
10089       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
10090     case EM_ALTERA_NIOS2:
10091     case EM_NIOS32:
10092       return reloc_type == 9; /* R_NIOS_16.  */
10093     case EM_TI_C6000:
10094       return reloc_type == 2; /* R_C6000_ABS16.  */
10095     case EM_XC16X:
10096     case EM_C166:
10097       return reloc_type == 2; /* R_XC16C_ABS_16.  */
10098     case EM_CYGNUS_MN10300:
10099     case EM_MN10300:
10100       return reloc_type == 2; /* R_MN10300_16.  */
10101     case EM_XGATE:
10102       return reloc_type == 3; /* R_XGATE_16.  */
10103     default:
10104       return FALSE;
10105     }
10106 }
10107
10108 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10109    relocation entries (possibly formerly used for SHT_GROUP sections).  */
10110
10111 static bfd_boolean
10112 is_none_reloc (unsigned int reloc_type)
10113 {
10114   switch (elf_header.e_machine)
10115     {
10116     case EM_68K:     /* R_68K_NONE.  */
10117     case EM_386:     /* R_386_NONE.  */
10118     case EM_SPARC32PLUS:
10119     case EM_SPARCV9:
10120     case EM_SPARC:   /* R_SPARC_NONE.  */
10121     case EM_MIPS:    /* R_MIPS_NONE.  */
10122     case EM_PARISC:  /* R_PARISC_NONE.  */
10123     case EM_ALPHA:   /* R_ALPHA_NONE.  */
10124     case EM_ADAPTEVA_EPIPHANY:
10125     case EM_PPC:     /* R_PPC_NONE.  */
10126     case EM_PPC64:   /* R_PPC64_NONE.  */
10127     case EM_ARM:     /* R_ARM_NONE.  */
10128     case EM_IA_64:   /* R_IA64_NONE.  */
10129     case EM_SH:      /* R_SH_NONE.  */
10130     case EM_S390_OLD:
10131     case EM_S390:    /* R_390_NONE.  */
10132     case EM_CRIS:    /* R_CRIS_NONE.  */
10133     case EM_X86_64:  /* R_X86_64_NONE.  */
10134     case EM_L1OM:    /* R_X86_64_NONE.  */
10135     case EM_K1OM:    /* R_X86_64_NONE.  */
10136     case EM_MN10300: /* R_MN10300_NONE.  */
10137     case EM_MOXIE:   /* R_MOXIE_NONE.  */
10138     case EM_M32R:    /* R_M32R_NONE.  */
10139     case EM_TI_C6000:/* R_C6000_NONE.  */
10140     case EM_TILEGX:  /* R_TILEGX_NONE.  */
10141     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
10142     case EM_XC16X:
10143     case EM_C166:    /* R_XC16X_NONE.  */
10144       return reloc_type == 0;
10145     case EM_XTENSA_OLD:
10146     case EM_XTENSA:
10147       return (reloc_type == 0      /* R_XTENSA_NONE.  */
10148               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
10149               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
10150               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
10151     }
10152   return FALSE;
10153 }
10154
10155 /* Apply relocations to a section.
10156    Note: So far support has been added only for those relocations
10157    which can be found in debug sections.
10158    FIXME: Add support for more relocations ?  */
10159
10160 static void
10161 apply_relocations (void * file,
10162                    Elf_Internal_Shdr * section,
10163                    unsigned char * start)
10164 {
10165   Elf_Internal_Shdr * relsec;
10166   unsigned char * end = start + section->sh_size;
10167
10168   if (elf_header.e_type != ET_REL)
10169     return;
10170
10171   /* Find the reloc section associated with the section.  */
10172   for (relsec = section_headers;
10173        relsec < section_headers + elf_header.e_shnum;
10174        ++relsec)
10175     {
10176       bfd_boolean is_rela;
10177       unsigned long num_relocs;
10178       Elf_Internal_Rela * relocs;
10179       Elf_Internal_Rela * rp;
10180       Elf_Internal_Shdr * symsec;
10181       Elf_Internal_Sym * symtab;
10182       unsigned long num_syms;
10183       Elf_Internal_Sym * sym;
10184
10185       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10186           || relsec->sh_info >= elf_header.e_shnum
10187           || section_headers + relsec->sh_info != section
10188           || relsec->sh_size == 0
10189           || relsec->sh_link >= elf_header.e_shnum)
10190         continue;
10191
10192       is_rela = relsec->sh_type == SHT_RELA;
10193
10194       if (is_rela)
10195         {
10196           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10197                                   relsec->sh_size, & relocs, & num_relocs))
10198             return;
10199         }
10200       else
10201         {
10202           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10203                                  relsec->sh_size, & relocs, & num_relocs))
10204             return;
10205         }
10206
10207       /* SH uses RELA but uses in place value instead of the addend field.  */
10208       if (elf_header.e_machine == EM_SH)
10209         is_rela = FALSE;
10210
10211       symsec = section_headers + relsec->sh_link;
10212       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
10213
10214       for (rp = relocs; rp < relocs + num_relocs; ++rp)
10215         {
10216           bfd_vma         addend;
10217           unsigned int    reloc_type;
10218           unsigned int    reloc_size;
10219           unsigned char * rloc;
10220           unsigned long   sym_index;
10221
10222           reloc_type = get_reloc_type (rp->r_info);
10223
10224           if (target_specific_reloc_handling (rp, start, symtab))
10225             continue;
10226           else if (is_none_reloc (reloc_type))
10227             continue;
10228           else if (is_32bit_abs_reloc (reloc_type)
10229                    || is_32bit_pcrel_reloc (reloc_type))
10230             reloc_size = 4;
10231           else if (is_64bit_abs_reloc (reloc_type)
10232                    || is_64bit_pcrel_reloc (reloc_type))
10233             reloc_size = 8;
10234           else if (is_24bit_abs_reloc (reloc_type))
10235             reloc_size = 3;
10236           else if (is_16bit_abs_reloc (reloc_type))
10237             reloc_size = 2;
10238           else
10239             {
10240               warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10241                     reloc_type, SECTION_NAME (section));
10242               continue;
10243             }
10244
10245           rloc = start + rp->r_offset;
10246           if ((rloc + reloc_size) > end)
10247             {
10248               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10249                     (unsigned long) rp->r_offset,
10250                     SECTION_NAME (section));
10251               continue;
10252             }
10253
10254           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10255           if (sym_index >= num_syms)
10256             {
10257               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10258                     sym_index, SECTION_NAME (section));
10259               continue;
10260             }
10261           sym = symtab + sym_index;
10262
10263           /* If the reloc has a symbol associated with it,
10264              make sure that it is of an appropriate type.
10265
10266              Relocations against symbols without type can happen.
10267              Gcc -feliminate-dwarf2-dups may generate symbols
10268              without type for debug info.
10269
10270              Icc generates relocations against function symbols
10271              instead of local labels.
10272
10273              Relocations against object symbols can happen, eg when
10274              referencing a global array.  For an example of this see
10275              the _clz.o binary in libgcc.a.  */
10276           if (sym != symtab
10277               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
10278             {
10279               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10280                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
10281                     (long int)(rp - relocs),
10282                     SECTION_NAME (relsec));
10283               continue;
10284             }
10285
10286           addend = 0;
10287           if (is_rela)
10288             addend += rp->r_addend;
10289           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10290              partial_inplace.  */
10291           if (!is_rela
10292               || (elf_header.e_machine == EM_XTENSA
10293                   && reloc_type == 1)
10294               || ((elf_header.e_machine == EM_PJ
10295                    || elf_header.e_machine == EM_PJ_OLD)
10296                   && reloc_type == 1)
10297               || ((elf_header.e_machine == EM_D30V
10298                    || elf_header.e_machine == EM_CYGNUS_D30V)
10299                   && reloc_type == 12))
10300             addend += byte_get (rloc, reloc_size);
10301
10302           if (is_32bit_pcrel_reloc (reloc_type)
10303               || is_64bit_pcrel_reloc (reloc_type))
10304             {
10305               /* On HPPA, all pc-relative relocations are biased by 8.  */
10306               if (elf_header.e_machine == EM_PARISC)
10307                 addend -= 8;
10308               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
10309                         reloc_size);
10310             }
10311           else
10312             byte_put (rloc, addend + sym->st_value, reloc_size);
10313         }
10314
10315       free (symtab);
10316       free (relocs);
10317       break;
10318     }
10319 }
10320
10321 #ifdef SUPPORT_DISASSEMBLY
10322 static int
10323 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10324 {
10325   printf (_("\nAssembly dump of section %s\n"),
10326           SECTION_NAME (section));
10327
10328   /* XXX -- to be done --- XXX */
10329
10330   return 1;
10331 }
10332 #endif
10333
10334 /* Reads in the contents of SECTION from FILE, returning a pointer
10335    to a malloc'ed buffer or NULL if something went wrong.  */
10336
10337 static char *
10338 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10339 {
10340   bfd_size_type num_bytes;
10341
10342   num_bytes = section->sh_size;
10343
10344   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10345     {
10346       printf (_("\nSection '%s' has no data to dump.\n"),
10347               SECTION_NAME (section));
10348       return NULL;
10349     }
10350
10351   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10352                              _("section contents"));
10353 }
10354
10355
10356 static void
10357 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10358 {
10359   Elf_Internal_Shdr * relsec;
10360   bfd_size_type num_bytes;
10361   char * data;
10362   char * end;
10363   char * start;
10364   char * name = SECTION_NAME (section);
10365   bfd_boolean some_strings_shown;
10366
10367   start = get_section_contents (section, file);
10368   if (start == NULL)
10369     return;
10370
10371   printf (_("\nString dump of section '%s':\n"), name);
10372
10373   /* If the section being dumped has relocations against it the user might
10374      be expecting these relocations to have been applied.  Check for this
10375      case and issue a warning message in order to avoid confusion.
10376      FIXME: Maybe we ought to have an option that dumps a section with
10377      relocs applied ?  */
10378   for (relsec = section_headers;
10379        relsec < section_headers + elf_header.e_shnum;
10380        ++relsec)
10381     {
10382       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10383           || relsec->sh_info >= elf_header.e_shnum
10384           || section_headers + relsec->sh_info != section
10385           || relsec->sh_size == 0
10386           || relsec->sh_link >= elf_header.e_shnum)
10387         continue;
10388
10389       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10390       break;
10391     }
10392
10393   num_bytes = section->sh_size;
10394   data = start;
10395   end  = start + num_bytes;
10396   some_strings_shown = FALSE;
10397
10398   while (data < end)
10399     {
10400       while (!ISPRINT (* data))
10401         if (++ data >= end)
10402           break;
10403
10404       if (data < end)
10405         {
10406 #ifndef __MSVCRT__
10407           /* PR 11128: Use two separate invocations in order to work
10408              around bugs in the Solaris 8 implementation of printf.  */
10409           printf ("  [%6tx]  ", data - start);
10410           printf ("%s\n", data);
10411 #else
10412           printf ("  [%6Ix]  %s\n", (size_t) (data - start), data);
10413 #endif
10414           data += strlen (data);
10415           some_strings_shown = TRUE;
10416         }
10417     }
10418
10419   if (! some_strings_shown)
10420     printf (_("  No strings found in this section."));
10421
10422   free (start);
10423
10424   putchar ('\n');
10425 }
10426
10427 static void
10428 dump_section_as_bytes (Elf_Internal_Shdr * section,
10429                        FILE * file,
10430                        bfd_boolean relocate)
10431 {
10432   Elf_Internal_Shdr * relsec;
10433   bfd_size_type bytes;
10434   bfd_vma addr;
10435   unsigned char * data;
10436   unsigned char * start;
10437
10438   start = (unsigned char *) get_section_contents (section, file);
10439   if (start == NULL)
10440     return;
10441
10442   printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10443
10444   if (relocate)
10445     {
10446       apply_relocations (file, section, start);
10447     }
10448   else
10449     {
10450       /* If the section being dumped has relocations against it the user might
10451          be expecting these relocations to have been applied.  Check for this
10452          case and issue a warning message in order to avoid confusion.
10453          FIXME: Maybe we ought to have an option that dumps a section with
10454          relocs applied ?  */
10455       for (relsec = section_headers;
10456            relsec < section_headers + elf_header.e_shnum;
10457            ++relsec)
10458         {
10459           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10460               || relsec->sh_info >= elf_header.e_shnum
10461               || section_headers + relsec->sh_info != section
10462               || relsec->sh_size == 0
10463               || relsec->sh_link >= elf_header.e_shnum)
10464             continue;
10465
10466           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10467           break;
10468         }
10469     }
10470
10471   addr = section->sh_addr;
10472   bytes = section->sh_size;
10473   data = start;
10474
10475   while (bytes)
10476     {
10477       int j;
10478       int k;
10479       int lbytes;
10480
10481       lbytes = (bytes > 16 ? 16 : bytes);
10482
10483       printf ("  0x%8.8lx ", (unsigned long) addr);
10484
10485       for (j = 0; j < 16; j++)
10486         {
10487           if (j < lbytes)
10488             printf ("%2.2x", data[j]);
10489           else
10490             printf ("  ");
10491
10492           if ((j & 3) == 3)
10493             printf (" ");
10494         }
10495
10496       for (j = 0; j < lbytes; j++)
10497         {
10498           k = data[j];
10499           if (k >= ' ' && k < 0x7f)
10500             printf ("%c", k);
10501           else
10502             printf (".");
10503         }
10504
10505       putchar ('\n');
10506
10507       data  += lbytes;
10508       addr  += lbytes;
10509       bytes -= lbytes;
10510     }
10511
10512   free (start);
10513
10514   putchar ('\n');
10515 }
10516
10517 /* Uncompresses a section that was compressed using zlib, in place.  */
10518
10519 static int
10520 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10521                              dwarf_size_type *size ATTRIBUTE_UNUSED)
10522 {
10523 #ifndef HAVE_ZLIB_H
10524   return FALSE;
10525 #else
10526   dwarf_size_type compressed_size = *size;
10527   unsigned char * compressed_buffer = *buffer;
10528   dwarf_size_type uncompressed_size;
10529   unsigned char * uncompressed_buffer;
10530   z_stream strm;
10531   int rc;
10532   dwarf_size_type header_size = 12;
10533
10534   /* Read the zlib header.  In this case, it should be "ZLIB" followed
10535      by the uncompressed section size, 8 bytes in big-endian order.  */
10536   if (compressed_size < header_size
10537       || ! streq ((char *) compressed_buffer, "ZLIB"))
10538     return 0;
10539
10540   uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10541   uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10542   uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10543   uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10544   uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10545   uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10546   uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10547   uncompressed_size += compressed_buffer[11];
10548
10549   /* It is possible the section consists of several compressed
10550      buffers concatenated together, so we uncompress in a loop.  */
10551   strm.zalloc = NULL;
10552   strm.zfree = NULL;
10553   strm.opaque = NULL;
10554   strm.avail_in = compressed_size - header_size;
10555   strm.next_in = (Bytef *) compressed_buffer + header_size;
10556   strm.avail_out = uncompressed_size;
10557   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
10558
10559   rc = inflateInit (& strm);
10560   while (strm.avail_in > 0)
10561     {
10562       if (rc != Z_OK)
10563         goto fail;
10564       strm.next_out = ((Bytef *) uncompressed_buffer
10565                        + (uncompressed_size - strm.avail_out));
10566       rc = inflate (&strm, Z_FINISH);
10567       if (rc != Z_STREAM_END)
10568         goto fail;
10569       rc = inflateReset (& strm);
10570     }
10571   rc = inflateEnd (& strm);
10572   if (rc != Z_OK
10573       || strm.avail_out != 0)
10574     goto fail;
10575
10576   free (compressed_buffer);
10577   *buffer = uncompressed_buffer;
10578   *size = uncompressed_size;
10579   return 1;
10580
10581  fail:
10582   free (uncompressed_buffer);
10583   /* Indicate decompression failure.  */
10584   *buffer = NULL;
10585   return 0;
10586 #endif  /* HAVE_ZLIB_H */
10587 }
10588
10589 static int
10590 load_specific_debug_section (enum dwarf_section_display_enum debug,
10591                              Elf_Internal_Shdr * sec, void * file)
10592 {
10593   struct dwarf_section * section = &debug_displays [debug].section;
10594   char buf [64];
10595
10596   /* If it is already loaded, do nothing.  */
10597   if (section->start != NULL)
10598     return 1;
10599
10600   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10601   section->address = sec->sh_addr;
10602   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10603                                                sec->sh_offset, 1,
10604                                                sec->sh_size, buf);
10605   if (section->start == NULL)
10606     section->size = 0;
10607   else
10608     {
10609       section->size = sec->sh_size;
10610       if (uncompress_section_contents (&section->start, &section->size))
10611         sec->sh_size = section->size;
10612     }
10613
10614   if (section->start == NULL)
10615     return 0;
10616
10617   if (debug_displays [debug].relocate)
10618     apply_relocations ((FILE *) file, sec, section->start);
10619
10620   return 1;
10621 }
10622
10623 int
10624 load_debug_section (enum dwarf_section_display_enum debug, void * file)
10625 {
10626   struct dwarf_section * section = &debug_displays [debug].section;
10627   Elf_Internal_Shdr * sec;
10628
10629   /* Locate the debug section.  */
10630   sec = find_section (section->uncompressed_name);
10631   if (sec != NULL)
10632     section->name = section->uncompressed_name;
10633   else
10634     {
10635       sec = find_section (section->compressed_name);
10636       if (sec != NULL)
10637         section->name = section->compressed_name;
10638     }
10639   if (sec == NULL)
10640     return 0;
10641
10642   return load_specific_debug_section (debug, sec, (FILE *) file);
10643 }
10644
10645 void
10646 free_debug_section (enum dwarf_section_display_enum debug)
10647 {
10648   struct dwarf_section * section = &debug_displays [debug].section;
10649
10650   if (section->start == NULL)
10651     return;
10652
10653   free ((char *) section->start);
10654   section->start = NULL;
10655   section->address = 0;
10656   section->size = 0;
10657 }
10658
10659 static int
10660 display_debug_section (Elf_Internal_Shdr * section, FILE * file)
10661 {
10662   char * name = SECTION_NAME (section);
10663   bfd_size_type length;
10664   int result = 1;
10665   int i;
10666
10667   length = section->sh_size;
10668   if (length == 0)
10669     {
10670       printf (_("\nSection '%s' has no debugging data.\n"), name);
10671       return 0;
10672     }
10673   if (section->sh_type == SHT_NOBITS)
10674     {
10675       /* There is no point in dumping the contents of a debugging section
10676          which has the NOBITS type - the bits in the file will be random.
10677          This can happen when a file containing a .eh_frame section is
10678          stripped with the --only-keep-debug command line option.  */
10679       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10680       return 0;
10681     }
10682
10683   if (const_strneq (name, ".gnu.linkonce.wi."))
10684     name = ".debug_info";
10685
10686   /* See if we know how to display the contents of this section.  */
10687   for (i = 0; i < max; i++)
10688     if (streq (debug_displays[i].section.uncompressed_name, name)
10689         || streq (debug_displays[i].section.compressed_name, name))
10690       {
10691         struct dwarf_section * sec = &debug_displays [i].section;
10692         int secondary = (section != find_section (name));
10693
10694         if (secondary)
10695           free_debug_section ((enum dwarf_section_display_enum) i);
10696
10697         if (streq (sec->uncompressed_name, name))
10698           sec->name = sec->uncompressed_name;
10699         else
10700           sec->name = sec->compressed_name;
10701         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10702                                          section, file))
10703           {
10704             result &= debug_displays[i].display (sec, file);
10705
10706             if (secondary || (i != info && i != abbrev))
10707               free_debug_section ((enum dwarf_section_display_enum) i);
10708           }
10709
10710         break;
10711       }
10712
10713   if (i == max)
10714     {
10715       printf (_("Unrecognized debug section: %s\n"), name);
10716       result = 0;
10717     }
10718
10719   return result;
10720 }
10721
10722 /* Set DUMP_SECTS for all sections where dumps were requested
10723    based on section name.  */
10724
10725 static void
10726 initialise_dumps_byname (void)
10727 {
10728   struct dump_list_entry * cur;
10729
10730   for (cur = dump_sects_byname; cur; cur = cur->next)
10731     {
10732       unsigned int i;
10733       int any;
10734
10735       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10736         if (streq (SECTION_NAME (section_headers + i), cur->name))
10737           {
10738             request_dump_bynumber (i, cur->type);
10739             any = 1;
10740           }
10741
10742       if (!any)
10743         warn (_("Section '%s' was not dumped because it does not exist!\n"),
10744               cur->name);
10745     }
10746 }
10747
10748 static void
10749 process_section_contents (FILE * file)
10750 {
10751   Elf_Internal_Shdr * section;
10752   unsigned int i;
10753
10754   if (! do_dump)
10755     return;
10756
10757   initialise_dumps_byname ();
10758
10759   for (i = 0, section = section_headers;
10760        i < elf_header.e_shnum && i < num_dump_sects;
10761        i++, section++)
10762     {
10763 #ifdef SUPPORT_DISASSEMBLY
10764       if (dump_sects[i] & DISASS_DUMP)
10765         disassemble_section (section, file);
10766 #endif
10767       if (dump_sects[i] & HEX_DUMP)
10768         dump_section_as_bytes (section, file, FALSE);
10769
10770       if (dump_sects[i] & RELOC_DUMP)
10771         dump_section_as_bytes (section, file, TRUE);
10772
10773       if (dump_sects[i] & STRING_DUMP)
10774         dump_section_as_strings (section, file);
10775
10776       if (dump_sects[i] & DEBUG_DUMP)
10777         display_debug_section (section, file);
10778     }
10779
10780   /* Check to see if the user requested a
10781      dump of a section that does not exist.  */
10782   while (i++ < num_dump_sects)
10783     if (dump_sects[i])
10784       warn (_("Section %d was not dumped because it does not exist!\n"), i);
10785 }
10786
10787 static void
10788 process_mips_fpe_exception (int mask)
10789 {
10790   if (mask)
10791     {
10792       int first = 1;
10793       if (mask & OEX_FPU_INEX)
10794         fputs ("INEX", stdout), first = 0;
10795       if (mask & OEX_FPU_UFLO)
10796         printf ("%sUFLO", first ? "" : "|"), first = 0;
10797       if (mask & OEX_FPU_OFLO)
10798         printf ("%sOFLO", first ? "" : "|"), first = 0;
10799       if (mask & OEX_FPU_DIV0)
10800         printf ("%sDIV0", first ? "" : "|"), first = 0;
10801       if (mask & OEX_FPU_INVAL)
10802         printf ("%sINVAL", first ? "" : "|");
10803     }
10804   else
10805     fputs ("0", stdout);
10806 }
10807
10808 /* ARM EABI attributes section.  */
10809 typedef struct
10810 {
10811   int tag;
10812   const char * name;
10813   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
10814   int type;
10815   const char ** table;
10816 } arm_attr_public_tag;
10817
10818 static const char * arm_attr_tag_CPU_arch[] =
10819   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
10820    "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
10821 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
10822 static const char * arm_attr_tag_THUMB_ISA_use[] =
10823   {"No", "Thumb-1", "Thumb-2"};
10824 static const char * arm_attr_tag_FP_arch[] =
10825   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
10826 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
10827 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
10828   {"No", "NEONv1", "NEONv1 with Fused-MAC"};
10829 static const char * arm_attr_tag_PCS_config[] =
10830   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10831    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
10832 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
10833   {"V6", "SB", "TLS", "Unused"};
10834 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
10835   {"Absolute", "PC-relative", "SB-relative", "None"};
10836 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
10837   {"Absolute", "PC-relative", "None"};
10838 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
10839   {"None", "direct", "GOT-indirect"};
10840 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
10841   {"None", "??? 1", "2", "??? 3", "4"};
10842 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
10843 static const char * arm_attr_tag_ABI_FP_denormal[] =
10844   {"Unused", "Needed", "Sign only"};
10845 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
10846 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
10847 static const char * arm_attr_tag_ABI_FP_number_model[] =
10848   {"Unused", "Finite", "RTABI", "IEEE 754"};
10849 static const char * arm_attr_tag_ABI_enum_size[] =
10850   {"Unused", "small", "int", "forced to int"};
10851 static const char * arm_attr_tag_ABI_HardFP_use[] =
10852   {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
10853 static const char * arm_attr_tag_ABI_VFP_args[] =
10854   {"AAPCS", "VFP registers", "custom"};
10855 static const char * arm_attr_tag_ABI_WMMX_args[] =
10856   {"AAPCS", "WMMX registers", "custom"};
10857 static const char * arm_attr_tag_ABI_optimization_goals[] =
10858   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10859     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
10860 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
10861   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10862     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
10863 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
10864 static const char * arm_attr_tag_FP_HP_extension[] =
10865   {"Not Allowed", "Allowed"};
10866 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
10867   {"None", "IEEE 754", "Alternative Format"};
10868 static const char * arm_attr_tag_MPextension_use[] =
10869   {"Not Allowed", "Allowed"};
10870 static const char * arm_attr_tag_DIV_use[] =
10871   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
10872     "Allowed in v7-A with integer division extension"};
10873 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
10874 static const char * arm_attr_tag_Virtualization_use[] =
10875   {"Not Allowed", "TrustZone", "Virtualization Extensions",
10876     "TrustZone and Virtualization Extensions"};
10877 static const char * arm_attr_tag_MPextension_use_legacy[] =
10878   {"Not Allowed", "Allowed"};
10879
10880 #define LOOKUP(id, name) \
10881   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
10882 static arm_attr_public_tag arm_attr_public_tags[] =
10883 {
10884   {4, "CPU_raw_name", 1, NULL},
10885   {5, "CPU_name", 1, NULL},
10886   LOOKUP(6, CPU_arch),
10887   {7, "CPU_arch_profile", 0, NULL},
10888   LOOKUP(8, ARM_ISA_use),
10889   LOOKUP(9, THUMB_ISA_use),
10890   LOOKUP(10, FP_arch),
10891   LOOKUP(11, WMMX_arch),
10892   LOOKUP(12, Advanced_SIMD_arch),
10893   LOOKUP(13, PCS_config),
10894   LOOKUP(14, ABI_PCS_R9_use),
10895   LOOKUP(15, ABI_PCS_RW_data),
10896   LOOKUP(16, ABI_PCS_RO_data),
10897   LOOKUP(17, ABI_PCS_GOT_use),
10898   LOOKUP(18, ABI_PCS_wchar_t),
10899   LOOKUP(19, ABI_FP_rounding),
10900   LOOKUP(20, ABI_FP_denormal),
10901   LOOKUP(21, ABI_FP_exceptions),
10902   LOOKUP(22, ABI_FP_user_exceptions),
10903   LOOKUP(23, ABI_FP_number_model),
10904   {24, "ABI_align_needed", 0, NULL},
10905   {25, "ABI_align_preserved", 0, NULL},
10906   LOOKUP(26, ABI_enum_size),
10907   LOOKUP(27, ABI_HardFP_use),
10908   LOOKUP(28, ABI_VFP_args),
10909   LOOKUP(29, ABI_WMMX_args),
10910   LOOKUP(30, ABI_optimization_goals),
10911   LOOKUP(31, ABI_FP_optimization_goals),
10912   {32, "compatibility", 0, NULL},
10913   LOOKUP(34, CPU_unaligned_access),
10914   LOOKUP(36, FP_HP_extension),
10915   LOOKUP(38, ABI_FP_16bit_format),
10916   LOOKUP(42, MPextension_use),
10917   LOOKUP(44, DIV_use),
10918   {64, "nodefaults", 0, NULL},
10919   {65, "also_compatible_with", 0, NULL},
10920   LOOKUP(66, T2EE_use),
10921   {67, "conformance", 1, NULL},
10922   LOOKUP(68, Virtualization_use),
10923   LOOKUP(70, MPextension_use_legacy)
10924 };
10925 #undef LOOKUP
10926
10927 static unsigned char *
10928 display_arm_attribute (unsigned char * p)
10929 {
10930   int tag;
10931   unsigned int len;
10932   int val;
10933   arm_attr_public_tag * attr;
10934   unsigned i;
10935   int type;
10936
10937   tag = read_uleb128 (p, &len);
10938   p += len;
10939   attr = NULL;
10940   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
10941     {
10942       if (arm_attr_public_tags[i].tag == tag)
10943         {
10944           attr = &arm_attr_public_tags[i];
10945           break;
10946         }
10947     }
10948
10949   if (attr)
10950     {
10951       printf ("  Tag_%s: ", attr->name);
10952       switch (attr->type)
10953         {
10954         case 0:
10955           switch (tag)
10956             {
10957             case 7: /* Tag_CPU_arch_profile.  */
10958               val = read_uleb128 (p, &len);
10959               p += len;
10960               switch (val)
10961                 {
10962                 case 0: printf (_("None\n")); break;
10963                 case 'A': printf (_("Application\n")); break;
10964                 case 'R': printf (_("Realtime\n")); break;
10965                 case 'M': printf (_("Microcontroller\n")); break;
10966                 case 'S': printf (_("Application or Realtime\n")); break;
10967                 default: printf ("??? (%d)\n", val); break;
10968                 }
10969               break;
10970
10971             case 24: /* Tag_align_needed.  */
10972               val = read_uleb128 (p, &len);
10973               p += len;
10974               switch (val)
10975                 {
10976                 case 0: printf (_("None\n")); break;
10977                 case 1: printf (_("8-byte\n")); break;
10978                 case 2: printf (_("4-byte\n")); break;
10979                 case 3: printf ("??? 3\n"); break;
10980                 default:
10981                   if (val <= 12)
10982                     printf (_("8-byte and up to %d-byte extended\n"),
10983                             1 << val);
10984                   else
10985                     printf ("??? (%d)\n", val);
10986                   break;
10987                 }
10988               break;
10989
10990             case 25: /* Tag_align_preserved.  */
10991               val = read_uleb128 (p, &len);
10992               p += len;
10993               switch (val)
10994                 {
10995                 case 0: printf (_("None\n")); break;
10996                 case 1: printf (_("8-byte, except leaf SP\n")); break;
10997                 case 2: printf (_("8-byte\n")); break;
10998                 case 3: printf ("??? 3\n"); break;
10999                 default:
11000                   if (val <= 12)
11001                     printf (_("8-byte and up to %d-byte extended\n"),
11002                             1 << val);
11003                   else
11004                     printf ("??? (%d)\n", val);
11005                   break;
11006                 }
11007               break;
11008
11009             case 32: /* Tag_compatibility.  */
11010               val = read_uleb128 (p, &len);
11011               p += len;
11012               printf (_("flag = %d, vendor = %s\n"), val, p);
11013               p += strlen ((char *) p) + 1;
11014               break;
11015
11016             case 64: /* Tag_nodefaults.  */
11017               p++;
11018               printf (_("True\n"));
11019               break;
11020
11021             case 65: /* Tag_also_compatible_with.  */
11022               val = read_uleb128 (p, &len);
11023               p += len;
11024               if (val == 6 /* Tag_CPU_arch.  */)
11025                 {
11026                   val = read_uleb128 (p, &len);
11027                   p += len;
11028                   if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
11029                     printf ("??? (%d)\n", val);
11030                   else
11031                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11032                 }
11033               else
11034                 printf ("???\n");
11035               while (*(p++) != '\0' /* NUL terminator.  */);
11036               break;
11037
11038             default:
11039               abort ();
11040             }
11041           return p;
11042
11043         case 1:
11044         case 2:
11045           type = attr->type;
11046           break;
11047
11048         default:
11049           assert (attr->type & 0x80);
11050           val = read_uleb128 (p, &len);
11051           p += len;
11052           type = attr->type & 0x7f;
11053           if (val >= type)
11054             printf ("??? (%d)\n", val);
11055           else
11056             printf ("%s\n", attr->table[val]);
11057           return p;
11058         }
11059     }
11060   else
11061     {
11062       if (tag & 1)
11063         type = 1; /* String.  */
11064       else
11065         type = 2; /* uleb128.  */
11066       printf ("  Tag_unknown_%d: ", tag);
11067     }
11068
11069   if (type == 1)
11070     {
11071       printf ("\"%s\"\n", p);
11072       p += strlen ((char *) p) + 1;
11073     }
11074   else
11075     {
11076       val = read_uleb128 (p, &len);
11077       p += len;
11078       printf ("%d (0x%x)\n", val, val);
11079     }
11080
11081   return p;
11082 }
11083
11084 static unsigned char *
11085 display_gnu_attribute (unsigned char * p,
11086                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11087 {
11088   int tag;
11089   unsigned int len;
11090   int val;
11091   int type;
11092
11093   tag = read_uleb128 (p, &len);
11094   p += len;
11095
11096   /* Tag_compatibility is the only generic GNU attribute defined at
11097      present.  */
11098   if (tag == 32)
11099     {
11100       val = read_uleb128 (p, &len);
11101       p += len;
11102       printf (_("flag = %d, vendor = %s\n"), val, p);
11103       p += strlen ((char *) p) + 1;
11104       return p;
11105     }
11106
11107   if ((tag & 2) == 0 && display_proc_gnu_attribute)
11108     return display_proc_gnu_attribute (p, tag);
11109
11110   if (tag & 1)
11111     type = 1; /* String.  */
11112   else
11113     type = 2; /* uleb128.  */
11114   printf ("  Tag_unknown_%d: ", tag);
11115
11116   if (type == 1)
11117     {
11118       printf ("\"%s\"\n", p);
11119       p += strlen ((char *) p) + 1;
11120     }
11121   else
11122     {
11123       val = read_uleb128 (p, &len);
11124       p += len;
11125       printf ("%d (0x%x)\n", val, val);
11126     }
11127
11128   return p;
11129 }
11130
11131 static unsigned char *
11132 display_power_gnu_attribute (unsigned char * p, int tag)
11133 {
11134   int type;
11135   unsigned int len;
11136   int val;
11137
11138   if (tag == Tag_GNU_Power_ABI_FP)
11139     {
11140       val = read_uleb128 (p, &len);
11141       p += len;
11142       printf ("  Tag_GNU_Power_ABI_FP: ");
11143
11144       switch (val)
11145         {
11146         case 0:
11147           printf (_("Hard or soft float\n"));
11148           break;
11149         case 1:
11150           printf (_("Hard float\n"));
11151           break;
11152         case 2:
11153           printf (_("Soft float\n"));
11154           break;
11155         case 3:
11156           printf (_("Single-precision hard float\n"));
11157           break;
11158         default:
11159           printf ("??? (%d)\n", val);
11160           break;
11161         }
11162       return p;
11163    }
11164
11165   if (tag == Tag_GNU_Power_ABI_Vector)
11166     {
11167       val = read_uleb128 (p, &len);
11168       p += len;
11169       printf ("  Tag_GNU_Power_ABI_Vector: ");
11170       switch (val)
11171         {
11172         case 0:
11173           printf (_("Any\n"));
11174           break;
11175         case 1:
11176           printf (_("Generic\n"));
11177           break;
11178         case 2:
11179           printf ("AltiVec\n");
11180           break;
11181         case 3:
11182           printf ("SPE\n");
11183           break;
11184         default:
11185           printf ("??? (%d)\n", val);
11186           break;
11187         }
11188       return p;
11189    }
11190
11191   if (tag == Tag_GNU_Power_ABI_Struct_Return)
11192     {
11193       val = read_uleb128 (p, &len);
11194       p += len;
11195       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
11196       switch (val)
11197        {
11198        case 0:
11199          printf (_("Any\n"));
11200          break;
11201        case 1:
11202          printf ("r3/r4\n");
11203          break;
11204        case 2:
11205          printf (_("Memory\n"));
11206          break;
11207        default:
11208          printf ("??? (%d)\n", val);
11209          break;
11210        }
11211       return p;
11212     }
11213
11214   if (tag & 1)
11215     type = 1; /* String.  */
11216   else
11217     type = 2; /* uleb128.  */
11218   printf ("  Tag_unknown_%d: ", tag);
11219
11220   if (type == 1)
11221     {
11222       printf ("\"%s\"\n", p);
11223       p += strlen ((char *) p) + 1;
11224     }
11225   else
11226     {
11227       val = read_uleb128 (p, &len);
11228       p += len;
11229       printf ("%d (0x%x)\n", val, val);
11230     }
11231
11232   return p;
11233 }
11234
11235 static void
11236 display_sparc_hwcaps (int mask)
11237 {
11238   if (mask)
11239     {
11240       int first = 1;
11241       if (mask & ELF_SPARC_HWCAP_MUL32)
11242         fputs ("mul32", stdout), first = 0;
11243       if (mask & ELF_SPARC_HWCAP_DIV32)
11244         printf ("%sdiv32", first ? "" : "|"), first = 0;
11245       if (mask & ELF_SPARC_HWCAP_FSMULD)
11246         printf ("%sfsmuld", first ? "" : "|"), first = 0;
11247       if (mask & ELF_SPARC_HWCAP_V8PLUS)
11248         printf ("%sv8plus", first ? "" : "|"), first = 0;
11249       if (mask & ELF_SPARC_HWCAP_POPC)
11250         printf ("%spopc", first ? "" : "|"), first = 0;
11251       if (mask & ELF_SPARC_HWCAP_VIS)
11252         printf ("%svis", first ? "" : "|"), first = 0;
11253       if (mask & ELF_SPARC_HWCAP_VIS2)
11254         printf ("%svis2", first ? "" : "|"), first = 0;
11255       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11256         printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11257       if (mask & ELF_SPARC_HWCAP_FMAF)
11258         printf ("%sfmaf", first ? "" : "|"), first = 0;
11259       if (mask & ELF_SPARC_HWCAP_VIS3)
11260         printf ("%svis3", first ? "" : "|"), first = 0;
11261       if (mask & ELF_SPARC_HWCAP_HPC)
11262         printf ("%shpc", first ? "" : "|"), first = 0;
11263       if (mask & ELF_SPARC_HWCAP_RANDOM)
11264         printf ("%srandom", first ? "" : "|"), first = 0;
11265       if (mask & ELF_SPARC_HWCAP_TRANS)
11266         printf ("%strans", first ? "" : "|"), first = 0;
11267       if (mask & ELF_SPARC_HWCAP_FJFMAU)
11268         printf ("%sfjfmau", first ? "" : "|"), first = 0;
11269       if (mask & ELF_SPARC_HWCAP_IMA)
11270         printf ("%sima", first ? "" : "|"), first = 0;
11271       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11272         printf ("%scspare", first ? "" : "|"), first = 0;
11273     }
11274   else
11275     fputc('0', stdout);
11276   fputc('\n', stdout);
11277 }
11278
11279 static unsigned char *
11280 display_sparc_gnu_attribute (unsigned char * p, int tag)
11281 {
11282   int type;
11283   unsigned int len;
11284   int val;
11285
11286   if (tag == Tag_GNU_Sparc_HWCAPS)
11287     {
11288       val = read_uleb128 (p, &len);
11289       p += len;
11290       printf ("  Tag_GNU_Sparc_HWCAPS: ");
11291
11292       display_sparc_hwcaps (val);
11293       return p;
11294    }
11295
11296   if (tag & 1)
11297     type = 1; /* String.  */
11298   else
11299     type = 2; /* uleb128.  */
11300   printf ("  Tag_unknown_%d: ", tag);
11301
11302   if (type == 1)
11303     {
11304       printf ("\"%s\"\n", p);
11305       p += strlen ((char *) p) + 1;
11306     }
11307   else
11308     {
11309       val = read_uleb128 (p, &len);
11310       p += len;
11311       printf ("%d (0x%x)\n", val, val);
11312     }
11313
11314   return p;
11315 }
11316
11317 static unsigned char *
11318 display_mips_gnu_attribute (unsigned char * p, int tag)
11319 {
11320   int type;
11321   unsigned int len;
11322   int val;
11323
11324   if (tag == Tag_GNU_MIPS_ABI_FP)
11325     {
11326       val = read_uleb128 (p, &len);
11327       p += len;
11328       printf ("  Tag_GNU_MIPS_ABI_FP: ");
11329
11330       switch (val)
11331         {
11332         case 0:
11333           printf (_("Hard or soft float\n"));
11334           break;
11335         case 1:
11336           printf (_("Hard float (double precision)\n"));
11337           break;
11338         case 2:
11339           printf (_("Hard float (single precision)\n"));
11340           break;
11341         case 3:
11342           printf (_("Soft float\n"));
11343           break;
11344         case 4:
11345           printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
11346           break;
11347         default:
11348           printf ("??? (%d)\n", val);
11349           break;
11350         }
11351       return p;
11352    }
11353
11354   if (tag & 1)
11355     type = 1; /* String.  */
11356   else
11357     type = 2; /* uleb128.  */
11358   printf ("  Tag_unknown_%d: ", tag);
11359
11360   if (type == 1)
11361     {
11362       printf ("\"%s\"\n", p);
11363       p += strlen ((char *) p) + 1;
11364     }
11365   else
11366     {
11367       val = read_uleb128 (p, &len);
11368       p += len;
11369       printf ("%d (0x%x)\n", val, val);
11370     }
11371
11372   return p;
11373 }
11374
11375 static unsigned char *
11376 display_tic6x_attribute (unsigned char * p)
11377 {
11378   int tag;
11379   unsigned int len;
11380   int val;
11381
11382   tag = read_uleb128 (p, &len);
11383   p += len;
11384
11385   switch (tag)
11386     {
11387     case Tag_ISA:
11388       val = read_uleb128 (p, &len);
11389       p += len;
11390       printf ("  Tag_ISA: ");
11391
11392       switch (val)
11393         {
11394         case C6XABI_Tag_ISA_none:
11395           printf (_("None\n"));
11396           break;
11397         case C6XABI_Tag_ISA_C62X:
11398           printf ("C62x\n");
11399           break;
11400         case C6XABI_Tag_ISA_C67X:
11401           printf ("C67x\n");
11402           break;
11403         case C6XABI_Tag_ISA_C67XP:
11404           printf ("C67x+\n");
11405           break;
11406         case C6XABI_Tag_ISA_C64X:
11407           printf ("C64x\n");
11408           break;
11409         case C6XABI_Tag_ISA_C64XP:
11410           printf ("C64x+\n");
11411           break;
11412         case C6XABI_Tag_ISA_C674X:
11413           printf ("C674x\n");
11414           break;
11415         default:
11416           printf ("??? (%d)\n", val);
11417           break;
11418         }
11419       return p;
11420
11421     case Tag_ABI_wchar_t:
11422       val = read_uleb128 (p, &len);
11423       p += len;
11424       printf ("  Tag_ABI_wchar_t: ");
11425       switch (val)
11426         {
11427         case 0:
11428           printf (_("Not used\n"));
11429           break;
11430         case 1:
11431           printf (_("2 bytes\n"));
11432           break;
11433         case 2:
11434           printf (_("4 bytes\n"));
11435           break;
11436         default:
11437           printf ("??? (%d)\n", val);
11438           break;
11439         }
11440       return p;
11441
11442     case Tag_ABI_stack_align_needed:
11443       val = read_uleb128 (p, &len);
11444       p += len;
11445       printf ("  Tag_ABI_stack_align_needed: ");
11446       switch (val)
11447         {
11448         case 0:
11449           printf (_("8-byte\n"));
11450           break;
11451         case 1:
11452           printf (_("16-byte\n"));
11453           break;
11454         default:
11455           printf ("??? (%d)\n", val);
11456           break;
11457         }
11458       return p;
11459
11460     case Tag_ABI_stack_align_preserved:
11461       val = read_uleb128 (p, &len);
11462       p += len;
11463       printf ("  Tag_ABI_stack_align_preserved: ");
11464       switch (val)
11465         {
11466         case 0:
11467           printf (_("8-byte\n"));
11468           break;
11469         case 1:
11470           printf (_("16-byte\n"));
11471           break;
11472         default:
11473           printf ("??? (%d)\n", val);
11474           break;
11475         }
11476       return p;
11477
11478     case Tag_ABI_DSBT:
11479       val = read_uleb128 (p, &len);
11480       p += len;
11481       printf ("  Tag_ABI_DSBT: ");
11482       switch (val)
11483         {
11484         case 0:
11485           printf (_("DSBT addressing not used\n"));
11486           break;
11487         case 1:
11488           printf (_("DSBT addressing used\n"));
11489           break;
11490         default:
11491           printf ("??? (%d)\n", val);
11492           break;
11493         }
11494       return p;
11495
11496     case Tag_ABI_PID:
11497       val = read_uleb128 (p, &len);
11498       p += len;
11499       printf ("  Tag_ABI_PID: ");
11500       switch (val)
11501         {
11502         case 0:
11503           printf (_("Data addressing position-dependent\n"));
11504           break;
11505         case 1:
11506           printf (_("Data addressing position-independent, GOT near DP\n"));
11507           break;
11508         case 2:
11509           printf (_("Data addressing position-independent, GOT far from DP\n"));
11510           break;
11511         default:
11512           printf ("??? (%d)\n", val);
11513           break;
11514         }
11515       return p;
11516
11517     case Tag_ABI_PIC:
11518       val = read_uleb128 (p, &len);
11519       p += len;
11520       printf ("  Tag_ABI_PIC: ");
11521       switch (val)
11522         {
11523         case 0:
11524           printf (_("Code addressing position-dependent\n"));
11525           break;
11526         case 1:
11527           printf (_("Code addressing position-independent\n"));
11528           break;
11529         default:
11530           printf ("??? (%d)\n", val);
11531           break;
11532         }
11533       return p;
11534
11535     case Tag_ABI_array_object_alignment:
11536       val = read_uleb128 (p, &len);
11537       p += len;
11538       printf ("  Tag_ABI_array_object_alignment: ");
11539       switch (val)
11540         {
11541         case 0:
11542           printf (_("8-byte\n"));
11543           break;
11544         case 1:
11545           printf (_("4-byte\n"));
11546           break;
11547         case 2:
11548           printf (_("16-byte\n"));
11549           break;
11550         default:
11551           printf ("??? (%d)\n", val);
11552           break;
11553         }
11554       return p;
11555
11556     case Tag_ABI_array_object_align_expected:
11557       val = read_uleb128 (p, &len);
11558       p += len;
11559       printf ("  Tag_ABI_array_object_align_expected: ");
11560       switch (val)
11561         {
11562         case 0:
11563           printf (_("8-byte\n"));
11564           break;
11565         case 1:
11566           printf (_("4-byte\n"));
11567           break;
11568         case 2:
11569           printf (_("16-byte\n"));
11570           break;
11571         default:
11572           printf ("??? (%d)\n", val);
11573           break;
11574         }
11575       return p;
11576
11577     case Tag_ABI_compatibility:
11578       val = read_uleb128 (p, &len);
11579       p += len;
11580       printf ("  Tag_ABI_compatibility: ");
11581       printf (_("flag = %d, vendor = %s\n"), val, p);
11582       p += strlen ((char *) p) + 1;
11583       return p;
11584
11585     case Tag_ABI_conformance:
11586       printf ("  Tag_ABI_conformance: ");
11587       printf ("\"%s\"\n", p);
11588       p += strlen ((char *) p) + 1;
11589       return p;
11590     }
11591
11592   printf ("  Tag_unknown_%d: ", tag);
11593
11594   if (tag & 1)
11595     {
11596       printf ("\"%s\"\n", p);
11597       p += strlen ((char *) p) + 1;
11598     }
11599   else
11600     {
11601       val = read_uleb128 (p, &len);
11602       p += len;
11603       printf ("%d (0x%x)\n", val, val);
11604     }
11605
11606   return p;
11607 }
11608
11609 static int
11610 process_attributes (FILE * file,
11611                     const char * public_name,
11612                     unsigned int proc_type,
11613                     unsigned char * (* display_pub_attribute) (unsigned char *),
11614                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11615 {
11616   Elf_Internal_Shdr * sect;
11617   unsigned char * contents;
11618   unsigned char * p;
11619   unsigned char * end;
11620   bfd_vma section_len;
11621   bfd_vma len;
11622   unsigned i;
11623
11624   /* Find the section header so that we get the size.  */
11625   for (i = 0, sect = section_headers;
11626        i < elf_header.e_shnum;
11627        i++, sect++)
11628     {
11629       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11630         continue;
11631
11632       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11633                                              sect->sh_size, _("attributes"));
11634       if (contents == NULL)
11635         continue;
11636
11637       p = contents;
11638       if (*p == 'A')
11639         {
11640           len = sect->sh_size - 1;
11641           p++;
11642
11643           while (len > 0)
11644             {
11645               int namelen;
11646               bfd_boolean public_section;
11647               bfd_boolean gnu_section;
11648
11649               section_len = byte_get (p, 4);
11650               p += 4;
11651
11652               if (section_len > len)
11653                 {
11654                   printf (_("ERROR: Bad section length (%d > %d)\n"),
11655                           (int) section_len, (int) len);
11656                   section_len = len;
11657                 }
11658
11659               len -= section_len;
11660               printf (_("Attribute Section: %s\n"), p);
11661
11662               if (public_name && streq ((char *) p, public_name))
11663                 public_section = TRUE;
11664               else
11665                 public_section = FALSE;
11666
11667               if (streq ((char *) p, "gnu"))
11668                 gnu_section = TRUE;
11669               else
11670                 gnu_section = FALSE;
11671
11672               namelen = strlen ((char *) p) + 1;
11673               p += namelen;
11674               section_len -= namelen + 4;
11675
11676               while (section_len > 0)
11677                 {
11678                   int tag = *(p++);
11679                   int val;
11680                   bfd_vma size;
11681
11682                   size = byte_get (p, 4);
11683                   if (size > section_len)
11684                     {
11685                       printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11686                               (int) size, (int) section_len);
11687                       size = section_len;
11688                     }
11689
11690                   section_len -= size;
11691                   end = p + size - 1;
11692                   p += 4;
11693
11694                   switch (tag)
11695                     {
11696                     case 1:
11697                       printf (_("File Attributes\n"));
11698                       break;
11699                     case 2:
11700                       printf (_("Section Attributes:"));
11701                       goto do_numlist;
11702                     case 3:
11703                       printf (_("Symbol Attributes:"));
11704                     do_numlist:
11705                       for (;;)
11706                         {
11707                           unsigned int j;
11708
11709                           val = read_uleb128 (p, &j);
11710                           p += j;
11711                           if (val == 0)
11712                             break;
11713                           printf (" %d", val);
11714                         }
11715                       printf ("\n");
11716                       break;
11717                     default:
11718                       printf (_("Unknown tag: %d\n"), tag);
11719                       public_section = FALSE;
11720                       break;
11721                     }
11722
11723                   if (public_section)
11724                     {
11725                       while (p < end)
11726                         p = display_pub_attribute (p);
11727                     }
11728                   else if (gnu_section)
11729                     {
11730                       while (p < end)
11731                         p = display_gnu_attribute (p,
11732                                                    display_proc_gnu_attribute);
11733                     }
11734                   else
11735                     {
11736                       /* ??? Do something sensible, like dump hex.  */
11737                       printf (_("  Unknown section contexts\n"));
11738                       p = end;
11739                     }
11740                 }
11741             }
11742         }
11743       else
11744         printf (_("Unknown format '%c'\n"), *p);
11745
11746       free (contents);
11747     }
11748   return 1;
11749 }
11750
11751 static int
11752 process_arm_specific (FILE * file)
11753 {
11754   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
11755                              display_arm_attribute, NULL);
11756 }
11757
11758 static int
11759 process_power_specific (FILE * file)
11760 {
11761   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11762                              display_power_gnu_attribute);
11763 }
11764
11765 static int
11766 process_sparc_specific (FILE * file)
11767 {
11768   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11769                              display_sparc_gnu_attribute);
11770 }
11771
11772 static int
11773 process_tic6x_specific (FILE * file)
11774 {
11775   return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
11776                              display_tic6x_attribute, NULL);
11777 }
11778
11779 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11780    Print the Address, Access and Initial fields of an entry at VMA ADDR
11781    and return the VMA of the next entry.  */
11782
11783 static bfd_vma
11784 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
11785 {
11786   printf ("  ");
11787   print_vma (addr, LONG_HEX);
11788   printf (" ");
11789   if (addr < pltgot + 0xfff0)
11790     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
11791   else
11792     printf ("%10s", "");
11793   printf (" ");
11794   if (data == NULL)
11795     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
11796   else
11797     {
11798       bfd_vma entry;
11799
11800       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11801       print_vma (entry, LONG_HEX);
11802     }
11803   return addr + (is_32bit_elf ? 4 : 8);
11804 }
11805
11806 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11807    PLTGOT.  Print the Address and Initial fields of an entry at VMA
11808    ADDR and return the VMA of the next entry.  */
11809
11810 static bfd_vma
11811 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
11812 {
11813   printf ("  ");
11814   print_vma (addr, LONG_HEX);
11815   printf (" ");
11816   if (data == NULL)
11817     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
11818   else
11819     {
11820       bfd_vma entry;
11821
11822       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11823       print_vma (entry, LONG_HEX);
11824     }
11825   return addr + (is_32bit_elf ? 4 : 8);
11826 }
11827
11828 static int
11829 process_mips_specific (FILE * file)
11830 {
11831   Elf_Internal_Dyn * entry;
11832   size_t liblist_offset = 0;
11833   size_t liblistno = 0;
11834   size_t conflictsno = 0;
11835   size_t options_offset = 0;
11836   size_t conflicts_offset = 0;
11837   size_t pltrelsz = 0;
11838   size_t pltrel = 0;
11839   bfd_vma pltgot = 0;
11840   bfd_vma mips_pltgot = 0;
11841   bfd_vma jmprel = 0;
11842   bfd_vma local_gotno = 0;
11843   bfd_vma gotsym = 0;
11844   bfd_vma symtabno = 0;
11845
11846   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11847                       display_mips_gnu_attribute);
11848
11849   /* We have a lot of special sections.  Thanks SGI!  */
11850   if (dynamic_section == NULL)
11851     /* No information available.  */
11852     return 0;
11853
11854   for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
11855     switch (entry->d_tag)
11856       {
11857       case DT_MIPS_LIBLIST:
11858         liblist_offset
11859           = offset_from_vma (file, entry->d_un.d_val,
11860                              liblistno * sizeof (Elf32_External_Lib));
11861         break;
11862       case DT_MIPS_LIBLISTNO:
11863         liblistno = entry->d_un.d_val;
11864         break;
11865       case DT_MIPS_OPTIONS:
11866         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
11867         break;
11868       case DT_MIPS_CONFLICT:
11869         conflicts_offset
11870           = offset_from_vma (file, entry->d_un.d_val,
11871                              conflictsno * sizeof (Elf32_External_Conflict));
11872         break;
11873       case DT_MIPS_CONFLICTNO:
11874         conflictsno = entry->d_un.d_val;
11875         break;
11876       case DT_PLTGOT:
11877         pltgot = entry->d_un.d_ptr;
11878         break;
11879       case DT_MIPS_LOCAL_GOTNO:
11880         local_gotno = entry->d_un.d_val;
11881         break;
11882       case DT_MIPS_GOTSYM:
11883         gotsym = entry->d_un.d_val;
11884         break;
11885       case DT_MIPS_SYMTABNO:
11886         symtabno = entry->d_un.d_val;
11887         break;
11888       case DT_MIPS_PLTGOT:
11889         mips_pltgot = entry->d_un.d_ptr;
11890         break;
11891       case DT_PLTREL:
11892         pltrel = entry->d_un.d_val;
11893         break;
11894       case DT_PLTRELSZ:
11895         pltrelsz = entry->d_un.d_val;
11896         break;
11897       case DT_JMPREL:
11898         jmprel = entry->d_un.d_ptr;
11899         break;
11900       default:
11901         break;
11902       }
11903
11904   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
11905     {
11906       Elf32_External_Lib * elib;
11907       size_t cnt;
11908
11909       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
11910                                               liblistno,
11911                                               sizeof (Elf32_External_Lib),
11912                                               _("liblist section data"));
11913       if (elib)
11914         {
11915           printf (_("\nSection '.liblist' contains %lu entries:\n"),
11916                   (unsigned long) liblistno);
11917           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
11918                  stdout);
11919
11920           for (cnt = 0; cnt < liblistno; ++cnt)
11921             {
11922               Elf32_Lib liblist;
11923               time_t atime;
11924               char timebuf[20];
11925               struct tm * tmp;
11926
11927               liblist.l_name = BYTE_GET (elib[cnt].l_name);
11928               atime = BYTE_GET (elib[cnt].l_time_stamp);
11929               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11930               liblist.l_version = BYTE_GET (elib[cnt].l_version);
11931               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11932
11933               tmp = gmtime (&atime);
11934               snprintf (timebuf, sizeof (timebuf),
11935                         "%04u-%02u-%02uT%02u:%02u:%02u",
11936                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11937                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
11938
11939               printf ("%3lu: ", (unsigned long) cnt);
11940               if (VALID_DYNAMIC_NAME (liblist.l_name))
11941                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
11942               else
11943                 printf (_("<corrupt: %9ld>"), liblist.l_name);
11944               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
11945                       liblist.l_version);
11946
11947               if (liblist.l_flags == 0)
11948                 puts (_(" NONE"));
11949               else
11950                 {
11951                   static const struct
11952                   {
11953                     const char * name;
11954                     int bit;
11955                   }
11956                   l_flags_vals[] =
11957                   {
11958                     { " EXACT_MATCH", LL_EXACT_MATCH },
11959                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
11960                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
11961                     { " EXPORTS", LL_EXPORTS },
11962                     { " DELAY_LOAD", LL_DELAY_LOAD },
11963                     { " DELTA", LL_DELTA }
11964                   };
11965                   int flags = liblist.l_flags;
11966                   size_t fcnt;
11967
11968                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
11969                     if ((flags & l_flags_vals[fcnt].bit) != 0)
11970                       {
11971                         fputs (l_flags_vals[fcnt].name, stdout);
11972                         flags ^= l_flags_vals[fcnt].bit;
11973                       }
11974                   if (flags != 0)
11975                     printf (" %#x", (unsigned int) flags);
11976
11977                   puts ("");
11978                 }
11979             }
11980
11981           free (elib);
11982         }
11983     }
11984
11985   if (options_offset != 0)
11986     {
11987       Elf_External_Options * eopt;
11988       Elf_Internal_Shdr * sect = section_headers;
11989       Elf_Internal_Options * iopt;
11990       Elf_Internal_Options * option;
11991       size_t offset;
11992       int cnt;
11993
11994       /* Find the section header so that we get the size.  */
11995       while (sect->sh_type != SHT_MIPS_OPTIONS)
11996         ++sect;
11997
11998       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
11999                                                 sect->sh_size, _("options"));
12000       if (eopt)
12001         {
12002           iopt = (Elf_Internal_Options *)
12003               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
12004           if (iopt == NULL)
12005             {
12006               error (_("Out of memory\n"));
12007               return 0;
12008             }
12009
12010           offset = cnt = 0;
12011           option = iopt;
12012
12013           while (offset < sect->sh_size)
12014             {
12015               Elf_External_Options * eoption;
12016
12017               eoption = (Elf_External_Options *) ((char *) eopt + offset);
12018
12019               option->kind = BYTE_GET (eoption->kind);
12020               option->size = BYTE_GET (eoption->size);
12021               option->section = BYTE_GET (eoption->section);
12022               option->info = BYTE_GET (eoption->info);
12023
12024               offset += option->size;
12025
12026               ++option;
12027               ++cnt;
12028             }
12029
12030           printf (_("\nSection '%s' contains %d entries:\n"),
12031                   SECTION_NAME (sect), cnt);
12032
12033           option = iopt;
12034
12035           while (cnt-- > 0)
12036             {
12037               size_t len;
12038
12039               switch (option->kind)
12040                 {
12041                 case ODK_NULL:
12042                   /* This shouldn't happen.  */
12043                   printf (" NULL       %d %lx", option->section, option->info);
12044                   break;
12045                 case ODK_REGINFO:
12046                   printf (" REGINFO    ");
12047                   if (elf_header.e_machine == EM_MIPS)
12048                     {
12049                       /* 32bit form.  */
12050                       Elf32_External_RegInfo * ereg;
12051                       Elf32_RegInfo reginfo;
12052
12053                       ereg = (Elf32_External_RegInfo *) (option + 1);
12054                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12055                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12056                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12057                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12058                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12059                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12060
12061                       printf ("GPR %08lx  GP 0x%lx\n",
12062                               reginfo.ri_gprmask,
12063                               (unsigned long) reginfo.ri_gp_value);
12064                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
12065                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12066                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12067                     }
12068                   else
12069                     {
12070                       /* 64 bit form.  */
12071                       Elf64_External_RegInfo * ereg;
12072                       Elf64_Internal_RegInfo reginfo;
12073
12074                       ereg = (Elf64_External_RegInfo *) (option + 1);
12075                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
12076                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12077                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12078                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12079                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12080                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
12081
12082                       printf ("GPR %08lx  GP 0x",
12083                               reginfo.ri_gprmask);
12084                       printf_vma (reginfo.ri_gp_value);
12085                       printf ("\n");
12086
12087                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
12088                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12089                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12090                     }
12091                   ++option;
12092                   continue;
12093                 case ODK_EXCEPTIONS:
12094                   fputs (" EXCEPTIONS fpe_min(", stdout);
12095                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12096                   fputs (") fpe_max(", stdout);
12097                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12098                   fputs (")", stdout);
12099
12100                   if (option->info & OEX_PAGE0)
12101                     fputs (" PAGE0", stdout);
12102                   if (option->info & OEX_SMM)
12103                     fputs (" SMM", stdout);
12104                   if (option->info & OEX_FPDBUG)
12105                     fputs (" FPDBUG", stdout);
12106                   if (option->info & OEX_DISMISS)
12107                     fputs (" DISMISS", stdout);
12108                   break;
12109                 case ODK_PAD:
12110                   fputs (" PAD       ", stdout);
12111                   if (option->info & OPAD_PREFIX)
12112                     fputs (" PREFIX", stdout);
12113                   if (option->info & OPAD_POSTFIX)
12114                     fputs (" POSTFIX", stdout);
12115                   if (option->info & OPAD_SYMBOL)
12116                     fputs (" SYMBOL", stdout);
12117                   break;
12118                 case ODK_HWPATCH:
12119                   fputs (" HWPATCH   ", stdout);
12120                   if (option->info & OHW_R4KEOP)
12121                     fputs (" R4KEOP", stdout);
12122                   if (option->info & OHW_R8KPFETCH)
12123                     fputs (" R8KPFETCH", stdout);
12124                   if (option->info & OHW_R5KEOP)
12125                     fputs (" R5KEOP", stdout);
12126                   if (option->info & OHW_R5KCVTL)
12127                     fputs (" R5KCVTL", stdout);
12128                   break;
12129                 case ODK_FILL:
12130                   fputs (" FILL       ", stdout);
12131                   /* XXX Print content of info word?  */
12132                   break;
12133                 case ODK_TAGS:
12134                   fputs (" TAGS       ", stdout);
12135                   /* XXX Print content of info word?  */
12136                   break;
12137                 case ODK_HWAND:
12138                   fputs (" HWAND     ", stdout);
12139                   if (option->info & OHWA0_R4KEOP_CHECKED)
12140                     fputs (" R4KEOP_CHECKED", stdout);
12141                   if (option->info & OHWA0_R4KEOP_CLEAN)
12142                     fputs (" R4KEOP_CLEAN", stdout);
12143                   break;
12144                 case ODK_HWOR:
12145                   fputs (" HWOR      ", stdout);
12146                   if (option->info & OHWA0_R4KEOP_CHECKED)
12147                     fputs (" R4KEOP_CHECKED", stdout);
12148                   if (option->info & OHWA0_R4KEOP_CLEAN)
12149                     fputs (" R4KEOP_CLEAN", stdout);
12150                   break;
12151                 case ODK_GP_GROUP:
12152                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
12153                           option->info & OGP_GROUP,
12154                           (option->info & OGP_SELF) >> 16);
12155                   break;
12156                 case ODK_IDENT:
12157                   printf (" IDENT     %#06lx  self-contained %#06lx",
12158                           option->info & OGP_GROUP,
12159                           (option->info & OGP_SELF) >> 16);
12160                   break;
12161                 default:
12162                   /* This shouldn't happen.  */
12163                   printf (" %3d ???     %d %lx",
12164                           option->kind, option->section, option->info);
12165                   break;
12166                 }
12167
12168               len = sizeof (* eopt);
12169               while (len < option->size)
12170                 if (((char *) option)[len] >= ' '
12171                     && ((char *) option)[len] < 0x7f)
12172                   printf ("%c", ((char *) option)[len++]);
12173                 else
12174                   printf ("\\%03o", ((char *) option)[len++]);
12175
12176               fputs ("\n", stdout);
12177               ++option;
12178             }
12179
12180           free (eopt);
12181         }
12182     }
12183
12184   if (conflicts_offset != 0 && conflictsno != 0)
12185     {
12186       Elf32_Conflict * iconf;
12187       size_t cnt;
12188
12189       if (dynamic_symbols == NULL)
12190         {
12191           error (_("conflict list found without a dynamic symbol table\n"));
12192           return 0;
12193         }
12194
12195       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
12196       if (iconf == NULL)
12197         {
12198           error (_("Out of memory\n"));
12199           return 0;
12200         }
12201
12202       if (is_32bit_elf)
12203         {
12204           Elf32_External_Conflict * econf32;
12205
12206           econf32 = (Elf32_External_Conflict *)
12207               get_data (NULL, file, conflicts_offset, conflictsno,
12208                         sizeof (* econf32), _("conflict"));
12209           if (!econf32)
12210             return 0;
12211
12212           for (cnt = 0; cnt < conflictsno; ++cnt)
12213             iconf[cnt] = BYTE_GET (econf32[cnt]);
12214
12215           free (econf32);
12216         }
12217       else
12218         {
12219           Elf64_External_Conflict * econf64;
12220
12221           econf64 = (Elf64_External_Conflict *)
12222               get_data (NULL, file, conflicts_offset, conflictsno,
12223                         sizeof (* econf64), _("conflict"));
12224           if (!econf64)
12225             return 0;
12226
12227           for (cnt = 0; cnt < conflictsno; ++cnt)
12228             iconf[cnt] = BYTE_GET (econf64[cnt]);
12229
12230           free (econf64);
12231         }
12232
12233       printf (_("\nSection '.conflict' contains %lu entries:\n"),
12234               (unsigned long) conflictsno);
12235       puts (_("  Num:    Index       Value  Name"));
12236
12237       for (cnt = 0; cnt < conflictsno; ++cnt)
12238         {
12239           Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
12240
12241           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
12242           print_vma (psym->st_value, FULL_HEX);
12243           putchar (' ');
12244           if (VALID_DYNAMIC_NAME (psym->st_name))
12245             print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
12246           else
12247             printf (_("<corrupt: %14ld>"), psym->st_name);
12248           putchar ('\n');
12249         }
12250
12251       free (iconf);
12252     }
12253
12254   if (pltgot != 0 && local_gotno != 0)
12255     {
12256       bfd_vma ent, local_end, global_end;
12257       size_t i, offset;
12258       unsigned char * data;
12259       int addr_size;
12260
12261       ent = pltgot;
12262       addr_size = (is_32bit_elf ? 4 : 8);
12263       local_end = pltgot + local_gotno * addr_size;
12264       global_end = local_end + (symtabno - gotsym) * addr_size;
12265
12266       offset = offset_from_vma (file, pltgot, global_end - pltgot);
12267       data = (unsigned char *) get_data (NULL, file, offset,
12268                                          global_end - pltgot, 1,
12269                                          _("Global Offset Table data"));
12270       if (data == NULL)
12271         return 0;
12272
12273       printf (_("\nPrimary GOT:\n"));
12274       printf (_(" Canonical gp value: "));
12275       print_vma (pltgot + 0x7ff0, LONG_HEX);
12276       printf ("\n\n");
12277
12278       printf (_(" Reserved entries:\n"));
12279       printf (_("  %*s %10s %*s Purpose\n"),
12280               addr_size * 2, _("Address"), _("Access"),
12281               addr_size * 2, _("Initial"));
12282       ent = print_mips_got_entry (data, pltgot, ent);
12283       printf (_(" Lazy resolver\n"));
12284       if (data
12285           && (byte_get (data + ent - pltgot, addr_size)
12286               >> (addr_size * 8 - 1)) != 0)
12287         {
12288           ent = print_mips_got_entry (data, pltgot, ent);
12289           printf (_(" Module pointer (GNU extension)\n"));
12290         }
12291       printf ("\n");
12292
12293       if (ent < local_end)
12294         {
12295           printf (_(" Local entries:\n"));
12296           printf ("  %*s %10s %*s\n",
12297                   addr_size * 2, _("Address"), _("Access"),
12298                   addr_size * 2, _("Initial"));
12299           while (ent < local_end)
12300             {
12301               ent = print_mips_got_entry (data, pltgot, ent);
12302               printf ("\n");
12303             }
12304           printf ("\n");
12305         }
12306
12307       if (gotsym < symtabno)
12308         {
12309           int sym_width;
12310
12311           printf (_(" Global entries:\n"));
12312           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
12313                   addr_size * 2, _("Address"),
12314                   _("Access"),
12315                   addr_size * 2, _("Initial"),
12316                   addr_size * 2, _("Sym.Val."),
12317                   _("Type"),
12318                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
12319                   _("Ndx"), _("Name"));
12320
12321           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12322           for (i = gotsym; i < symtabno; i++)
12323             {
12324               Elf_Internal_Sym * psym;
12325
12326               psym = dynamic_symbols + i;
12327               ent = print_mips_got_entry (data, pltgot, ent);
12328               printf (" ");
12329               print_vma (psym->st_value, LONG_HEX);
12330               printf (" %-7s %3s ",
12331                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12332                       get_symbol_index_type (psym->st_shndx));
12333               if (VALID_DYNAMIC_NAME (psym->st_name))
12334                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12335               else
12336                 printf (_("<corrupt: %14ld>"), psym->st_name);
12337               printf ("\n");
12338             }
12339           printf ("\n");
12340         }
12341
12342       if (data)
12343         free (data);
12344     }
12345
12346   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12347     {
12348       bfd_vma ent, end;
12349       size_t offset, rel_offset;
12350       unsigned long count, i;
12351       unsigned char * data;
12352       int addr_size, sym_width;
12353       Elf_Internal_Rela * rels;
12354
12355       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12356       if (pltrel == DT_RELA)
12357         {
12358           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12359             return 0;
12360         }
12361       else
12362         {
12363           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12364             return 0;
12365         }
12366
12367       ent = mips_pltgot;
12368       addr_size = (is_32bit_elf ? 4 : 8);
12369       end = mips_pltgot + (2 + count) * addr_size;
12370
12371       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
12372       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
12373                                          1, _("Procedure Linkage Table data"));
12374       if (data == NULL)
12375         return 0;
12376
12377       printf ("\nPLT GOT:\n\n");
12378       printf (_(" Reserved entries:\n"));
12379       printf (_("  %*s %*s Purpose\n"),
12380               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
12381       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12382       printf (_(" PLT lazy resolver\n"));
12383       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12384       printf (_(" Module pointer\n"));
12385       printf ("\n");
12386
12387       printf (_(" Entries:\n"));
12388       printf ("  %*s %*s %*s %-7s %3s %s\n",
12389               addr_size * 2, _("Address"),
12390               addr_size * 2, _("Initial"),
12391               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12392       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12393       for (i = 0; i < count; i++)
12394         {
12395           Elf_Internal_Sym * psym;
12396
12397           psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
12398           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12399           printf (" ");
12400           print_vma (psym->st_value, LONG_HEX);
12401           printf (" %-7s %3s ",
12402                   get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12403                   get_symbol_index_type (psym->st_shndx));
12404           if (VALID_DYNAMIC_NAME (psym->st_name))
12405             print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12406           else
12407             printf (_("<corrupt: %14ld>"), psym->st_name);
12408           printf ("\n");
12409         }
12410       printf ("\n");
12411
12412       if (data)
12413         free (data);
12414       free (rels);
12415     }
12416
12417   return 1;
12418 }
12419
12420 static int
12421 process_gnu_liblist (FILE * file)
12422 {
12423   Elf_Internal_Shdr * section;
12424   Elf_Internal_Shdr * string_sec;
12425   Elf32_External_Lib * elib;
12426   char * strtab;
12427   size_t strtab_size;
12428   size_t cnt;
12429   unsigned i;
12430
12431   if (! do_arch)
12432     return 0;
12433
12434   for (i = 0, section = section_headers;
12435        i < elf_header.e_shnum;
12436        i++, section++)
12437     {
12438       switch (section->sh_type)
12439         {
12440         case SHT_GNU_LIBLIST:
12441           if (section->sh_link >= elf_header.e_shnum)
12442             break;
12443
12444           elib = (Elf32_External_Lib *)
12445               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
12446                         _("liblist section data"));
12447
12448           if (elib == NULL)
12449             break;
12450           string_sec = section_headers + section->sh_link;
12451
12452           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12453                                       string_sec->sh_size,
12454                                       _("liblist string table"));
12455           if (strtab == NULL
12456               || section->sh_entsize != sizeof (Elf32_External_Lib))
12457             {
12458               free (elib);
12459               free (strtab);
12460               break;
12461             }
12462           strtab_size = string_sec->sh_size;
12463
12464           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12465                   SECTION_NAME (section),
12466                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
12467
12468           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
12469
12470           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12471                ++cnt)
12472             {
12473               Elf32_Lib liblist;
12474               time_t atime;
12475               char timebuf[20];
12476               struct tm * tmp;
12477
12478               liblist.l_name = BYTE_GET (elib[cnt].l_name);
12479               atime = BYTE_GET (elib[cnt].l_time_stamp);
12480               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12481               liblist.l_version = BYTE_GET (elib[cnt].l_version);
12482               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12483
12484               tmp = gmtime (&atime);
12485               snprintf (timebuf, sizeof (timebuf),
12486                         "%04u-%02u-%02uT%02u:%02u:%02u",
12487                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12488                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12489
12490               printf ("%3lu: ", (unsigned long) cnt);
12491               if (do_wide)
12492                 printf ("%-20s", liblist.l_name < strtab_size
12493                         ? strtab + liblist.l_name : _("<corrupt>"));
12494               else
12495                 printf ("%-20.20s", liblist.l_name < strtab_size
12496                         ? strtab + liblist.l_name : _("<corrupt>"));
12497               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12498                       liblist.l_version, liblist.l_flags);
12499             }
12500
12501           free (elib);
12502           free (strtab);
12503         }
12504     }
12505
12506   return 1;
12507 }
12508
12509 static const char *
12510 get_note_type (unsigned e_type)
12511 {
12512   static char buff[64];
12513
12514   if (elf_header.e_type == ET_CORE)
12515     switch (e_type)
12516       {
12517       case NT_AUXV:
12518         return _("NT_AUXV (auxiliary vector)");
12519       case NT_PRSTATUS:
12520         return _("NT_PRSTATUS (prstatus structure)");
12521       case NT_FPREGSET:
12522         return _("NT_FPREGSET (floating point registers)");
12523       case NT_PRPSINFO:
12524         return _("NT_PRPSINFO (prpsinfo structure)");
12525       case NT_TASKSTRUCT:
12526         return _("NT_TASKSTRUCT (task structure)");
12527       case NT_PRXFPREG:
12528         return _("NT_PRXFPREG (user_xfpregs structure)");
12529       case NT_PPC_VMX:
12530         return _("NT_PPC_VMX (ppc Altivec registers)");
12531       case NT_PPC_VSX:
12532         return _("NT_PPC_VSX (ppc VSX registers)");
12533       case NT_X86_XSTATE:
12534         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
12535       case NT_S390_HIGH_GPRS:
12536         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
12537       case NT_S390_TIMER:
12538         return _("NT_S390_TIMER (s390 timer register)");
12539       case NT_S390_TODCMP:
12540         return _("NT_S390_TODCMP (s390 TOD comparator register)");
12541       case NT_S390_TODPREG:
12542         return _("NT_S390_TODPREG (s390 TOD programmable register)");
12543       case NT_S390_CTRS:
12544         return _("NT_S390_CTRS (s390 control registers)");
12545       case NT_S390_PREFIX:
12546         return _("NT_S390_PREFIX (s390 prefix register)");
12547       case NT_ARM_VFP:
12548         return _("NT_ARM_VFP (arm VFP registers)");
12549       case NT_PSTATUS:
12550         return _("NT_PSTATUS (pstatus structure)");
12551       case NT_FPREGS:
12552         return _("NT_FPREGS (floating point registers)");
12553       case NT_PSINFO:
12554         return _("NT_PSINFO (psinfo structure)");
12555       case NT_LWPSTATUS:
12556         return _("NT_LWPSTATUS (lwpstatus_t structure)");
12557       case NT_LWPSINFO:
12558         return _("NT_LWPSINFO (lwpsinfo_t structure)");
12559       case NT_WIN32PSTATUS:
12560         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12561       default:
12562         break;
12563       }
12564   else
12565     switch (e_type)
12566       {
12567       case NT_VERSION:
12568         return _("NT_VERSION (version)");
12569       case NT_ARCH:
12570         return _("NT_ARCH (architecture)");
12571       default:
12572         break;
12573       }
12574
12575   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12576   return buff;
12577 }
12578
12579 static const char *
12580 get_gnu_elf_note_type (unsigned e_type)
12581 {
12582   static char buff[64];
12583
12584   switch (e_type)
12585     {
12586     case NT_GNU_ABI_TAG:
12587       return _("NT_GNU_ABI_TAG (ABI version tag)");
12588     case NT_GNU_HWCAP:
12589       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12590     case NT_GNU_BUILD_ID:
12591       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
12592     case NT_GNU_GOLD_VERSION:
12593       return _("NT_GNU_GOLD_VERSION (gold version)");
12594     default:
12595       break;
12596     }
12597
12598   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12599   return buff;
12600 }
12601
12602 static int
12603 print_gnu_note (Elf_Internal_Note *pnote)
12604 {
12605   switch (pnote->type)
12606     {
12607     case NT_GNU_BUILD_ID:
12608       {
12609         unsigned long i;
12610
12611         printf (_("    Build ID: "));
12612         for (i = 0; i < pnote->descsz; ++i)
12613           printf ("%02x", pnote->descdata[i] & 0xff);
12614         printf ("\n");
12615       }
12616       break;
12617
12618     case NT_GNU_ABI_TAG:
12619       {
12620         unsigned long os, major, minor, subminor;
12621         const char *osname;
12622
12623         os = byte_get ((unsigned char *) pnote->descdata, 4);
12624         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
12625         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
12626         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
12627
12628         switch (os)
12629           {
12630           case GNU_ABI_TAG_LINUX:
12631             osname = "Linux";
12632             break;
12633           case GNU_ABI_TAG_HURD:
12634             osname = "Hurd";
12635             break;
12636           case GNU_ABI_TAG_SOLARIS:
12637             osname = "Solaris";
12638             break;
12639           case GNU_ABI_TAG_FREEBSD:
12640             osname = "FreeBSD";
12641             break;
12642           case GNU_ABI_TAG_NETBSD:
12643             osname = "NetBSD";
12644             break;
12645           default:
12646             osname = "Unknown";
12647             break;
12648           }
12649
12650         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
12651                 major, minor, subminor);
12652       }
12653       break;
12654     }
12655
12656   return 1;
12657 }
12658
12659 static const char *
12660 get_netbsd_elfcore_note_type (unsigned e_type)
12661 {
12662   static char buff[64];
12663
12664   if (e_type == NT_NETBSDCORE_PROCINFO)
12665     {
12666       /* NetBSD core "procinfo" structure.  */
12667       return _("NetBSD procinfo structure");
12668     }
12669
12670   /* As of Jan 2002 there are no other machine-independent notes
12671      defined for NetBSD core files.  If the note type is less
12672      than the start of the machine-dependent note types, we don't
12673      understand it.  */
12674
12675   if (e_type < NT_NETBSDCORE_FIRSTMACH)
12676     {
12677       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12678       return buff;
12679     }
12680
12681   switch (elf_header.e_machine)
12682     {
12683     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
12684        and PT_GETFPREGS == mach+2.  */
12685
12686     case EM_OLD_ALPHA:
12687     case EM_ALPHA:
12688     case EM_SPARC:
12689     case EM_SPARC32PLUS:
12690     case EM_SPARCV9:
12691       switch (e_type)
12692         {
12693         case NT_NETBSDCORE_FIRSTMACH + 0:
12694           return _("PT_GETREGS (reg structure)");
12695         case NT_NETBSDCORE_FIRSTMACH + 2:
12696           return _("PT_GETFPREGS (fpreg structure)");
12697         default:
12698           break;
12699         }
12700       break;
12701
12702     /* On all other arch's, PT_GETREGS == mach+1 and
12703        PT_GETFPREGS == mach+3.  */
12704     default:
12705       switch (e_type)
12706         {
12707         case NT_NETBSDCORE_FIRSTMACH + 1:
12708           return _("PT_GETREGS (reg structure)");
12709         case NT_NETBSDCORE_FIRSTMACH + 3:
12710           return _("PT_GETFPREGS (fpreg structure)");
12711         default:
12712           break;
12713         }
12714     }
12715
12716   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
12717             e_type - NT_NETBSDCORE_FIRSTMACH);
12718   return buff;
12719 }
12720
12721 static const char *
12722 get_stapsdt_note_type (unsigned e_type)
12723 {
12724   static char buff[64];
12725
12726   switch (e_type)
12727     {
12728     case NT_STAPSDT:
12729       return _("NT_STAPSDT (SystemTap probe descriptors)");
12730
12731     default:
12732       break;
12733     }
12734
12735   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12736   return buff;
12737 }
12738
12739 static int
12740 print_stapsdt_note (Elf_Internal_Note *pnote)
12741 {
12742   int addr_size = is_32bit_elf ? 4 : 8;
12743   char *data = pnote->descdata;
12744   char *data_end = pnote->descdata + pnote->descsz;
12745   bfd_vma pc, base_addr, semaphore;
12746   char *provider, *probe, *arg_fmt;
12747
12748   pc = byte_get ((unsigned char *) data, addr_size);
12749   data += addr_size;
12750   base_addr = byte_get ((unsigned char *) data, addr_size);
12751   data += addr_size;
12752   semaphore = byte_get ((unsigned char *) data, addr_size);
12753   data += addr_size;
12754
12755   provider = data;
12756   data += strlen (data) + 1;
12757   probe = data;
12758   data += strlen (data) + 1;
12759   arg_fmt = data;
12760   data += strlen (data) + 1;
12761
12762   printf (_("    Provider: %s\n"), provider);
12763   printf (_("    Name: %s\n"), probe);
12764   printf (_("    Location: "));
12765   print_vma (pc, FULL_HEX);
12766   printf (_(", Base: "));
12767   print_vma (base_addr, FULL_HEX);
12768   printf (_(", Semaphore: "));
12769   print_vma (semaphore, FULL_HEX);
12770   printf ("\n");
12771   printf (_("    Arguments: %s\n"), arg_fmt);
12772
12773   return data == data_end;
12774 }
12775
12776 static const char *
12777 get_ia64_vms_note_type (unsigned e_type)
12778 {
12779   static char buff[64];
12780
12781   switch (e_type)
12782     {
12783     case NT_VMS_MHD:
12784       return _("NT_VMS_MHD (module header)");
12785     case NT_VMS_LNM:
12786       return _("NT_VMS_LNM (language name)");
12787     case NT_VMS_SRC:
12788       return _("NT_VMS_SRC (source files)");
12789     case NT_VMS_TITLE:
12790       return "NT_VMS_TITLE";
12791     case NT_VMS_EIDC:
12792       return _("NT_VMS_EIDC (consistency check)");
12793     case NT_VMS_FPMODE:
12794       return _("NT_VMS_FPMODE (FP mode)");
12795     case NT_VMS_LINKTIME:
12796       return "NT_VMS_LINKTIME";
12797     case NT_VMS_IMGNAM:
12798       return _("NT_VMS_IMGNAM (image name)");
12799     case NT_VMS_IMGID:
12800       return _("NT_VMS_IMGID (image id)");
12801     case NT_VMS_LINKID:
12802       return _("NT_VMS_LINKID (link id)");
12803     case NT_VMS_IMGBID:
12804       return _("NT_VMS_IMGBID (build id)");
12805     case NT_VMS_GSTNAM:
12806       return _("NT_VMS_GSTNAM (sym table name)");
12807     case NT_VMS_ORIG_DYN:
12808       return "NT_VMS_ORIG_DYN";
12809     case NT_VMS_PATCHTIME:
12810       return "NT_VMS_PATCHTIME";
12811     default:
12812       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12813       return buff;
12814     }
12815 }
12816
12817 static int
12818 print_ia64_vms_note (Elf_Internal_Note * pnote)
12819 {
12820   switch (pnote->type)
12821     {
12822     case NT_VMS_MHD:
12823       if (pnote->descsz > 36)
12824         {
12825           size_t l = strlen (pnote->descdata + 34);
12826           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
12827           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
12828           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
12829           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
12830         }
12831       else
12832         printf (_("    Invalid size\n"));
12833       break;
12834     case NT_VMS_LNM:
12835       printf (_("   Language: %s\n"), pnote->descdata);
12836       break;
12837 #ifdef BFD64
12838     case NT_VMS_FPMODE:
12839       printf (_("   Floating Point mode: "));
12840       printf ("0x%016" BFD_VMA_FMT "x\n",
12841               (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
12842       break;
12843     case NT_VMS_LINKTIME:
12844       printf (_("   Link time: "));
12845       print_vms_time
12846         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12847       printf ("\n");
12848       break;
12849     case NT_VMS_PATCHTIME:
12850       printf (_("   Patch time: "));
12851       print_vms_time
12852         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12853       printf ("\n");
12854       break;
12855     case NT_VMS_ORIG_DYN:
12856       printf (_("   Major id: %u,  minor id: %u\n"),
12857               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
12858               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
12859       printf (_("   Last modified  : "));
12860       print_vms_time
12861         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
12862       printf (_("\n   Link flags  : "));
12863       printf ("0x%016" BFD_VMA_FMT "x\n",
12864               (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
12865       printf (_("   Header flags: 0x%08x\n"),
12866               (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
12867       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
12868       break;
12869 #endif
12870     case NT_VMS_IMGNAM:
12871       printf (_("    Image name: %s\n"), pnote->descdata);
12872       break;
12873     case NT_VMS_GSTNAM:
12874       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
12875       break;
12876     case NT_VMS_IMGID:
12877       printf (_("    Image id: %s\n"), pnote->descdata);
12878       break;
12879     case NT_VMS_LINKID:
12880       printf (_("    Linker id: %s\n"), pnote->descdata);
12881       break;
12882     default:
12883       break;
12884     }
12885   return 1;
12886 }
12887
12888 /* Note that by the ELF standard, the name field is already null byte
12889    terminated, and namesz includes the terminating null byte.
12890    I.E. the value of namesz for the name "FSF" is 4.
12891
12892    If the value of namesz is zero, there is no name present.  */
12893 static int
12894 process_note (Elf_Internal_Note * pnote)
12895 {
12896   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
12897   const char * nt;
12898
12899   if (pnote->namesz == 0)
12900     /* If there is no note name, then use the default set of
12901        note type strings.  */
12902     nt = get_note_type (pnote->type);
12903
12904   else if (const_strneq (pnote->namedata, "GNU"))
12905     /* GNU-specific object file notes.  */
12906     nt = get_gnu_elf_note_type (pnote->type);
12907
12908   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
12909     /* NetBSD-specific core file notes.  */
12910     nt = get_netbsd_elfcore_note_type (pnote->type);
12911
12912   else if (strneq (pnote->namedata, "SPU/", 4))
12913     {
12914       /* SPU-specific core file notes.  */
12915       nt = pnote->namedata + 4;
12916       name = "SPU";
12917     }
12918
12919   else if (const_strneq (pnote->namedata, "IPF/VMS"))
12920     /* VMS/ia64-specific file notes.  */
12921     nt = get_ia64_vms_note_type (pnote->type);
12922
12923   else if (const_strneq (pnote->namedata, "stapsdt"))
12924     nt = get_stapsdt_note_type (pnote->type);
12925
12926   else
12927     /* Don't recognize this note name; just use the default set of
12928        note type strings.  */
12929     nt = get_note_type (pnote->type);
12930
12931   printf ("  %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
12932
12933   if (const_strneq (pnote->namedata, "IPF/VMS"))
12934     return print_ia64_vms_note (pnote);
12935   else if (const_strneq (pnote->namedata, "GNU"))
12936     return print_gnu_note (pnote);
12937   else if (const_strneq (pnote->namedata, "stapsdt"))
12938     return print_stapsdt_note (pnote);
12939   else
12940     return 1;
12941 }
12942
12943
12944 static int
12945 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
12946 {
12947   Elf_External_Note * pnotes;
12948   Elf_External_Note * external;
12949   int res = 1;
12950
12951   if (length <= 0)
12952     return 0;
12953
12954   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
12955                                            _("notes"));
12956   if (pnotes == NULL)
12957     return 0;
12958
12959   external = pnotes;
12960
12961   printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
12962           (unsigned long) offset, (unsigned long) length);
12963   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
12964
12965   while (external < (Elf_External_Note *) ((char *) pnotes + length))
12966     {
12967       Elf_External_Note * next;
12968       Elf_Internal_Note inote;
12969       char * temp = NULL;
12970
12971       if (!is_ia64_vms ())
12972         {
12973           inote.type     = BYTE_GET (external->type);
12974           inote.namesz   = BYTE_GET (external->namesz);
12975           inote.namedata = external->name;
12976           inote.descsz   = BYTE_GET (external->descsz);
12977           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
12978           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
12979
12980           next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
12981         }
12982       else
12983         {
12984           Elf64_External_VMS_Note *vms_external;
12985
12986           vms_external = (Elf64_External_VMS_Note *)external;
12987           inote.type     = BYTE_GET (vms_external->type);
12988           inote.namesz   = BYTE_GET (vms_external->namesz);
12989           inote.namedata = vms_external->name;
12990           inote.descsz   = BYTE_GET (vms_external->descsz);
12991           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
12992           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
12993
12994           next = (Elf_External_Note *)
12995             (inote.descdata + align_power (inote.descsz, 3));
12996         }
12997
12998       if (   ((char *) next > ((char *) pnotes) + length)
12999           || ((char *) next <  (char *) pnotes))
13000         {
13001           warn (_("corrupt note found at offset %lx into core notes\n"),
13002                 (unsigned long) ((char *) external - (char *) pnotes));
13003           warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13004                 inote.type, inote.namesz, inote.descsz);
13005           break;
13006         }
13007
13008       external = next;
13009
13010       /* Prevent out-of-bounds indexing.  */
13011       if (inote.namedata + inote.namesz > (char *) pnotes + length
13012           || inote.namedata + inote.namesz < inote.namedata)
13013         {
13014           warn (_("corrupt note found at offset %lx into core notes\n"),
13015                 (unsigned long) ((char *) external - (char *) pnotes));
13016           warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13017                 inote.type, inote.namesz, inote.descsz);
13018           break;
13019         }
13020
13021       /* Verify that name is null terminated.  It appears that at least
13022          one version of Linux (RedHat 6.0) generates corefiles that don't
13023          comply with the ELF spec by failing to include the null byte in
13024          namesz.  */
13025       if (inote.namedata[inote.namesz - 1] != '\0')
13026         {
13027           temp = (char *) malloc (inote.namesz + 1);
13028
13029           if (temp == NULL)
13030             {
13031               error (_("Out of memory\n"));
13032               res = 0;
13033               break;
13034             }
13035
13036           strncpy (temp, inote.namedata, inote.namesz);
13037           temp[inote.namesz] = 0;
13038
13039           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
13040           inote.namedata = temp;
13041         }
13042
13043       res &= process_note (& inote);
13044
13045       if (temp != NULL)
13046         {
13047           free (temp);
13048           temp = NULL;
13049         }
13050     }
13051
13052   free (pnotes);
13053
13054   return res;
13055 }
13056
13057 static int
13058 process_corefile_note_segments (FILE * file)
13059 {
13060   Elf_Internal_Phdr * segment;
13061   unsigned int i;
13062   int res = 1;
13063
13064   if (! get_program_headers (file))
13065       return 0;
13066
13067   for (i = 0, segment = program_headers;
13068        i < elf_header.e_phnum;
13069        i++, segment++)
13070     {
13071       if (segment->p_type == PT_NOTE)
13072         res &= process_corefile_note_segment (file,
13073                                               (bfd_vma) segment->p_offset,
13074                                               (bfd_vma) segment->p_filesz);
13075     }
13076
13077   return res;
13078 }
13079
13080 static int
13081 process_note_sections (FILE * file)
13082 {
13083   Elf_Internal_Shdr * section;
13084   unsigned long i;
13085   int res = 1;
13086
13087   for (i = 0, section = section_headers;
13088        i < elf_header.e_shnum && section != NULL;
13089        i++, section++)
13090     if (section->sh_type == SHT_NOTE)
13091       res &= process_corefile_note_segment (file,
13092                                             (bfd_vma) section->sh_offset,
13093                                             (bfd_vma) section->sh_size);
13094
13095   return res;
13096 }
13097
13098 static int
13099 process_notes (FILE * file)
13100 {
13101   /* If we have not been asked to display the notes then do nothing.  */
13102   if (! do_notes)
13103     return 1;
13104
13105   if (elf_header.e_type != ET_CORE)
13106     return process_note_sections (file);
13107
13108   /* No program headers means no NOTE segment.  */
13109   if (elf_header.e_phnum > 0)
13110     return process_corefile_note_segments (file);
13111
13112   printf (_("No note segments present in the core file.\n"));
13113   return 1;
13114 }
13115
13116 static int
13117 process_arch_specific (FILE * file)
13118 {
13119   if (! do_arch)
13120     return 1;
13121
13122   switch (elf_header.e_machine)
13123     {
13124     case EM_ARM:
13125       return process_arm_specific (file);
13126     case EM_MIPS:
13127     case EM_MIPS_RS3_LE:
13128       return process_mips_specific (file);
13129       break;
13130     case EM_PPC:
13131       return process_power_specific (file);
13132       break;
13133     case EM_SPARC:
13134     case EM_SPARC32PLUS:
13135     case EM_SPARCV9:
13136       return process_sparc_specific (file);
13137       break;
13138     case EM_TI_C6000:
13139       return process_tic6x_specific (file);
13140       break;
13141     default:
13142       break;
13143     }
13144   return 1;
13145 }
13146
13147 static int
13148 get_file_header (FILE * file)
13149 {
13150   /* Read in the identity array.  */
13151   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
13152     return 0;
13153
13154   /* Determine how to read the rest of the header.  */
13155   switch (elf_header.e_ident[EI_DATA])
13156     {
13157     default: /* fall through */
13158     case ELFDATANONE: /* fall through */
13159     case ELFDATA2LSB:
13160       byte_get = byte_get_little_endian;
13161       byte_put = byte_put_little_endian;
13162       break;
13163     case ELFDATA2MSB:
13164       byte_get = byte_get_big_endian;
13165       byte_put = byte_put_big_endian;
13166       break;
13167     }
13168
13169   /* For now we only support 32 bit and 64 bit ELF files.  */
13170   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
13171
13172   /* Read in the rest of the header.  */
13173   if (is_32bit_elf)
13174     {
13175       Elf32_External_Ehdr ehdr32;
13176
13177       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
13178         return 0;
13179
13180       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
13181       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
13182       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
13183       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
13184       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
13185       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
13186       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
13187       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
13188       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
13189       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
13190       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
13191       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
13192       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
13193     }
13194   else
13195     {
13196       Elf64_External_Ehdr ehdr64;
13197
13198       /* If we have been compiled with sizeof (bfd_vma) == 4, then
13199          we will not be able to cope with the 64bit data found in
13200          64 ELF files.  Detect this now and abort before we start
13201          overwriting things.  */
13202       if (sizeof (bfd_vma) < 8)
13203         {
13204           error (_("This instance of readelf has been built without support for a\n\
13205 64 bit data type and so it cannot read 64 bit ELF files.\n"));
13206           return 0;
13207         }
13208
13209       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
13210         return 0;
13211
13212       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
13213       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
13214       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
13215       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
13216       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
13217       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
13218       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
13219       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
13220       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
13221       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
13222       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
13223       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
13224       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
13225     }
13226
13227   if (elf_header.e_shoff)
13228     {
13229       /* There may be some extensions in the first section header.  Don't
13230          bomb if we can't read it.  */
13231       if (is_32bit_elf)
13232         get_32bit_section_headers (file, 1);
13233       else
13234         get_64bit_section_headers (file, 1);
13235     }
13236
13237   return 1;
13238 }
13239
13240 /* Process one ELF object file according to the command line options.
13241    This file may actually be stored in an archive.  The file is
13242    positioned at the start of the ELF object.  */
13243
13244 static int
13245 process_object (char * file_name, FILE * file)
13246 {
13247   unsigned int i;
13248
13249   if (! get_file_header (file))
13250     {
13251       error (_("%s: Failed to read file header\n"), file_name);
13252       return 1;
13253     }
13254
13255   /* Initialise per file variables.  */
13256   for (i = ARRAY_SIZE (version_info); i--;)
13257     version_info[i] = 0;
13258
13259   for (i = ARRAY_SIZE (dynamic_info); i--;)
13260     dynamic_info[i] = 0;
13261   dynamic_info_DT_GNU_HASH = 0;
13262
13263   /* Process the file.  */
13264   if (show_name)
13265     printf (_("\nFile: %s\n"), file_name);
13266
13267   /* Initialise the dump_sects array from the cmdline_dump_sects array.
13268      Note we do this even if cmdline_dump_sects is empty because we
13269      must make sure that the dump_sets array is zeroed out before each
13270      object file is processed.  */
13271   if (num_dump_sects > num_cmdline_dump_sects)
13272     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
13273
13274   if (num_cmdline_dump_sects > 0)
13275     {
13276       if (num_dump_sects == 0)
13277         /* A sneaky way of allocating the dump_sects array.  */
13278         request_dump_bynumber (num_cmdline_dump_sects, 0);
13279
13280       assert (num_dump_sects >= num_cmdline_dump_sects);
13281       memcpy (dump_sects, cmdline_dump_sects,
13282               num_cmdline_dump_sects * sizeof (* dump_sects));
13283     }
13284
13285   if (! process_file_header ())
13286     return 1;
13287
13288   if (! process_section_headers (file))
13289     {
13290       /* Without loaded section headers we cannot process lots of
13291          things.  */
13292       do_unwind = do_version = do_dump = do_arch = 0;
13293
13294       if (! do_using_dynamic)
13295         do_syms = do_dyn_syms = do_reloc = 0;
13296     }
13297
13298   if (! process_section_groups (file))
13299     {
13300       /* Without loaded section groups we cannot process unwind.  */
13301       do_unwind = 0;
13302     }
13303
13304   if (process_program_headers (file))
13305     process_dynamic_section (file);
13306
13307   process_relocs (file);
13308
13309   process_unwind (file);
13310
13311   process_symbol_table (file);
13312
13313   process_syminfo (file);
13314
13315   process_version_sections (file);
13316
13317   process_section_contents (file);
13318
13319   process_notes (file);
13320
13321   process_gnu_liblist (file);
13322
13323   process_arch_specific (file);
13324
13325   if (program_headers)
13326     {
13327       free (program_headers);
13328       program_headers = NULL;
13329     }
13330
13331   if (section_headers)
13332     {
13333       free (section_headers);
13334       section_headers = NULL;
13335     }
13336
13337   if (string_table)
13338     {
13339       free (string_table);
13340       string_table = NULL;
13341       string_table_length = 0;
13342     }
13343
13344   if (dynamic_strings)
13345     {
13346       free (dynamic_strings);
13347       dynamic_strings = NULL;
13348       dynamic_strings_length = 0;
13349     }
13350
13351   if (dynamic_symbols)
13352     {
13353       free (dynamic_symbols);
13354       dynamic_symbols = NULL;
13355       num_dynamic_syms = 0;
13356     }
13357
13358   if (dynamic_syminfo)
13359     {
13360       free (dynamic_syminfo);
13361       dynamic_syminfo = NULL;
13362     }
13363
13364   if (dynamic_section)
13365     {
13366       free (dynamic_section);
13367       dynamic_section = NULL;
13368     }
13369
13370   if (section_headers_groups)
13371     {
13372       free (section_headers_groups);
13373       section_headers_groups = NULL;
13374     }
13375
13376   if (section_groups)
13377     {
13378       struct group_list * g;
13379       struct group_list * next;
13380
13381       for (i = 0; i < group_count; i++)
13382         {
13383           for (g = section_groups [i].root; g != NULL; g = next)
13384             {
13385               next = g->next;
13386               free (g);
13387             }
13388         }
13389
13390       free (section_groups);
13391       section_groups = NULL;
13392     }
13393
13394   free_debug_memory ();
13395
13396   return 0;
13397 }
13398
13399 /* Process an ELF archive.
13400    On entry the file is positioned just after the ARMAG string.  */
13401
13402 static int
13403 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
13404 {
13405   struct archive_info arch;
13406   struct archive_info nested_arch;
13407   size_t got;
13408   int ret;
13409
13410   show_name = 1;
13411
13412   /* The ARCH structure is used to hold information about this archive.  */
13413   arch.file_name = NULL;
13414   arch.file = NULL;
13415   arch.index_array = NULL;
13416   arch.sym_table = NULL;
13417   arch.longnames = NULL;
13418
13419   /* The NESTED_ARCH structure is used as a single-item cache of information
13420      about a nested archive (when members of a thin archive reside within
13421      another regular archive file).  */
13422   nested_arch.file_name = NULL;
13423   nested_arch.file = NULL;
13424   nested_arch.index_array = NULL;
13425   nested_arch.sym_table = NULL;
13426   nested_arch.longnames = NULL;
13427
13428   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
13429     {
13430       ret = 1;
13431       goto out;
13432     }
13433
13434   if (do_archive_index)
13435     {
13436       if (arch.sym_table == NULL)
13437         error (_("%s: unable to dump the index as none was found\n"), file_name);
13438       else
13439         {
13440           unsigned int i, l;
13441           unsigned long current_pos;
13442
13443           printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
13444                   file_name, arch.index_num, arch.sym_size);
13445           current_pos = ftell (file);
13446
13447           for (i = l = 0; i < arch.index_num; i++)
13448             {
13449               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
13450                 {
13451                   char * member_name;
13452
13453                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
13454
13455                   if (member_name != NULL)
13456                     {
13457                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
13458
13459                       if (qualified_name != NULL)
13460                         {
13461                           printf (_("Binary %s contains:\n"), qualified_name);
13462                           free (qualified_name);
13463                         }
13464                     }
13465                 }
13466
13467               if (l >= arch.sym_size)
13468                 {
13469                   error (_("%s: end of the symbol table reached before the end of the index\n"),
13470                          file_name);
13471                   break;
13472                 }
13473               printf ("\t%s\n", arch.sym_table + l);
13474               l += strlen (arch.sym_table + l) + 1;
13475             }
13476
13477           if (l & 01)
13478             ++l;
13479           if (l < arch.sym_size)
13480             error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
13481                    file_name);
13482
13483           if (fseek (file, current_pos, SEEK_SET) != 0)
13484             {
13485               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
13486               ret = 1;
13487               goto out;
13488             }
13489         }
13490
13491       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
13492           && !do_segments && !do_header && !do_dump && !do_version
13493           && !do_histogram && !do_debugging && !do_arch && !do_notes
13494           && !do_section_groups && !do_dyn_syms)
13495         {
13496           ret = 0; /* Archive index only.  */
13497           goto out;
13498         }
13499     }
13500
13501   ret = 0;
13502
13503   while (1)
13504     {
13505       char * name;
13506       size_t namelen;
13507       char * qualified_name;
13508
13509       /* Read the next archive header.  */
13510       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13511         {
13512           error (_("%s: failed to seek to next archive header\n"), file_name);
13513           return 1;
13514         }
13515       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13516       if (got != sizeof arch.arhdr)
13517         {
13518           if (got == 0)
13519             break;
13520           error (_("%s: failed to read archive header\n"), file_name);
13521           ret = 1;
13522           break;
13523         }
13524       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13525         {
13526           error (_("%s: did not find a valid archive header\n"), arch.file_name);
13527           ret = 1;
13528           break;
13529         }
13530
13531       arch.next_arhdr_offset += sizeof arch.arhdr;
13532
13533       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13534       if (archive_file_size & 01)
13535         ++archive_file_size;
13536
13537       name = get_archive_member_name (&arch, &nested_arch);
13538       if (name == NULL)
13539         {
13540           error (_("%s: bad archive file name\n"), file_name);
13541           ret = 1;
13542           break;
13543         }
13544       namelen = strlen (name);
13545
13546       qualified_name = make_qualified_name (&arch, &nested_arch, name);
13547       if (qualified_name == NULL)
13548         {
13549           error (_("%s: bad archive file name\n"), file_name);
13550           ret = 1;
13551           break;
13552         }
13553
13554       if (is_thin_archive && arch.nested_member_origin == 0)
13555         {
13556           /* This is a proxy for an external member of a thin archive.  */
13557           FILE * member_file;
13558           char * member_file_name = adjust_relative_path (file_name, name, namelen);
13559           if (member_file_name == NULL)
13560             {
13561               ret = 1;
13562               break;
13563             }
13564
13565           member_file = fopen (member_file_name, "rb");
13566           if (member_file == NULL)
13567             {
13568               error (_("Input file '%s' is not readable.\n"), member_file_name);
13569               free (member_file_name);
13570               ret = 1;
13571               break;
13572             }
13573
13574           archive_file_offset = arch.nested_member_origin;
13575
13576           ret |= process_object (qualified_name, member_file);
13577
13578           fclose (member_file);
13579           free (member_file_name);
13580         }
13581       else if (is_thin_archive)
13582         {
13583           /* This is a proxy for a member of a nested archive.  */
13584           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
13585
13586           /* The nested archive file will have been opened and setup by
13587              get_archive_member_name.  */
13588           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
13589             {
13590               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
13591               ret = 1;
13592               break;
13593             }
13594
13595           ret |= process_object (qualified_name, nested_arch.file);
13596         }
13597       else
13598         {
13599           archive_file_offset = arch.next_arhdr_offset;
13600           arch.next_arhdr_offset += archive_file_size;
13601
13602           ret |= process_object (qualified_name, file);
13603         }
13604
13605       if (dump_sects != NULL)
13606         {
13607           free (dump_sects);
13608           dump_sects = NULL;
13609           num_dump_sects = 0;
13610         }
13611
13612       free (qualified_name);
13613     }
13614
13615  out:
13616   if (nested_arch.file != NULL)
13617     fclose (nested_arch.file);
13618   release_archive (&nested_arch);
13619   release_archive (&arch);
13620
13621   return ret;
13622 }
13623
13624 static int
13625 process_file (char * file_name)
13626 {
13627   FILE * file;
13628   struct stat statbuf;
13629   char armag[SARMAG];
13630   int ret;
13631
13632   if (stat (file_name, &statbuf) < 0)
13633     {
13634       if (errno == ENOENT)
13635         error (_("'%s': No such file\n"), file_name);
13636       else
13637         error (_("Could not locate '%s'.  System error message: %s\n"),
13638                file_name, strerror (errno));
13639       return 1;
13640     }
13641
13642   if (! S_ISREG (statbuf.st_mode))
13643     {
13644       error (_("'%s' is not an ordinary file\n"), file_name);
13645       return 1;
13646     }
13647
13648   file = fopen (file_name, "rb");
13649   if (file == NULL)
13650     {
13651       error (_("Input file '%s' is not readable.\n"), file_name);
13652       return 1;
13653     }
13654
13655   if (fread (armag, SARMAG, 1, file) != 1)
13656     {
13657       error (_("%s: Failed to read file's magic number\n"), file_name);
13658       fclose (file);
13659       return 1;
13660     }
13661
13662   if (memcmp (armag, ARMAG, SARMAG) == 0)
13663     ret = process_archive (file_name, file, FALSE);
13664   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
13665     ret = process_archive (file_name, file, TRUE);
13666   else
13667     {
13668       if (do_archive_index)
13669         error (_("File %s is not an archive so its index cannot be displayed.\n"),
13670                file_name);
13671
13672       rewind (file);
13673       archive_file_size = archive_file_offset = 0;
13674       ret = process_object (file_name, file);
13675     }
13676
13677   fclose (file);
13678
13679   return ret;
13680 }
13681
13682 #ifdef SUPPORT_DISASSEMBLY
13683 /* Needed by the i386 disassembler.  For extra credit, someone could
13684    fix this so that we insert symbolic addresses here, esp for GOT/PLT
13685    symbols.  */
13686
13687 void
13688 print_address (unsigned int addr, FILE * outfile)
13689 {
13690   fprintf (outfile,"0x%8.8x", addr);
13691 }
13692
13693 /* Needed by the i386 disassembler.  */
13694 void
13695 db_task_printsym (unsigned int addr)
13696 {
13697   print_address (addr, stderr);
13698 }
13699 #endif
13700
13701 int
13702 main (int argc, char ** argv)
13703 {
13704   int err;
13705
13706 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
13707   setlocale (LC_MESSAGES, "");
13708 #endif
13709 #if defined (HAVE_SETLOCALE)
13710   setlocale (LC_CTYPE, "");
13711 #endif
13712   bindtextdomain (PACKAGE, LOCALEDIR);
13713   textdomain (PACKAGE);
13714
13715   expandargv (&argc, &argv);
13716
13717   parse_args (argc, argv);
13718
13719   if (num_dump_sects > 0)
13720     {
13721       /* Make a copy of the dump_sects array.  */
13722       cmdline_dump_sects = (dump_type *)
13723           malloc (num_dump_sects * sizeof (* dump_sects));
13724       if (cmdline_dump_sects == NULL)
13725         error (_("Out of memory allocating dump request table.\n"));
13726       else
13727         {
13728           memcpy (cmdline_dump_sects, dump_sects,
13729                   num_dump_sects * sizeof (* dump_sects));
13730           num_cmdline_dump_sects = num_dump_sects;
13731         }
13732     }
13733
13734   if (optind < (argc - 1))
13735     show_name = 1;
13736
13737   err = 0;
13738   while (optind < argc)
13739     err |= process_file (argv[optind++]);
13740
13741   if (dump_sects != NULL)
13742     free (dump_sects);
13743   if (cmdline_dump_sects != NULL)
13744     free (cmdline_dump_sects);
13745
13746   return err;
13747 }