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 ("  [%2u] %-17.17s %-15.15s ",
4379                 i,
4380                 SECTION_NAME (section),
4381                 get_section_type_name (section->sh_type));
4382
4383       if (is_32bit_elf)
4384         {
4385           print_vma (section->sh_addr, LONG_HEX);
4386
4387           printf ( " %6.6lx %6.6lx %2.2lx",
4388                    (unsigned long) section->sh_offset,
4389                    (unsigned long) section->sh_size,
4390                    (unsigned long) section->sh_entsize);
4391
4392           if (do_section_details)
4393             fputs ("  ", stdout);
4394           else
4395             printf (" %3s ", get_elf_section_flags (section->sh_flags));
4396
4397           printf ("%2u %3u %2lu\n",
4398                   section->sh_link,
4399                   section->sh_info,
4400                   (unsigned long) section->sh_addralign);
4401         }
4402       else if (do_wide)
4403         {
4404           print_vma (section->sh_addr, LONG_HEX);
4405
4406           if ((long) section->sh_offset == section->sh_offset)
4407             printf (" %6.6lx", (unsigned long) section->sh_offset);
4408           else
4409             {
4410               putchar (' ');
4411               print_vma (section->sh_offset, LONG_HEX);
4412             }
4413
4414           if ((unsigned long) section->sh_size == section->sh_size)
4415             printf (" %6.6lx", (unsigned long) section->sh_size);
4416           else
4417             {
4418               putchar (' ');
4419               print_vma (section->sh_size, LONG_HEX);
4420             }
4421
4422           if ((unsigned long) section->sh_entsize == section->sh_entsize)
4423             printf (" %2.2lx", (unsigned long) section->sh_entsize);
4424           else
4425             {
4426               putchar (' ');
4427               print_vma (section->sh_entsize, LONG_HEX);
4428             }
4429
4430           if (do_section_details)
4431             fputs ("  ", stdout);
4432           else
4433             printf (" %3s ", get_elf_section_flags (section->sh_flags));
4434
4435           printf ("%2u %3u ", section->sh_link, section->sh_info);
4436
4437           if ((unsigned long) section->sh_addralign == section->sh_addralign)
4438             printf ("%2lu\n", (unsigned long) section->sh_addralign);
4439           else
4440             {
4441               print_vma (section->sh_addralign, DEC);
4442               putchar ('\n');
4443             }
4444         }
4445       else if (do_section_details)
4446         {
4447           printf ("       %-15.15s  ",
4448                   get_section_type_name (section->sh_type));
4449           print_vma (section->sh_addr, LONG_HEX);
4450           if ((long) section->sh_offset == section->sh_offset)
4451             printf ("  %16.16lx", (unsigned long) section->sh_offset);
4452           else
4453             {
4454               printf ("  ");
4455               print_vma (section->sh_offset, LONG_HEX);
4456             }
4457           printf ("  %u\n       ", section->sh_link);
4458           print_vma (section->sh_size, LONG_HEX);
4459           putchar (' ');
4460           print_vma (section->sh_entsize, LONG_HEX);
4461
4462           printf ("  %-16u  %lu\n",
4463                   section->sh_info,
4464                   (unsigned long) section->sh_addralign);
4465         }
4466       else
4467         {
4468           putchar (' ');
4469           print_vma (section->sh_addr, LONG_HEX);
4470           if ((long) section->sh_offset == section->sh_offset)
4471             printf ("  %8.8lx", (unsigned long) section->sh_offset);
4472           else
4473             {
4474               printf ("  ");
4475               print_vma (section->sh_offset, LONG_HEX);
4476             }
4477           printf ("\n       ");
4478           print_vma (section->sh_size, LONG_HEX);
4479           printf ("  ");
4480           print_vma (section->sh_entsize, LONG_HEX);
4481
4482           printf (" %3s ", get_elf_section_flags (section->sh_flags));
4483
4484           printf ("     %2u   %3u     %lu\n",
4485                   section->sh_link,
4486                   section->sh_info,
4487                   (unsigned long) section->sh_addralign);
4488         }
4489
4490       if (do_section_details)
4491         printf ("       %s\n", get_elf_section_flags (section->sh_flags));
4492     }
4493
4494   if (!do_section_details)
4495     printf (_("Key to Flags:\n\
4496   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4497   I (info), L (link order), G (group), x (unknown)\n\
4498   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4499
4500   return 1;
4501 }
4502
4503 static const char *
4504 get_group_flags (unsigned int flags)
4505 {
4506   static char buff[32];
4507   switch (flags)
4508     {
4509     case GRP_COMDAT:
4510       return "COMDAT";
4511
4512    default:
4513       snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x]"), flags);
4514       break;
4515     }
4516   return buff;
4517 }
4518
4519 static int
4520 process_section_groups (FILE *file)
4521 {
4522   Elf_Internal_Shdr *section;
4523   unsigned int i;
4524   struct group *group;
4525   Elf_Internal_Shdr *symtab_sec, *strtab_sec;
4526   Elf_Internal_Sym *symtab;
4527   char *strtab;
4528   size_t strtab_size;
4529
4530   /* Don't process section groups unless needed.  */
4531   if (!do_unwind && !do_section_groups)
4532     return 1;
4533
4534   if (elf_header.e_shnum == 0)
4535     {
4536       if (do_section_groups)
4537         printf (_("\nThere are no sections in this file.\n"));
4538
4539       return 1;
4540     }
4541
4542   if (section_headers == NULL)
4543     {
4544       error (_("Section headers are not available!\n"));
4545       abort ();
4546     }
4547
4548   section_headers_groups = calloc (elf_header.e_shnum,
4549                                    sizeof (struct group *));
4550
4551   if (section_headers_groups == NULL)
4552     {
4553       error (_("Out of memory\n"));
4554       return 0;
4555     }
4556
4557   /* Scan the sections for the group section.  */
4558   group_count = 0;
4559   for (i = 0, section = section_headers;
4560        i < elf_header.e_shnum;
4561        i++, section++)
4562     if (section->sh_type == SHT_GROUP)
4563       group_count++;
4564
4565   if (group_count == 0)
4566     {
4567       if (do_section_groups)
4568         printf (_("\nThere are no section groups in this file.\n"));
4569
4570       return 1;
4571     }
4572
4573   section_groups = calloc (group_count, sizeof (struct group));
4574
4575   if (section_groups == NULL)
4576     {
4577       error (_("Out of memory\n"));
4578       return 0;
4579     }
4580
4581   symtab_sec = NULL;
4582   strtab_sec = NULL;
4583   symtab = NULL;
4584   strtab = NULL;
4585   strtab_size = 0;
4586   for (i = 0, section = section_headers, group = section_groups;
4587        i < elf_header.e_shnum;
4588        i++, section++)
4589     {
4590       if (section->sh_type == SHT_GROUP)
4591         {
4592           char *name = SECTION_NAME (section);
4593           char *group_name;
4594           unsigned char *start, *indices;
4595           unsigned int entry, j, size;
4596           Elf_Internal_Shdr *sec;
4597           Elf_Internal_Sym *sym;
4598
4599           /* Get the symbol table.  */
4600           if (section->sh_link >= elf_header.e_shnum
4601               || ((sec = section_headers + section->sh_link)->sh_type
4602                   != SHT_SYMTAB))
4603             {
4604               error (_("Bad sh_link in group section `%s'\n"), name);
4605               continue;
4606             }
4607
4608           if (symtab_sec != sec)
4609             {
4610               symtab_sec = sec;
4611               if (symtab)
4612                 free (symtab);
4613               symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4614             }
4615
4616           sym = symtab + section->sh_info;
4617
4618           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4619             {
4620               if (sym->st_shndx == 0
4621                   || sym->st_shndx >= elf_header.e_shnum)
4622                 {
4623                   error (_("Bad sh_info in group section `%s'\n"), name);
4624                   continue;
4625                 }
4626
4627               group_name = SECTION_NAME (section_headers + sym->st_shndx);
4628               strtab_sec = NULL;
4629               if (strtab)
4630                 free (strtab);
4631               strtab = NULL;
4632               strtab_size = 0;
4633             }
4634           else
4635             {
4636               /* Get the string table.  */
4637               if (symtab_sec->sh_link >= elf_header.e_shnum)
4638                 {
4639                   strtab_sec = NULL;
4640                   if (strtab)
4641                     free (strtab);
4642                   strtab = NULL;
4643                   strtab_size = 0;
4644                 }
4645               else if (strtab_sec
4646                        != (sec = section_headers + symtab_sec->sh_link))
4647                 {
4648                   strtab_sec = sec;
4649                   if (strtab)
4650                     free (strtab);
4651                   strtab = get_data (NULL, file, strtab_sec->sh_offset,
4652                                      1, strtab_sec->sh_size,
4653                                      _("string table"));
4654                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
4655                 }
4656               group_name = sym->st_name < strtab_size
4657                            ? strtab + sym->st_name : "<corrupt>";
4658             }
4659
4660           start = get_data (NULL, file, section->sh_offset,
4661                             1, section->sh_size, _("section data"));
4662
4663           indices = start;
4664           size = (section->sh_size / section->sh_entsize) - 1;
4665           entry = byte_get (indices, 4);
4666           indices += 4;
4667
4668           if (do_section_groups)
4669             {
4670               printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4671                       get_group_flags (entry), i, name, group_name, size);
4672
4673               printf (_("   [Index]    Name\n"));
4674             }
4675
4676           group->group_index = i;
4677
4678           for (j = 0; j < size; j++)
4679             {
4680               struct group_list *g;
4681
4682               entry = byte_get (indices, 4);
4683               indices += 4;
4684
4685               if (entry >= elf_header.e_shnum)
4686                 {
4687                   error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4688                          entry, i, elf_header.e_shnum - 1);
4689                   continue;
4690                 }
4691
4692               if (section_headers_groups [entry] != NULL)
4693                 {
4694                   if (entry)
4695                     {
4696                       error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4697                              entry, i,
4698                              section_headers_groups [entry]->group_index);
4699                       continue;
4700                     }
4701                   else
4702                     {
4703                       /* Intel C/C++ compiler may put section 0 in a
4704                          section group. We just warn it the first time
4705                          and ignore it afterwards.  */
4706                       static int warned = 0;
4707                       if (!warned)
4708                         {
4709                           error (_("section 0 in group section [%5u]\n"),
4710                                  section_headers_groups [entry]->group_index);
4711                           warned++;
4712                         }
4713                     }
4714                 }
4715
4716               section_headers_groups [entry] = group;
4717
4718               if (do_section_groups)
4719                 {
4720                   sec = section_headers + entry;
4721                   printf ("   [%5u]   %s\n", entry, SECTION_NAME (sec));
4722                 }
4723
4724               g = xmalloc (sizeof (struct group_list));
4725               g->section_index = entry;
4726               g->next = group->root;
4727               group->root = g;
4728             }
4729
4730           if (start)
4731             free (start);
4732
4733           group++;
4734         }
4735     }
4736
4737   if (symtab)
4738     free (symtab);
4739   if (strtab)
4740     free (strtab);
4741   return 1;
4742 }
4743
4744 static struct
4745 {
4746   const char *name;
4747   int reloc;
4748   int size;
4749   int rela;
4750 } dynamic_relocations [] =
4751 {
4752     { "REL", DT_REL, DT_RELSZ, FALSE },
4753     { "RELA", DT_RELA, DT_RELASZ, TRUE },
4754     { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
4755 };
4756
4757 /* Process the reloc section.  */
4758
4759 static int
4760 process_relocs (FILE *file)
4761 {
4762   unsigned long rel_size;
4763   unsigned long rel_offset;
4764
4765
4766   if (!do_reloc)
4767     return 1;
4768
4769   if (do_using_dynamic)
4770     {
4771       int is_rela;
4772       const char *name;
4773       int has_dynamic_reloc;
4774       unsigned int i;
4775
4776       has_dynamic_reloc = 0;
4777
4778       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
4779         {
4780           is_rela = dynamic_relocations [i].rela;
4781           name = dynamic_relocations [i].name;
4782           rel_size = dynamic_info [dynamic_relocations [i].size];
4783           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
4784
4785           has_dynamic_reloc |= rel_size;
4786
4787           if (is_rela == UNKNOWN)
4788             {
4789               if (dynamic_relocations [i].reloc == DT_JMPREL)
4790                 switch (dynamic_info[DT_PLTREL])
4791                   {
4792                   case DT_REL:
4793                     is_rela = FALSE;
4794                     break;
4795                   case DT_RELA:
4796                     is_rela = TRUE;
4797                     break;
4798                   }
4799             }
4800
4801           if (rel_size)
4802             {
4803               printf
4804                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4805                  name, rel_offset, rel_size);
4806
4807               dump_relocations (file,
4808                                 offset_from_vma (file, rel_offset, rel_size),
4809                                 rel_size,
4810                                 dynamic_symbols, num_dynamic_syms,
4811                                 dynamic_strings, dynamic_strings_length, is_rela);
4812             }
4813         }
4814
4815       if (! has_dynamic_reloc)
4816         printf (_("\nThere are no dynamic relocations in this file.\n"));
4817     }
4818   else
4819     {
4820       Elf_Internal_Shdr *section;
4821       unsigned long i;
4822       int found = 0;
4823
4824       for (i = 0, section = section_headers;
4825            i < elf_header.e_shnum;
4826            i++, section++)
4827         {
4828           if (   section->sh_type != SHT_RELA
4829               && section->sh_type != SHT_REL)
4830             continue;
4831
4832           rel_offset = section->sh_offset;
4833           rel_size   = section->sh_size;
4834
4835           if (rel_size)
4836             {
4837               Elf_Internal_Shdr *strsec;
4838               int is_rela;
4839
4840               printf (_("\nRelocation section "));
4841
4842               if (string_table == NULL)
4843                 printf ("%d", section->sh_name);
4844               else
4845                 printf (_("'%s'"), SECTION_NAME (section));
4846
4847               printf (_(" at offset 0x%lx contains %lu entries:\n"),
4848                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
4849
4850               is_rela = section->sh_type == SHT_RELA;
4851
4852               if (section->sh_link != 0
4853                   && section->sh_link < elf_header.e_shnum)
4854                 {
4855                   Elf_Internal_Shdr *symsec;
4856                   Elf_Internal_Sym *symtab;
4857                   unsigned long nsyms;
4858                   unsigned long strtablen = 0;
4859                   char *strtab = NULL;
4860
4861                   symsec = section_headers + section->sh_link;
4862                   if (symsec->sh_type != SHT_SYMTAB
4863                       && symsec->sh_type != SHT_DYNSYM)
4864                     continue;
4865
4866                   nsyms = symsec->sh_size / symsec->sh_entsize;
4867                   symtab = GET_ELF_SYMBOLS (file, symsec);
4868
4869                   if (symtab == NULL)
4870                     continue;
4871
4872                   if (symsec->sh_link != 0
4873                       && symsec->sh_link < elf_header.e_shnum)
4874                     {
4875                       strsec = section_headers + symsec->sh_link;
4876
4877                       strtab = get_data (NULL, file, strsec->sh_offset,
4878                                          1, strsec->sh_size,
4879                                          _("string table"));
4880                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
4881                     }
4882
4883                   dump_relocations (file, rel_offset, rel_size,
4884                                     symtab, nsyms, strtab, strtablen, is_rela);
4885                   if (strtab)
4886                     free (strtab);
4887                   free (symtab);
4888                 }
4889               else
4890                 dump_relocations (file, rel_offset, rel_size,
4891                                   NULL, 0, NULL, 0, is_rela);
4892
4893               found = 1;
4894             }
4895         }
4896
4897       if (! found)
4898         printf (_("\nThere are no relocations in this file.\n"));
4899     }
4900
4901   return 1;
4902 }
4903
4904 /* Process the unwind section.  */
4905
4906 #include "unwind-ia64.h"
4907
4908 /* An absolute address consists of a section and an offset.  If the
4909    section is NULL, the offset itself is the address, otherwise, the
4910    address equals to LOAD_ADDRESS(section) + offset.  */
4911
4912 struct absaddr
4913   {
4914     unsigned short section;
4915     bfd_vma offset;
4916   };
4917
4918 #define ABSADDR(a) \
4919   ((a).section \
4920    ? section_headers [(a).section].sh_addr + (a).offset \
4921    : (a).offset)
4922
4923 struct ia64_unw_aux_info
4924   {
4925     struct ia64_unw_table_entry
4926       {
4927         struct absaddr start;
4928         struct absaddr end;
4929         struct absaddr info;
4930       }
4931     *table;                     /* Unwind table.  */
4932     unsigned long table_len;    /* Length of unwind table.  */
4933     unsigned char *info;        /* Unwind info.  */
4934     unsigned long info_size;    /* Size of unwind info.  */
4935     bfd_vma info_addr;          /* starting address of unwind info.  */
4936     bfd_vma seg_base;           /* Starting address of segment.  */
4937     Elf_Internal_Sym *symtab;   /* The symbol table.  */
4938     unsigned long nsyms;        /* Number of symbols.  */
4939     char *strtab;               /* The string table.  */
4940     unsigned long strtab_size;  /* Size of string table.  */
4941   };
4942
4943 static void
4944 find_symbol_for_address (Elf_Internal_Sym *symtab,
4945                          unsigned long nsyms,
4946                          const char *strtab,
4947                          unsigned long strtab_size,
4948                          struct absaddr addr,
4949                          const char **symname,
4950                          bfd_vma *offset)
4951 {
4952   bfd_vma dist = 0x100000;
4953   Elf_Internal_Sym *sym, *best = NULL;
4954   unsigned long i;
4955
4956   for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4957     {
4958       if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
4959           && sym->st_name != 0
4960           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
4961           && addr.offset >= sym->st_value
4962           && addr.offset - sym->st_value < dist)
4963         {
4964           best = sym;
4965           dist = addr.offset - sym->st_value;
4966           if (!dist)
4967             break;
4968         }
4969     }
4970   if (best)
4971     {
4972       *symname = (best->st_name >= strtab_size
4973                   ? "<corrupt>" : strtab + best->st_name);
4974       *offset = dist;
4975       return;
4976     }
4977   *symname = NULL;
4978   *offset = addr.offset;
4979 }
4980
4981 static void
4982 dump_ia64_unwind (struct ia64_unw_aux_info *aux)
4983 {
4984   struct ia64_unw_table_entry *tp;
4985   int in_body;
4986
4987   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
4988     {
4989       bfd_vma stamp;
4990       bfd_vma offset;
4991       const unsigned char *dp;
4992       const unsigned char *head;
4993       const char *procname;
4994
4995       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
4996                                aux->strtab_size, tp->start, &procname, &offset);
4997
4998       fputs ("\n<", stdout);
4999
5000       if (procname)
5001         {
5002           fputs (procname, stdout);
5003
5004           if (offset)
5005             printf ("+%lx", (unsigned long) offset);
5006         }
5007
5008       fputs (">: [", stdout);
5009       print_vma (tp->start.offset, PREFIX_HEX);
5010       fputc ('-', stdout);
5011       print_vma (tp->end.offset, PREFIX_HEX);
5012       printf ("], info at +0x%lx\n",
5013               (unsigned long) (tp->info.offset - aux->seg_base));
5014
5015       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5016       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5017
5018       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5019               (unsigned) UNW_VER (stamp),
5020               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5021               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5022               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5023               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5024
5025       if (UNW_VER (stamp) != 1)
5026         {
5027           printf ("\tUnknown version.\n");
5028           continue;
5029         }
5030
5031       in_body = 0;
5032       for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5033         dp = unw_decode (dp, in_body, & in_body);
5034     }
5035 }
5036
5037 static int
5038 slurp_ia64_unwind_table (FILE *file,
5039                          struct ia64_unw_aux_info *aux,
5040                          Elf_Internal_Shdr *sec)
5041 {
5042   unsigned long size, nrelas, i;
5043   Elf_Internal_Phdr *seg;
5044   struct ia64_unw_table_entry *tep;
5045   Elf_Internal_Shdr *relsec;
5046   Elf_Internal_Rela *rela, *rp;
5047   unsigned char *table, *tp;
5048   Elf_Internal_Sym *sym;
5049   const char *relname;
5050
5051   /* First, find the starting address of the segment that includes
5052      this section: */
5053
5054   if (elf_header.e_phnum)
5055     {
5056       if (! get_program_headers (file))
5057           return 0;
5058
5059       for (seg = program_headers;
5060            seg < program_headers + elf_header.e_phnum;
5061            ++seg)
5062         {
5063           if (seg->p_type != PT_LOAD)
5064             continue;
5065
5066           if (sec->sh_addr >= seg->p_vaddr
5067               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5068             {
5069               aux->seg_base = seg->p_vaddr;
5070               break;
5071             }
5072         }
5073     }
5074
5075   /* Second, build the unwind table from the contents of the unwind section:  */
5076   size = sec->sh_size;
5077   table = get_data (NULL, file, sec->sh_offset, 1, size, _("unwind table"));
5078   if (!table)
5079     return 0;
5080
5081   aux->table = xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5082   tep = aux->table;
5083   for (tp = table; tp < table + size; tp += 3 * eh_addr_size, ++tep)
5084     {
5085       tep->start.section = SHN_UNDEF;
5086       tep->end.section   = SHN_UNDEF;
5087       tep->info.section  = SHN_UNDEF;
5088       if (is_32bit_elf)
5089         {
5090           tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
5091           tep->end.offset   = byte_get ((unsigned char *) tp + 4, 4);
5092           tep->info.offset  = byte_get ((unsigned char *) tp + 8, 4);
5093         }
5094       else
5095         {
5096           tep->start.offset = BYTE_GET ((unsigned char *) tp +  0);
5097           tep->end.offset   = BYTE_GET ((unsigned char *) tp +  8);
5098           tep->info.offset  = BYTE_GET ((unsigned char *) tp + 16);
5099         }
5100       tep->start.offset += aux->seg_base;
5101       tep->end.offset   += aux->seg_base;
5102       tep->info.offset  += aux->seg_base;
5103     }
5104   free (table);
5105
5106   /* Third, apply any relocations to the unwind table:  */
5107   for (relsec = section_headers;
5108        relsec < section_headers + elf_header.e_shnum;
5109        ++relsec)
5110     {
5111       if (relsec->sh_type != SHT_RELA
5112           || relsec->sh_info >= elf_header.e_shnum
5113           || section_headers + relsec->sh_info != sec)
5114         continue;
5115
5116       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5117                               & rela, & nrelas))
5118         return 0;
5119
5120       for (rp = rela; rp < rela + nrelas; ++rp)
5121         {
5122           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5123           sym = aux->symtab + get_reloc_symindex (rp->r_info);
5124
5125           if (! const_strneq (relname, "R_IA64_SEGREL"))
5126             {
5127               warn (_("Skipping unexpected relocation type %s\n"), relname);
5128               continue;
5129             }
5130
5131           i = rp->r_offset / (3 * eh_addr_size);
5132
5133           switch (rp->r_offset/eh_addr_size % 3)
5134             {
5135             case 0:
5136               aux->table[i].start.section = sym->st_shndx;
5137               aux->table[i].start.offset += rp->r_addend + sym->st_value;
5138               break;
5139             case 1:
5140               aux->table[i].end.section   = sym->st_shndx;
5141               aux->table[i].end.offset   += rp->r_addend + sym->st_value;
5142               break;
5143             case 2:
5144               aux->table[i].info.section  = sym->st_shndx;
5145               aux->table[i].info.offset  += rp->r_addend + sym->st_value;
5146               break;
5147             default:
5148               break;
5149             }
5150         }
5151
5152       free (rela);
5153     }
5154
5155   aux->table_len = size / (3 * eh_addr_size);
5156   return 1;
5157 }
5158
5159 static int
5160 ia64_process_unwind (FILE *file)
5161 {
5162   Elf_Internal_Shdr *sec, *unwsec = NULL, *strsec;
5163   unsigned long i, unwcount = 0, unwstart = 0;
5164   struct ia64_unw_aux_info aux;
5165
5166   memset (& aux, 0, sizeof (aux));
5167
5168   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5169     {
5170       if (sec->sh_type == SHT_SYMTAB
5171           && sec->sh_link < elf_header.e_shnum)
5172         {
5173           aux.nsyms = sec->sh_size / sec->sh_entsize;
5174           aux.symtab = GET_ELF_SYMBOLS (file, sec);
5175
5176           strsec = section_headers + sec->sh_link;
5177           aux.strtab = get_data (NULL, file, strsec->sh_offset,
5178                                  1, strsec->sh_size, _("string table"));
5179           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5180         }
5181       else if (sec->sh_type == SHT_IA_64_UNWIND)
5182         unwcount++;
5183     }
5184
5185   if (!unwcount)
5186     printf (_("\nThere are no unwind sections in this file.\n"));
5187
5188   while (unwcount-- > 0)
5189     {
5190       char *suffix;
5191       size_t len, len2;
5192
5193       for (i = unwstart, sec = section_headers + unwstart;
5194            i < elf_header.e_shnum; ++i, ++sec)
5195         if (sec->sh_type == SHT_IA_64_UNWIND)
5196           {
5197             unwsec = sec;
5198             break;
5199           }
5200
5201       unwstart = i + 1;
5202       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5203
5204       if ((unwsec->sh_flags & SHF_GROUP) != 0)
5205         {
5206           /* We need to find which section group it is in.  */
5207           struct group_list *g = section_headers_groups [i]->root;
5208
5209           for (; g != NULL; g = g->next)
5210             {
5211               sec = section_headers + g->section_index;
5212
5213               if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
5214                 break;
5215             }
5216
5217           if (g == NULL)
5218             i = elf_header.e_shnum;
5219         }
5220       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
5221         {
5222           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
5223           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5224           suffix = SECTION_NAME (unwsec) + len;
5225           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5226                ++i, ++sec)
5227             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5228                 && streq (SECTION_NAME (sec) + len2, suffix))
5229               break;
5230         }
5231       else
5232         {
5233           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5234              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
5235           len = sizeof (ELF_STRING_ia64_unwind) - 1;
5236           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5237           suffix = "";
5238           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
5239             suffix = SECTION_NAME (unwsec) + len;
5240           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5241                ++i, ++sec)
5242             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5243                 && streq (SECTION_NAME (sec) + len2, suffix))
5244               break;
5245         }
5246
5247       if (i == elf_header.e_shnum)
5248         {
5249           printf (_("\nCould not find unwind info section for "));
5250
5251           if (string_table == NULL)
5252             printf ("%d", unwsec->sh_name);
5253           else
5254             printf (_("'%s'"), SECTION_NAME (unwsec));
5255         }
5256       else
5257         {
5258           aux.info_size = sec->sh_size;
5259           aux.info_addr = sec->sh_addr;
5260           aux.info = get_data (NULL, file, sec->sh_offset, 1, aux.info_size,
5261                                _("unwind info"));
5262
5263           printf (_("\nUnwind section "));
5264
5265           if (string_table == NULL)
5266             printf ("%d", unwsec->sh_name);
5267           else
5268             printf (_("'%s'"), SECTION_NAME (unwsec));
5269
5270           printf (_(" at offset 0x%lx contains %lu entries:\n"),
5271                   (unsigned long) unwsec->sh_offset,
5272                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
5273
5274           (void) slurp_ia64_unwind_table (file, & aux, unwsec);
5275
5276           if (aux.table_len > 0)
5277             dump_ia64_unwind (& aux);
5278
5279           if (aux.table)
5280             free ((char *) aux.table);
5281           if (aux.info)
5282             free ((char *) aux.info);
5283           aux.table = NULL;
5284           aux.info = NULL;
5285         }
5286     }
5287
5288   if (aux.symtab)
5289     free (aux.symtab);
5290   if (aux.strtab)
5291     free ((char *) aux.strtab);
5292
5293   return 1;
5294 }
5295
5296 struct hppa_unw_aux_info
5297   {
5298     struct hppa_unw_table_entry
5299       {
5300         struct absaddr start;
5301         struct absaddr end;
5302         unsigned int Cannot_unwind:1;                   /* 0 */
5303         unsigned int Millicode:1;                       /* 1 */
5304         unsigned int Millicode_save_sr0:1;              /* 2 */
5305         unsigned int Region_description:2;              /* 3..4 */
5306         unsigned int reserved1:1;                       /* 5 */
5307         unsigned int Entry_SR:1;                        /* 6 */
5308         unsigned int Entry_FR:4;     /* number saved */ /* 7..10 */
5309         unsigned int Entry_GR:5;     /* number saved */ /* 11..15 */
5310         unsigned int Args_stored:1;                     /* 16 */
5311         unsigned int Variable_Frame:1;                  /* 17 */
5312         unsigned int Separate_Package_Body:1;           /* 18 */
5313         unsigned int Frame_Extension_Millicode:1;       /* 19 */
5314         unsigned int Stack_Overflow_Check:1;            /* 20 */
5315         unsigned int Two_Instruction_SP_Increment:1;    /* 21 */
5316         unsigned int Ada_Region:1;                      /* 22 */
5317         unsigned int cxx_info:1;                        /* 23 */
5318         unsigned int cxx_try_catch:1;                   /* 24 */
5319         unsigned int sched_entry_seq:1;                 /* 25 */
5320         unsigned int reserved2:1;                       /* 26 */
5321         unsigned int Save_SP:1;                         /* 27 */
5322         unsigned int Save_RP:1;                         /* 28 */
5323         unsigned int Save_MRP_in_frame:1;               /* 29 */
5324         unsigned int extn_ptr_defined:1;                /* 30 */
5325         unsigned int Cleanup_defined:1;                 /* 31 */
5326
5327         unsigned int MPE_XL_interrupt_marker:1;         /* 0 */
5328         unsigned int HP_UX_interrupt_marker:1;          /* 1 */
5329         unsigned int Large_frame:1;                     /* 2 */
5330         unsigned int Pseudo_SP_Set:1;                   /* 3 */
5331         unsigned int reserved4:1;                       /* 4 */
5332         unsigned int Total_frame_size:27;               /* 5..31 */
5333       }
5334     *table;                     /* Unwind table.  */
5335     unsigned long table_len;    /* Length of unwind table.  */
5336     bfd_vma seg_base;           /* Starting address of segment.  */
5337     Elf_Internal_Sym *symtab;   /* The symbol table.  */
5338     unsigned long nsyms;        /* Number of symbols.  */
5339     char *strtab;               /* The string table.  */
5340     unsigned long strtab_size;  /* Size of string table.  */
5341   };
5342
5343 static void
5344 dump_hppa_unwind (struct hppa_unw_aux_info *aux)
5345 {
5346   struct hppa_unw_table_entry *tp;
5347
5348   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5349     {
5350       bfd_vma offset;
5351       const char *procname;
5352
5353       find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5354                                aux->strtab_size, tp->start, &procname,
5355                                &offset);
5356
5357       fputs ("\n<", stdout);
5358
5359       if (procname)
5360         {
5361           fputs (procname, stdout);
5362
5363           if (offset)
5364             printf ("+%lx", (unsigned long) offset);
5365         }
5366
5367       fputs (">: [", stdout);
5368       print_vma (tp->start.offset, PREFIX_HEX);
5369       fputc ('-', stdout);
5370       print_vma (tp->end.offset, PREFIX_HEX);
5371       printf ("]\n\t");
5372
5373 #define PF(_m) if (tp->_m) printf (#_m " ");
5374 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5375       PF(Cannot_unwind);
5376       PF(Millicode);
5377       PF(Millicode_save_sr0);
5378       /* PV(Region_description);  */
5379       PF(Entry_SR);
5380       PV(Entry_FR);
5381       PV(Entry_GR);
5382       PF(Args_stored);
5383       PF(Variable_Frame);
5384       PF(Separate_Package_Body);
5385       PF(Frame_Extension_Millicode);
5386       PF(Stack_Overflow_Check);
5387       PF(Two_Instruction_SP_Increment);
5388       PF(Ada_Region);
5389       PF(cxx_info);
5390       PF(cxx_try_catch);
5391       PF(sched_entry_seq);
5392       PF(Save_SP);
5393       PF(Save_RP);
5394       PF(Save_MRP_in_frame);
5395       PF(extn_ptr_defined);
5396       PF(Cleanup_defined);
5397       PF(MPE_XL_interrupt_marker);
5398       PF(HP_UX_interrupt_marker);
5399       PF(Large_frame);
5400       PF(Pseudo_SP_Set);
5401       PV(Total_frame_size);
5402 #undef PF
5403 #undef PV
5404     }
5405
5406   printf ("\n");
5407 }
5408
5409 static int
5410 slurp_hppa_unwind_table (FILE *file,
5411                          struct hppa_unw_aux_info *aux,
5412                          Elf_Internal_Shdr *sec)
5413 {
5414   unsigned long size, unw_ent_size, nentries, nrelas, i;
5415   Elf_Internal_Phdr *seg;
5416   struct hppa_unw_table_entry *tep;
5417   Elf_Internal_Shdr *relsec;
5418   Elf_Internal_Rela *rela, *rp;
5419   unsigned char *table, *tp;
5420   Elf_Internal_Sym *sym;
5421   const char *relname;
5422
5423   /* First, find the starting address of the segment that includes
5424      this section.  */
5425
5426   if (elf_header.e_phnum)
5427     {
5428       if (! get_program_headers (file))
5429         return 0;
5430
5431       for (seg = program_headers;
5432            seg < program_headers + elf_header.e_phnum;
5433            ++seg)
5434         {
5435           if (seg->p_type != PT_LOAD)
5436             continue;
5437
5438           if (sec->sh_addr >= seg->p_vaddr
5439               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5440             {
5441               aux->seg_base = seg->p_vaddr;
5442               break;
5443             }
5444         }
5445     }
5446
5447   /* Second, build the unwind table from the contents of the unwind
5448      section.  */
5449   size = sec->sh_size;
5450   table = get_data (NULL, file, sec->sh_offset, 1, size, _("unwind table"));
5451   if (!table)
5452     return 0;
5453
5454   unw_ent_size = 16;
5455   nentries = size / unw_ent_size;
5456   size = unw_ent_size * nentries;
5457
5458   tep = aux->table = xcmalloc (nentries, sizeof (aux->table[0]));
5459
5460   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
5461     {
5462       unsigned int tmp1, tmp2;
5463
5464       tep->start.section = SHN_UNDEF;
5465       tep->end.section   = SHN_UNDEF;
5466
5467       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
5468       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
5469       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
5470       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
5471
5472       tep->start.offset += aux->seg_base;
5473       tep->end.offset   += aux->seg_base;
5474
5475       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
5476       tep->Millicode = (tmp1 >> 30) & 0x1;
5477       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
5478       tep->Region_description = (tmp1 >> 27) & 0x3;
5479       tep->reserved1 = (tmp1 >> 26) & 0x1;
5480       tep->Entry_SR = (tmp1 >> 25) & 0x1;
5481       tep->Entry_FR = (tmp1 >> 21) & 0xf;
5482       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
5483       tep->Args_stored = (tmp1 >> 15) & 0x1;
5484       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
5485       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
5486       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
5487       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
5488       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
5489       tep->Ada_Region = (tmp1 >> 9) & 0x1;
5490       tep->cxx_info = (tmp1 >> 8) & 0x1;
5491       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
5492       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
5493       tep->reserved2 = (tmp1 >> 5) & 0x1;
5494       tep->Save_SP = (tmp1 >> 4) & 0x1;
5495       tep->Save_RP = (tmp1 >> 3) & 0x1;
5496       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
5497       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
5498       tep->Cleanup_defined = tmp1 & 0x1;
5499
5500       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
5501       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
5502       tep->Large_frame = (tmp2 >> 29) & 0x1;
5503       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
5504       tep->reserved4 = (tmp2 >> 27) & 0x1;
5505       tep->Total_frame_size = tmp2 & 0x7ffffff;
5506     }
5507   free (table);
5508
5509   /* Third, apply any relocations to the unwind table.  */
5510   for (relsec = section_headers;
5511        relsec < section_headers + elf_header.e_shnum;
5512        ++relsec)
5513     {
5514       if (relsec->sh_type != SHT_RELA
5515           || relsec->sh_info >= elf_header.e_shnum
5516           || section_headers + relsec->sh_info != sec)
5517         continue;
5518
5519       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5520                               & rela, & nrelas))
5521         return 0;
5522
5523       for (rp = rela; rp < rela + nrelas; ++rp)
5524         {
5525           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
5526           sym = aux->symtab + get_reloc_symindex (rp->r_info);
5527
5528           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
5529           if (! const_strneq (relname, "R_PARISC_SEGREL"))
5530             {
5531               warn (_("Skipping unexpected relocation type %s\n"), relname);
5532               continue;
5533             }
5534
5535           i = rp->r_offset / unw_ent_size;
5536
5537           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
5538             {
5539             case 0:
5540               aux->table[i].start.section = sym->st_shndx;
5541               aux->table[i].start.offset += sym->st_value + rp->r_addend;
5542               break;
5543             case 1:
5544               aux->table[i].end.section   = sym->st_shndx;
5545               aux->table[i].end.offset   += sym->st_value + rp->r_addend;
5546               break;
5547             default:
5548               break;
5549             }
5550         }
5551
5552       free (rela);
5553     }
5554
5555   aux->table_len = nentries;
5556
5557   return 1;
5558 }
5559
5560 static int
5561 hppa_process_unwind (FILE *file)
5562 {
5563   struct hppa_unw_aux_info aux;
5564   Elf_Internal_Shdr *unwsec = NULL;
5565   Elf_Internal_Shdr *strsec;
5566   Elf_Internal_Shdr *sec;
5567   unsigned long i;
5568
5569   memset (& aux, 0, sizeof (aux));
5570
5571   if (string_table == NULL)
5572     return 1;
5573
5574   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5575     {
5576       if (sec->sh_type == SHT_SYMTAB
5577           && sec->sh_link < elf_header.e_shnum)
5578         {
5579           aux.nsyms = sec->sh_size / sec->sh_entsize;
5580           aux.symtab = GET_ELF_SYMBOLS (file, sec);
5581
5582           strsec = section_headers + sec->sh_link;
5583           aux.strtab = get_data (NULL, file, strsec->sh_offset,
5584                                  1, strsec->sh_size, _("string table"));
5585           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5586         }
5587       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5588         unwsec = sec;
5589     }
5590
5591   if (!unwsec)
5592     printf (_("\nThere are no unwind sections in this file.\n"));
5593
5594   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5595     {
5596       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5597         {
5598           printf (_("\nUnwind section "));
5599           printf (_("'%s'"), SECTION_NAME (sec));
5600
5601           printf (_(" at offset 0x%lx contains %lu entries:\n"),
5602                   (unsigned long) sec->sh_offset,
5603                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
5604
5605           slurp_hppa_unwind_table (file, &aux, sec);
5606           if (aux.table_len > 0)
5607             dump_hppa_unwind (&aux);
5608
5609           if (aux.table)
5610             free ((char *) aux.table);
5611           aux.table = NULL;
5612         }
5613     }
5614
5615   if (aux.symtab)
5616     free (aux.symtab);
5617   if (aux.strtab)
5618     free ((char *) aux.strtab);
5619
5620   return 1;
5621 }
5622
5623 static int
5624 process_unwind (FILE *file)
5625 {
5626   struct unwind_handler {
5627     int machtype;
5628     int (*handler)(FILE *file);
5629   } handlers[] = {
5630     { EM_IA_64, ia64_process_unwind },
5631     { EM_PARISC, hppa_process_unwind },
5632     { 0, 0 }
5633   };
5634   int i;
5635
5636   if (!do_unwind)
5637     return 1;
5638
5639   for (i = 0; handlers[i].handler != NULL; i++)
5640     if (elf_header.e_machine == handlers[i].machtype)
5641       return handlers[i].handler (file);
5642
5643   printf (_("\nThere are no unwind sections in this file.\n"));
5644   return 1;
5645 }
5646
5647 static void
5648 dynamic_section_mips_val (Elf_Internal_Dyn *entry)
5649 {
5650   switch (entry->d_tag)
5651     {
5652     case DT_MIPS_FLAGS:
5653       if (entry->d_un.d_val == 0)
5654         printf ("NONE\n");
5655       else
5656         {
5657           static const char * opts[] =
5658           {
5659             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5660             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5661             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5662             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5663             "RLD_ORDER_SAFE"
5664           };
5665           unsigned int cnt;
5666           int first = 1;
5667           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
5668             if (entry->d_un.d_val & (1 << cnt))
5669               {
5670                 printf ("%s%s", first ? "" : " ", opts[cnt]);
5671                 first = 0;
5672               }
5673           puts ("");
5674         }
5675       break;
5676
5677     case DT_MIPS_IVERSION:
5678       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
5679         printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
5680       else
5681         printf ("<corrupt: %ld>\n", (long) entry->d_un.d_ptr);
5682       break;
5683
5684     case DT_MIPS_TIME_STAMP:
5685       {
5686         char timebuf[20];
5687         struct tm *tmp;
5688
5689         time_t time = entry->d_un.d_val;
5690         tmp = gmtime (&time);
5691         snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
5692                   tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
5693                   tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
5694         printf ("Time Stamp: %s\n", timebuf);
5695       }
5696       break;
5697
5698     case DT_MIPS_RLD_VERSION:
5699     case DT_MIPS_LOCAL_GOTNO:
5700     case DT_MIPS_CONFLICTNO:
5701     case DT_MIPS_LIBLISTNO:
5702     case DT_MIPS_SYMTABNO:
5703     case DT_MIPS_UNREFEXTNO:
5704     case DT_MIPS_HIPAGENO:
5705     case DT_MIPS_DELTA_CLASS_NO:
5706     case DT_MIPS_DELTA_INSTANCE_NO:
5707     case DT_MIPS_DELTA_RELOC_NO:
5708     case DT_MIPS_DELTA_SYM_NO:
5709     case DT_MIPS_DELTA_CLASSSYM_NO:
5710     case DT_MIPS_COMPACT_SIZE:
5711       printf ("%ld\n", (long) entry->d_un.d_ptr);
5712       break;
5713
5714     default:
5715       printf ("%#lx\n", (unsigned long) entry->d_un.d_ptr);
5716     }
5717 }
5718
5719
5720 static void
5721 dynamic_section_parisc_val (Elf_Internal_Dyn *entry)
5722 {
5723   switch (entry->d_tag)
5724     {
5725     case DT_HP_DLD_FLAGS:
5726       {
5727         static struct
5728         {
5729           long int bit;
5730           const char *str;
5731         }
5732         flags[] =
5733         {
5734           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
5735           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
5736           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
5737           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
5738           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
5739           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
5740           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
5741           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
5742           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
5743           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
5744           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
5745           { DT_HP_GST, "HP_GST" },
5746           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
5747           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
5748           { DT_HP_NODELETE, "HP_NODELETE" },
5749           { DT_HP_GROUP, "HP_GROUP" },
5750           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5751         };
5752         int first = 1;
5753         size_t cnt;
5754         bfd_vma val = entry->d_un.d_val;
5755
5756         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
5757           if (val & flags[cnt].bit)
5758             {
5759               if (! first)
5760                 putchar (' ');
5761               fputs (flags[cnt].str, stdout);
5762               first = 0;
5763               val ^= flags[cnt].bit;
5764             }
5765
5766         if (val != 0 || first)
5767           {
5768             if (! first)
5769               putchar (' ');
5770             print_vma (val, HEX);
5771           }
5772       }
5773       break;
5774
5775     default:
5776       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5777       break;
5778     }
5779   putchar ('\n');
5780 }
5781
5782 static void
5783 dynamic_section_ia64_val (Elf_Internal_Dyn *entry)
5784 {
5785   switch (entry->d_tag)
5786     {
5787     case DT_IA_64_PLT_RESERVE:
5788       /* First 3 slots reserved.  */
5789       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5790       printf (" -- ");
5791       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
5792       break;
5793
5794     default:
5795       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5796       break;
5797     }
5798   putchar ('\n');
5799 }
5800
5801 static int
5802 get_32bit_dynamic_section (FILE *file)
5803 {
5804   Elf32_External_Dyn *edyn, *ext;
5805   Elf_Internal_Dyn *entry;
5806
5807   edyn = get_data (NULL, file, dynamic_addr, 1, dynamic_size,
5808                    _("dynamic section"));
5809   if (!edyn)
5810     return 0;
5811
5812 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5813    might not have the luxury of section headers.  Look for the DT_NULL
5814    terminator to determine the number of entries.  */
5815   for (ext = edyn, dynamic_nent = 0;
5816        (char *) ext < (char *) edyn + dynamic_size;
5817        ext++)
5818     {
5819       dynamic_nent++;
5820       if (BYTE_GET (ext->d_tag) == DT_NULL)
5821         break;
5822     }
5823
5824   dynamic_section = cmalloc (dynamic_nent, sizeof (*entry));
5825   if (dynamic_section == NULL)
5826     {
5827       error (_("Out of memory\n"));
5828       free (edyn);
5829       return 0;
5830     }
5831
5832   for (ext = edyn, entry = dynamic_section;
5833        entry < dynamic_section + dynamic_nent;
5834        ext++, entry++)
5835     {
5836       entry->d_tag      = BYTE_GET (ext->d_tag);
5837       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
5838     }
5839
5840   free (edyn);
5841
5842   return 1;
5843 }
5844
5845 static int
5846 get_64bit_dynamic_section (FILE *file)
5847 {
5848   Elf64_External_Dyn *edyn, *ext;
5849   Elf_Internal_Dyn *entry;
5850
5851   edyn = get_data (NULL, file, dynamic_addr, 1, dynamic_size,
5852                    _("dynamic section"));
5853   if (!edyn)
5854     return 0;
5855
5856 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5857    might not have the luxury of section headers.  Look for the DT_NULL
5858    terminator to determine the number of entries.  */
5859   for (ext = edyn, dynamic_nent = 0;
5860        (char *) ext < (char *) edyn + dynamic_size;
5861        ext++)
5862     {
5863       dynamic_nent++;
5864       if (BYTE_GET (ext->d_tag) == DT_NULL)
5865         break;
5866     }
5867
5868   dynamic_section = cmalloc (dynamic_nent, sizeof (*entry));
5869   if (dynamic_section == NULL)
5870     {
5871       error (_("Out of memory\n"));
5872       free (edyn);
5873       return 0;
5874     }
5875
5876   for (ext = edyn, entry = dynamic_section;
5877        entry < dynamic_section + dynamic_nent;
5878        ext++, entry++)
5879     {
5880       entry->d_tag      = BYTE_GET (ext->d_tag);
5881       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
5882     }
5883
5884   free (edyn);
5885
5886   return 1;
5887 }
5888
5889 static void
5890 print_dynamic_flags (bfd_vma flags)
5891 {
5892   int first = 1;
5893
5894   while (flags)
5895     {
5896       bfd_vma flag;
5897
5898       flag = flags & - flags;
5899       flags &= ~ flag;
5900
5901       if (first)
5902         first = 0;
5903       else
5904         putc (' ', stdout);
5905
5906       switch (flag)
5907         {
5908         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
5909         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
5910         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
5911         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
5912         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
5913         default:                fputs ("unknown", stdout); break;
5914         }
5915     }
5916   puts ("");
5917 }
5918
5919 /* Parse and display the contents of the dynamic section.  */
5920
5921 static int
5922 process_dynamic_section (FILE *file)
5923 {
5924   Elf_Internal_Dyn *entry;
5925
5926   if (dynamic_size == 0)
5927     {
5928       if (do_dynamic)
5929         printf (_("\nThere is no dynamic section in this file.\n"));
5930
5931       return 1;
5932     }
5933
5934   if (is_32bit_elf)
5935     {
5936       if (! get_32bit_dynamic_section (file))
5937         return 0;
5938     }
5939   else if (! get_64bit_dynamic_section (file))
5940     return 0;
5941
5942   /* Find the appropriate symbol table.  */
5943   if (dynamic_symbols == NULL)
5944     {
5945       for (entry = dynamic_section;
5946            entry < dynamic_section + dynamic_nent;
5947            ++entry)
5948         {
5949           Elf_Internal_Shdr section;
5950
5951           if (entry->d_tag != DT_SYMTAB)
5952             continue;
5953
5954           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
5955
5956           /* Since we do not know how big the symbol table is,
5957              we default to reading in the entire file (!) and
5958              processing that.  This is overkill, I know, but it
5959              should work.  */
5960           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
5961
5962           if (archive_file_offset != 0)
5963             section.sh_size = archive_file_size - section.sh_offset;
5964           else
5965             {
5966               if (fseek (file, 0, SEEK_END))
5967                 error (_("Unable to seek to end of file!\n"));
5968
5969               section.sh_size = ftell (file) - section.sh_offset;
5970             }
5971
5972           if (is_32bit_elf)
5973             section.sh_entsize = sizeof (Elf32_External_Sym);
5974           else
5975             section.sh_entsize = sizeof (Elf64_External_Sym);
5976
5977           num_dynamic_syms = section.sh_size / section.sh_entsize;
5978           if (num_dynamic_syms < 1)
5979             {
5980               error (_("Unable to determine the number of symbols to load\n"));
5981               continue;
5982             }
5983
5984           dynamic_symbols = GET_ELF_SYMBOLS (file, &section);
5985         }
5986     }
5987
5988   /* Similarly find a string table.  */
5989   if (dynamic_strings == NULL)
5990     {
5991       for (entry = dynamic_section;
5992            entry < dynamic_section + dynamic_nent;
5993            ++entry)
5994         {
5995           unsigned long offset;
5996           long str_tab_len;
5997
5998           if (entry->d_tag != DT_STRTAB)
5999             continue;
6000
6001           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
6002
6003           /* Since we do not know how big the string table is,
6004              we default to reading in the entire file (!) and
6005              processing that.  This is overkill, I know, but it
6006              should work.  */
6007
6008           offset = offset_from_vma (file, entry->d_un.d_val, 0);
6009
6010           if (archive_file_offset != 0)
6011             str_tab_len = archive_file_size - offset;
6012           else
6013             {
6014               if (fseek (file, 0, SEEK_END))
6015                 error (_("Unable to seek to end of file\n"));
6016               str_tab_len = ftell (file) - offset;
6017             }
6018
6019           if (str_tab_len < 1)
6020             {
6021               error
6022                 (_("Unable to determine the length of the dynamic string table\n"));
6023               continue;
6024             }
6025
6026           dynamic_strings = get_data (NULL, file, offset, 1, str_tab_len,
6027                                       _("dynamic string table"));
6028           dynamic_strings_length = str_tab_len;
6029           break;
6030         }
6031     }
6032
6033   /* And find the syminfo section if available.  */
6034   if (dynamic_syminfo == NULL)
6035     {
6036       unsigned long syminsz = 0;
6037
6038       for (entry = dynamic_section;
6039            entry < dynamic_section + dynamic_nent;
6040            ++entry)
6041         {
6042           if (entry->d_tag == DT_SYMINENT)
6043             {
6044               /* Note: these braces are necessary to avoid a syntax
6045                  error from the SunOS4 C compiler.  */
6046               assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
6047             }
6048           else if (entry->d_tag == DT_SYMINSZ)
6049             syminsz = entry->d_un.d_val;
6050           else if (entry->d_tag == DT_SYMINFO)
6051             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
6052                                                       syminsz);
6053         }
6054
6055       if (dynamic_syminfo_offset != 0 && syminsz != 0)
6056         {
6057           Elf_External_Syminfo *extsyminfo, *extsym;
6058           Elf_Internal_Syminfo *syminfo;
6059
6060           /* There is a syminfo section.  Read the data.  */
6061           extsyminfo = get_data (NULL, file, dynamic_syminfo_offset, 1,
6062                                  syminsz, _("symbol information"));
6063           if (!extsyminfo)
6064             return 0;
6065
6066           dynamic_syminfo = malloc (syminsz);
6067           if (dynamic_syminfo == NULL)
6068             {
6069               error (_("Out of memory\n"));
6070               return 0;
6071             }
6072
6073           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
6074           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
6075                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
6076                ++syminfo, ++extsym)
6077             {
6078               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
6079               syminfo->si_flags = BYTE_GET (extsym->si_flags);
6080             }
6081
6082           free (extsyminfo);
6083         }
6084     }
6085
6086   if (do_dynamic && dynamic_addr)
6087     printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6088             dynamic_addr, dynamic_nent);
6089   if (do_dynamic)
6090     printf (_("  Tag        Type                         Name/Value\n"));
6091
6092   for (entry = dynamic_section;
6093        entry < dynamic_section + dynamic_nent;
6094        entry++)
6095     {
6096       if (do_dynamic)
6097         {
6098           const char *dtype;
6099
6100           putchar (' ');
6101           print_vma (entry->d_tag, FULL_HEX);
6102           dtype = get_dynamic_type (entry->d_tag);
6103           printf (" (%s)%*s", dtype,
6104                   ((is_32bit_elf ? 27 : 19)
6105                    - (int) strlen (dtype)),
6106                   " ");
6107         }
6108
6109       switch (entry->d_tag)
6110         {
6111         case DT_FLAGS:
6112           if (do_dynamic)
6113             print_dynamic_flags (entry->d_un.d_val);
6114           break;
6115
6116         case DT_AUXILIARY:
6117         case DT_FILTER:
6118         case DT_CONFIG:
6119         case DT_DEPAUDIT:
6120         case DT_AUDIT:
6121           if (do_dynamic)
6122             {
6123               switch (entry->d_tag)
6124                 {
6125                 case DT_AUXILIARY:
6126                   printf (_("Auxiliary library"));
6127                   break;
6128
6129                 case DT_FILTER:
6130                   printf (_("Filter library"));
6131                   break;
6132
6133                 case DT_CONFIG:
6134                   printf (_("Configuration file"));
6135                   break;
6136
6137                 case DT_DEPAUDIT:
6138                   printf (_("Dependency audit library"));
6139                   break;
6140
6141                 case DT_AUDIT:
6142                   printf (_("Audit library"));
6143                   break;
6144                 }
6145
6146               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6147                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
6148               else
6149                 {
6150                   printf (": ");
6151                   print_vma (entry->d_un.d_val, PREFIX_HEX);
6152                   putchar ('\n');
6153                 }
6154             }
6155           break;
6156
6157         case DT_FEATURE:
6158           if (do_dynamic)
6159             {
6160               printf (_("Flags:"));
6161
6162               if (entry->d_un.d_val == 0)
6163                 printf (_(" None\n"));
6164               else
6165                 {
6166                   unsigned long int val = entry->d_un.d_val;
6167
6168                   if (val & DTF_1_PARINIT)
6169                     {
6170                       printf (" PARINIT");
6171                       val ^= DTF_1_PARINIT;
6172                     }
6173                   if (val & DTF_1_CONFEXP)
6174                     {
6175                       printf (" CONFEXP");
6176                       val ^= DTF_1_CONFEXP;
6177                     }
6178                   if (val != 0)
6179                     printf (" %lx", val);
6180                   puts ("");
6181                 }
6182             }
6183           break;
6184
6185         case DT_POSFLAG_1:
6186           if (do_dynamic)
6187             {
6188               printf (_("Flags:"));
6189
6190               if (entry->d_un.d_val == 0)
6191                 printf (_(" None\n"));
6192               else
6193                 {
6194                   unsigned long int val = entry->d_un.d_val;
6195
6196                   if (val & DF_P1_LAZYLOAD)
6197                     {
6198                       printf (" LAZYLOAD");
6199                       val ^= DF_P1_LAZYLOAD;
6200                     }
6201                   if (val & DF_P1_GROUPPERM)
6202                     {
6203                       printf (" GROUPPERM");
6204                       val ^= DF_P1_GROUPPERM;
6205                     }
6206                   if (val != 0)
6207                     printf (" %lx", val);
6208                   puts ("");
6209                 }
6210             }
6211           break;
6212
6213         case DT_FLAGS_1:
6214           if (do_dynamic)
6215             {
6216               printf (_("Flags:"));
6217               if (entry->d_un.d_val == 0)
6218                 printf (_(" None\n"));
6219               else
6220                 {
6221                   unsigned long int val = entry->d_un.d_val;
6222
6223                   if (val & DF_1_NOW)
6224                     {
6225                       printf (" NOW");
6226                       val ^= DF_1_NOW;
6227                     }
6228                   if (val & DF_1_GLOBAL)
6229                     {
6230                       printf (" GLOBAL");
6231                       val ^= DF_1_GLOBAL;
6232                     }
6233                   if (val & DF_1_GROUP)
6234                     {
6235                       printf (" GROUP");
6236                       val ^= DF_1_GROUP;
6237                     }
6238                   if (val & DF_1_NODELETE)
6239                     {
6240                       printf (" NODELETE");
6241                       val ^= DF_1_NODELETE;
6242                     }
6243                   if (val & DF_1_LOADFLTR)
6244                     {
6245                       printf (" LOADFLTR");
6246                       val ^= DF_1_LOADFLTR;
6247                     }
6248                   if (val & DF_1_INITFIRST)
6249                     {
6250                       printf (" INITFIRST");
6251                       val ^= DF_1_INITFIRST;
6252                     }
6253                   if (val & DF_1_NOOPEN)
6254                     {
6255                       printf (" NOOPEN");
6256                       val ^= DF_1_NOOPEN;
6257                     }
6258                   if (val & DF_1_ORIGIN)
6259                     {
6260                       printf (" ORIGIN");
6261                       val ^= DF_1_ORIGIN;
6262                     }
6263                   if (val & DF_1_DIRECT)
6264                     {
6265                       printf (" DIRECT");
6266                       val ^= DF_1_DIRECT;
6267                     }
6268                   if (val & DF_1_TRANS)
6269                     {
6270                       printf (" TRANS");
6271                       val ^= DF_1_TRANS;
6272                     }
6273                   if (val & DF_1_INTERPOSE)
6274                     {
6275                       printf (" INTERPOSE");
6276                       val ^= DF_1_INTERPOSE;
6277                     }
6278                   if (val & DF_1_NODEFLIB)
6279                     {
6280                       printf (" NODEFLIB");
6281                       val ^= DF_1_NODEFLIB;
6282                     }
6283                   if (val & DF_1_NODUMP)
6284                     {
6285                       printf (" NODUMP");
6286                       val ^= DF_1_NODUMP;
6287                     }
6288                   if (val & DF_1_CONLFAT)
6289                     {
6290                       printf (" CONLFAT");
6291                       val ^= DF_1_CONLFAT;
6292                     }
6293                   if (val != 0)
6294                     printf (" %lx", val);
6295                   puts ("");
6296                 }
6297             }
6298           break;
6299
6300         case DT_PLTREL:
6301           dynamic_info[entry->d_tag] = entry->d_un.d_val;
6302           if (do_dynamic)
6303             puts (get_dynamic_type (entry->d_un.d_val));
6304           break;
6305
6306         case DT_NULL    :
6307         case DT_NEEDED  :
6308         case DT_PLTGOT  :
6309         case DT_HASH    :
6310         case DT_STRTAB  :
6311         case DT_SYMTAB  :
6312         case DT_RELA    :
6313         case DT_INIT    :
6314         case DT_FINI    :
6315         case DT_SONAME  :
6316         case DT_RPATH   :
6317         case DT_SYMBOLIC:
6318         case DT_REL     :
6319         case DT_DEBUG   :
6320         case DT_TEXTREL :
6321         case DT_JMPREL  :
6322         case DT_RUNPATH :
6323           dynamic_info[entry->d_tag] = entry->d_un.d_val;
6324
6325           if (do_dynamic)
6326             {
6327               char *name;
6328
6329               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6330                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
6331               else
6332                 name = NULL;
6333
6334               if (name)
6335                 {
6336                   switch (entry->d_tag)
6337                     {
6338                     case DT_NEEDED:
6339                       printf (_("Shared library: [%s]"), name);
6340
6341                       if (streq (name, program_interpreter))
6342                         printf (_(" program interpreter"));
6343                       break;
6344
6345                     case DT_SONAME:
6346                       printf (_("Library soname: [%s]"), name);
6347                       break;
6348
6349                     case DT_RPATH:
6350                       printf (_("Library rpath: [%s]"), name);
6351                       break;
6352
6353                     case DT_RUNPATH:
6354                       printf (_("Library runpath: [%s]"), name);
6355                       break;
6356
6357                     default:
6358                       print_vma (entry->d_un.d_val, PREFIX_HEX);
6359                       break;
6360                     }
6361                 }
6362               else
6363                 print_vma (entry->d_un.d_val, PREFIX_HEX);
6364
6365               putchar ('\n');
6366             }
6367           break;
6368
6369         case DT_PLTRELSZ:
6370         case DT_RELASZ  :
6371         case DT_STRSZ   :
6372         case DT_RELSZ   :
6373         case DT_RELAENT :
6374         case DT_SYMENT  :
6375         case DT_RELENT  :
6376           dynamic_info[entry->d_tag] = entry->d_un.d_val;
6377         case DT_PLTPADSZ:
6378         case DT_MOVEENT :
6379         case DT_MOVESZ  :
6380         case DT_INIT_ARRAYSZ:
6381         case DT_FINI_ARRAYSZ:
6382         case DT_GNU_CONFLICTSZ:
6383         case DT_GNU_LIBLISTSZ:
6384           if (do_dynamic)
6385             {
6386               print_vma (entry->d_un.d_val, UNSIGNED);
6387               printf (" (bytes)\n");
6388             }
6389           break;
6390
6391         case DT_VERDEFNUM:
6392         case DT_VERNEEDNUM:
6393         case DT_RELACOUNT:
6394         case DT_RELCOUNT:
6395           if (do_dynamic)
6396             {
6397               print_vma (entry->d_un.d_val, UNSIGNED);
6398               putchar ('\n');
6399             }
6400           break;
6401
6402         case DT_SYMINSZ:
6403         case DT_SYMINENT:
6404         case DT_SYMINFO:
6405         case DT_USED:
6406         case DT_INIT_ARRAY:
6407         case DT_FINI_ARRAY:
6408           if (do_dynamic)
6409             {
6410               if (entry->d_tag == DT_USED
6411                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
6412                 {
6413                   char *name = GET_DYNAMIC_NAME (entry->d_un.d_val);
6414
6415                   if (*name)
6416                     {
6417                       printf (_("Not needed object: [%s]\n"), name);
6418                       break;
6419                     }
6420                 }
6421
6422               print_vma (entry->d_un.d_val, PREFIX_HEX);
6423               putchar ('\n');
6424             }
6425           break;
6426
6427         case DT_BIND_NOW:
6428           /* The value of this entry is ignored.  */
6429           if (do_dynamic)
6430             putchar ('\n');
6431           break;
6432
6433         case DT_GNU_PRELINKED:
6434           if (do_dynamic)
6435             {
6436               struct tm *tmp;
6437               time_t time = entry->d_un.d_val;
6438
6439               tmp = gmtime (&time);
6440               printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6441                       tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
6442                       tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
6443
6444             }
6445           break;
6446
6447         case DT_GNU_HASH:
6448           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
6449           if (do_dynamic)
6450             {
6451               print_vma (entry->d_un.d_val, PREFIX_HEX);
6452               putchar ('\n');
6453             }
6454           break;
6455
6456         default:
6457           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
6458             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
6459               entry->d_un.d_val;
6460
6461           if (do_dynamic)
6462             {
6463               switch (elf_header.e_machine)
6464                 {
6465                 case EM_MIPS:
6466                 case EM_MIPS_RS3_LE:
6467                   dynamic_section_mips_val (entry);
6468                   break;
6469                 case EM_PARISC:
6470                   dynamic_section_parisc_val (entry);
6471                   break;
6472                 case EM_IA_64:
6473                   dynamic_section_ia64_val (entry);
6474                   break;
6475                 default:
6476                   print_vma (entry->d_un.d_val, PREFIX_HEX);
6477                   putchar ('\n');
6478                 }
6479             }
6480           break;
6481         }
6482     }
6483
6484   return 1;
6485 }
6486
6487 static char *
6488 get_ver_flags (unsigned int flags)
6489 {
6490   static char buff[32];
6491
6492   buff[0] = 0;
6493
6494   if (flags == 0)
6495     return _("none");
6496
6497   if (flags & VER_FLG_BASE)
6498     strcat (buff, "BASE ");
6499
6500   if (flags & VER_FLG_WEAK)
6501     {
6502       if (flags & VER_FLG_BASE)
6503         strcat (buff, "| ");
6504
6505       strcat (buff, "WEAK ");
6506     }
6507
6508   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
6509     strcat (buff, "| <unknown>");
6510
6511   return buff;
6512 }
6513
6514 /* Display the contents of the version sections.  */
6515 static int
6516 process_version_sections (FILE *file)
6517 {
6518   Elf_Internal_Shdr *section;
6519   unsigned i;
6520   int found = 0;
6521
6522   if (! do_version)
6523     return 1;
6524
6525   for (i = 0, section = section_headers;
6526        i < elf_header.e_shnum;
6527        i++, section++)
6528     {
6529       switch (section->sh_type)
6530         {
6531         case SHT_GNU_verdef:
6532           {
6533             Elf_External_Verdef *edefs;
6534             unsigned int idx;
6535             unsigned int cnt;
6536             char *endbuf;
6537
6538             found = 1;
6539
6540             printf
6541               (_("\nVersion definition section '%s' contains %u entries:\n"),
6542                SECTION_NAME (section), section->sh_info);
6543
6544             printf (_("  Addr: 0x"));
6545             printf_vma (section->sh_addr);
6546             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
6547                     (unsigned long) section->sh_offset, section->sh_link,
6548                     section->sh_link < elf_header.e_shnum
6549                     ? SECTION_NAME (section_headers + section->sh_link)
6550                     : "<corrupt>");
6551
6552             edefs = get_data (NULL, file, section->sh_offset, 1,
6553                               section->sh_size,
6554                               _("version definition section"));
6555             endbuf = (char *) edefs + section->sh_size;
6556             if (!edefs)
6557               break;
6558
6559             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6560               {
6561                 char *vstart;
6562                 Elf_External_Verdef *edef;
6563                 Elf_Internal_Verdef ent;
6564                 Elf_External_Verdaux *eaux;
6565                 Elf_Internal_Verdaux aux;
6566                 int j;
6567                 int isum;
6568
6569                 vstart = ((char *) edefs) + idx;
6570                 if (vstart + sizeof (*edef) > endbuf)
6571                   break;
6572
6573                 edef = (Elf_External_Verdef *) vstart;
6574
6575                 ent.vd_version = BYTE_GET (edef->vd_version);
6576                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
6577                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
6578                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
6579                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
6580                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
6581                 ent.vd_next    = BYTE_GET (edef->vd_next);
6582
6583                 printf (_("  %#06x: Rev: %d  Flags: %s"),
6584                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
6585
6586                 printf (_("  Index: %d  Cnt: %d  "),
6587                         ent.vd_ndx, ent.vd_cnt);
6588
6589                 vstart += ent.vd_aux;
6590
6591                 eaux = (Elf_External_Verdaux *) vstart;
6592
6593                 aux.vda_name = BYTE_GET (eaux->vda_name);
6594                 aux.vda_next = BYTE_GET (eaux->vda_next);
6595
6596                 if (VALID_DYNAMIC_NAME (aux.vda_name))
6597                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
6598                 else
6599                   printf (_("Name index: %ld\n"), aux.vda_name);
6600
6601                 isum = idx + ent.vd_aux;
6602
6603                 for (j = 1; j < ent.vd_cnt; j++)
6604                   {
6605                     isum   += aux.vda_next;
6606                     vstart += aux.vda_next;
6607
6608                     eaux = (Elf_External_Verdaux *) vstart;
6609                     if (vstart + sizeof (*eaux) > endbuf)
6610                       break;
6611
6612                     aux.vda_name = BYTE_GET (eaux->vda_name);
6613                     aux.vda_next = BYTE_GET (eaux->vda_next);
6614
6615                     if (VALID_DYNAMIC_NAME (aux.vda_name))
6616                       printf (_("  %#06x: Parent %d: %s\n"),
6617                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
6618                     else
6619                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
6620                               isum, j, aux.vda_name);
6621                   }
6622                 if (j < ent.vd_cnt)
6623                   printf (_("  Version def aux past end of section\n"));
6624
6625                 idx += ent.vd_next;
6626               }
6627             if (cnt < section->sh_info)
6628               printf (_("  Version definition past end of section\n"));
6629
6630             free (edefs);
6631           }
6632           break;
6633
6634         case SHT_GNU_verneed:
6635           {
6636             Elf_External_Verneed *eneed;
6637             unsigned int idx;
6638             unsigned int cnt;
6639             char *endbuf;
6640
6641             found = 1;
6642
6643             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6644                     SECTION_NAME (section), section->sh_info);
6645
6646             printf (_(" Addr: 0x"));
6647             printf_vma (section->sh_addr);
6648             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
6649                     (unsigned long) section->sh_offset, section->sh_link,
6650                     section->sh_link < elf_header.e_shnum
6651                     ? SECTION_NAME (section_headers + section->sh_link)
6652                     : "<corrupt>");
6653
6654             eneed = get_data (NULL, file, section->sh_offset, 1,
6655                               section->sh_size,
6656                               _("version need section"));
6657             endbuf = (char *) eneed + section->sh_size;
6658             if (!eneed)
6659               break;
6660
6661             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6662               {
6663                 Elf_External_Verneed *entry;
6664                 Elf_Internal_Verneed ent;
6665                 int j;
6666                 int isum;
6667                 char *vstart;
6668
6669                 vstart = ((char *) eneed) + idx;
6670                 if (vstart + sizeof (*entry) > endbuf)
6671                   break;
6672
6673                 entry = (Elf_External_Verneed *) vstart;
6674
6675                 ent.vn_version = BYTE_GET (entry->vn_version);
6676                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
6677                 ent.vn_file    = BYTE_GET (entry->vn_file);
6678                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
6679                 ent.vn_next    = BYTE_GET (entry->vn_next);
6680
6681                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
6682
6683                 if (VALID_DYNAMIC_NAME (ent.vn_file))
6684                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
6685                 else
6686                   printf (_("  File: %lx"), ent.vn_file);
6687
6688                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
6689
6690                 vstart += ent.vn_aux;
6691
6692                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
6693                   {
6694                     Elf_External_Vernaux *eaux;
6695                     Elf_Internal_Vernaux aux;
6696
6697                     if (vstart + sizeof (*eaux) > endbuf)
6698                       break;
6699                     eaux = (Elf_External_Vernaux *) vstart;
6700
6701                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
6702                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
6703                     aux.vna_other = BYTE_GET (eaux->vna_other);
6704                     aux.vna_name  = BYTE_GET (eaux->vna_name);
6705                     aux.vna_next  = BYTE_GET (eaux->vna_next);
6706
6707                     if (VALID_DYNAMIC_NAME (aux.vna_name))
6708                       printf (_("  %#06x:   Name: %s"),
6709                               isum, GET_DYNAMIC_NAME (aux.vna_name));
6710                     else
6711                       printf (_("  %#06x:   Name index: %lx"),
6712                               isum, aux.vna_name);
6713
6714                     printf (_("  Flags: %s  Version: %d\n"),
6715                             get_ver_flags (aux.vna_flags), aux.vna_other);
6716
6717                     isum   += aux.vna_next;
6718                     vstart += aux.vna_next;
6719                   }
6720                 if (j < ent.vn_cnt)
6721                   printf (_("  Version need aux past end of section\n"));
6722
6723                 idx += ent.vn_next;
6724               }
6725             if (cnt < section->sh_info)
6726               printf (_("  Version need past end of section\n"));
6727
6728             free (eneed);
6729           }
6730           break;
6731
6732         case SHT_GNU_versym:
6733           {
6734             Elf_Internal_Shdr *link_section;
6735             int total;
6736             int cnt;
6737             unsigned char *edata;
6738             unsigned short *data;
6739             char *strtab;
6740             Elf_Internal_Sym *symbols;
6741             Elf_Internal_Shdr *string_sec;
6742             long off;
6743
6744             if (section->sh_link >= elf_header.e_shnum)
6745               break;
6746
6747             link_section = section_headers + section->sh_link;
6748             total = section->sh_size / sizeof (Elf_External_Versym);
6749
6750             if (link_section->sh_link >= elf_header.e_shnum)
6751               break;
6752
6753             found = 1;
6754
6755             symbols = GET_ELF_SYMBOLS (file, link_section);
6756
6757             string_sec = section_headers + link_section->sh_link;
6758
6759             strtab = get_data (NULL, file, string_sec->sh_offset, 1,
6760                                string_sec->sh_size, _("version string table"));
6761             if (!strtab)
6762               break;
6763
6764             printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6765                     SECTION_NAME (section), total);
6766
6767             printf (_(" Addr: "));
6768             printf_vma (section->sh_addr);
6769             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
6770                     (unsigned long) section->sh_offset, section->sh_link,
6771                     SECTION_NAME (link_section));
6772
6773             off = offset_from_vma (file,
6774                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
6775                                    total * sizeof (short));
6776             edata = get_data (NULL, file, off, total, sizeof (short),
6777                               _("version symbol data"));
6778             if (!edata)
6779               {
6780                 free (strtab);
6781                 break;
6782               }
6783
6784             data = cmalloc (total, sizeof (short));
6785
6786             for (cnt = total; cnt --;)
6787               data[cnt] = byte_get (edata + cnt * sizeof (short),
6788                                     sizeof (short));
6789
6790             free (edata);
6791
6792             for (cnt = 0; cnt < total; cnt += 4)
6793               {
6794                 int j, nn;
6795                 int check_def, check_need;
6796                 char *name;
6797
6798                 printf ("  %03x:", cnt);
6799
6800                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
6801                   switch (data[cnt + j])
6802                     {
6803                     case 0:
6804                       fputs (_("   0 (*local*)    "), stdout);
6805                       break;
6806
6807                     case 1:
6808                       fputs (_("   1 (*global*)   "), stdout);
6809                       break;
6810
6811                     default:
6812                       nn = printf ("%4x%c", data[cnt + j] & 0x7fff,
6813                                    data[cnt + j] & 0x8000 ? 'h' : ' ');
6814
6815                       check_def = 1;
6816                       check_need = 1;
6817                       if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
6818                           || section_headers[symbols[cnt + j].st_shndx].sh_type
6819                              != SHT_NOBITS)
6820                         {
6821                           if (symbols[cnt + j].st_shndx == SHN_UNDEF)
6822                             check_def = 0;
6823                           else
6824                             check_need = 0;
6825                         }
6826
6827                       if (check_need
6828                           && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
6829                         {
6830                           Elf_Internal_Verneed ivn;
6831                           unsigned long offset;
6832
6833                           offset = offset_from_vma
6834                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
6835                              sizeof (Elf_External_Verneed));
6836
6837                           do
6838                             {
6839                               Elf_Internal_Vernaux ivna;
6840                               Elf_External_Verneed evn;
6841                               Elf_External_Vernaux evna;
6842                               unsigned long a_off;
6843
6844                               get_data (&evn, file, offset, sizeof (evn), 1,
6845                                         _("version need"));
6846
6847                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
6848                               ivn.vn_next = BYTE_GET (evn.vn_next);
6849
6850                               a_off = offset + ivn.vn_aux;
6851
6852                               do
6853                                 {
6854                                   get_data (&evna, file, a_off, sizeof (evna),
6855                                             1, _("version need aux (2)"));
6856
6857                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
6858                                   ivna.vna_other = BYTE_GET (evna.vna_other);
6859
6860                                   a_off += ivna.vna_next;
6861                                 }
6862                               while (ivna.vna_other != data[cnt + j]
6863                                      && ivna.vna_next != 0);
6864
6865                               if (ivna.vna_other == data[cnt + j])
6866                                 {
6867                                   ivna.vna_name = BYTE_GET (evna.vna_name);
6868
6869                                   if (ivna.vna_name >= string_sec->sh_size)
6870                                     name = _("*invalid*");
6871                                   else
6872                                     name = strtab + ivna.vna_name;
6873                                   nn += printf ("(%s%-*s",
6874                                                 name,
6875                                                 12 - (int) strlen (name),
6876                                                 ")");
6877                                   check_def = 0;
6878                                   break;
6879                                 }
6880
6881                               offset += ivn.vn_next;
6882                             }
6883                           while (ivn.vn_next);
6884                         }
6885
6886                       if (check_def && data[cnt + j] != 0x8001
6887                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
6888                         {
6889                           Elf_Internal_Verdef ivd;
6890                           Elf_External_Verdef evd;
6891                           unsigned long offset;
6892
6893                           offset = offset_from_vma
6894                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
6895                              sizeof evd);
6896
6897                           do
6898                             {
6899                               get_data (&evd, file, offset, sizeof (evd), 1,
6900                                         _("version def"));
6901
6902                               ivd.vd_next = BYTE_GET (evd.vd_next);
6903                               ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
6904
6905                               offset += ivd.vd_next;
6906                             }
6907                           while (ivd.vd_ndx != (data[cnt + j] & 0x7fff)
6908                                  && ivd.vd_next != 0);
6909
6910                           if (ivd.vd_ndx == (data[cnt + j] & 0x7fff))
6911                             {
6912                               Elf_External_Verdaux evda;
6913                               Elf_Internal_Verdaux ivda;
6914
6915                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
6916
6917                               get_data (&evda, file,
6918                                         offset - ivd.vd_next + ivd.vd_aux,
6919                                         sizeof (evda), 1,
6920                                         _("version def aux"));
6921
6922                               ivda.vda_name = BYTE_GET (evda.vda_name);
6923
6924                               if (ivda.vda_name >= string_sec->sh_size)
6925                                 name = _("*invalid*");
6926                               else
6927                                 name = strtab + ivda.vda_name;
6928                               nn += printf ("(%s%-*s",
6929                                             name,
6930                                             12 - (int) strlen (name),
6931                                             ")");
6932                             }
6933                         }
6934
6935                       if (nn < 18)
6936                         printf ("%*c", 18 - nn, ' ');
6937                     }
6938
6939                 putchar ('\n');
6940               }
6941
6942             free (data);
6943             free (strtab);
6944             free (symbols);
6945           }
6946           break;
6947
6948         default:
6949           break;
6950         }
6951     }
6952
6953   if (! found)
6954     printf (_("\nNo version information found in this file.\n"));
6955
6956   return 1;
6957 }
6958
6959 static const char *
6960 get_symbol_binding (unsigned int binding)
6961 {
6962   static char buff[32];
6963
6964   switch (binding)
6965     {
6966     case STB_LOCAL:     return "LOCAL";
6967     case STB_GLOBAL:    return "GLOBAL";
6968     case STB_WEAK:      return "WEAK";
6969     default:
6970       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
6971         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
6972                   binding);
6973       else if (binding >= STB_LOOS && binding <= STB_HIOS)
6974         snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
6975       else
6976         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
6977       return buff;
6978     }
6979 }
6980
6981 static const char *
6982 get_symbol_type (unsigned int type)
6983 {
6984   static char buff[32];
6985
6986   switch (type)
6987     {
6988     case STT_NOTYPE:    return "NOTYPE";
6989     case STT_OBJECT:    return "OBJECT";
6990     case STT_FUNC:      return "FUNC";
6991     case STT_SECTION:   return "SECTION";
6992     case STT_FILE:      return "FILE";
6993     case STT_COMMON:    return "COMMON";
6994     case STT_TLS:       return "TLS";
6995     case STT_RELC:      return "RELC";
6996     case STT_SRELC:     return "SRELC";
6997     default:
6998       if (type >= STT_LOPROC && type <= STT_HIPROC)
6999         {
7000           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
7001             return "THUMB_FUNC";
7002
7003           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
7004             return "REGISTER";
7005
7006           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
7007             return "PARISC_MILLI";
7008
7009           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
7010         }
7011       else if (type >= STT_LOOS && type <= STT_HIOS)
7012         {
7013           if (elf_header.e_machine == EM_PARISC)
7014             {
7015               if (type == STT_HP_OPAQUE)
7016                 return "HP_OPAQUE";
7017               if (type == STT_HP_STUB)
7018                 return "HP_STUB";
7019             }
7020
7021           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
7022         }
7023       else
7024         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
7025       return buff;
7026     }
7027 }
7028
7029 static const char *
7030 get_symbol_visibility (unsigned int visibility)
7031 {
7032   switch (visibility)
7033     {
7034     case STV_DEFAULT:   return "DEFAULT";
7035     case STV_INTERNAL:  return "INTERNAL";
7036     case STV_HIDDEN:    return "HIDDEN";
7037     case STV_PROTECTED: return "PROTECTED";
7038     default: abort ();
7039     }
7040 }
7041
7042 static const char *
7043 get_mips_symbol_other (unsigned int other)
7044 {
7045   switch (other)
7046     {
7047     case STO_OPTIONAL:  return "OPTIONAL";
7048     case STO_MIPS16:    return "MIPS16";
7049     case STO_MIPS_PLT:  return "MIPS PLT";
7050     case STO_MIPS_PIC:  return "MIPS PIC";
7051     default:            return NULL;
7052     }
7053 }
7054
7055 static const char *
7056 get_symbol_other (unsigned int other)
7057 {
7058   const char * result = NULL;
7059   static char buff [32];
7060
7061   if (other == 0)
7062     return "";
7063
7064   switch (elf_header.e_machine)
7065     {
7066     case EM_MIPS:
7067       result = get_mips_symbol_other (other);
7068     default:
7069       break;
7070     }
7071
7072   if (result)
7073     return result;
7074
7075   snprintf (buff, sizeof buff, _("<other>: %x"), other);
7076   return buff;
7077 }
7078
7079 static const char *
7080 get_symbol_index_type (unsigned int type)
7081 {
7082   static char buff[32];
7083
7084   switch (type)
7085     {
7086     case SHN_UNDEF:     return "UND";
7087     case SHN_ABS:       return "ABS";
7088     case SHN_COMMON:    return "COM";
7089     default:
7090       if (type == SHN_IA_64_ANSI_COMMON
7091           && elf_header.e_machine == EM_IA_64
7092           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
7093         return "ANSI_COM";
7094       else if (elf_header.e_machine == EM_X86_64
7095                && type == SHN_X86_64_LCOMMON)
7096         return "LARGE_COM";
7097       else if (type == SHN_MIPS_SCOMMON
7098                && elf_header.e_machine == EM_MIPS)
7099         return "SCOM";
7100       else if (type == SHN_MIPS_SUNDEFINED
7101                && elf_header.e_machine == EM_MIPS)
7102         return "SUND";
7103       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
7104         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
7105       else if (type >= SHN_LOOS && type <= SHN_HIOS)
7106         sprintf (buff, "OS [0x%04x]", type & 0xffff);
7107       else if (type >= SHN_LORESERVE)
7108         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
7109       else
7110         sprintf (buff, "%3d", type);
7111       break;
7112     }
7113
7114   return buff;
7115 }
7116
7117 static bfd_vma *
7118 get_dynamic_data (FILE *file, unsigned int number, unsigned int ent_size)
7119 {
7120   unsigned char *e_data;
7121   bfd_vma *i_data;
7122
7123   e_data = cmalloc (number, ent_size);
7124
7125   if (e_data == NULL)
7126     {
7127       error (_("Out of memory\n"));
7128       return NULL;
7129     }
7130
7131   if (fread (e_data, ent_size, number, file) != number)
7132     {
7133       error (_("Unable to read in dynamic data\n"));
7134       return NULL;
7135     }
7136
7137   i_data = cmalloc (number, sizeof (*i_data));
7138
7139   if (i_data == NULL)
7140     {
7141       error (_("Out of memory\n"));
7142       free (e_data);
7143       return NULL;
7144     }
7145
7146   while (number--)
7147     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
7148
7149   free (e_data);
7150
7151   return i_data;
7152 }
7153
7154 static void
7155 print_dynamic_symbol (bfd_vma si, unsigned long hn)
7156 {
7157   Elf_Internal_Sym *psym;
7158   int n;
7159
7160   psym = dynamic_symbols + si;
7161
7162   n = print_vma (si, DEC_5);
7163   if (n < 5)
7164     fputs ("     " + n, stdout);
7165   printf (" %3lu: ", hn);
7166   print_vma (psym->st_value, LONG_HEX);
7167   putchar (' ');
7168   print_vma (psym->st_size, DEC_5);
7169
7170   printf ("  %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
7171   printf (" %6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
7172   printf (" %3s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
7173   /* Check to see if any other bits in the st_other field are set.
7174      Note - displaying this information disrupts the layout of the
7175      table being generated, but for the moment this case is very
7176      rare.  */
7177   if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
7178     printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
7179   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
7180   if (VALID_DYNAMIC_NAME (psym->st_name))
7181     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
7182   else
7183     printf (" <corrupt: %14ld>", psym->st_name);
7184   putchar ('\n');
7185 }
7186
7187 /* Dump the symbol table.  */
7188 static int
7189 process_symbol_table (FILE *file)
7190 {
7191   Elf_Internal_Shdr *section;
7192   bfd_vma nbuckets = 0;
7193   bfd_vma nchains = 0;
7194   bfd_vma *buckets = NULL;
7195   bfd_vma *chains = NULL;
7196   bfd_vma ngnubuckets = 0;
7197   bfd_vma *gnubuckets = NULL;
7198   bfd_vma *gnuchains = NULL;
7199   bfd_vma gnusymidx = 0;
7200
7201   if (! do_syms && !do_histogram)
7202     return 1;
7203
7204   if (dynamic_info[DT_HASH]
7205       && (do_histogram
7206           || (do_using_dynamic && dynamic_strings != NULL)))
7207     {
7208       unsigned char nb[8];
7209       unsigned char nc[8];
7210       int hash_ent_size = 4;
7211
7212       if ((elf_header.e_machine == EM_ALPHA
7213            || elf_header.e_machine == EM_S390
7214            || elf_header.e_machine == EM_S390_OLD)
7215           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
7216         hash_ent_size = 8;
7217
7218       if (fseek (file,
7219                  (archive_file_offset
7220                   + offset_from_vma (file, dynamic_info[DT_HASH],
7221                                      sizeof nb + sizeof nc)),
7222                  SEEK_SET))
7223         {
7224           error (_("Unable to seek to start of dynamic information\n"));
7225           return 0;
7226         }
7227
7228       if (fread (nb, hash_ent_size, 1, file) != 1)
7229         {
7230           error (_("Failed to read in number of buckets\n"));
7231           return 0;
7232         }
7233
7234       if (fread (nc, hash_ent_size, 1, file) != 1)
7235         {
7236           error (_("Failed to read in number of chains\n"));
7237           return 0;
7238         }
7239
7240       nbuckets = byte_get (nb, hash_ent_size);
7241       nchains  = byte_get (nc, hash_ent_size);
7242
7243       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
7244       chains  = get_dynamic_data (file, nchains, hash_ent_size);
7245
7246       if (buckets == NULL || chains == NULL)
7247         return 0;
7248     }
7249
7250   if (dynamic_info_DT_GNU_HASH
7251       && (do_histogram
7252           || (do_using_dynamic && dynamic_strings != NULL)))
7253     {
7254       unsigned char nb[16];
7255       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
7256       bfd_vma buckets_vma;
7257
7258       if (fseek (file,
7259                  (archive_file_offset
7260                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
7261                                      sizeof nb)),
7262                  SEEK_SET))
7263         {
7264           error (_("Unable to seek to start of dynamic information\n"));
7265           return 0;
7266         }
7267
7268       if (fread (nb, 16, 1, file) != 1)
7269         {
7270           error (_("Failed to read in number of buckets\n"));
7271           return 0;
7272         }
7273
7274       ngnubuckets = byte_get (nb, 4);
7275       gnusymidx = byte_get (nb + 4, 4);
7276       bitmaskwords = byte_get (nb + 8, 4);
7277       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
7278       if (is_32bit_elf)
7279         buckets_vma += bitmaskwords * 4;
7280       else
7281         buckets_vma += bitmaskwords * 8;
7282
7283       if (fseek (file,
7284                  (archive_file_offset
7285                   + offset_from_vma (file, buckets_vma, 4)),
7286                  SEEK_SET))
7287         {
7288           error (_("Unable to seek to start of dynamic information\n"));
7289           return 0;
7290         }
7291
7292       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
7293
7294       if (gnubuckets == NULL)
7295         return 0;
7296
7297       for (i = 0; i < ngnubuckets; i++)
7298         if (gnubuckets[i] != 0)
7299           {
7300             if (gnubuckets[i] < gnusymidx)
7301               return 0;
7302
7303             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
7304               maxchain = gnubuckets[i];
7305           }
7306
7307       if (maxchain == 0xffffffff)
7308         return 0;
7309
7310       maxchain -= gnusymidx;
7311
7312       if (fseek (file,
7313                  (archive_file_offset
7314                   + offset_from_vma (file, buckets_vma
7315                                            + 4 * (ngnubuckets + maxchain), 4)),
7316                  SEEK_SET))
7317         {
7318           error (_("Unable to seek to start of dynamic information\n"));
7319           return 0;
7320         }
7321
7322       do
7323         {
7324           if (fread (nb, 4, 1, file) != 1)
7325             {
7326               error (_("Failed to determine last chain length\n"));
7327               return 0;
7328             }
7329
7330           if (maxchain + 1 == 0)
7331             return 0;
7332
7333           ++maxchain;
7334         }
7335       while ((byte_get (nb, 4) & 1) == 0);
7336
7337       if (fseek (file,
7338                  (archive_file_offset
7339                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
7340                  SEEK_SET))
7341         {
7342           error (_("Unable to seek to start of dynamic information\n"));
7343           return 0;
7344         }
7345
7346       gnuchains = get_dynamic_data (file, maxchain, 4);
7347
7348       if (gnuchains == NULL)
7349         return 0;
7350     }
7351
7352   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
7353       && do_syms
7354       && do_using_dynamic
7355       && dynamic_strings != NULL)
7356     {
7357       unsigned long hn;
7358
7359       if (dynamic_info[DT_HASH])
7360         {
7361           bfd_vma si;
7362
7363           printf (_("\nSymbol table for image:\n"));
7364           if (is_32bit_elf)
7365             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
7366           else
7367             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
7368
7369           for (hn = 0; hn < nbuckets; hn++)
7370             {
7371               if (! buckets[hn])
7372                 continue;
7373
7374               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
7375                 print_dynamic_symbol (si, hn);
7376             }
7377         }
7378
7379       if (dynamic_info_DT_GNU_HASH)
7380         {
7381           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7382           if (is_32bit_elf)
7383             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
7384           else
7385             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
7386
7387           for (hn = 0; hn < ngnubuckets; ++hn)
7388             if (gnubuckets[hn] != 0)
7389               {
7390                 bfd_vma si = gnubuckets[hn];
7391                 bfd_vma off = si - gnusymidx;
7392
7393                 do
7394                   {
7395                     print_dynamic_symbol (si, hn);
7396                     si++;
7397                   }
7398                 while ((gnuchains[off++] & 1) == 0);
7399               }
7400         }
7401     }
7402   else if (do_syms && !do_using_dynamic)
7403     {
7404       unsigned int i;
7405
7406       for (i = 0, section = section_headers;
7407            i < elf_header.e_shnum;
7408            i++, section++)
7409         {
7410           unsigned int si;
7411           char *strtab = NULL;
7412           unsigned long int strtab_size = 0;
7413           Elf_Internal_Sym *symtab;
7414           Elf_Internal_Sym *psym;
7415
7416
7417           if (   section->sh_type != SHT_SYMTAB
7418               && section->sh_type != SHT_DYNSYM)
7419             continue;
7420
7421           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7422                   SECTION_NAME (section),
7423                   (unsigned long) (section->sh_size / section->sh_entsize));
7424           if (is_32bit_elf)
7425             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
7426           else
7427             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
7428
7429           symtab = GET_ELF_SYMBOLS (file, section);
7430           if (symtab == NULL)
7431             continue;
7432
7433           if (section->sh_link == elf_header.e_shstrndx)
7434             {
7435               strtab = string_table;
7436               strtab_size = string_table_length;
7437             }
7438           else if (section->sh_link < elf_header.e_shnum)
7439             {
7440               Elf_Internal_Shdr *string_sec;
7441
7442               string_sec = section_headers + section->sh_link;
7443
7444               strtab = get_data (NULL, file, string_sec->sh_offset,
7445                                  1, string_sec->sh_size, _("string table"));
7446               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
7447             }
7448
7449           for (si = 0, psym = symtab;
7450                si < section->sh_size / section->sh_entsize;
7451                si++, psym++)
7452             {
7453               printf ("%6d: ", si);
7454               print_vma (psym->st_value, LONG_HEX);
7455               putchar (' ');
7456               print_vma (psym->st_size, DEC_5);
7457               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
7458               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
7459               printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
7460               /* Check to see if any other bits in the st_other field are set.
7461                  Note - displaying this information disrupts the layout of the
7462                  table being generated, but for the moment this case is very rare.  */
7463               if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
7464                 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
7465               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
7466               print_symbol (25, psym->st_name < strtab_size
7467                             ? strtab + psym->st_name : "<corrupt>");
7468
7469               if (section->sh_type == SHT_DYNSYM &&
7470                   version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
7471                 {
7472                   unsigned char data[2];
7473                   unsigned short vers_data;
7474                   unsigned long offset;
7475                   int is_nobits;
7476                   int check_def;
7477
7478                   offset = offset_from_vma
7479                     (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
7480                      sizeof data + si * sizeof (vers_data));
7481
7482                   get_data (&data, file, offset + si * sizeof (vers_data),
7483                             sizeof (data), 1, _("version data"));
7484
7485                   vers_data = byte_get (data, 2);
7486
7487                   is_nobits = (psym->st_shndx < elf_header.e_shnum
7488                                && section_headers[psym->st_shndx].sh_type
7489                                   == SHT_NOBITS);
7490
7491                   check_def = (psym->st_shndx != SHN_UNDEF);
7492
7493                   if ((vers_data & 0x8000) || vers_data > 1)
7494                     {
7495                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
7496                           && (is_nobits || ! check_def))
7497                         {
7498                           Elf_External_Verneed evn;
7499                           Elf_Internal_Verneed ivn;
7500                           Elf_Internal_Vernaux ivna;
7501
7502                           /* We must test both.  */
7503                           offset = offset_from_vma
7504                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
7505                              sizeof evn);
7506
7507                           do
7508                             {
7509                               unsigned long vna_off;
7510
7511                               get_data (&evn, file, offset, sizeof (evn), 1,
7512                                         _("version need"));
7513
7514                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
7515                               ivn.vn_next = BYTE_GET (evn.vn_next);
7516
7517                               vna_off = offset + ivn.vn_aux;
7518
7519                               do
7520                                 {
7521                                   Elf_External_Vernaux evna;
7522
7523                                   get_data (&evna, file, vna_off,
7524                                             sizeof (evna), 1,
7525                                             _("version need aux (3)"));
7526
7527                                   ivna.vna_other = BYTE_GET (evna.vna_other);
7528                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
7529                                   ivna.vna_name  = BYTE_GET (evna.vna_name);
7530
7531                                   vna_off += ivna.vna_next;
7532                                 }
7533                               while (ivna.vna_other != vers_data
7534                                      && ivna.vna_next != 0);
7535
7536                               if (ivna.vna_other == vers_data)
7537                                 break;
7538
7539                               offset += ivn.vn_next;
7540                             }
7541                           while (ivn.vn_next != 0);
7542
7543                           if (ivna.vna_other == vers_data)
7544                             {
7545                               printf ("@%s (%d)",
7546                                       ivna.vna_name < strtab_size
7547                                       ? strtab + ivna.vna_name : "<corrupt>",
7548                                       ivna.vna_other);
7549                               check_def = 0;
7550                             }
7551                           else if (! is_nobits)
7552                             error (_("bad dynamic symbol\n"));
7553                           else
7554                             check_def = 1;
7555                         }
7556
7557                       if (check_def)
7558                         {
7559                           if (vers_data != 0x8001
7560                               && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
7561                             {
7562                               Elf_Internal_Verdef ivd;
7563                               Elf_Internal_Verdaux ivda;
7564                               Elf_External_Verdaux evda;
7565                               unsigned long offset;
7566
7567                               offset = offset_from_vma
7568                                 (file,
7569                                  version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
7570                                  sizeof (Elf_External_Verdef));
7571
7572                               do
7573                                 {
7574                                   Elf_External_Verdef evd;
7575
7576                                   get_data (&evd, file, offset, sizeof (evd),
7577                                             1, _("version def"));
7578
7579                                   ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
7580                                   ivd.vd_aux = BYTE_GET (evd.vd_aux);
7581                                   ivd.vd_next = BYTE_GET (evd.vd_next);
7582
7583                                   offset += ivd.vd_next;
7584                                 }
7585                               while (ivd.vd_ndx != (vers_data & 0x7fff)
7586                                      && ivd.vd_next != 0);
7587
7588                               offset -= ivd.vd_next;
7589                               offset += ivd.vd_aux;
7590
7591                               get_data (&evda, file, offset, sizeof (evda),
7592                                         1, _("version def aux"));
7593
7594                               ivda.vda_name = BYTE_GET (evda.vda_name);
7595
7596                               if (psym->st_name != ivda.vda_name)
7597                                 printf ((vers_data & 0x8000)
7598                                         ? "@%s" : "@@%s",
7599                                         ivda.vda_name < strtab_size
7600                                         ? strtab + ivda.vda_name : "<corrupt>");
7601                             }
7602                         }
7603                     }
7604                 }
7605
7606               putchar ('\n');
7607             }
7608
7609           free (symtab);
7610           if (strtab != string_table)
7611             free (strtab);
7612         }
7613     }
7614   else if (do_syms)
7615     printf
7616       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7617
7618   if (do_histogram && buckets != NULL)
7619     {
7620       unsigned long *lengths;
7621       unsigned long *counts;
7622       unsigned long hn;
7623       bfd_vma si;
7624       unsigned long maxlength = 0;
7625       unsigned long nzero_counts = 0;
7626       unsigned long nsyms = 0;
7627
7628       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7629               (unsigned long) nbuckets);
7630       printf (_(" Length  Number     %% of total  Coverage\n"));
7631
7632       lengths = calloc (nbuckets, sizeof (*lengths));
7633       if (lengths == NULL)
7634         {
7635           error (_("Out of memory\n"));
7636           return 0;
7637         }
7638       for (hn = 0; hn < nbuckets; ++hn)
7639         {
7640           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
7641             {
7642               ++nsyms;
7643               if (maxlength < ++lengths[hn])
7644                 ++maxlength;
7645             }
7646         }
7647
7648       counts = calloc (maxlength + 1, sizeof (*counts));
7649       if (counts == NULL)
7650         {
7651           error (_("Out of memory\n"));
7652           return 0;
7653         }
7654
7655       for (hn = 0; hn < nbuckets; ++hn)
7656         ++counts[lengths[hn]];
7657
7658       if (nbuckets > 0)
7659         {
7660           unsigned long i;
7661           printf ("      0  %-10lu (%5.1f%%)\n",
7662                   counts[0], (counts[0] * 100.0) / nbuckets);
7663           for (i = 1; i <= maxlength; ++i)
7664             {
7665               nzero_counts += counts[i] * i;
7666               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
7667                       i, counts[i], (counts[i] * 100.0) / nbuckets,
7668                       (nzero_counts * 100.0) / nsyms);
7669             }
7670         }
7671
7672       free (counts);
7673       free (lengths);
7674     }
7675
7676   if (buckets != NULL)
7677     {
7678       free (buckets);
7679       free (chains);
7680     }
7681
7682   if (do_histogram && dynamic_info_DT_GNU_HASH)
7683     {
7684       unsigned long *lengths;
7685       unsigned long *counts;
7686       unsigned long hn;
7687       unsigned long maxlength = 0;
7688       unsigned long nzero_counts = 0;
7689       unsigned long nsyms = 0;
7690
7691       lengths = calloc (ngnubuckets, sizeof (*lengths));
7692       if (lengths == NULL)
7693         {
7694           error (_("Out of memory\n"));
7695           return 0;
7696         }
7697
7698       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7699               (unsigned long) ngnubuckets);
7700       printf (_(" Length  Number     %% of total  Coverage\n"));
7701
7702       for (hn = 0; hn < ngnubuckets; ++hn)
7703         if (gnubuckets[hn] != 0)
7704           {
7705             bfd_vma off, length = 1;
7706
7707             for (off = gnubuckets[hn] - gnusymidx;
7708                  (gnuchains[off] & 1) == 0; ++off)
7709               ++length;
7710             lengths[hn] = length;
7711             if (length > maxlength)
7712               maxlength = length;
7713             nsyms += length;
7714           }
7715
7716       counts = calloc (maxlength + 1, sizeof (*counts));
7717       if (counts == NULL)
7718         {
7719           error (_("Out of memory\n"));
7720           return 0;
7721         }
7722
7723       for (hn = 0; hn < ngnubuckets; ++hn)
7724         ++counts[lengths[hn]];
7725
7726       if (ngnubuckets > 0)
7727         {
7728           unsigned long j;
7729           printf ("      0  %-10lu (%5.1f%%)\n",
7730                   counts[0], (counts[0] * 100.0) / ngnubuckets);
7731           for (j = 1; j <= maxlength; ++j)
7732             {
7733               nzero_counts += counts[j] * j;
7734               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
7735                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
7736                       (nzero_counts * 100.0) / nsyms);
7737             }
7738         }
7739
7740       free (counts);
7741       free (lengths);
7742       free (gnubuckets);
7743       free (gnuchains);
7744     }
7745
7746   return 1;
7747 }
7748
7749 static int
7750 process_syminfo (FILE *file ATTRIBUTE_UNUSED)
7751 {
7752   unsigned int i;
7753
7754   if (dynamic_syminfo == NULL
7755       || !do_dynamic)
7756     /* No syminfo, this is ok.  */
7757     return 1;
7758
7759   /* There better should be a dynamic symbol section.  */
7760   if (dynamic_symbols == NULL || dynamic_strings == NULL)
7761     return 0;
7762
7763   if (dynamic_addr)
7764     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7765             dynamic_syminfo_offset, dynamic_syminfo_nent);
7766
7767   printf (_(" Num: Name                           BoundTo     Flags\n"));
7768   for (i = 0; i < dynamic_syminfo_nent; ++i)
7769     {
7770       unsigned short int flags = dynamic_syminfo[i].si_flags;
7771
7772       printf ("%4d: ", i);
7773       if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
7774         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
7775       else
7776         printf ("<corrupt: %19ld>", dynamic_symbols[i].st_name);
7777       putchar (' ');
7778
7779       switch (dynamic_syminfo[i].si_boundto)
7780         {
7781         case SYMINFO_BT_SELF:
7782           fputs ("SELF       ", stdout);
7783           break;
7784         case SYMINFO_BT_PARENT:
7785           fputs ("PARENT     ", stdout);
7786           break;
7787         default:
7788           if (dynamic_syminfo[i].si_boundto > 0
7789               && dynamic_syminfo[i].si_boundto < dynamic_nent
7790               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
7791             {
7792               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
7793               putchar (' ' );
7794             }
7795           else
7796             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
7797           break;
7798         }
7799
7800       if (flags & SYMINFO_FLG_DIRECT)
7801         printf (" DIRECT");
7802       if (flags & SYMINFO_FLG_PASSTHRU)
7803         printf (" PASSTHRU");
7804       if (flags & SYMINFO_FLG_COPY)
7805         printf (" COPY");
7806       if (flags & SYMINFO_FLG_LAZYLOAD)
7807         printf (" LAZYLOAD");
7808
7809       puts ("");
7810     }
7811
7812   return 1;
7813 }
7814
7815 #ifdef SUPPORT_DISASSEMBLY
7816 static int
7817 disassemble_section (Elf_Internal_Shdr *section, FILE *file)
7818 {
7819   printf (_("\nAssembly dump of section %s\n"),
7820           SECTION_NAME (section));
7821
7822   /* XXX -- to be done --- XXX */
7823
7824   return 1;
7825 }
7826 #endif
7827
7828 static int
7829 dump_section_as_strings (Elf_Internal_Shdr *section, FILE *file)
7830 {
7831   Elf_Internal_Shdr *relsec;
7832   bfd_size_type num_bytes;
7833   bfd_vma addr;
7834   char *data;
7835   char *end;
7836   char *start;
7837   char *name = SECTION_NAME (section);
7838   bfd_boolean some_strings_shown;
7839
7840   num_bytes = section->sh_size;
7841
7842   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
7843     {
7844       printf (_("\nSection '%s' has no data to dump.\n"), name);
7845       return 0;
7846     }
7847
7848   addr = section->sh_addr;
7849
7850   start = get_data (NULL, file, section->sh_offset, 1, num_bytes,
7851                     _("section data"));
7852   if (!start)
7853     return 0;
7854
7855   printf (_("\nString dump of section '%s':\n"), name);
7856
7857   /* If the section being dumped has relocations against it the user might
7858      be expecting these relocations to have been applied.  Check for this
7859      case and issue a warning message in order to avoid confusion.
7860      FIXME: Maybe we ought to have an option that dumps a section with
7861      relocs applied ?  */
7862   for (relsec = section_headers;
7863        relsec < section_headers + elf_header.e_shnum;
7864        ++relsec)
7865     {
7866       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
7867           || relsec->sh_info >= elf_header.e_shnum
7868           || section_headers + relsec->sh_info != section
7869           || relsec->sh_size == 0
7870           || relsec->sh_link >= elf_header.e_shnum)
7871         continue;
7872
7873       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7874       break;
7875     }
7876
7877   data = start;
7878   end  = start + num_bytes;
7879   some_strings_shown = FALSE;
7880
7881   while (data < end)
7882     {
7883       while (!ISPRINT (* data))
7884         if (++ data >= end)
7885           break;
7886
7887       if (data < end)
7888         {
7889 #ifndef __MSVCRT__
7890           printf ("  [%6tx]  %s\n", data - start, data);
7891 #else
7892           printf ("  [%6Ix]  %s\n", (size_t) (data - start), data);
7893 #endif
7894           data += strlen (data);
7895           some_strings_shown = TRUE;
7896         }
7897     }
7898
7899   if (! some_strings_shown)
7900     printf (_("  No strings found in this section."));
7901
7902   free (start);
7903
7904   putchar ('\n');
7905   return 1;
7906 }
7907
7908
7909 static int
7910 dump_section_as_bytes (Elf_Internal_Shdr *section, FILE *file)
7911 {
7912   Elf_Internal_Shdr *relsec;
7913   bfd_size_type bytes;
7914   bfd_vma addr;
7915   unsigned char *data;
7916   unsigned char *start;
7917
7918   bytes = section->sh_size;
7919
7920   if (bytes == 0 || section->sh_type == SHT_NOBITS)
7921     {
7922       printf (_("\nSection '%s' has no data to dump.\n"),
7923               SECTION_NAME (section));
7924       return 0;
7925     }
7926   else
7927     printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
7928
7929   addr = section->sh_addr;
7930
7931   start = get_data (NULL, file, section->sh_offset, 1, bytes,
7932                     _("section data"));
7933   if (!start)
7934     return 0;
7935
7936   /* If the section being dumped has relocations against it the user might
7937      be expecting these relocations to have been applied.  Check for this
7938      case and issue a warning message in order to avoid confusion.
7939      FIXME: Maybe we ought to have an option that dumps a section with
7940      relocs applied ?  */
7941   for (relsec = section_headers;
7942        relsec < section_headers + elf_header.e_shnum;
7943        ++relsec)
7944     {
7945       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
7946           || relsec->sh_info >= elf_header.e_shnum
7947           || section_headers + relsec->sh_info != section
7948           || relsec->sh_size == 0
7949           || relsec->sh_link >= elf_header.e_shnum)
7950         continue;
7951
7952       printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7953       break;
7954     }
7955
7956   data = start;
7957
7958   while (bytes)
7959     {
7960       int j;
7961       int k;
7962       int lbytes;
7963
7964       lbytes = (bytes > 16 ? 16 : bytes);
7965
7966       printf ("  0x%8.8lx ", (unsigned long) addr);
7967
7968       for (j = 0; j < 16; j++)
7969         {
7970           if (j < lbytes)
7971             printf ("%2.2x", data[j]);
7972           else
7973             printf ("  ");
7974
7975           if ((j & 3) == 3)
7976             printf (" ");
7977         }
7978
7979       for (j = 0; j < lbytes; j++)
7980         {
7981           k = data[j];
7982           if (k >= ' ' && k < 0x7f)
7983             printf ("%c", k);
7984           else
7985             printf (".");
7986         }
7987
7988       putchar ('\n');
7989
7990       data  += lbytes;
7991       addr  += lbytes;
7992       bytes -= lbytes;
7993     }
7994
7995   free (start);
7996
7997   putchar ('\n');
7998   return 1;
7999 }
8000
8001 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
8002    DWARF debug sections.  This is a target specific test.  Note - we do not
8003    go through the whole including-target-headers-multiple-times route, (as
8004    we have already done with <elf/h8.h>) because this would become very
8005    messy and even then this function would have to contain target specific
8006    information (the names of the relocs instead of their numeric values).
8007    FIXME: This is not the correct way to solve this problem.  The proper way
8008    is to have target specific reloc sizing and typing functions created by
8009    the reloc-macros.h header, in the same way that it already creates the
8010    reloc naming functions.  */
8011
8012 static bfd_boolean
8013 is_32bit_abs_reloc (unsigned int reloc_type)
8014 {
8015   switch (elf_header.e_machine)
8016     {
8017     case EM_386:
8018     case EM_486:
8019       return reloc_type == 1; /* R_386_32.  */
8020     case EM_68K:
8021       return reloc_type == 1; /* R_68K_32.  */
8022     case EM_860:
8023       return reloc_type == 1; /* R_860_32.  */
8024     case EM_ALPHA:
8025       return reloc_type == 1; /* XXX Is this right ?  */
8026     case EM_ARC:
8027       return reloc_type == 1; /* R_ARC_32.  */
8028     case EM_ARM:
8029       return reloc_type == 2; /* R_ARM_ABS32 */
8030     case EM_AVR_OLD:
8031     case EM_AVR:
8032       return reloc_type == 1;
8033     case EM_BLACKFIN:
8034       return reloc_type == 0x12; /* R_byte4_data.  */
8035     case EM_CRIS:
8036       return reloc_type == 3; /* R_CRIS_32.  */
8037     case EM_CR16:
8038     case EM_CR16_OLD:
8039       return reloc_type == 3; /* R_CR16_NUM32.  */
8040     case EM_CRX:
8041       return reloc_type == 15; /* R_CRX_NUM32.  */
8042     case EM_CYGNUS_FRV:
8043       return reloc_type == 1;
8044     case EM_CYGNUS_D10V:
8045     case EM_D10V:
8046       return reloc_type == 6; /* R_D10V_32.  */
8047     case EM_CYGNUS_D30V:
8048     case EM_D30V:
8049       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
8050     case EM_DLX:
8051       return reloc_type == 3; /* R_DLX_RELOC_32.  */
8052     case EM_CYGNUS_FR30:
8053     case EM_FR30:
8054       return reloc_type == 3; /* R_FR30_32.  */
8055     case EM_H8S:
8056     case EM_H8_300:
8057     case EM_H8_300H:
8058       return reloc_type == 1; /* R_H8_DIR32.  */
8059     case EM_IA_64:
8060       return reloc_type == 0x65; /* R_IA64_SECREL32LSB.  */
8061     case EM_IP2K_OLD:
8062     case EM_IP2K:
8063       return reloc_type == 2; /* R_IP2K_32.  */
8064     case EM_IQ2000:
8065       return reloc_type == 2; /* R_IQ2000_32.  */
8066     case EM_M32C_OLD:
8067     case EM_M32C:
8068       return reloc_type == 3; /* R_M32C_32.  */
8069     case EM_M32R:
8070       return reloc_type == 34; /* R_M32R_32_RELA.  */
8071     case EM_MCORE:
8072       return reloc_type == 1; /* R_MCORE_ADDR32.  */
8073     case EM_CYGNUS_MEP:
8074       return reloc_type == 4; /* R_MEP_32.  */
8075     case EM_MIPS:
8076       return reloc_type == 2; /* R_MIPS_32.  */
8077     case EM_MMIX:
8078       return reloc_type == 4; /* R_MMIX_32.  */
8079     case EM_CYGNUS_MN10200:
8080     case EM_MN10200:
8081       return reloc_type == 1; /* R_MN10200_32.  */
8082     case EM_CYGNUS_MN10300:
8083     case EM_MN10300:
8084       return reloc_type == 1; /* R_MN10300_32.  */
8085     case EM_MSP430_OLD:
8086     case EM_MSP430:
8087       return reloc_type == 1; /* R_MSP43_32.  */
8088     case EM_MT:
8089       return reloc_type == 2; /* R_MT_32.  */
8090     case EM_ALTERA_NIOS2:
8091     case EM_NIOS32:
8092       return reloc_type == 1; /* R_NIOS_32.  */
8093     case EM_OPENRISC:
8094     case EM_OR32:
8095       return reloc_type == 1; /* R_OR32_32.  */
8096     case EM_PARISC:
8097       return reloc_type == 1; /* R_PARISC_DIR32.  */
8098     case EM_PJ:
8099     case EM_PJ_OLD:
8100       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
8101     case EM_PPC64:
8102       return reloc_type == 1; /* R_PPC64_ADDR32.  */
8103     case EM_PPC:
8104       return reloc_type == 1; /* R_PPC_ADDR32.  */
8105     case EM_S370:
8106       return reloc_type == 1; /* R_I370_ADDR31.  */
8107     case EM_S390_OLD:
8108     case EM_S390:
8109       return reloc_type == 4; /* R_S390_32.  */
8110     case EM_SCORE:
8111       return reloc_type == 8; /* R_SCORE_ABS32.  */
8112     case EM_SH:
8113       return reloc_type == 1; /* R_SH_DIR32.  */
8114     case EM_SPARC32PLUS:
8115     case EM_SPARCV9:
8116     case EM_SPARC:
8117       return reloc_type == 3 /* R_SPARC_32.  */
8118         || reloc_type == 23; /* R_SPARC_UA32.  */
8119     case EM_SPU:
8120       return reloc_type == 6; /* R_SPU_ADDR32 */
8121     case EM_CYGNUS_V850:
8122     case EM_V850:
8123       return reloc_type == 6; /* R_V850_ABS32.  */
8124     case EM_VAX:
8125       return reloc_type == 1; /* R_VAX_32.  */
8126     case EM_X86_64:
8127       return reloc_type == 10; /* R_X86_64_32.  */
8128     case EM_XSTORMY16:
8129       return reloc_type == 1; /* R_XSTROMY16_32.  */
8130     case EM_XTENSA_OLD:
8131     case EM_XTENSA:
8132       return reloc_type == 1; /* R_XTENSA_32.  */
8133
8134     default:
8135       error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8136              elf_header.e_machine);
8137       abort ();
8138     }
8139 }
8140
8141 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8142    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
8143
8144 static bfd_boolean
8145 is_32bit_pcrel_reloc (unsigned int reloc_type)
8146 {
8147   switch (elf_header.e_machine)
8148     {
8149     case EM_386:
8150     case EM_486:
8151       return reloc_type == 2;  /* R_386_PC32.  */
8152     case EM_68K:
8153       return reloc_type == 4;  /* R_68K_PC32.  */
8154     case EM_ALPHA:
8155       return reloc_type == 10; /* R_ALPHA_SREL32.  */
8156     case EM_ARM:
8157       return reloc_type == 3;  /* R_ARM_REL32 */
8158     case EM_PARISC:
8159       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
8160     case EM_PPC:
8161       return reloc_type == 26; /* R_PPC_REL32.  */
8162     case EM_PPC64:
8163       return reloc_type == 26; /* R_PPC64_REL32.  */
8164     case EM_S390_OLD:
8165     case EM_S390:
8166       return reloc_type == 5;  /* R_390_PC32.  */
8167     case EM_SH:
8168       return reloc_type == 2;  /* R_SH_REL32.  */
8169     case EM_SPARC32PLUS:
8170     case EM_SPARCV9:
8171     case EM_SPARC:
8172       return reloc_type == 6;  /* R_SPARC_DISP32.  */
8173     case EM_SPU:
8174       return reloc_type == 13; /* R_SPU_REL32.  */
8175     case EM_X86_64:
8176       return reloc_type == 2;  /* R_X86_64_PC32.  */
8177     case EM_XTENSA_OLD:
8178     case EM_XTENSA:
8179       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
8180     default:
8181       /* Do not abort or issue an error message here.  Not all targets use
8182          pc-relative 32-bit relocs in their DWARF debug information and we
8183          have already tested for target coverage in is_32bit_abs_reloc.  A
8184          more helpful warning message will be generated by
8185          debug_apply_relocations anyway, so just return.  */
8186       return FALSE;
8187     }
8188 }
8189
8190 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8191    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
8192
8193 static bfd_boolean
8194 is_64bit_abs_reloc (unsigned int reloc_type)
8195 {
8196   switch (elf_header.e_machine)
8197     {
8198     case EM_ALPHA:
8199       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
8200     case EM_IA_64:
8201       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
8202     case EM_PARISC:
8203       return reloc_type == 80; /* R_PARISC_DIR64.  */
8204     case EM_PPC64:
8205       return reloc_type == 38; /* R_PPC64_ADDR64.  */
8206     case EM_SPARC32PLUS:
8207     case EM_SPARCV9:
8208     case EM_SPARC:
8209       return reloc_type == 54; /* R_SPARC_UA64.  */
8210     case EM_X86_64:
8211       return reloc_type == 1; /* R_X86_64_64.  */
8212     case EM_S390_OLD:
8213     case EM_S390:
8214       return reloc_type == 22;  /* R_S390_64 */
8215     case EM_MIPS:
8216       return reloc_type == 18;  /* R_MIPS_64 */
8217     default:
8218       return FALSE;
8219     }
8220 }
8221
8222 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
8223    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
8224
8225 static bfd_boolean
8226 is_64bit_pcrel_reloc (unsigned int reloc_type)
8227 {
8228   switch (elf_header.e_machine)
8229     {
8230     case EM_ALPHA:
8231       return reloc_type == 11; /* R_ALPHA_SREL64 */
8232     case EM_IA_64:
8233       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB */
8234     case EM_PARISC:
8235       return reloc_type == 72; /* R_PARISC_PCREL64 */
8236     case EM_PPC64:
8237       return reloc_type == 44; /* R_PPC64_REL64 */
8238     case EM_SPARC32PLUS:
8239     case EM_SPARCV9:
8240     case EM_SPARC:
8241       return reloc_type == 46; /* R_SPARC_DISP64 */
8242     case EM_X86_64:
8243       return reloc_type == 24; /* R_X86_64_PC64 */
8244     case EM_S390_OLD:
8245     case EM_S390:
8246       return reloc_type == 23;  /* R_S390_PC64 */
8247     default:
8248       return FALSE;
8249     }
8250 }
8251
8252 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8253    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
8254
8255 static bfd_boolean
8256 is_16bit_abs_reloc (unsigned int reloc_type)
8257 {
8258   switch (elf_header.e_machine)
8259     {
8260     case EM_AVR_OLD:
8261     case EM_AVR:
8262       return reloc_type == 4; /* R_AVR_16.  */
8263     case EM_CYGNUS_D10V:
8264     case EM_D10V:
8265       return reloc_type == 3; /* R_D10V_16.  */
8266     case EM_H8S:
8267     case EM_H8_300:
8268     case EM_H8_300H:
8269       return reloc_type == R_H8_DIR16;
8270     case EM_IP2K_OLD:
8271     case EM_IP2K:
8272       return reloc_type == 1; /* R_IP2K_16.  */
8273     case EM_M32C_OLD:
8274     case EM_M32C:
8275       return reloc_type == 1; /* R_M32C_16 */
8276     case EM_MSP430_OLD:
8277     case EM_MSP430:
8278       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
8279     case EM_ALTERA_NIOS2:
8280     case EM_NIOS32:
8281       return reloc_type == 9; /* R_NIOS_16.  */
8282     default:
8283       return FALSE;
8284     }
8285 }
8286
8287 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
8288    relocation entries (possibly formerly used for SHT_GROUP sections).  */
8289
8290 static bfd_boolean
8291 is_none_reloc (unsigned int reloc_type)
8292 {
8293   switch (elf_header.e_machine)
8294     {
8295     case EM_68K:
8296       return reloc_type == 0; /* R_68K_NONE.  */
8297     case EM_386:
8298       return reloc_type == 0; /* R_386_NONE.  */
8299     case EM_SPARC32PLUS:
8300     case EM_SPARCV9:
8301     case EM_SPARC:
8302       return reloc_type == 0; /* R_SPARC_NONE.  */
8303     case EM_MIPS:
8304       return reloc_type == 0; /* R_MIPS_NONE.  */
8305     case EM_PARISC:
8306       return reloc_type == 0; /* R_PARISC_NONE.  */
8307     case EM_ALPHA:
8308       return reloc_type == 0; /* R_ALPHA_NONE.  */
8309     case EM_PPC:
8310       return reloc_type == 0; /* R_PPC_NONE.  */
8311     case EM_PPC64:
8312       return reloc_type == 0; /* R_PPC64_NONE.  */
8313     case EM_ARM:
8314       return reloc_type == 0; /* R_ARM_NONE.  */
8315     case EM_IA_64:
8316       return reloc_type == 0; /* R_IA64_NONE.  */
8317     case EM_SH:
8318       return reloc_type == 0; /* R_SH_NONE.  */
8319     case EM_S390_OLD:
8320     case EM_S390:
8321       return reloc_type == 0; /* R_390_NONE.  */
8322     case EM_CRIS:
8323       return reloc_type == 0; /* R_CRIS_NONE.  */
8324     case EM_X86_64:
8325       return reloc_type == 0; /* R_X86_64_NONE.  */
8326     case EM_MN10300:
8327       return reloc_type == 0; /* R_MN10300_NONE.  */
8328     case EM_M32R:
8329       return reloc_type == 0; /* R_M32R_NONE.  */
8330     }
8331   return FALSE;
8332 }
8333
8334 /* Uncompresses a section that was compressed using zlib, in place.
8335  * This is a copy of bfd_uncompress_section_contents, in bfd/compress.c  */
8336
8337 static int
8338 uncompress_section_contents (unsigned char **buffer, dwarf_size_type *size)
8339 {
8340 #ifndef HAVE_ZLIB_H
8341   /* These are just to quiet gcc.  */
8342   buffer = 0;
8343   size = 0;
8344   return FALSE;
8345 #else
8346   dwarf_size_type compressed_size = *size;
8347   unsigned char* compressed_buffer = *buffer;
8348   dwarf_size_type uncompressed_size;
8349   unsigned char* uncompressed_buffer;
8350   z_stream strm;
8351   int rc;
8352   dwarf_size_type header_size = 12;
8353
8354   /* Read the zlib header.  In this case, it should be "ZLIB" followed
8355      by the uncompressed section size, 8 bytes in big-endian order.  */
8356   if (compressed_size < header_size
8357       || ! streq ((char*) compressed_buffer, "ZLIB"))
8358     return 0;
8359   uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
8360   uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
8361   uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
8362   uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
8363   uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
8364   uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
8365   uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
8366   uncompressed_size += compressed_buffer[11];
8367
8368   /* It is possible the section consists of several compressed
8369      buffers concatenated together, so we uncompress in a loop.  */
8370   strm.zalloc = NULL;
8371   strm.zfree = NULL;
8372   strm.opaque = NULL;
8373   strm.avail_in = compressed_size - header_size;
8374   strm.next_in = (Bytef*) compressed_buffer + header_size;
8375   strm.avail_out = uncompressed_size;
8376   uncompressed_buffer = xmalloc (uncompressed_size);
8377
8378   rc = inflateInit (&strm);
8379   while (strm.avail_in > 0)
8380     {
8381       if (rc != Z_OK)
8382         goto fail;
8383       strm.next_out = ((Bytef*) uncompressed_buffer
8384                        + (uncompressed_size - strm.avail_out));
8385       rc = inflate (&strm, Z_FINISH);
8386       if (rc != Z_STREAM_END)
8387         goto fail;
8388       rc = inflateReset (&strm);
8389     }
8390   rc = inflateEnd (&strm);
8391   if (rc != Z_OK
8392       || strm.avail_out != 0)
8393     goto fail;
8394
8395   free (compressed_buffer);
8396   *buffer = uncompressed_buffer;
8397   *size = uncompressed_size;
8398   return 1;
8399
8400  fail:
8401   free (uncompressed_buffer);
8402   return 0;
8403 #endif  /* HAVE_ZLIB_H */
8404 }
8405
8406 /* Apply relocations to a debug section.  */
8407
8408 static void
8409 debug_apply_relocations (void *file,
8410                          Elf_Internal_Shdr *section,
8411                          unsigned char *start)
8412 {
8413   Elf_Internal_Shdr *relsec;
8414   unsigned char *end = start + section->sh_size;
8415
8416   if (elf_header.e_type != ET_REL)
8417     return;
8418
8419   /* Find the reloc section associated with the debug section.  */
8420   for (relsec = section_headers;
8421        relsec < section_headers + elf_header.e_shnum;
8422        ++relsec)
8423     {
8424       bfd_boolean is_rela;
8425       unsigned long num_relocs;
8426       Elf_Internal_Rela *relocs, *rp;
8427       Elf_Internal_Shdr *symsec;
8428       Elf_Internal_Sym *symtab;
8429       Elf_Internal_Sym *sym;
8430
8431       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
8432           || relsec->sh_info >= elf_header.e_shnum
8433           || section_headers + relsec->sh_info != section
8434           || relsec->sh_size == 0
8435           || relsec->sh_link >= elf_header.e_shnum)
8436         continue;
8437
8438       is_rela = relsec->sh_type == SHT_RELA;
8439
8440       if (is_rela)
8441         {
8442           if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
8443                                   & relocs, & num_relocs))
8444             return;
8445         }
8446       else
8447         {
8448           if (!slurp_rel_relocs (file, relsec->sh_offset, relsec->sh_size,
8449                                  & relocs, & num_relocs))
8450             return;
8451         }
8452
8453       /* SH uses RELA but uses in place value instead of the addend field.  */
8454       if (elf_header.e_machine == EM_SH)
8455         is_rela = FALSE;
8456
8457       symsec = section_headers + relsec->sh_link;
8458       symtab = GET_ELF_SYMBOLS (file, symsec);
8459
8460       for (rp = relocs; rp < relocs + num_relocs; ++rp)
8461         {
8462           bfd_vma         addend;
8463           unsigned int    reloc_type;
8464           unsigned int    reloc_size;
8465           unsigned char * loc;
8466
8467           reloc_type = get_reloc_type (rp->r_info);
8468
8469           if (is_none_reloc (reloc_type))
8470             continue;
8471
8472           if (is_32bit_abs_reloc (reloc_type)
8473               || is_32bit_pcrel_reloc (reloc_type))
8474             reloc_size = 4;
8475           else if (is_64bit_abs_reloc (reloc_type)
8476                    || is_64bit_pcrel_reloc (reloc_type))
8477             reloc_size = 8;
8478           else if (is_16bit_abs_reloc (reloc_type))
8479             reloc_size = 2;
8480           else
8481             {
8482               warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8483                     reloc_type, SECTION_NAME (section));
8484               continue;
8485             }
8486
8487           loc = start + rp->r_offset;
8488           if ((loc + reloc_size) > end)
8489             {
8490               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8491                     (unsigned long) rp->r_offset,
8492                     SECTION_NAME (section));
8493               continue;
8494             }
8495
8496           sym = symtab + get_reloc_symindex (rp->r_info);
8497
8498           /* If the reloc has a symbol associated with it,
8499              make sure that it is of an appropriate type.  */
8500           if (sym != symtab
8501               && ELF_ST_TYPE (sym->st_info) != STT_SECTION
8502               /* Relocations against symbols without type can happen.
8503                  Gcc -feliminate-dwarf2-dups may generate symbols
8504                  without type for debug info.  */
8505               && ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
8506               /* Relocations against object symbols can happen,
8507                  eg when referencing a global array.  For an
8508                  example of this see the _clz.o binary in libgcc.a.  */
8509               && ELF_ST_TYPE (sym->st_info) != STT_OBJECT)
8510             {
8511               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8512                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
8513                     (long int)(rp - relocs),
8514                     SECTION_NAME (relsec));
8515               continue;
8516             }
8517
8518           addend = is_rela ? rp->r_addend : byte_get (loc, reloc_size);
8519
8520           if (is_32bit_pcrel_reloc (reloc_type)
8521               || is_64bit_pcrel_reloc (reloc_type))
8522             {
8523               /* On HPPA, all pc-relative relocations are biased by 8.  */
8524               if (elf_header.e_machine == EM_PARISC)
8525                 addend -= 8;
8526               byte_put (loc, (addend + sym->st_value) - rp->r_offset,
8527                         reloc_size);
8528             }
8529           else
8530             byte_put (loc, addend + sym->st_value, reloc_size);
8531         }
8532
8533       free (symtab);
8534       free (relocs);
8535       break;
8536     }
8537 }
8538
8539 static int
8540 load_specific_debug_section (enum dwarf_section_display_enum debug,
8541                              Elf_Internal_Shdr *sec, void *file)
8542 {
8543   struct dwarf_section *section = &debug_displays [debug].section;
8544   char buf [64];
8545   int section_is_compressed;
8546
8547   /* If it is already loaded, do nothing.  */
8548   if (section->start != NULL)
8549     return 1;
8550
8551   section_is_compressed = section->name == section->compressed_name;
8552
8553   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
8554   section->address = sec->sh_addr;
8555   section->size = sec->sh_size;
8556   section->start = get_data (NULL, file, sec->sh_offset, 1,
8557                              sec->sh_size, buf);
8558   if (section->start == NULL)
8559     return 0;
8560
8561   if (section_is_compressed)
8562     if (! uncompress_section_contents (&section->start, &section->size))
8563       return 0;
8564
8565   if (debug_displays [debug].relocate)
8566     debug_apply_relocations (file, sec, section->start);
8567
8568   return 1;
8569 }
8570
8571 int
8572 load_debug_section (enum dwarf_section_display_enum debug, void *file)
8573 {
8574   struct dwarf_section *section = &debug_displays [debug].section;
8575   Elf_Internal_Shdr *sec;
8576
8577   /* Locate the debug section.  */
8578   sec = find_section (section->uncompressed_name);
8579   if (sec != NULL)
8580     section->name = section->uncompressed_name;
8581   else
8582     {
8583       sec = find_section (section->compressed_name);
8584       if (sec != NULL)
8585         section->name = section->compressed_name;
8586     }
8587   if (sec == NULL)
8588     return 0;
8589
8590   return load_specific_debug_section (debug, sec, file);
8591 }
8592
8593 void
8594 free_debug_section (enum dwarf_section_display_enum debug)
8595 {
8596   struct dwarf_section *section = &debug_displays [debug].section;
8597
8598   if (section->start == NULL)
8599     return;
8600
8601   free ((char *) section->start);
8602   section->start = NULL;
8603   section->address = 0;
8604   section->size = 0;
8605 }
8606
8607 static int
8608 display_debug_section (Elf_Internal_Shdr *section, FILE *file)
8609 {
8610   char *name = SECTION_NAME (section);
8611   bfd_size_type length;
8612   int result = 1;
8613   enum dwarf_section_display_enum i;
8614
8615   length = section->sh_size;
8616   if (length == 0)
8617     {
8618       printf (_("\nSection '%s' has no debugging data.\n"), name);
8619       return 0;
8620     }
8621
8622   if (const_strneq (name, ".gnu.linkonce.wi."))
8623     name = ".debug_info";
8624
8625   /* See if we know how to display the contents of this section.  */
8626   for (i = 0; i < max; i++)
8627     if (streq (debug_displays[i].section.uncompressed_name, name)
8628         || streq (debug_displays[i].section.compressed_name, name))
8629       {
8630         struct dwarf_section *sec = &debug_displays [i].section;
8631         int secondary = (section != find_section (name));
8632
8633         if (secondary)
8634           free_debug_section (i);
8635
8636         if (streq (debug_displays[i].section.uncompressed_name, name))
8637           sec->name = sec->uncompressed_name;
8638         else
8639           sec->name = sec->compressed_name;
8640         if (load_specific_debug_section (i, section, file))
8641           {
8642             result &= debug_displays[i].display (sec, file);
8643
8644             if (secondary || (i != info && i != abbrev))
8645               free_debug_section (i);
8646           }
8647
8648         break;
8649       }
8650
8651   if (i == max)
8652     {
8653       printf (_("Unrecognized debug section: %s\n"), name);
8654       result = 0;
8655     }
8656
8657   return result;
8658 }
8659
8660 /* Set DUMP_SECTS for all sections where dumps were requested
8661    based on section name.  */
8662
8663 static void
8664 initialise_dumps_byname (void)
8665 {
8666   struct dump_list_entry *cur;
8667
8668   for (cur = dump_sects_byname; cur; cur = cur->next)
8669     {
8670       unsigned int i;
8671       int any;
8672
8673       for (i = 0, any = 0; i < elf_header.e_shnum; i++)
8674         if (streq (SECTION_NAME (section_headers + i), cur->name))
8675           {
8676             request_dump_bynumber (i, cur->type);
8677             any = 1;
8678           }
8679
8680       if (!any)
8681         warn (_("Section '%s' was not dumped because it does not exist!\n"),
8682               cur->name);
8683     }
8684 }
8685
8686 static void
8687 process_section_contents (FILE *file)
8688 {
8689   Elf_Internal_Shdr *section;
8690   unsigned int i;
8691
8692   if (! do_dump)
8693     return;
8694
8695   initialise_dumps_byname ();
8696
8697   for (i = 0, section = section_headers;
8698        i < elf_header.e_shnum && i < num_dump_sects;
8699        i++, section++)
8700     {
8701 #ifdef SUPPORT_DISASSEMBLY
8702       if (dump_sects[i] & DISASS_DUMP)
8703         disassemble_section (section, file);
8704 #endif
8705       if (dump_sects[i] & HEX_DUMP)
8706         dump_section_as_bytes (section, file);
8707
8708       if (dump_sects[i] & DEBUG_DUMP)
8709         display_debug_section (section, file);
8710
8711       if (dump_sects[i] & STRING_DUMP)
8712         dump_section_as_strings (section, file);
8713     }
8714
8715   /* Check to see if the user requested a
8716      dump of a section that does not exist.  */
8717   while (i++ < num_dump_sects)
8718     if (dump_sects[i])
8719       warn (_("Section %d was not dumped because it does not exist!\n"), i);
8720 }
8721
8722 static void
8723 process_mips_fpe_exception (int mask)
8724 {
8725   if (mask)
8726     {
8727       int first = 1;
8728       if (mask & OEX_FPU_INEX)
8729         fputs ("INEX", stdout), first = 0;
8730       if (mask & OEX_FPU_UFLO)
8731         printf ("%sUFLO", first ? "" : "|"), first = 0;
8732       if (mask & OEX_FPU_OFLO)
8733         printf ("%sOFLO", first ? "" : "|"), first = 0;
8734       if (mask & OEX_FPU_DIV0)
8735         printf ("%sDIV0", first ? "" : "|"), first = 0;
8736       if (mask & OEX_FPU_INVAL)
8737         printf ("%sINVAL", first ? "" : "|");
8738     }
8739   else
8740     fputs ("0", stdout);
8741 }
8742
8743 /* ARM EABI attributes section.  */
8744 typedef struct
8745 {
8746   int tag;
8747   const char *name;
8748   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
8749   int type;
8750   const char **table;
8751 } arm_attr_public_tag;
8752
8753 static const char *arm_attr_tag_CPU_arch[] =
8754   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8755    "v6K", "v7"};
8756 static const char *arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
8757 static const char *arm_attr_tag_THUMB_ISA_use[] =
8758   {"No", "Thumb-1", "Thumb-2"};
8759 static const char *arm_attr_tag_VFP_arch[] =
8760   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16"};
8761 static const char *arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1"};
8762 static const char *arm_attr_tag_NEON_arch[] = {"No", "NEONv1"};
8763 static const char *arm_attr_tag_ABI_PCS_config[] =
8764   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8765    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8766 static const char *arm_attr_tag_ABI_PCS_R9_use[] =
8767   {"V6", "SB", "TLS", "Unused"};
8768 static const char *arm_attr_tag_ABI_PCS_RW_data[] =
8769   {"Absolute", "PC-relative", "SB-relative", "None"};
8770 static const char *arm_attr_tag_ABI_PCS_RO_DATA[] =
8771   {"Absolute", "PC-relative", "None"};
8772 static const char *arm_attr_tag_ABI_PCS_GOT_use[] =
8773   {"None", "direct", "GOT-indirect"};
8774 static const char *arm_attr_tag_ABI_PCS_wchar_t[] =
8775   {"None", "??? 1", "2", "??? 3", "4"};
8776 static const char *arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
8777 static const char *arm_attr_tag_ABI_FP_denormal[] = {"Unused", "Needed"};
8778 static const char *arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
8779 static const char *arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
8780 static const char *arm_attr_tag_ABI_FP_number_model[] =
8781   {"Unused", "Finite", "RTABI", "IEEE 754"};
8782 static const char *arm_attr_tag_ABI_align8_needed[] = {"No", "Yes", "4-byte"};
8783 static const char *arm_attr_tag_ABI_align8_preserved[] =
8784   {"No", "Yes, except leaf SP", "Yes"};
8785 static const char *arm_attr_tag_ABI_enum_size[] =
8786   {"Unused", "small", "int", "forced to int"};
8787 static const char *arm_attr_tag_ABI_HardFP_use[] =
8788   {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8789 static const char *arm_attr_tag_ABI_VFP_args[] =
8790   {"AAPCS", "VFP registers", "custom"};
8791 static const char *arm_attr_tag_ABI_WMMX_args[] =
8792   {"AAPCS", "WMMX registers", "custom"};
8793 static const char *arm_attr_tag_ABI_optimization_goals[] =
8794   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8795     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8796 static const char *arm_attr_tag_ABI_FP_optimization_goals[] =
8797   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8798     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8799
8800 #define LOOKUP(id, name) \
8801   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8802 static arm_attr_public_tag arm_attr_public_tags[] =
8803 {
8804   {4, "CPU_raw_name", 1, NULL},
8805   {5, "CPU_name", 1, NULL},
8806   LOOKUP(6, CPU_arch),
8807   {7, "CPU_arch_profile", 0, NULL},
8808   LOOKUP(8, ARM_ISA_use),
8809   LOOKUP(9, THUMB_ISA_use),
8810   LOOKUP(10, VFP_arch),
8811   LOOKUP(11, WMMX_arch),
8812   LOOKUP(12, NEON_arch),
8813   LOOKUP(13, ABI_PCS_config),
8814   LOOKUP(14, ABI_PCS_R9_use),
8815   LOOKUP(15, ABI_PCS_RW_data),
8816   LOOKUP(16, ABI_PCS_RO_DATA),
8817   LOOKUP(17, ABI_PCS_GOT_use),
8818   LOOKUP(18, ABI_PCS_wchar_t),
8819   LOOKUP(19, ABI_FP_rounding),
8820   LOOKUP(20, ABI_FP_denormal),
8821   LOOKUP(21, ABI_FP_exceptions),
8822   LOOKUP(22, ABI_FP_user_exceptions),
8823   LOOKUP(23, ABI_FP_number_model),
8824   LOOKUP(24, ABI_align8_needed),
8825   LOOKUP(25, ABI_align8_preserved),
8826   LOOKUP(26, ABI_enum_size),
8827   LOOKUP(27, ABI_HardFP_use),
8828   LOOKUP(28, ABI_VFP_args),
8829   LOOKUP(29, ABI_WMMX_args),
8830   LOOKUP(30, ABI_optimization_goals),
8831   LOOKUP(31, ABI_FP_optimization_goals),
8832   {32, "compatibility", 0, NULL}
8833 };
8834 #undef LOOKUP
8835
8836 /* Read an unsigned LEB128 encoded value from p.  Set *PLEN to the number of
8837    bytes read.  */
8838 static unsigned int
8839 read_uleb128 (unsigned char *p, unsigned int *plen)
8840 {
8841   unsigned char c;
8842   unsigned int val;
8843   int shift;
8844   int len;
8845
8846   val = 0;
8847   shift = 0;
8848   len = 0;
8849   do
8850     {
8851       c = *(p++);
8852       len++;
8853       val |= ((unsigned int)c & 0x7f) << shift;
8854       shift += 7;
8855     }
8856   while (c & 0x80);
8857
8858   *plen = len;
8859   return val;
8860 }
8861
8862 static unsigned char *
8863 display_arm_attribute (unsigned char *p)
8864 {
8865   int tag;
8866   unsigned int len;
8867   int val;
8868   arm_attr_public_tag *attr;
8869   unsigned i;
8870   int type;
8871
8872   tag = read_uleb128 (p, &len);
8873   p += len;
8874   attr = NULL;
8875   for (i = 0; i < ARRAY_SIZE(arm_attr_public_tags); i++)
8876     {
8877       if (arm_attr_public_tags[i].tag == tag)
8878         {
8879           attr = &arm_attr_public_tags[i];
8880           break;
8881         }
8882     }
8883
8884   if (attr)
8885     {
8886       printf ("  Tag_%s: ", attr->name);
8887       switch (attr->type)
8888         {
8889         case 0:
8890           switch (tag)
8891             {
8892             case 7: /* Tag_CPU_arch_profile.  */
8893               val = read_uleb128 (p, &len);
8894               p += len;
8895               switch (val)
8896                 {
8897                 case 0: printf ("None\n"); break;
8898                 case 'A': printf ("Application\n"); break;
8899                 case 'R': printf ("Realtime\n"); break;
8900                 case 'M': printf ("Microcontroller\n"); break;
8901                 default: printf ("??? (%d)\n", val); break;
8902                 }
8903               break;
8904
8905             case 32: /* Tag_compatibility.  */
8906               val = read_uleb128 (p, &len);
8907               p += len;
8908               printf ("flag = %d, vendor = %s\n", val, p);
8909               p += strlen((char *)p) + 1;
8910               break;
8911
8912             default:
8913               abort();
8914             }
8915           return p;
8916
8917         case 1:
8918         case 2:
8919           type = attr->type;
8920           break;
8921
8922         default:
8923           assert (attr->type & 0x80);
8924           val = read_uleb128 (p, &len);
8925           p += len;
8926           type = attr->type & 0x7f;
8927           if (val >= type)
8928             printf ("??? (%d)\n", val);
8929           else
8930             printf ("%s\n", attr->table[val]);
8931           return p;
8932         }
8933     }
8934   else
8935     {
8936       if (tag & 1)
8937         type = 1; /* String.  */
8938       else
8939         type = 2; /* uleb128.  */
8940       printf ("  Tag_unknown_%d: ", tag);
8941     }
8942
8943   if (type == 1)
8944     {
8945       printf ("\"%s\"\n", p);
8946       p += strlen((char *)p) + 1;
8947     }
8948   else
8949     {
8950       val = read_uleb128 (p, &len);
8951       p += len;
8952       printf ("%d (0x%x)\n", val, val);
8953     }
8954
8955   return p;
8956 }
8957
8958 static unsigned char *
8959 display_gnu_attribute (unsigned char * p,
8960                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
8961 {
8962   int tag;
8963   unsigned int len;
8964   int val;
8965   int type;
8966
8967   tag = read_uleb128 (p, &len);
8968   p += len;
8969
8970   /* Tag_compatibility is the only generic GNU attribute defined at
8971      present.  */
8972   if (tag == 32)
8973     {
8974       val = read_uleb128 (p, &len);
8975       p += len;
8976       printf ("flag = %d, vendor = %s\n", val, p);
8977       p += strlen ((char *) p) + 1;
8978       return p;
8979     }
8980
8981   if ((tag & 2) == 0 && display_proc_gnu_attribute)
8982     return display_proc_gnu_attribute (p, tag);
8983
8984   if (tag & 1)
8985     type = 1; /* String.  */
8986   else
8987     type = 2; /* uleb128.  */
8988   printf ("  Tag_unknown_%d: ", tag);
8989
8990   if (type == 1)
8991     {
8992       printf ("\"%s\"\n", p);
8993       p += strlen ((char *) p) + 1;
8994     }
8995   else
8996     {
8997       val = read_uleb128 (p, &len);
8998       p += len;
8999       printf ("%d (0x%x)\n", val, val);
9000     }
9001
9002   return p;
9003 }
9004
9005 static unsigned char *
9006 display_power_gnu_attribute (unsigned char *p, int tag)
9007 {
9008   int type;
9009   unsigned int len;
9010   int val;
9011
9012   if (tag == Tag_GNU_Power_ABI_FP)
9013     {
9014       val = read_uleb128 (p, &len);
9015       p += len;
9016       printf ("  Tag_GNU_Power_ABI_FP: ");
9017
9018       switch (val)
9019         {
9020         case 0:
9021           printf ("Hard or soft float\n");
9022           break;
9023         case 1:
9024           printf ("Hard float\n");
9025           break;
9026         case 2:
9027           printf ("Soft float\n");
9028           break;
9029         case 3:
9030           printf ("Single-precision hard float\n");
9031           break;
9032         default:
9033           printf ("??? (%d)\n", val);
9034           break;
9035         }
9036       return p;
9037    }
9038
9039   if (tag == Tag_GNU_Power_ABI_Vector)
9040     {
9041       val = read_uleb128 (p, &len);
9042       p += len;
9043       printf ("  Tag_GNU_Power_ABI_Vector: ");
9044       switch (val)
9045         {
9046         case 0:
9047           printf ("Any\n");
9048           break;
9049         case 1:
9050           printf ("Generic\n");
9051           break;
9052         case 2:
9053           printf ("AltiVec\n");
9054           break;
9055         case 3:
9056           printf ("SPE\n");
9057           break;
9058         default:
9059           printf ("??? (%d)\n", val);
9060           break;
9061         }
9062       return p;
9063    }
9064
9065   if (tag & 1)
9066     type = 1; /* String.  */
9067   else
9068     type = 2; /* uleb128.  */
9069   printf ("  Tag_unknown_%d: ", tag);
9070
9071   if (type == 1)
9072     {
9073       printf ("\"%s\"\n", p);
9074       p += strlen ((char *) p) + 1;
9075     }
9076   else
9077     {
9078       val = read_uleb128 (p, &len);
9079       p += len;
9080       printf ("%d (0x%x)\n", val, val);
9081     }
9082
9083   return p;
9084 }
9085
9086 static unsigned char *
9087 display_mips_gnu_attribute (unsigned char *p, int tag)
9088 {
9089   int type;
9090   unsigned int len;
9091   int val;
9092
9093   if (tag == Tag_GNU_MIPS_ABI_FP)
9094     {
9095       val = read_uleb128 (p, &len);
9096       p += len;
9097       printf ("  Tag_GNU_MIPS_ABI_FP: ");
9098
9099       switch (val)
9100         {
9101         case 0:
9102           printf ("Hard or soft float\n");
9103           break;
9104         case 1:
9105           printf ("Hard float (-mdouble-float)\n");
9106           break;
9107         case 2:
9108           printf ("Hard float (-msingle-float)\n");
9109           break;
9110         case 3:
9111           printf ("Soft float\n");
9112           break;
9113         case 4:
9114           printf ("64-bit float (-mips32r2 -mfp64)\n");
9115           break;
9116         default:
9117           printf ("??? (%d)\n", val);
9118           break;
9119         }
9120       return p;
9121    }
9122
9123   if (tag & 1)
9124     type = 1; /* String.  */
9125   else
9126     type = 2; /* uleb128.  */
9127   printf ("  Tag_unknown_%d: ", tag);
9128
9129   if (type == 1)
9130     {
9131       printf ("\"%s\"\n", p);
9132       p += strlen ((char *) p) + 1;
9133     }
9134   else
9135     {
9136       val = read_uleb128 (p, &len);
9137       p += len;
9138       printf ("%d (0x%x)\n", val, val);
9139     }
9140
9141   return p;
9142 }
9143
9144 static int
9145 process_attributes (FILE * file,
9146                     const char * public_name,
9147                     unsigned int proc_type,
9148                     unsigned char * (* display_pub_attribute) (unsigned char *),
9149                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
9150 {
9151   Elf_Internal_Shdr *sect;
9152   unsigned char *contents;
9153   unsigned char *p;
9154   unsigned char *end;
9155   bfd_vma section_len;
9156   bfd_vma len;
9157   unsigned i;
9158
9159   /* Find the section header so that we get the size.  */
9160   for (i = 0, sect = section_headers;
9161        i < elf_header.e_shnum;
9162        i++, sect++)
9163     {
9164       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
9165         continue;
9166
9167       contents = get_data (NULL, file, sect->sh_offset, 1, sect->sh_size,
9168                            _("attributes"));
9169       if (contents == NULL)
9170         continue;
9171
9172       p = contents;
9173       if (*p == 'A')
9174         {
9175           len = sect->sh_size - 1;
9176           p++;
9177
9178           while (len > 0)
9179             {
9180               int namelen;
9181               bfd_boolean public_section;
9182               bfd_boolean gnu_section;
9183
9184               section_len = byte_get (p, 4);
9185               p += 4;
9186
9187               if (section_len > len)
9188                 {
9189                   printf (_("ERROR: Bad section length (%d > %d)\n"),
9190                           (int) section_len, (int) len);
9191                   section_len = len;
9192                 }
9193
9194               len -= section_len;
9195               printf ("Attribute Section: %s\n", p);
9196
9197               if (public_name && streq ((char *) p, public_name))
9198                 public_section = TRUE;
9199               else
9200                 public_section = FALSE;
9201
9202               if (streq ((char *) p, "gnu"))
9203                 gnu_section = TRUE;
9204               else
9205                 gnu_section = FALSE;
9206
9207               namelen = strlen ((char *) p) + 1;
9208               p += namelen;
9209               section_len -= namelen + 4;
9210
9211               while (section_len > 0)
9212                 {
9213                   int tag = *(p++);
9214                   int val;
9215                   bfd_vma size;
9216
9217                   size = byte_get (p, 4);
9218                   if (size > section_len)
9219                     {
9220                       printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9221                               (int) size, (int) section_len);
9222                       size = section_len;
9223                     }
9224
9225                   section_len -= size;
9226                   end = p + size - 1;
9227                   p += 4;
9228
9229                   switch (tag)
9230                     {
9231                     case 1:
9232                       printf ("File Attributes\n");
9233                       break;
9234                     case 2:
9235                       printf ("Section Attributes:");
9236                       goto do_numlist;
9237                     case 3:
9238                       printf ("Symbol Attributes:");
9239                     do_numlist:
9240                       for (;;)
9241                         {
9242                           unsigned int i;
9243
9244                           val = read_uleb128 (p, &i);
9245                           p += i;
9246                           if (val == 0)
9247                             break;
9248                           printf (" %d", val);
9249                         }
9250                       printf ("\n");
9251                       break;
9252                     default:
9253                       printf ("Unknown tag: %d\n", tag);
9254                       public_section = FALSE;
9255                       break;
9256                     }
9257
9258                   if (public_section)
9259                     {
9260                       while (p < end)
9261                         p = display_pub_attribute (p);
9262                     }
9263                   else if (gnu_section)
9264                     {
9265                       while (p < end)
9266                         p = display_gnu_attribute (p,
9267                                                    display_proc_gnu_attribute);
9268                     }
9269                   else
9270                     {
9271                       /* ??? Do something sensible, like dump hex.  */
9272                       printf ("  Unknown section contexts\n");
9273                       p = end;
9274                     }
9275                 }
9276             }
9277         }
9278       else
9279         printf (_("Unknown format '%c'\n"), *p);
9280
9281       free (contents);
9282     }
9283   return 1;
9284 }
9285
9286 static int
9287 process_arm_specific (FILE *file)
9288 {
9289   return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
9290                              display_arm_attribute, NULL);
9291 }
9292
9293 static int
9294 process_power_specific (FILE *file)
9295 {
9296   return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
9297                              display_power_gnu_attribute);
9298 }
9299
9300 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9301    Print the Address, Access and Initial fields of an entry at VMA ADDR
9302    and return the VMA of the next entry.  */
9303
9304 static bfd_vma
9305 print_mips_got_entry (unsigned char *data, bfd_vma pltgot, bfd_vma addr)
9306 {
9307   printf ("  ");
9308   print_vma (addr, LONG_HEX);
9309   printf (" ");
9310   if (addr < pltgot + 0xfff0)
9311     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
9312   else
9313     printf ("%10s", "");
9314   printf (" ");
9315   if (data == NULL)
9316     printf ("%*s", is_32bit_elf ? 8 : 16, "<unknown>");
9317   else
9318     {
9319       bfd_vma entry;
9320
9321       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
9322       print_vma (entry, LONG_HEX);
9323     }
9324   return addr + (is_32bit_elf ? 4 : 8);
9325 }
9326
9327 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9328    PLTGOT.  Print the Address and Initial fields of an entry at VMA
9329    ADDR and return the VMA of the next entry.  */
9330
9331 static bfd_vma
9332 print_mips_pltgot_entry (unsigned char *data, bfd_vma pltgot, bfd_vma addr)
9333 {
9334   printf ("  ");
9335   print_vma (addr, LONG_HEX);
9336   printf (" ");
9337   if (data == NULL)
9338     printf ("%*s", is_32bit_elf ? 8 : 16, "<unknown>");
9339   else
9340     {
9341       bfd_vma entry;
9342
9343       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
9344       print_vma (entry, LONG_HEX);
9345     }
9346   return addr + (is_32bit_elf ? 4 : 8);
9347 }
9348
9349 static int
9350 process_mips_specific (FILE *file)
9351 {
9352   Elf_Internal_Dyn *entry;
9353   size_t liblist_offset = 0;
9354   size_t liblistno = 0;
9355   size_t conflictsno = 0;
9356   size_t options_offset = 0;
9357   size_t conflicts_offset = 0;
9358   size_t pltrelsz = 0;
9359   size_t pltrel = 0;
9360   bfd_vma pltgot = 0;
9361   bfd_vma mips_pltgot = 0;
9362   bfd_vma jmprel = 0;
9363   bfd_vma local_gotno = 0;
9364   bfd_vma gotsym = 0;
9365   bfd_vma symtabno = 0;
9366
9367   process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
9368                       display_mips_gnu_attribute);
9369
9370   /* We have a lot of special sections.  Thanks SGI!  */
9371   if (dynamic_section == NULL)
9372     /* No information available.  */
9373     return 0;
9374
9375   for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
9376     switch (entry->d_tag)
9377       {
9378       case DT_MIPS_LIBLIST:
9379         liblist_offset
9380           = offset_from_vma (file, entry->d_un.d_val,
9381                              liblistno * sizeof (Elf32_External_Lib));
9382         break;
9383       case DT_MIPS_LIBLISTNO:
9384         liblistno = entry->d_un.d_val;
9385         break;
9386       case DT_MIPS_OPTIONS:
9387         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
9388         break;
9389       case DT_MIPS_CONFLICT:
9390         conflicts_offset
9391           = offset_from_vma (file, entry->d_un.d_val,
9392                              conflictsno * sizeof (Elf32_External_Conflict));
9393         break;
9394       case DT_MIPS_CONFLICTNO:
9395         conflictsno = entry->d_un.d_val;
9396         break;
9397       case DT_PLTGOT:
9398         pltgot = entry->d_un.d_ptr;
9399         break;
9400       case DT_MIPS_LOCAL_GOTNO:
9401         local_gotno = entry->d_un.d_val;
9402         break;
9403       case DT_MIPS_GOTSYM:
9404         gotsym = entry->d_un.d_val;
9405         break;
9406       case DT_MIPS_SYMTABNO:
9407         symtabno = entry->d_un.d_val;
9408         break;
9409       case DT_MIPS_PLTGOT:
9410         mips_pltgot = entry->d_un.d_ptr;
9411         break;
9412       case DT_PLTREL:
9413         pltrel = entry->d_un.d_val;
9414         break;
9415       case DT_PLTRELSZ:
9416         pltrelsz = entry->d_un.d_val;
9417         break;
9418       case DT_JMPREL:
9419         jmprel = entry->d_un.d_ptr;
9420         break;
9421       default:
9422         break;
9423       }
9424
9425   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
9426     {
9427       Elf32_External_Lib *elib;
9428       size_t cnt;
9429
9430       elib = get_data (NULL, file, liblist_offset,
9431                        liblistno, sizeof (Elf32_External_Lib),
9432                        _("liblist"));
9433       if (elib)
9434         {
9435           printf ("\nSection '.liblist' contains %lu entries:\n",
9436                   (unsigned long) liblistno);
9437           fputs ("     Library              Time Stamp          Checksum   Version Flags\n",
9438                  stdout);
9439
9440           for (cnt = 0; cnt < liblistno; ++cnt)
9441             {
9442               Elf32_Lib liblist;
9443               time_t time;
9444               char timebuf[20];
9445               struct tm *tmp;
9446
9447               liblist.l_name = BYTE_GET (elib[cnt].l_name);
9448               time = BYTE_GET (elib[cnt].l_time_stamp);
9449               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9450               liblist.l_version = BYTE_GET (elib[cnt].l_version);
9451               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9452
9453               tmp = gmtime (&time);
9454               snprintf (timebuf, sizeof (timebuf),
9455                         "%04u-%02u-%02uT%02u:%02u:%02u",
9456                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9457                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9458
9459               printf ("%3lu: ", (unsigned long) cnt);
9460               if (VALID_DYNAMIC_NAME (liblist.l_name))
9461                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
9462               else
9463                 printf ("<corrupt: %9ld>", liblist.l_name);
9464               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
9465                       liblist.l_version);
9466
9467               if (liblist.l_flags == 0)
9468                 puts (" NONE");
9469               else
9470                 {
9471                   static const struct
9472                   {
9473                     const char *name;
9474                     int bit;
9475                   }
9476                   l_flags_vals[] =
9477                   {
9478                     { " EXACT_MATCH", LL_EXACT_MATCH },
9479                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
9480                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
9481                     { " EXPORTS", LL_EXPORTS },
9482                     { " DELAY_LOAD", LL_DELAY_LOAD },
9483                     { " DELTA", LL_DELTA }
9484                   };
9485                   int flags = liblist.l_flags;
9486                   size_t fcnt;
9487
9488                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
9489                     if ((flags & l_flags_vals[fcnt].bit) != 0)
9490                       {
9491                         fputs (l_flags_vals[fcnt].name, stdout);
9492                         flags ^= l_flags_vals[fcnt].bit;
9493                       }
9494                   if (flags != 0)
9495                     printf (" %#x", (unsigned int) flags);
9496
9497                   puts ("");
9498                 }
9499             }
9500
9501           free (elib);
9502         }
9503     }
9504
9505   if (options_offset != 0)
9506     {
9507       Elf_External_Options *eopt;
9508       Elf_Internal_Shdr *sect = section_headers;
9509       Elf_Internal_Options *iopt;
9510       Elf_Internal_Options *option;
9511       size_t offset;
9512       int cnt;
9513
9514       /* Find the section header so that we get the size.  */
9515       while (sect->sh_type != SHT_MIPS_OPTIONS)
9516         ++sect;
9517
9518       eopt = get_data (NULL, file, options_offset, 1, sect->sh_size,
9519                        _("options"));
9520       if (eopt)
9521         {
9522           iopt = cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (*iopt));
9523           if (iopt == NULL)
9524             {
9525               error (_("Out of memory\n"));
9526               return 0;
9527             }
9528
9529           offset = cnt = 0;
9530           option = iopt;
9531
9532           while (offset < sect->sh_size)
9533             {
9534               Elf_External_Options *eoption;
9535
9536               eoption = (Elf_External_Options *) ((char *) eopt + offset);
9537
9538               option->kind = BYTE_GET (eoption->kind);
9539               option->size = BYTE_GET (eoption->size);
9540               option->section = BYTE_GET (eoption->section);
9541               option->info = BYTE_GET (eoption->info);
9542
9543               offset += option->size;
9544
9545               ++option;
9546               ++cnt;
9547             }
9548
9549           printf (_("\nSection '%s' contains %d entries:\n"),
9550                   SECTION_NAME (sect), cnt);
9551
9552           option = iopt;
9553
9554           while (cnt-- > 0)
9555             {
9556               size_t len;
9557
9558               switch (option->kind)
9559                 {
9560                 case ODK_NULL:
9561                   /* This shouldn't happen.  */
9562                   printf (" NULL       %d %lx", option->section, option->info);
9563                   break;
9564                 case ODK_REGINFO:
9565                   printf (" REGINFO    ");
9566                   if (elf_header.e_machine == EM_MIPS)
9567                     {
9568                       /* 32bit form.  */
9569                       Elf32_External_RegInfo *ereg;
9570                       Elf32_RegInfo reginfo;
9571
9572                       ereg = (Elf32_External_RegInfo *) (option + 1);
9573                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9574                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9575                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9576                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9577                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9578                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
9579
9580                       printf ("GPR %08lx  GP 0x%lx\n",
9581                               reginfo.ri_gprmask,
9582                               (unsigned long) reginfo.ri_gp_value);
9583                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
9584                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9585                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9586                     }
9587                   else
9588                     {
9589                       /* 64 bit form.  */
9590                       Elf64_External_RegInfo *ereg;
9591                       Elf64_Internal_RegInfo reginfo;
9592
9593                       ereg = (Elf64_External_RegInfo *) (option + 1);
9594                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
9595                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9596                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9597                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9598                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9599                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
9600
9601                       printf ("GPR %08lx  GP 0x",
9602                               reginfo.ri_gprmask);
9603                       printf_vma (reginfo.ri_gp_value);
9604                       printf ("\n");
9605
9606                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
9607                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9608                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9609                     }
9610                   ++option;
9611                   continue;
9612                 case ODK_EXCEPTIONS:
9613                   fputs (" EXCEPTIONS fpe_min(", stdout);
9614                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
9615                   fputs (") fpe_max(", stdout);
9616                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
9617                   fputs (")", stdout);
9618
9619                   if (option->info & OEX_PAGE0)
9620                     fputs (" PAGE0", stdout);
9621                   if (option->info & OEX_SMM)
9622                     fputs (" SMM", stdout);
9623                   if (option->info & OEX_FPDBUG)
9624                     fputs (" FPDBUG", stdout);
9625                   if (option->info & OEX_DISMISS)
9626                     fputs (" DISMISS", stdout);
9627                   break;
9628                 case ODK_PAD:
9629                   fputs (" PAD       ", stdout);
9630                   if (option->info & OPAD_PREFIX)
9631                     fputs (" PREFIX", stdout);
9632                   if (option->info & OPAD_POSTFIX)
9633                     fputs (" POSTFIX", stdout);
9634                   if (option->info & OPAD_SYMBOL)
9635                     fputs (" SYMBOL", stdout);
9636                   break;
9637                 case ODK_HWPATCH:
9638                   fputs (" HWPATCH   ", stdout);
9639                   if (option->info & OHW_R4KEOP)
9640                     fputs (" R4KEOP", stdout);
9641                   if (option->info & OHW_R8KPFETCH)
9642                     fputs (" R8KPFETCH", stdout);
9643                   if (option->info & OHW_R5KEOP)
9644                     fputs (" R5KEOP", stdout);
9645                   if (option->info & OHW_R5KCVTL)
9646                     fputs (" R5KCVTL", stdout);
9647                   break;
9648                 case ODK_FILL:
9649                   fputs (" FILL       ", stdout);
9650                   /* XXX Print content of info word?  */
9651                   break;
9652                 case ODK_TAGS:
9653                   fputs (" TAGS       ", stdout);
9654                   /* XXX Print content of info word?  */
9655                   break;
9656                 case ODK_HWAND:
9657                   fputs (" HWAND     ", stdout);
9658                   if (option->info & OHWA0_R4KEOP_CHECKED)
9659                     fputs (" R4KEOP_CHECKED", stdout);
9660                   if (option->info & OHWA0_R4KEOP_CLEAN)
9661                     fputs (" R4KEOP_CLEAN", stdout);
9662                   break;
9663                 case ODK_HWOR:
9664                   fputs (" HWOR      ", stdout);
9665                   if (option->info & OHWA0_R4KEOP_CHECKED)
9666                     fputs (" R4KEOP_CHECKED", stdout);
9667                   if (option->info & OHWA0_R4KEOP_CLEAN)
9668                     fputs (" R4KEOP_CLEAN", stdout);
9669                   break;
9670                 case ODK_GP_GROUP:
9671                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
9672                           option->info & OGP_GROUP,
9673                           (option->info & OGP_SELF) >> 16);
9674                   break;
9675                 case ODK_IDENT:
9676                   printf (" IDENT     %#06lx  self-contained %#06lx",
9677                           option->info & OGP_GROUP,
9678                           (option->info & OGP_SELF) >> 16);
9679                   break;
9680                 default:
9681                   /* This shouldn't happen.  */
9682                   printf (" %3d ???     %d %lx",
9683                           option->kind, option->section, option->info);
9684                   break;
9685                 }
9686
9687               len = sizeof (*eopt);
9688               while (len < option->size)
9689                 if (((char *) option)[len] >= ' '
9690                     && ((char *) option)[len] < 0x7f)
9691                   printf ("%c", ((char *) option)[len++]);
9692                 else
9693                   printf ("\\%03o", ((char *) option)[len++]);
9694
9695               fputs ("\n", stdout);
9696               ++option;
9697             }
9698
9699           free (eopt);
9700         }
9701     }
9702
9703   if (conflicts_offset != 0 && conflictsno != 0)
9704     {
9705       Elf32_Conflict *iconf;
9706       size_t cnt;
9707
9708       if (dynamic_symbols == NULL)
9709         {
9710           error (_("conflict list found without a dynamic symbol table\n"));
9711           return 0;
9712         }
9713
9714       iconf = cmalloc (conflictsno, sizeof (*iconf));
9715       if (iconf == NULL)
9716         {
9717           error (_("Out of memory\n"));
9718           return 0;
9719         }
9720
9721       if (is_32bit_elf)
9722         {
9723           Elf32_External_Conflict *econf32;
9724
9725           econf32 = get_data (NULL, file, conflicts_offset,
9726                               conflictsno, sizeof (*econf32), _("conflict"));
9727           if (!econf32)
9728             return 0;
9729
9730           for (cnt = 0; cnt < conflictsno; ++cnt)
9731             iconf[cnt] = BYTE_GET (econf32[cnt]);
9732
9733           free (econf32);
9734         }
9735       else
9736         {
9737           Elf64_External_Conflict *econf64;
9738
9739           econf64 = get_data (NULL, file, conflicts_offset,
9740                               conflictsno, sizeof (*econf64), _("conflict"));
9741           if (!econf64)
9742             return 0;
9743
9744           for (cnt = 0; cnt < conflictsno; ++cnt)
9745             iconf[cnt] = BYTE_GET (econf64[cnt]);
9746
9747           free (econf64);
9748         }
9749
9750       printf (_("\nSection '.conflict' contains %lu entries:\n"),
9751               (unsigned long) conflictsno);
9752       puts (_("  Num:    Index       Value  Name"));
9753
9754       for (cnt = 0; cnt < conflictsno; ++cnt)
9755         {
9756           Elf_Internal_Sym *psym = & dynamic_symbols[iconf[cnt]];
9757
9758           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
9759           print_vma (psym->st_value, FULL_HEX);
9760           putchar (' ');
9761           if (VALID_DYNAMIC_NAME (psym->st_name))
9762             print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9763           else
9764             printf ("<corrupt: %14ld>", psym->st_name);
9765           putchar ('\n');
9766         }
9767
9768       free (iconf);
9769     }
9770
9771   if (pltgot != 0 && local_gotno != 0)
9772     {
9773       bfd_vma entry, local_end, global_end;
9774       size_t i, offset;
9775       unsigned char *data;
9776       int addr_size;
9777
9778       entry = pltgot;
9779       addr_size = (is_32bit_elf ? 4 : 8);
9780       local_end = pltgot + local_gotno * addr_size;
9781       global_end = local_end + (symtabno - gotsym) * addr_size;
9782
9783       offset = offset_from_vma (file, pltgot, global_end - pltgot);
9784       data = get_data (NULL, file, offset, global_end - pltgot, 1, _("GOT"));
9785       printf (_("\nPrimary GOT:\n"));
9786       printf (_(" Canonical gp value: "));
9787       print_vma (pltgot + 0x7ff0, LONG_HEX);
9788       printf ("\n\n");
9789
9790       printf (_(" Reserved entries:\n"));
9791       printf (_("  %*s %10s %*s Purpose\n"),
9792               addr_size * 2, "Address", "Access",
9793               addr_size * 2, "Initial");
9794       entry = print_mips_got_entry (data, pltgot, entry);
9795       printf (" Lazy resolver\n");
9796       if (data
9797           && (byte_get (data + entry - pltgot, addr_size)
9798               >> (addr_size * 8 - 1)) != 0)
9799         {
9800           entry = print_mips_got_entry (data, pltgot, entry);
9801           printf (" Module pointer (GNU extension)\n");
9802         }
9803       printf ("\n");
9804
9805       if (entry < local_end)
9806         {
9807           printf (_(" Local entries:\n"));
9808           printf (_("  %*s %10s %*s\n"),
9809                   addr_size * 2, "Address", "Access",
9810                   addr_size * 2, "Initial");
9811           while (entry < local_end)
9812             {
9813               entry = print_mips_got_entry (data, pltgot, entry);
9814               printf ("\n");
9815             }
9816           printf ("\n");
9817         }
9818
9819       if (gotsym < symtabno)
9820         {
9821           int sym_width;
9822
9823           printf (_(" Global entries:\n"));
9824           printf (_("  %*s %10s %*s %*s %-7s %3s %s\n"),
9825                   addr_size * 2, "Address", "Access",
9826                   addr_size * 2, "Initial",
9827                   addr_size * 2, "Sym.Val.", "Type", "Ndx", "Name");
9828           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
9829           for (i = gotsym; i < symtabno; i++)
9830             {
9831               Elf_Internal_Sym *psym;
9832
9833               psym = dynamic_symbols + i;
9834               entry = print_mips_got_entry (data, pltgot, entry);
9835               printf (" ");
9836               print_vma (psym->st_value, LONG_HEX);
9837               printf (" %-7s %3s ",
9838                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
9839                       get_symbol_index_type (psym->st_shndx));
9840               if (VALID_DYNAMIC_NAME (psym->st_name))
9841                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
9842               else
9843                 printf ("<corrupt: %14ld>", psym->st_name);
9844               printf ("\n");
9845             }
9846           printf ("\n");
9847         }
9848
9849       if (data)
9850         free (data);
9851     }
9852
9853   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
9854     {
9855       bfd_vma entry, end;
9856       size_t offset, rel_offset;
9857       unsigned long count, i;
9858       unsigned char *data;
9859       int addr_size, sym_width;
9860       Elf_Internal_Rela *rels;
9861
9862       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
9863       if (pltrel == DT_RELA)
9864         {
9865           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
9866             return 0;
9867         }
9868       else
9869         {
9870           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
9871             return 0;
9872         }
9873
9874       entry = mips_pltgot;
9875       addr_size = (is_32bit_elf ? 4 : 8);
9876       end = mips_pltgot + (2 + count) * addr_size;
9877
9878       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
9879       data = get_data (NULL, file, offset, end - mips_pltgot, 1, _("PLT GOT"));
9880       printf (_("\nPLT GOT:\n\n"));
9881       printf (_(" Reserved entries:\n"));
9882       printf (_("  %*s %*s Purpose\n"),
9883               addr_size * 2, "Address", addr_size * 2, "Initial");
9884       entry = print_mips_pltgot_entry (data, mips_pltgot, entry);
9885       printf (" PLT lazy resolver\n");
9886       entry = print_mips_pltgot_entry (data, mips_pltgot, entry);
9887       printf (" Module pointer\n");
9888       printf ("\n");
9889
9890       printf (_(" Entries:\n"));
9891       printf (_("  %*s %*s %*s %-7s %3s %s\n"),
9892               addr_size * 2, "Address",
9893               addr_size * 2, "Initial",
9894               addr_size * 2, "Sym.Val.", "Type", "Ndx", "Name");
9895       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
9896       for (i = 0; i < count; i++)
9897         {
9898           Elf_Internal_Sym *psym;
9899
9900           psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
9901           entry = print_mips_pltgot_entry (data, mips_pltgot, entry);
9902           printf (" ");
9903           print_vma (psym->st_value, LONG_HEX);
9904           printf (" %-7s %3s ",
9905                   get_symbol_type (ELF_ST_TYPE (psym->st_info)),
9906                   get_symbol_index_type (psym->st_shndx));
9907           if (VALID_DYNAMIC_NAME (psym->st_name))
9908             print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
9909           else
9910             printf ("<corrupt: %14ld>", psym->st_name);
9911           printf ("\n");
9912         }
9913       printf ("\n");
9914
9915       if (data)
9916         free (data);
9917       free (rels);
9918     }
9919
9920   return 1;
9921 }
9922
9923 static int
9924 process_gnu_liblist (FILE *file)
9925 {
9926   Elf_Internal_Shdr *section, *string_sec;
9927   Elf32_External_Lib *elib;
9928   char *strtab;
9929   size_t strtab_size;
9930   size_t cnt;
9931   unsigned i;
9932
9933   if (! do_arch)
9934     return 0;
9935
9936   for (i = 0, section = section_headers;
9937        i < elf_header.e_shnum;
9938        i++, section++)
9939     {
9940       switch (section->sh_type)
9941         {
9942         case SHT_GNU_LIBLIST:
9943           if (section->sh_link >= elf_header.e_shnum)
9944             break;
9945
9946           elib = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9947                            _("liblist"));
9948
9949           if (elib == NULL)
9950             break;
9951           string_sec = section_headers + section->sh_link;
9952
9953           strtab = get_data (NULL, file, string_sec->sh_offset, 1,
9954                              string_sec->sh_size, _("liblist string table"));
9955           strtab_size = string_sec->sh_size;
9956
9957           if (strtab == NULL
9958               || section->sh_entsize != sizeof (Elf32_External_Lib))
9959             {
9960               free (elib);
9961               break;
9962             }
9963
9964           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9965                   SECTION_NAME (section),
9966                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
9967
9968           puts ("     Library              Time Stamp          Checksum   Version Flags");
9969
9970           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
9971                ++cnt)
9972             {
9973               Elf32_Lib liblist;
9974               time_t time;
9975               char timebuf[20];
9976               struct tm *tmp;
9977
9978               liblist.l_name = BYTE_GET (elib[cnt].l_name);
9979               time = BYTE_GET (elib[cnt].l_time_stamp);
9980               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9981               liblist.l_version = BYTE_GET (elib[cnt].l_version);
9982               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9983
9984               tmp = gmtime (&time);
9985               snprintf (timebuf, sizeof (timebuf),
9986                         "%04u-%02u-%02uT%02u:%02u:%02u",
9987                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9988                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9989
9990               printf ("%3lu: ", (unsigned long) cnt);
9991               if (do_wide)
9992                 printf ("%-20s", liblist.l_name < strtab_size
9993                                  ? strtab + liblist.l_name : "<corrupt>");
9994               else
9995                 printf ("%-20.20s", liblist.l_name < strtab_size
9996                                     ? strtab + liblist.l_name : "<corrupt>");
9997               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
9998                       liblist.l_version, liblist.l_flags);
9999             }
10000
10001           free (elib);
10002         }
10003     }
10004
10005   return 1;
10006 }
10007
10008 static const char *
10009 get_note_type (unsigned e_type)
10010 {
10011   static char buff[64];
10012
10013   if (elf_header.e_type == ET_CORE)
10014     switch (e_type)
10015       {
10016       case NT_AUXV:
10017         return _("NT_AUXV (auxiliary vector)");
10018       case NT_PRSTATUS:
10019         return _("NT_PRSTATUS (prstatus structure)");
10020       case NT_FPREGSET:
10021         return _("NT_FPREGSET (floating point registers)");
10022       case NT_PRPSINFO:
10023         return _("NT_PRPSINFO (prpsinfo structure)");
10024       case NT_TASKSTRUCT:
10025         return _("NT_TASKSTRUCT (task structure)");
10026       case NT_PRXFPREG:
10027         return _("NT_PRXFPREG (user_xfpregs structure)");
10028       case NT_PPC_VMX:
10029         return _("NT_PPC_VMX (ppc Altivec registers)");
10030       case NT_PPC_VSX:
10031         return _("NT_PPC_VSX (ppc VSX registers)");
10032       case NT_PSTATUS:
10033         return _("NT_PSTATUS (pstatus structure)");
10034       case NT_FPREGS:
10035         return _("NT_FPREGS (floating point registers)");
10036       case NT_PSINFO:
10037         return _("NT_PSINFO (psinfo structure)");
10038       case NT_LWPSTATUS:
10039         return _("NT_LWPSTATUS (lwpstatus_t structure)");
10040       case NT_LWPSINFO:
10041         return _("NT_LWPSINFO (lwpsinfo_t structure)");
10042       case NT_WIN32PSTATUS:
10043         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10044       default:
10045         break;
10046       }
10047   else
10048     switch (e_type)
10049       {
10050       case NT_VERSION:
10051         return _("NT_VERSION (version)");
10052       case NT_ARCH:
10053         return _("NT_ARCH (architecture)");
10054       default:
10055         break;
10056       }
10057
10058   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
10059   return buff;
10060 }
10061
10062 static const char *
10063 get_gnu_elf_note_type (unsigned e_type)
10064 {
10065   static char buff[64];
10066
10067   switch (e_type)
10068     {
10069     case NT_GNU_ABI_TAG:
10070       return _("NT_GNU_ABI_TAG (ABI version tag)");
10071     case NT_GNU_HWCAP:
10072       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10073     case NT_GNU_BUILD_ID:
10074       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
10075     case NT_GNU_GOLD_VERSION:
10076       return _("NT_GNU_GOLD_VERSION (gold version)");
10077     default:
10078       break;
10079     }
10080
10081   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
10082   return buff;
10083 }
10084
10085 static const char *
10086 get_netbsd_elfcore_note_type (unsigned e_type)
10087 {
10088   static char buff[64];
10089
10090   if (e_type == NT_NETBSDCORE_PROCINFO)
10091     {
10092       /* NetBSD core "procinfo" structure.  */
10093       return _("NetBSD procinfo structure");
10094     }
10095
10096   /* As of Jan 2002 there are no other machine-independent notes
10097      defined for NetBSD core files.  If the note type is less
10098      than the start of the machine-dependent note types, we don't
10099      understand it.  */
10100
10101   if (e_type < NT_NETBSDCORE_FIRSTMACH)
10102     {
10103       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
10104       return buff;
10105     }
10106
10107   switch (elf_header.e_machine)
10108     {
10109     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10110        and PT_GETFPREGS == mach+2.  */
10111
10112     case EM_OLD_ALPHA:
10113     case EM_ALPHA:
10114     case EM_SPARC:
10115     case EM_SPARC32PLUS:
10116     case EM_SPARCV9:
10117       switch (e_type)
10118         {
10119         case NT_NETBSDCORE_FIRSTMACH+0:
10120           return _("PT_GETREGS (reg structure)");
10121         case NT_NETBSDCORE_FIRSTMACH+2:
10122           return _("PT_GETFPREGS (fpreg structure)");
10123         default:
10124           break;
10125         }
10126       break;
10127
10128     /* On all other arch's, PT_GETREGS == mach+1 and
10129        PT_GETFPREGS == mach+3.  */
10130     default:
10131       switch (e_type)
10132         {
10133         case NT_NETBSDCORE_FIRSTMACH+1:
10134           return _("PT_GETREGS (reg structure)");
10135         case NT_NETBSDCORE_FIRSTMACH+3:
10136           return _("PT_GETFPREGS (fpreg structure)");
10137         default:
10138           break;
10139         }
10140     }
10141
10142   snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
10143             e_type - NT_NETBSDCORE_FIRSTMACH);
10144   return buff;
10145 }
10146
10147 /* Note that by the ELF standard, the name field is already null byte
10148    terminated, and namesz includes the terminating null byte.
10149    I.E. the value of namesz for the name "FSF" is 4.
10150
10151    If the value of namesz is zero, there is no name present.  */
10152 static int
10153 process_note (Elf_Internal_Note *pnote)
10154 {
10155   const char *name = pnote->namesz ? pnote->namedata : "(NONE)";
10156   const char *nt;
10157
10158   if (pnote->namesz == 0)
10159     /* If there is no note name, then use the default set of
10160        note type strings.  */
10161     nt = get_note_type (pnote->type);
10162
10163   else if (const_strneq (pnote->namedata, "GNU"))
10164     /* GNU-specific object file notes.  */
10165     nt = get_gnu_elf_note_type (pnote->type);
10166
10167   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
10168     /* NetBSD-specific core file notes.  */
10169     nt = get_netbsd_elfcore_note_type (pnote->type);
10170
10171   else if (strneq (pnote->namedata, "SPU/", 4))
10172     {
10173       /* SPU-specific core file notes.  */
10174       nt = pnote->namedata + 4;
10175       name = "SPU";
10176     }
10177
10178   else
10179     /* Don't recognize this note name; just use the default set of
10180        note type strings.  */
10181       nt = get_note_type (pnote->type);
10182
10183   printf ("  %s\t\t0x%08lx\t%s\n", name, pnote->descsz, nt);
10184   return 1;
10185 }
10186
10187
10188 static int
10189 process_corefile_note_segment (FILE *file, bfd_vma offset, bfd_vma length)
10190 {
10191   Elf_External_Note *pnotes;
10192   Elf_External_Note *external;
10193   int res = 1;
10194
10195   if (length <= 0)
10196     return 0;
10197
10198   pnotes = get_data (NULL, file, offset, 1, length, _("notes"));
10199   if (!pnotes)
10200     return 0;
10201
10202   external = pnotes;
10203
10204   printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10205           (unsigned long) offset, (unsigned long) length);
10206   printf (_("  Owner\t\tData size\tDescription\n"));
10207
10208   while (external < (Elf_External_Note *)((char *) pnotes + length))
10209     {
10210       Elf_External_Note *next;
10211       Elf_Internal_Note inote;
10212       char *temp = NULL;
10213
10214       inote.type     = BYTE_GET (external->type);
10215       inote.namesz   = BYTE_GET (external->namesz);
10216       inote.namedata = external->name;
10217       inote.descsz   = BYTE_GET (external->descsz);
10218       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
10219       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
10220
10221       next = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
10222
10223       if (((char *) next) > (((char *) pnotes) + length))
10224         {
10225           warn (_("corrupt note found at offset %lx into core notes\n"),
10226                 (unsigned long) ((char *) external - (char *) pnotes));
10227           warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10228                 inote.type, inote.namesz, inote.descsz);
10229           break;
10230         }
10231
10232       external = next;
10233
10234       /* Verify that name is null terminated.  It appears that at least
10235          one version of Linux (RedHat 6.0) generates corefiles that don't
10236          comply with the ELF spec by failing to include the null byte in
10237          namesz.  */
10238       if (inote.namedata[inote.namesz] != '\0')
10239         {
10240           temp = malloc (inote.namesz + 1);
10241
10242           if (temp == NULL)
10243             {
10244               error (_("Out of memory\n"));
10245               res = 0;
10246               break;
10247             }
10248
10249           strncpy (temp, inote.namedata, inote.namesz);
10250           temp[inote.namesz] = 0;
10251
10252           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
10253           inote.namedata = temp;
10254         }
10255
10256       res &= process_note (& inote);
10257
10258       if (temp != NULL)
10259         {
10260           free (temp);
10261           temp = NULL;
10262         }
10263     }
10264
10265   free (pnotes);
10266
10267   return res;
10268 }
10269
10270 static int
10271 process_corefile_note_segments (FILE *file)
10272 {
10273   Elf_Internal_Phdr *segment;
10274   unsigned int i;
10275   int res = 1;
10276
10277   if (! get_program_headers (file))
10278       return 0;
10279
10280   for (i = 0, segment = program_headers;
10281        i < elf_header.e_phnum;
10282        i++, segment++)
10283     {
10284       if (segment->p_type == PT_NOTE)
10285         res &= process_corefile_note_segment (file,
10286                                               (bfd_vma) segment->p_offset,
10287                                               (bfd_vma) segment->p_filesz);
10288     }
10289
10290   return res;
10291 }
10292
10293 static int
10294 process_note_sections (FILE *file)
10295 {
10296   Elf_Internal_Shdr *section;
10297   unsigned long i;
10298   int res = 1;
10299
10300   for (i = 0, section = section_headers;
10301        i < elf_header.e_shnum;
10302        i++, section++)
10303     if (section->sh_type == SHT_NOTE)
10304       res &= process_corefile_note_segment (file,
10305                                             (bfd_vma) section->sh_offset,
10306                                             (bfd_vma) section->sh_size);
10307
10308   return res;
10309 }
10310
10311 static int
10312 process_notes (FILE *file)
10313 {
10314   /* If we have not been asked to display the notes then do nothing.  */
10315   if (! do_notes)
10316     return 1;
10317
10318   if (elf_header.e_type != ET_CORE)
10319     return process_note_sections (file);
10320
10321   /* No program headers means no NOTE segment.  */
10322   if (elf_header.e_phnum > 0)
10323     return process_corefile_note_segments (file);
10324
10325   printf (_("No note segments present in the core file.\n"));
10326   return 1;
10327 }
10328
10329 static int
10330 process_arch_specific (FILE *file)
10331 {
10332   if (! do_arch)
10333     return 1;
10334
10335   switch (elf_header.e_machine)
10336     {
10337     case EM_ARM:
10338       return process_arm_specific (file);
10339     case EM_MIPS:
10340     case EM_MIPS_RS3_LE:
10341       return process_mips_specific (file);
10342       break;
10343     case EM_PPC:
10344       return process_power_specific (file);
10345       break;
10346     default:
10347       break;
10348     }
10349   return 1;
10350 }
10351
10352 static int
10353 get_file_header (FILE *file)
10354 {
10355   /* Read in the identity array.  */
10356   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
10357     return 0;
10358
10359   /* Determine how to read the rest of the header.  */
10360   switch (elf_header.e_ident[EI_DATA])
10361     {
10362     default: /* fall through */
10363     case ELFDATANONE: /* fall through */
10364     case ELFDATA2LSB:
10365       byte_get = byte_get_little_endian;
10366       byte_put = byte_put_little_endian;
10367       break;
10368     case ELFDATA2MSB:
10369       byte_get = byte_get_big_endian;
10370       byte_put = byte_put_big_endian;
10371       break;
10372     }
10373
10374   /* For now we only support 32 bit and 64 bit ELF files.  */
10375   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
10376
10377   /* Read in the rest of the header.  */
10378   if (is_32bit_elf)
10379     {
10380       Elf32_External_Ehdr ehdr32;
10381
10382       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
10383         return 0;
10384
10385       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
10386       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
10387       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
10388       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
10389       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
10390       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
10391       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
10392       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
10393       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
10394       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
10395       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
10396       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
10397       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
10398     }
10399   else
10400     {
10401       Elf64_External_Ehdr ehdr64;
10402
10403       /* If we have been compiled with sizeof (bfd_vma) == 4, then
10404          we will not be able to cope with the 64bit data found in
10405          64 ELF files.  Detect this now and abort before we start
10406          overwriting things.  */
10407       if (sizeof (bfd_vma) < 8)
10408         {
10409           error (_("This instance of readelf has been built without support for a\n\
10410 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10411           return 0;
10412         }
10413
10414       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
10415         return 0;
10416
10417       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
10418       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
10419       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
10420       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
10421       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
10422       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
10423       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
10424       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
10425       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
10426       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
10427       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
10428       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
10429       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
10430     }
10431
10432   if (elf_header.e_shoff)
10433     {
10434       /* There may be some extensions in the first section header.  Don't
10435          bomb if we can't read it.  */
10436       if (is_32bit_elf)
10437         get_32bit_section_headers (file, 1);
10438       else
10439         get_64bit_section_headers (file, 1);
10440     }
10441
10442   return 1;
10443 }
10444
10445 /* Process one ELF object file according to the command line options.
10446    This file may actually be stored in an archive.  The file is
10447    positioned at the start of the ELF object.  */
10448
10449 static int
10450 process_object (char *file_name, FILE *file)
10451 {
10452   unsigned int i;
10453
10454   if (! get_file_header (file))
10455     {
10456       error (_("%s: Failed to read file header\n"), file_name);
10457       return 1;
10458     }
10459
10460   /* Initialise per file variables.  */
10461   for (i = ARRAY_SIZE (version_info); i--;)
10462     version_info[i] = 0;
10463
10464   for (i = ARRAY_SIZE (dynamic_info); i--;)
10465     dynamic_info[i] = 0;
10466
10467   /* Process the file.  */
10468   if (show_name)
10469     printf (_("\nFile: %s\n"), file_name);
10470
10471   /* Initialise the dump_sects array from the cmdline_dump_sects array.
10472      Note we do this even if cmdline_dump_sects is empty because we
10473      must make sure that the dump_sets array is zeroed out before each
10474      object file is processed.  */
10475   if (num_dump_sects > num_cmdline_dump_sects)
10476     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
10477
10478   if (num_cmdline_dump_sects > 0)
10479     {
10480       if (num_dump_sects == 0)
10481         /* A sneaky way of allocating the dump_sects array.  */
10482         request_dump_bynumber (num_cmdline_dump_sects, 0);
10483
10484       assert (num_dump_sects >= num_cmdline_dump_sects);
10485       memcpy (dump_sects, cmdline_dump_sects,
10486               num_cmdline_dump_sects * sizeof (* dump_sects));
10487     }
10488
10489   if (! process_file_header ())
10490     return 1;
10491
10492   if (! process_section_headers (file))
10493     {
10494       /* Without loaded section headers we cannot process lots of
10495          things.  */
10496       do_unwind = do_version = do_dump = do_arch = 0;
10497
10498       if (! do_using_dynamic)
10499         do_syms = do_reloc = 0;
10500     }
10501
10502   if (! process_section_groups (file))
10503     {
10504       /* Without loaded section groups we cannot process unwind.  */
10505       do_unwind = 0;
10506     }
10507
10508   if (process_program_headers (file))
10509     process_dynamic_section (file);
10510
10511   process_relocs (file);
10512
10513   process_unwind (file);
10514
10515   process_symbol_table (file);
10516
10517   process_syminfo (file);
10518
10519   process_version_sections (file);
10520
10521   process_section_contents (file);
10522
10523   process_notes (file);
10524
10525   process_gnu_liblist (file);
10526
10527   process_arch_specific (file);
10528
10529   if (program_headers)
10530     {
10531       free (program_headers);
10532       program_headers = NULL;
10533     }
10534
10535   if (section_headers)
10536     {
10537       free (section_headers);
10538       section_headers = NULL;
10539     }
10540
10541   if (string_table)
10542     {
10543       free (string_table);
10544       string_table = NULL;
10545       string_table_length = 0;
10546     }
10547
10548   if (dynamic_strings)
10549     {
10550       free (dynamic_strings);
10551       dynamic_strings = NULL;
10552       dynamic_strings_length = 0;
10553     }
10554
10555   if (dynamic_symbols)
10556     {
10557       free (dynamic_symbols);
10558       dynamic_symbols = NULL;
10559       num_dynamic_syms = 0;
10560     }
10561
10562   if (dynamic_syminfo)
10563     {
10564       free (dynamic_syminfo);
10565       dynamic_syminfo = NULL;
10566     }
10567
10568   if (section_headers_groups)
10569     {
10570       free (section_headers_groups);
10571       section_headers_groups = NULL;
10572     }
10573
10574   if (section_groups)
10575     {
10576       struct group_list *g, *next;
10577
10578       for (i = 0; i < group_count; i++)
10579         {
10580           for (g = section_groups [i].root; g != NULL; g = next)
10581             {
10582               next = g->next;
10583               free (g);
10584             }
10585         }
10586
10587       free (section_groups);
10588       section_groups = NULL;
10589     }
10590
10591   free_debug_memory ();
10592
10593   return 0;
10594 }
10595
10596 /* Process an ELF archive.
10597    On entry the file is positioned just after the ARMAG string.  */
10598
10599 static int
10600 process_archive (char *file_name, FILE *file)
10601 {
10602   struct ar_hdr arhdr;
10603   size_t got;
10604   unsigned long size;
10605   unsigned long index_num = 0;
10606   unsigned long *index_array = NULL;
10607   char *sym_table = NULL;
10608   unsigned long sym_size = 0;
10609   char *longnames = NULL;
10610   unsigned long longnames_size = 0;
10611   size_t file_name_size;
10612   int ret;
10613
10614   show_name = 1;
10615
10616   got = fread (&arhdr, 1, sizeof arhdr, file);
10617   if (got != sizeof arhdr)
10618     {
10619       if (got == 0)
10620         return 0;
10621
10622       error (_("%s: failed to read archive header\n"), file_name);
10623       return 1;
10624     }
10625
10626   /* See if this is the archive symbol table.  */
10627   if (const_strneq (arhdr.ar_name, "/               ")
10628       || const_strneq (arhdr.ar_name, "/SYM64/         "))
10629     {
10630       size = strtoul (arhdr.ar_size, NULL, 10);
10631       size = size + (size & 1);
10632
10633       if (do_archive_index)
10634         {
10635           unsigned long i;
10636           /* A buffer used to hold numbers read in from an archive index.
10637              These are always 4 bytes long and stored in big-endian format.  */
10638 #define SIZEOF_AR_INDEX_NUMBERS 4
10639           unsigned char integer_buffer[SIZEOF_AR_INDEX_NUMBERS];
10640           unsigned char * index_buffer;
10641
10642           /* Check the size of the archive index.  */
10643           if (size < SIZEOF_AR_INDEX_NUMBERS)
10644             {
10645               error (_("%s: the archive index is empty\n"), file_name);
10646               return 1;
10647             }
10648
10649           /* Read the numer of entries in the archive index.  */
10650           got = fread (integer_buffer, 1, sizeof integer_buffer, file);
10651           if (got != sizeof (integer_buffer))
10652             {
10653               error (_("%s: failed to read archive index\n"), file_name);
10654               return 1;
10655             }
10656           index_num = byte_get_big_endian (integer_buffer, sizeof integer_buffer);
10657           size -= SIZEOF_AR_INDEX_NUMBERS;
10658
10659           /* Read in the archive index.  */
10660           if (size < index_num * SIZEOF_AR_INDEX_NUMBERS)
10661             {
10662               error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
10663                      file_name, index_num);
10664               return 1;
10665             }
10666           index_buffer = malloc (index_num * SIZEOF_AR_INDEX_NUMBERS);
10667           if (index_buffer == NULL)
10668             {
10669               error (_("Out of memory whilst trying to read archive symbol index\n"));
10670               return 1;
10671             }
10672           got = fread (index_buffer, SIZEOF_AR_INDEX_NUMBERS, index_num, file);
10673           if (got != index_num)
10674             {
10675               free (index_buffer);
10676               error (_("%s: failed to read archive index\n"), file_name);
10677               ret = 1;
10678               goto out;
10679             }
10680           size -= index_num * SIZEOF_AR_INDEX_NUMBERS;
10681
10682           /* Convert the index numbers into the host's numeric format.  */
10683           index_array = malloc (index_num * sizeof (* index_array));
10684           if (index_array == NULL)
10685             {
10686               free (index_buffer);
10687               error (_("Out of memory whilst trying to convert the archive symbol index\n"));
10688               return 1;
10689             }
10690
10691           for (i = 0; i < index_num; i++)
10692             index_array[i] = byte_get_big_endian ((unsigned char *)(index_buffer + (i * SIZEOF_AR_INDEX_NUMBERS)),
10693                                                   SIZEOF_AR_INDEX_NUMBERS);
10694           free (index_buffer);
10695
10696           /* The remaining space in the header is taken up by the symbol table.  */
10697           if (size < 1)
10698             {
10699               error (_("%s: the archive has an index but no symbols\n"), file_name);
10700               ret = 1;
10701               goto out;
10702             }
10703           sym_table = malloc (size);
10704           sym_size = size;
10705           if (sym_table == NULL)
10706             {
10707               error (_("Out of memory whilst trying to read archive index symbol table\n"));
10708               ret = 1;
10709               goto out;
10710             }
10711           got = fread (sym_table, 1, size, file);
10712           if (got != size)
10713             {
10714               error (_("%s: failed to read archive index symbol table\n"), file_name);
10715               ret = 1;
10716               goto out;
10717             }
10718         }
10719       else
10720         {
10721           if (fseek (file, size, SEEK_CUR) != 0)
10722             {
10723               error (_("%s: failed to skip archive symbol table\n"), file_name);
10724               return 1;
10725             }
10726         }
10727
10728       got = fread (& arhdr, 1, sizeof arhdr, file);
10729       if (got != sizeof arhdr)
10730         {
10731           if (got == 0)
10732             {
10733               ret = 0;
10734               goto out;
10735             }
10736
10737           error (_("%s: failed to read archive header following archive index\n"), file_name);
10738           ret = 1;
10739           goto out;
10740         }
10741     }
10742   else if (do_archive_index)
10743     printf (_("%s has no archive index\n"), file_name);
10744
10745   if (const_strneq (arhdr.ar_name, "//              "))
10746     {
10747       /* This is the archive string table holding long member
10748          names.  */
10749
10750       longnames_size = strtoul (arhdr.ar_size, NULL, 10);
10751       longnames = malloc (longnames_size);
10752       if (longnames == NULL)
10753         {
10754           error (_("Out of memory reading long symbol names in archive\n"));
10755           ret = 1;
10756           goto out;
10757         }
10758
10759       if (fread (longnames, longnames_size, 1, file) != 1)
10760         {
10761           free (longnames);
10762           error (_("%s: failed to read long symbol name string table\n"), file_name);
10763           ret = 1;
10764           goto out;
10765         }
10766
10767       if ((longnames_size & 1) != 0)
10768         getc (file);
10769
10770       got = fread (& arhdr, 1, sizeof arhdr, file);
10771       if (got != sizeof arhdr)
10772         {
10773           if (got == 0)
10774             ret = 0;
10775           else
10776             {
10777               error (_("%s: failed to read archive header following long symbol names\n"), file_name);
10778               ret = 1;
10779             }
10780           goto out;
10781         }
10782     }
10783
10784   if (do_archive_index)
10785     {
10786       if (sym_table == NULL)
10787         error (_("%s: unable to dump the index as none was found\n"), file_name);
10788       else
10789         {
10790           unsigned int i, j, k, l;
10791           char elf_name[16];
10792           unsigned long current_pos;
10793
10794           printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
10795                   file_name, index_num, sym_size);
10796           current_pos = ftell (file);
10797
10798           for (i = l = 0; i < index_num; i++)
10799             {
10800               if ((i == 0) || ((i > 0) && (index_array[i] != index_array[i - 1])))
10801                 {
10802                   if (fseek (file, index_array[i], SEEK_SET) != 0)
10803                     {
10804                       error (_("%s: failed to seek to next file name\n"), file_name);
10805                       ret = 1;
10806                       goto out;
10807                     }
10808                   got = fread (elf_name, 1, 16, file);
10809                   if (got != 16)
10810                     {
10811                       error (_("%s: failed to read file name\n"), file_name);
10812                       ret = 1;
10813                       goto out;
10814                     }
10815
10816                   if (elf_name[0] == '/')
10817                     {
10818                       /* We have a long name.  */
10819                       k = j = strtoul (elf_name + 1, NULL, 10);
10820                       while ((j < longnames_size) && (longnames[j] != '/'))
10821                         j++;
10822                       longnames[j] = '\0';
10823                       printf (_("Binary %s contains:\n"), longnames + k);
10824                       longnames[j] = '/';
10825                     }
10826                   else
10827                     {
10828                       j = 0;
10829                       while ((elf_name[j] != '/') && (j < 16))
10830                         j++;
10831                       elf_name[j] = '\0';
10832                       printf(_("Binary %s contains:\n"), elf_name);
10833                     }
10834                 }
10835               if (l >= sym_size)
10836                 {
10837                   error (_("%s: end of the symbol table reached before the end of the index\n"),
10838                          file_name);
10839                   break;
10840                 }
10841               printf ("\t%s\n", sym_table + l);
10842               l += strlen (sym_table + l) + 1;
10843             }
10844
10845           if (l < sym_size)
10846             error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
10847                    file_name);
10848
10849           free (index_array);
10850           index_array = NULL;
10851           free (sym_table);
10852           sym_table = NULL;
10853           if (fseek (file, current_pos, SEEK_SET) != 0)
10854             {
10855               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
10856               return 1;
10857             }
10858         }
10859
10860       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
10861           && !do_segments && !do_header && !do_dump && !do_version
10862           && !do_histogram && !do_debugging && !do_arch && !do_notes
10863           && !do_section_groups)
10864         return 0; /* Archive index only.  */
10865     }
10866
10867   file_name_size = strlen (file_name);
10868   ret = 0;
10869
10870   while (1)
10871     {
10872       char *name;
10873       char *nameend;
10874       char *namealc;
10875
10876       if (arhdr.ar_name[0] == '/')
10877         {
10878           unsigned long off;
10879
10880           off = strtoul (arhdr.ar_name + 1, NULL, 10);
10881           if (off >= longnames_size)
10882             {
10883               error (_("%s: invalid archive string table offset %lu\n"), file_name, off);
10884               ret = 1;
10885               break;
10886             }
10887
10888           name = longnames + off;
10889           nameend = memchr (name, '/', longnames_size - off);
10890         }
10891       else
10892         {
10893           name = arhdr.ar_name;
10894           nameend = memchr (name, '/', 16);
10895         }
10896
10897       if (nameend == NULL)
10898         {
10899           error (_("%s: bad archive file name\n"), file_name);
10900           ret = 1;
10901           break;
10902         }
10903
10904       namealc = malloc (file_name_size + (nameend - name) + 3);
10905       if (namealc == NULL)
10906         {
10907           error (_("Out of memory\n"));
10908           ret = 1;
10909           break;
10910         }
10911
10912       memcpy (namealc, file_name, file_name_size);
10913       namealc[file_name_size] = '(';
10914       memcpy (namealc + file_name_size + 1, name, nameend - name);
10915       namealc[file_name_size + 1 + (nameend - name)] = ')';
10916       namealc[file_name_size + 2 + (nameend - name)] = '\0';
10917
10918       archive_file_offset = ftell (file);
10919       archive_file_size = strtoul (arhdr.ar_size, NULL, 10);
10920
10921       ret |= process_object (namealc, file);
10922
10923       free (namealc);
10924
10925       if (fseek (file,
10926                  (archive_file_offset
10927                   + archive_file_size
10928                   + (archive_file_size & 1)),
10929                  SEEK_SET) != 0)
10930         {
10931           error (_("%s: failed to seek to next archive header\n"), file_name);
10932           ret = 1;
10933           break;
10934         }
10935
10936       got = fread (&arhdr, 1, sizeof arhdr, file);
10937       if (got != sizeof arhdr)
10938         {
10939           if (got == 0)
10940             break;
10941
10942           error (_("%s: failed to read archive header\n"), file_name);
10943           ret = 1;
10944           break;
10945         }
10946     }
10947
10948  out:
10949   if (index_array != NULL)
10950     free (index_array);
10951   if (sym_table != NULL)
10952     free (sym_table);
10953   if (longnames != NULL)
10954     free (longnames);
10955
10956   return ret;
10957 }
10958
10959 static int
10960 process_file (char *file_name)
10961 {
10962   FILE *file;
10963   struct stat statbuf;
10964   char armag[SARMAG];
10965   int ret;
10966
10967   if (stat (file_name, &statbuf) < 0)
10968     {
10969       if (errno == ENOENT)
10970         error (_("'%s': No such file\n"), file_name);
10971       else
10972         error (_("Could not locate '%s'.  System error message: %s\n"),
10973                file_name, strerror (errno));
10974       return 1;
10975     }
10976
10977   if (! S_ISREG (statbuf.st_mode))
10978     {
10979       error (_("'%s' is not an ordinary file\n"), file_name);
10980       return 1;
10981     }
10982
10983   file = fopen (file_name, "rb");
10984   if (file == NULL)
10985     {
10986       error (_("Input file '%s' is not readable.\n"), file_name);
10987       return 1;
10988     }
10989
10990   if (fread (armag, SARMAG, 1, file) != 1)
10991     {
10992       error (_("%s: Failed to read file's magic number\n"), file_name);
10993       fclose (file);
10994       return 1;
10995     }
10996
10997   if (memcmp (armag, ARMAG, SARMAG) == 0)
10998     ret = process_archive (file_name, file);
10999   else
11000     {
11001       if (do_archive_index)
11002         error (_("File %s is not an archive so its index cannot be displayed.\n"),
11003                file_name);
11004
11005       rewind (file);
11006       archive_file_size = archive_file_offset = 0;
11007       ret = process_object (file_name, file);
11008     }
11009
11010   fclose (file);
11011
11012   return ret;
11013 }
11014
11015 #ifdef SUPPORT_DISASSEMBLY
11016 /* Needed by the i386 disassembler.  For extra credit, someone could
11017    fix this so that we insert symbolic addresses here, esp for GOT/PLT
11018    symbols.  */
11019
11020 void
11021 print_address (unsigned int addr, FILE *outfile)
11022 {
11023   fprintf (outfile,"0x%8.8x", addr);
11024 }
11025
11026 /* Needed by the i386 disassembler.  */
11027 void
11028 db_task_printsym (unsigned int addr)
11029 {
11030   print_address (addr, stderr);
11031 }
11032 #endif
11033
11034 int
11035 main (int argc, char **argv)
11036 {
11037   int err;
11038
11039 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11040   setlocale (LC_MESSAGES, "");
11041 #endif
11042 #if defined (HAVE_SETLOCALE)
11043   setlocale (LC_CTYPE, "");
11044 #endif
11045   bindtextdomain (PACKAGE, LOCALEDIR);
11046   textdomain (PACKAGE);
11047
11048   expandargv (&argc, &argv);
11049
11050   parse_args (argc, argv);
11051
11052   if (num_dump_sects > 0)
11053     {
11054       /* Make a copy of the dump_sects array.  */
11055       cmdline_dump_sects = malloc (num_dump_sects * sizeof (* dump_sects));
11056       if (cmdline_dump_sects == NULL)
11057         error (_("Out of memory allocating dump request table.\n"));
11058       else
11059         {
11060           memcpy (cmdline_dump_sects, dump_sects,
11061                   num_dump_sects * sizeof (* dump_sects));
11062           num_cmdline_dump_sects = num_dump_sects;
11063         }
11064     }
11065
11066   if (optind < (argc - 1))
11067     show_name = 1;
11068
11069   err = 0;
11070   while (optind < argc)
11071     err |= process_file (argv[optind++]);
11072
11073   if (dump_sects != NULL)
11074     free (dump_sects);
11075   if (cmdline_dump_sects != NULL)
11076     free (cmdline_dump_sects);
11077
11078   return err;
11079 }