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