binutils/readelf.c

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