binutils/readelf.c

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