binutils/readelf.c

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