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