binutils/readelf.c

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