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