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