binutils/readelf.c

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