binutils/readelf.c

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