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