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               do_debugging = 0;
2206               switch (optarg[0])
2207                 {
2208                 case 'i':
2209                 case 'I':
2210                   do_debug_info = 1;
2211                   break;
2212
2213                 case 'a':
2214                 case 'A':
2215                   do_debug_abbrevs = 1;
2216                   break;
2217
2218                 case 'l':
2219                 case 'L':
2220                   do_debug_lines = 1;
2221                   break;
2222
2223                 case 'p':
2224                 case 'P':
2225                   do_debug_pubnames = 1;
2226                   break;
2227
2228                 case 'r':
2229                 case 'R':
2230                   do_debug_aranges = 1;
2231                   break;
2232
2233                 case 'F':
2234                   do_debug_frames_interp = 1;
2235                 case 'f':
2236                   do_debug_frames = 1;
2237                   break;
2238
2239                 case 'm':
2240                 case 'M':
2241                   do_debug_macinfo = 1;
2242                   break;
2243
2244                 default:
2245                   warn (_("Unrecognised debug option '%s'\n"), optarg);
2246                   break;
2247                 }
2248             }
2249           break;
2250 #ifdef SUPPORT_DISASSEMBLY
2251         case 'i':
2252           do_dump ++;
2253           section = strtoul (optarg, & cp, 0);
2254           if (! * cp && section >= 0)
2255             {
2256               request_dump (section, DISASS_DUMP);
2257               break;
2258             }
2259           goto oops;
2260 #endif
2261         case 'v':
2262           print_version (program_name);
2263           break;
2264         case 'V':
2265           do_version ++;
2266           break;
2267         case 'W':
2268           do_wide ++;
2269           break;
2270         default:
2271         oops:
2272           /* xgettext:c-format */
2273           error (_("Invalid option '-%c'\n"), c);
2274           /* Drop through.  */
2275         case '?':
2276           usage ();
2277         }
2278     }
2279
2280   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
2281       && !do_segments && !do_header && !do_dump && !do_version
2282       && !do_histogram && !do_debugging && !do_arch && !do_notes)
2283     usage ();
2284   else if (argc < 3)
2285     {
2286       warn (_("Nothing to do.\n"));
2287       usage();
2288     }
2289 }
2290
2291 static const char *
2292 get_elf_class (elf_class)
2293      unsigned char elf_class;
2294 {
2295   static char buff [32];
2296
2297   switch (elf_class)
2298     {
2299     case ELFCLASSNONE: return _("none");
2300     case ELFCLASS32:   return _("ELF32");
2301     case ELFCLASS64:   return _("ELF64");
2302     default:
2303       sprintf (buff, _("<unknown: %x>"), elf_class);
2304       return buff;
2305     }
2306 }
2307
2308 static const char *
2309 get_data_encoding (encoding)
2310      unsigned char encoding;
2311 {
2312   static char buff [32];
2313
2314   switch (encoding)
2315     {
2316     case ELFDATANONE: return _("none");
2317     case ELFDATA2LSB: return _("2's complement, little endian");
2318     case ELFDATA2MSB: return _("2's complement, big endian");
2319     default:
2320       sprintf (buff, _("<unknown: %x>"), encoding);
2321       return buff;
2322     }
2323 }
2324
2325 static const char *
2326 get_osabi_name (osabi)
2327      unsigned char osabi;
2328 {
2329   static char buff [32];
2330
2331   switch (osabi)
2332     {
2333     case ELFOSABI_NONE:       return _("UNIX - System V");
2334     case ELFOSABI_HPUX:       return _("UNIX - HP-UX");
2335     case ELFOSABI_NETBSD:     return _("UNIX - NetBSD");
2336     case ELFOSABI_LINUX:      return _("UNIX - Linux");
2337     case ELFOSABI_HURD:       return _("GNU/Hurd");
2338     case ELFOSABI_SOLARIS:    return _("UNIX - Solaris");
2339     case ELFOSABI_AIX:        return _("UNIX - AIX");
2340     case ELFOSABI_IRIX:       return _("UNIX - IRIX");
2341     case ELFOSABI_FREEBSD:    return _("UNIX - FreeBSD");
2342     case ELFOSABI_TRU64:      return _("UNIX - TRU64");
2343     case ELFOSABI_MODESTO:    return _("Novell - Modesto");
2344     case ELFOSABI_OPENBSD:    return _("UNIX - OpenBSD");
2345     case ELFOSABI_STANDALONE: return _("Standalone App");
2346     case ELFOSABI_ARM:        return _("ARM");
2347     default:
2348       sprintf (buff, _("<unknown: %x>"), osabi);
2349       return buff;
2350     }
2351 }
2352
2353 /* Decode the data held in 'elf_header'.  */
2354 static int
2355 process_file_header ()
2356 {
2357   if (   elf_header.e_ident [EI_MAG0] != ELFMAG0
2358       || elf_header.e_ident [EI_MAG1] != ELFMAG1
2359       || elf_header.e_ident [EI_MAG2] != ELFMAG2
2360       || elf_header.e_ident [EI_MAG3] != ELFMAG3)
2361     {
2362       error
2363         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2364       return 0;
2365     }
2366
2367   if (do_header)
2368     {
2369       int i;
2370
2371       printf (_("ELF Header:\n"));
2372       printf (_("  Magic:   "));
2373       for (i = 0; i < EI_NIDENT; i ++)
2374         printf ("%2.2x ", elf_header.e_ident [i]);
2375       printf ("\n");
2376       printf (_("  Class:                             %s\n"),
2377               get_elf_class (elf_header.e_ident [EI_CLASS]));
2378       printf (_("  Data:                              %s\n"),
2379               get_data_encoding (elf_header.e_ident [EI_DATA]));
2380       printf (_("  Version:                           %d %s\n"),
2381               elf_header.e_ident [EI_VERSION],
2382               (elf_header.e_ident [EI_VERSION] == EV_CURRENT
2383                ? "(current)"
2384                : (elf_header.e_ident [EI_VERSION] != EV_NONE
2385                   ? "<unknown: %lx>"
2386                   : "")));
2387       printf (_("  OS/ABI:                            %s\n"),
2388               get_osabi_name (elf_header.e_ident [EI_OSABI]));
2389       printf (_("  ABI Version:                       %d\n"),
2390               elf_header.e_ident [EI_ABIVERSION]);
2391       printf (_("  Type:                              %s\n"),
2392               get_file_type (elf_header.e_type));
2393       printf (_("  Machine:                           %s\n"),
2394               get_machine_name (elf_header.e_machine));
2395       printf (_("  Version:                           0x%lx\n"),
2396               (unsigned long) elf_header.e_version);
2397
2398       printf (_("  Entry point address:               "));
2399       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2400       printf (_("\n  Start of program headers:          "));
2401       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2402       printf (_(" (bytes into file)\n  Start of section headers:          "));
2403       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
2404       printf (_(" (bytes into file)\n"));
2405
2406       printf (_("  Flags:                             0x%lx%s\n"),
2407               (unsigned long) elf_header.e_flags,
2408               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2409       printf (_("  Size of this header:               %ld (bytes)\n"),
2410               (long) elf_header.e_ehsize);
2411       printf (_("  Size of program headers:           %ld (bytes)\n"),
2412               (long) elf_header.e_phentsize);
2413       printf (_("  Number of program headers:         %ld\n"),
2414               (long) elf_header.e_phnum);
2415       printf (_("  Size of section headers:           %ld (bytes)\n"),
2416               (long) elf_header.e_shentsize);
2417       printf (_("  Number of section headers:         %ld\n"),
2418               (long) elf_header.e_shnum);
2419       printf (_("  Section header string table index: %ld\n"),
2420               (long) elf_header.e_shstrndx);
2421     }
2422
2423   return 1;
2424 }
2425
2426
2427 static int
2428 get_32bit_program_headers (file, program_headers)
2429      FILE * file;
2430      Elf_Internal_Phdr * program_headers;
2431 {
2432   Elf32_External_Phdr * phdrs;
2433   Elf32_External_Phdr * external;
2434   Elf32_Internal_Phdr * internal;
2435   unsigned int          i;
2436
2437   phdrs = ((Elf32_External_Phdr *)
2438            get_data (NULL, file, elf_header.e_phoff,
2439                      elf_header.e_phentsize * elf_header.e_phnum,
2440                      _("program headers")));
2441   if (!phdrs)
2442     return 0;
2443
2444   for (i = 0, internal = program_headers, external = phdrs;
2445        i < elf_header.e_phnum;
2446        i ++, internal ++, external ++)
2447     {
2448       internal->p_type   = BYTE_GET (external->p_type);
2449       internal->p_offset = BYTE_GET (external->p_offset);
2450       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
2451       internal->p_paddr  = BYTE_GET (external->p_paddr);
2452       internal->p_filesz = BYTE_GET (external->p_filesz);
2453       internal->p_memsz  = BYTE_GET (external->p_memsz);
2454       internal->p_flags  = BYTE_GET (external->p_flags);
2455       internal->p_align  = BYTE_GET (external->p_align);
2456     }
2457
2458   free (phdrs);
2459
2460   return 1;
2461 }
2462
2463 static int
2464 get_64bit_program_headers (file, program_headers)
2465      FILE * file;
2466      Elf_Internal_Phdr * program_headers;
2467 {
2468   Elf64_External_Phdr * phdrs;
2469   Elf64_External_Phdr * external;
2470   Elf64_Internal_Phdr * internal;
2471   unsigned int          i;
2472
2473   phdrs = ((Elf64_External_Phdr *)
2474            get_data (NULL, file, elf_header.e_phoff,
2475                      elf_header.e_phentsize * elf_header.e_phnum,
2476                      _("program headers")));
2477   if (!phdrs)
2478     return 0;
2479
2480   for (i = 0, internal = program_headers, external = phdrs;
2481        i < elf_header.e_phnum;
2482        i ++, internal ++, external ++)
2483     {
2484       internal->p_type   = BYTE_GET (external->p_type);
2485       internal->p_flags  = BYTE_GET (external->p_flags);
2486       internal->p_offset = BYTE_GET8 (external->p_offset);
2487       internal->p_vaddr  = BYTE_GET8 (external->p_vaddr);
2488       internal->p_paddr  = BYTE_GET8 (external->p_paddr);
2489       internal->p_filesz = BYTE_GET8 (external->p_filesz);
2490       internal->p_memsz  = BYTE_GET8 (external->p_memsz);
2491       internal->p_align  = BYTE_GET8 (external->p_align);
2492     }
2493
2494   free (phdrs);
2495
2496   return 1;
2497 }
2498
2499 static int
2500 process_program_headers (file)
2501      FILE * file;
2502 {
2503   Elf_Internal_Phdr * program_headers;
2504   Elf_Internal_Phdr * segment;
2505   unsigned int        i;
2506
2507   if (elf_header.e_phnum == 0)
2508     {
2509       if (do_segments)
2510         printf (_("\nThere are no program headers in this file.\n"));
2511       return 1;
2512     }
2513
2514   if (do_segments && !do_header)
2515     {
2516       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
2517       printf (_("Entry point "));
2518       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2519       printf (_("\nThere are %d program headers, starting at offset "),
2520               elf_header.e_phnum);
2521       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2522       printf ("\n");
2523     }
2524
2525   program_headers = (Elf_Internal_Phdr *) malloc
2526     (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
2527
2528   if (program_headers == NULL)
2529     {
2530       error (_("Out of memory\n"));
2531       return 0;
2532     }
2533
2534   if (is_32bit_elf)
2535     i = get_32bit_program_headers (file, program_headers);
2536   else
2537     i = get_64bit_program_headers (file, program_headers);
2538
2539   if (i == 0)
2540     {
2541       free (program_headers);
2542       return 0;
2543     }
2544
2545   if (do_segments)
2546     {
2547       printf
2548         (_("\nProgram Header%s:\n"), elf_header.e_phnum > 1 ? "s" : "");
2549
2550       if (is_32bit_elf)
2551         printf
2552           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
2553       else if (do_wide)
2554         printf
2555           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
2556       else
2557         {
2558           printf
2559             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
2560           printf
2561             (_("                 FileSiz            MemSiz              Flags  Align\n"));
2562         }
2563     }
2564
2565   loadaddr = -1;
2566   dynamic_addr = 0;
2567   dynamic_size = 0;
2568
2569   for (i = 0, segment = program_headers;
2570        i < elf_header.e_phnum;
2571        i ++, segment ++)
2572     {
2573       if (do_segments)
2574         {
2575           printf ("  %-14.14s ", get_segment_type (segment->p_type));
2576
2577           if (is_32bit_elf)
2578             {
2579               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2580               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
2581               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
2582               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
2583               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
2584               printf ("%c%c%c ",
2585                       (segment->p_flags & PF_R ? 'R' : ' '),
2586                       (segment->p_flags & PF_W ? 'W' : ' '),
2587                       (segment->p_flags & PF_X ? 'E' : ' '));
2588               printf ("%#lx", (unsigned long) segment->p_align);
2589             }
2590           else if (do_wide)
2591             {
2592               if ((unsigned long) segment->p_offset == segment->p_offset)
2593                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2594               else
2595                 {
2596                   print_vma (segment->p_offset, FULL_HEX);
2597                   putchar (' ');
2598                 }
2599
2600               print_vma (segment->p_vaddr, FULL_HEX);
2601               putchar (' ');
2602               print_vma (segment->p_paddr, FULL_HEX);
2603               putchar (' ');
2604
2605               if ((unsigned long) segment->p_filesz == segment->p_filesz)
2606                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
2607               else
2608                 {
2609                   print_vma (segment->p_filesz, FULL_HEX);
2610                   putchar (' ');
2611                 }
2612
2613               if ((unsigned long) segment->p_memsz == segment->p_memsz)
2614                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
2615               else
2616                 {
2617                   print_vma (segment->p_offset, FULL_HEX);
2618                 }
2619
2620               printf (" %c%c%c ",
2621                       (segment->p_flags & PF_R ? 'R' : ' '),
2622                       (segment->p_flags & PF_W ? 'W' : ' '),
2623                       (segment->p_flags & PF_X ? 'E' : ' '));
2624
2625               if ((unsigned long) segment->p_align == segment->p_align)
2626                 printf ("%#lx", (unsigned long) segment->p_align);
2627               else
2628                 {
2629                   print_vma (segment->p_align, PREFIX_HEX);
2630                 }
2631             }
2632           else
2633             {
2634               print_vma (segment->p_offset, FULL_HEX);
2635               putchar (' ');
2636               print_vma (segment->p_vaddr, FULL_HEX);
2637               putchar (' ');
2638               print_vma (segment->p_paddr, FULL_HEX);
2639               printf ("\n                 ");
2640               print_vma (segment->p_filesz, FULL_HEX);
2641               putchar (' ');
2642               print_vma (segment->p_memsz, FULL_HEX);
2643               printf ("  %c%c%c    ",
2644                       (segment->p_flags & PF_R ? 'R' : ' '),
2645                       (segment->p_flags & PF_W ? 'W' : ' '),
2646                       (segment->p_flags & PF_X ? 'E' : ' '));
2647               print_vma (segment->p_align, HEX);
2648             }
2649         }
2650
2651       switch (segment->p_type)
2652         {
2653         case PT_LOAD:
2654           if (loadaddr == -1)
2655             loadaddr = (segment->p_vaddr & 0xfffff000)
2656               - (segment->p_offset & 0xfffff000);
2657           break;
2658
2659         case PT_DYNAMIC:
2660           if (dynamic_addr)
2661             error (_("more than one dynamic segment\n"));
2662
2663           dynamic_addr = segment->p_offset;
2664           dynamic_size = segment->p_filesz;
2665           break;
2666
2667         case PT_INTERP:
2668           if (fseek (file, (long) segment->p_offset, SEEK_SET))
2669             error (_("Unable to find program interpreter name\n"));
2670           else
2671             {
2672               program_interpreter[0] = 0;
2673               fscanf (file, "%63s", program_interpreter);
2674
2675               if (do_segments)
2676                 printf (_("\n      [Requesting program interpreter: %s]"),
2677                     program_interpreter);
2678             }
2679           break;
2680         }
2681
2682       if (do_segments)
2683         putc ('\n', stdout);
2684     }
2685
2686   if (loadaddr == -1)
2687     {
2688       /* Very strange. */
2689       loadaddr = 0;
2690     }
2691
2692   if (do_segments && section_headers != NULL)
2693     {
2694       printf (_("\n Section to Segment mapping:\n"));
2695       printf (_("  Segment Sections...\n"));
2696
2697       assert (string_table != NULL);
2698
2699       for (i = 0; i < elf_header.e_phnum; i++)
2700         {
2701           int                 j;
2702           Elf_Internal_Shdr * section;
2703
2704           segment = program_headers + i;
2705           section = section_headers;
2706
2707           printf ("   %2.2d     ", i);
2708
2709           for (j = 0; j < elf_header.e_shnum; j++, section ++)
2710             {
2711               if (section->sh_size > 0
2712                   /* Compare allocated sections by VMA, unallocated
2713                      sections by file offset.  */
2714                   && (section->sh_flags & SHF_ALLOC
2715                       ? (section->sh_addr >= segment->p_vaddr
2716                          && section->sh_addr + section->sh_size
2717                          <= segment->p_vaddr + segment->p_memsz)
2718                       : ((bfd_vma) section->sh_offset >= segment->p_offset
2719                          && (section->sh_offset + section->sh_size
2720                              <= segment->p_offset + segment->p_filesz))))
2721                 printf ("%s ", SECTION_NAME (section));
2722             }
2723
2724           putc ('\n',stdout);
2725         }
2726     }
2727
2728   free (program_headers);
2729
2730   return 1;
2731 }
2732
2733
2734 static int
2735 get_32bit_section_headers (file)
2736      FILE * file;
2737 {
2738   Elf32_External_Shdr * shdrs;
2739   Elf32_Internal_Shdr * internal;
2740   unsigned int          i;
2741
2742   shdrs = ((Elf32_External_Shdr *)
2743            get_data (NULL, file, elf_header.e_shoff,
2744                      elf_header.e_shentsize * elf_header.e_shnum,
2745                      _("section headers")));
2746   if (!shdrs)
2747     return 0;
2748
2749   section_headers = (Elf_Internal_Shdr *) malloc
2750     (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2751
2752   if (section_headers == NULL)
2753     {
2754       error (_("Out of memory\n"));
2755       return 0;
2756     }
2757
2758   for (i = 0, internal = section_headers;
2759        i < elf_header.e_shnum;
2760        i ++, internal ++)
2761     {
2762       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
2763       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
2764       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
2765       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
2766       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
2767       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
2768       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
2769       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
2770       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2771       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
2772     }
2773
2774   free (shdrs);
2775
2776   return 1;
2777 }
2778
2779 static int
2780 get_64bit_section_headers (file)
2781      FILE * file;
2782 {
2783   Elf64_External_Shdr * shdrs;
2784   Elf64_Internal_Shdr * internal;
2785   unsigned int          i;
2786
2787   shdrs = ((Elf64_External_Shdr *)
2788            get_data (NULL, file, elf_header.e_shoff,
2789                      elf_header.e_shentsize * elf_header.e_shnum,
2790                      _("section headers")));
2791   if (!shdrs)
2792     return 0;
2793
2794   section_headers = (Elf_Internal_Shdr *) malloc
2795     (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2796
2797   if (section_headers == NULL)
2798     {
2799       error (_("Out of memory\n"));
2800       return 0;
2801     }
2802
2803   for (i = 0, internal = section_headers;
2804        i < elf_header.e_shnum;
2805        i ++, internal ++)
2806     {
2807       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
2808       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
2809       internal->sh_flags     = BYTE_GET8 (shdrs[i].sh_flags);
2810       internal->sh_addr      = BYTE_GET8 (shdrs[i].sh_addr);
2811       internal->sh_size      = BYTE_GET8 (shdrs[i].sh_size);
2812       internal->sh_entsize   = BYTE_GET8 (shdrs[i].sh_entsize);
2813       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
2814       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
2815       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
2816       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2817     }
2818
2819   free (shdrs);
2820
2821   return 1;
2822 }
2823
2824 static Elf_Internal_Sym *
2825 get_32bit_elf_symbols (file, offset, number)
2826      FILE * file;
2827      unsigned long offset;
2828      unsigned long number;
2829 {
2830   Elf32_External_Sym * esyms;
2831   Elf_Internal_Sym *   isyms;
2832   Elf_Internal_Sym *   psym;
2833   unsigned int         j;
2834
2835   esyms = ((Elf32_External_Sym *)
2836            get_data (NULL, file, offset,
2837                      number * sizeof (Elf32_External_Sym), _("symbols")));
2838   if (!esyms)
2839     return NULL;
2840
2841   isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2842
2843   if (isyms == NULL)
2844     {
2845       error (_("Out of memory\n"));
2846       free (esyms);
2847
2848       return NULL;
2849     }
2850
2851   for (j = 0, psym = isyms;
2852        j < number;
2853        j ++, psym ++)
2854     {
2855       psym->st_name  = BYTE_GET (esyms[j].st_name);
2856       psym->st_value = BYTE_GET (esyms[j].st_value);
2857       psym->st_size  = BYTE_GET (esyms[j].st_size);
2858       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2859       psym->st_info  = BYTE_GET (esyms[j].st_info);
2860       psym->st_other = BYTE_GET (esyms[j].st_other);
2861     }
2862
2863   free (esyms);
2864
2865   return isyms;
2866 }
2867
2868 static Elf_Internal_Sym *
2869 get_64bit_elf_symbols (file, offset, number)
2870      FILE * file;
2871      unsigned long offset;
2872      unsigned long number;
2873 {
2874   Elf64_External_Sym * esyms;
2875   Elf_Internal_Sym *   isyms;
2876   Elf_Internal_Sym *   psym;
2877   unsigned int         j;
2878
2879   esyms = ((Elf64_External_Sym *)
2880            get_data (NULL, file, offset,
2881                      number * sizeof (Elf64_External_Sym), _("symbols")));
2882   if (!esyms)
2883     return NULL;
2884
2885   isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2886
2887   if (isyms == NULL)
2888     {
2889       error (_("Out of memory\n"));
2890       free (esyms);
2891
2892       return NULL;
2893     }
2894
2895   for (j = 0, psym = isyms;
2896        j < number;
2897        j ++, psym ++)
2898     {
2899       psym->st_name  = BYTE_GET (esyms[j].st_name);
2900       psym->st_info  = BYTE_GET (esyms[j].st_info);
2901       psym->st_other = BYTE_GET (esyms[j].st_other);
2902       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2903       psym->st_value = BYTE_GET8 (esyms[j].st_value);
2904       psym->st_size  = BYTE_GET8 (esyms[j].st_size);
2905     }
2906
2907   free (esyms);
2908
2909   return isyms;
2910 }
2911
2912 static const char *
2913 get_elf_section_flags (sh_flags)
2914      bfd_vma sh_flags;
2915 {
2916   static char buff [32];
2917
2918   * buff = 0;
2919
2920   while (sh_flags)
2921     {
2922       bfd_vma flag;
2923
2924       flag = sh_flags & - sh_flags;
2925       sh_flags &= ~ flag;
2926
2927       switch (flag)
2928         {
2929         case SHF_WRITE:            strcat (buff, "W"); break;
2930         case SHF_ALLOC:            strcat (buff, "A"); break;
2931         case SHF_EXECINSTR:        strcat (buff, "X"); break;
2932         case SHF_MERGE:            strcat (buff, "M"); break;
2933         case SHF_STRINGS:          strcat (buff, "S"); break;
2934         case SHF_INFO_LINK:        strcat (buff, "I"); break;
2935         case SHF_LINK_ORDER:       strcat (buff, "L"); break;
2936         case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
2937         case SHF_GROUP:            strcat (buff, "G"); break;
2938
2939         default:
2940           if (flag & SHF_MASKOS)
2941             {
2942               strcat (buff, "o");
2943               sh_flags &= ~ SHF_MASKOS;
2944             }
2945           else if (flag & SHF_MASKPROC)
2946             {
2947               strcat (buff, "p");
2948               sh_flags &= ~ SHF_MASKPROC;
2949             }
2950           else
2951             strcat (buff, "x");
2952           break;
2953         }
2954     }
2955
2956   return buff;
2957 }
2958
2959 static int
2960 process_section_headers (file)
2961      FILE * file;
2962 {
2963   Elf_Internal_Shdr * section;
2964   int                 i;
2965
2966   section_headers = NULL;
2967
2968   if (elf_header.e_shnum == 0)
2969     {
2970       if (do_sections)
2971         printf (_("\nThere are no sections in this file.\n"));
2972
2973       return 1;
2974     }
2975
2976   if (do_sections && !do_header)
2977     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2978             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
2979
2980   if (is_32bit_elf)
2981     {
2982       if (! get_32bit_section_headers (file))
2983         return 0;
2984     }
2985   else if (! get_64bit_section_headers (file))
2986     return 0;
2987
2988   /* Read in the string table, so that we have names to display.  */
2989   section = section_headers + elf_header.e_shstrndx;
2990
2991   if (section->sh_size != 0)
2992     {
2993       string_table = (char *) get_data (NULL, file, section->sh_offset,
2994                                         section->sh_size, _("string table"));
2995
2996       string_table_length = section->sh_size;
2997     }
2998
2999   /* Scan the sections for the dynamic symbol table
3000      and dynamic string table and debug sections. */
3001   dynamic_symbols = NULL;
3002   dynamic_strings = NULL;
3003   dynamic_syminfo = NULL;
3004
3005   for (i = 0, section = section_headers;
3006        i < elf_header.e_shnum;
3007        i ++, section ++)
3008     {
3009       char * name = SECTION_NAME (section);
3010
3011       if (section->sh_type == SHT_DYNSYM)
3012         {
3013           if (dynamic_symbols != NULL)
3014             {
3015               error (_("File contains multiple dynamic symbol tables\n"));
3016               continue;
3017             }
3018
3019           num_dynamic_syms = section->sh_size / section->sh_entsize;
3020           dynamic_symbols =
3021             GET_ELF_SYMBOLS (file, section->sh_offset, num_dynamic_syms);
3022         }
3023       else if (section->sh_type == SHT_STRTAB
3024                && strcmp (name, ".dynstr") == 0)
3025         {
3026           if (dynamic_strings != NULL)
3027             {
3028               error (_("File contains multiple dynamic string tables\n"));
3029               continue;
3030             }
3031
3032           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
3033                                                section->sh_size,
3034                                                _("dynamic strings"));
3035         }
3036       else if ((do_debugging || do_debug_info || do_debug_abbrevs
3037                 || do_debug_lines || do_debug_pubnames || do_debug_aranges
3038                 || do_debug_frames || do_debug_macinfo)
3039                && strncmp (name, ".debug_", 7) == 0)
3040         {
3041           name += 7;
3042
3043           if (do_debugging
3044               || (do_debug_info     && (strcmp (name, "info") == 0))
3045               || (do_debug_abbrevs  && (strcmp (name, "abbrev") == 0))
3046               || (do_debug_lines    && (strcmp (name, "line") == 0))
3047               || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
3048               || (do_debug_aranges  && (strcmp (name, "aranges") == 0))
3049               || (do_debug_frames   && (strcmp (name, "frame") == 0))
3050               || (do_debug_macinfo  && (strcmp (name, "macinfo") == 0))
3051               )
3052             request_dump (i, DEBUG_DUMP);
3053         }
3054       /* linkonce section to be combined with .debug_info at link time.  */
3055       else if ((do_debugging || do_debug_info)
3056                && strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
3057         request_dump (i, DEBUG_DUMP);
3058       else if (do_debug_frames && strcmp (name, ".eh_frame") == 0)
3059         request_dump (i, DEBUG_DUMP);
3060     }
3061
3062   if (! do_sections)
3063     return 1;
3064
3065   printf (_("\nSection Header%s:\n"), elf_header.e_shnum > 1 ? "s" : "");
3066
3067   if (is_32bit_elf)
3068     printf
3069       (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
3070   else if (do_wide)
3071     printf
3072       (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
3073   else
3074     {
3075       printf (_("  [Nr] Name              Type             Address           Offset\n"));
3076       printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
3077     }
3078
3079   for (i = 0, section = section_headers;
3080        i < elf_header.e_shnum;
3081        i ++, section ++)
3082     {
3083       printf ("  [%2d] %-17.17s %-15.15s ",
3084               i,
3085               SECTION_NAME (section),
3086               get_section_type_name (section->sh_type));
3087
3088       if (is_32bit_elf)
3089         {
3090           print_vma (section->sh_addr, LONG_HEX);
3091
3092           printf ( " %6.6lx %6.6lx %2.2lx",
3093                    (unsigned long) section->sh_offset,
3094                    (unsigned long) section->sh_size,
3095                    (unsigned long) section->sh_entsize);
3096
3097           printf (" %3s ", get_elf_section_flags (section->sh_flags));
3098
3099           printf ("%2ld %3lx %2ld\n",
3100                   (unsigned long) section->sh_link,
3101                   (unsigned long) section->sh_info,
3102                   (unsigned long) section->sh_addralign);
3103         }
3104       else if (do_wide)
3105         {
3106           print_vma (section->sh_addr, LONG_HEX);
3107
3108           if ((long) section->sh_offset == section->sh_offset)
3109             printf (" %6.6lx", (unsigned long) section->sh_offset);
3110           else
3111             {
3112               putchar (' ');
3113               print_vma (section->sh_offset, LONG_HEX);
3114             }
3115
3116           if ((unsigned long) section->sh_size == section->sh_size)
3117             printf (" %6.6lx", (unsigned long) section->sh_size);
3118           else
3119             {
3120               putchar (' ');
3121               print_vma (section->sh_size, LONG_HEX);
3122             }
3123
3124           if ((unsigned long) section->sh_entsize == section->sh_entsize)
3125             printf (" %2.2lx", (unsigned long) section->sh_entsize);
3126           else
3127             {
3128               putchar (' ');
3129               print_vma (section->sh_entsize, LONG_HEX);
3130             }
3131
3132           printf (" %3s ", get_elf_section_flags (section->sh_flags));
3133
3134           printf ("%2ld %3lx ",
3135                   (unsigned long) section->sh_link,
3136                   (unsigned long) section->sh_info);
3137
3138           if ((unsigned long) section->sh_addralign == section->sh_addralign)
3139             printf ("%2ld\n", (unsigned long) section->sh_addralign);
3140           else
3141             {
3142               print_vma (section->sh_addralign, DEC);
3143               putchar ('\n');
3144             }
3145         }
3146       else
3147         {
3148           putchar (' ');
3149           print_vma (section->sh_addr, LONG_HEX);
3150           if ((long) section->sh_offset == section->sh_offset)
3151             printf ("  %8.8lx", (unsigned long) section->sh_offset);
3152           else
3153             {
3154               printf ("  ");
3155               print_vma (section->sh_offset, LONG_HEX);
3156             }
3157           printf ("\n       ");
3158           print_vma (section->sh_size, LONG_HEX);
3159           printf ("  ");
3160           print_vma (section->sh_entsize, LONG_HEX);
3161
3162           printf (" %3s ", get_elf_section_flags (section->sh_flags));
3163
3164           printf ("     %2ld   %3lx     %ld\n",
3165                   (unsigned long) section->sh_link,
3166                   (unsigned long) section->sh_info,
3167                   (unsigned long) section->sh_addralign);
3168         }
3169     }
3170
3171   printf (_("Key to Flags:\n"));
3172   printf (_("  W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
3173   printf (_("  I (info), L (link order), G (group), x (unknown)\n"));
3174   printf (_("  O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3175
3176   return 1;
3177 }
3178
3179 /* Process the reloc section.  */
3180 static int
3181 process_relocs (file)
3182      FILE * file;
3183 {
3184   unsigned long    rel_size;
3185   unsigned long    rel_offset;
3186
3187
3188   if (!do_reloc)
3189     return 1;
3190
3191   if (do_using_dynamic)
3192     {
3193       int is_rela = FALSE;
3194
3195       rel_size   = 0;
3196       rel_offset = 0;
3197
3198       if (dynamic_info[DT_REL])
3199         {
3200           rel_offset = dynamic_info[DT_REL];
3201           rel_size   = dynamic_info[DT_RELSZ];
3202           is_rela    = FALSE;
3203         }
3204       else if (dynamic_info [DT_RELA])
3205         {
3206           rel_offset = dynamic_info[DT_RELA];
3207           rel_size   = dynamic_info[DT_RELASZ];
3208           is_rela    = TRUE;
3209         }
3210       else if (dynamic_info[DT_JMPREL])
3211         {
3212           rel_offset = dynamic_info[DT_JMPREL];
3213           rel_size   = dynamic_info[DT_PLTRELSZ];
3214
3215           switch (dynamic_info[DT_PLTREL])
3216             {
3217             case DT_REL:
3218               is_rela = FALSE;
3219               break;
3220             case DT_RELA:
3221               is_rela = TRUE;
3222               break;
3223             default:
3224               is_rela = UNKNOWN;
3225               break;
3226             }
3227         }
3228
3229       if (rel_size)
3230         {
3231           printf
3232             (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3233              rel_offset, rel_size);
3234
3235           dump_relocations (file, rel_offset - loadaddr, rel_size,
3236                             dynamic_symbols, num_dynamic_syms, dynamic_strings, is_rela);
3237         }
3238       else
3239         printf (_("\nThere are no dynamic relocations in this file.\n"));
3240     }
3241   else
3242     {
3243       Elf32_Internal_Shdr *     section;
3244       unsigned long             i;
3245       int               found = 0;
3246
3247       for (i = 0, section = section_headers;
3248            i < elf_header.e_shnum;
3249            i++, section ++)
3250         {
3251           if (   section->sh_type != SHT_RELA
3252               && section->sh_type != SHT_REL)
3253             continue;
3254
3255           rel_offset = section->sh_offset;
3256           rel_size   = section->sh_size;
3257
3258           if (rel_size)
3259             {
3260               Elf32_Internal_Shdr * strsec;
3261               Elf_Internal_Sym *    symtab;
3262               char *                strtab;
3263               int                   is_rela;
3264               unsigned long         nsyms;
3265
3266               printf (_("\nRelocation section "));
3267
3268               if (string_table == NULL)
3269                 printf ("%d", section->sh_name);
3270               else
3271                 printf ("'%s'", SECTION_NAME (section));
3272
3273               printf (_(" at offset 0x%lx contains %lu entries:\n"),
3274                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
3275
3276               symtab = NULL;
3277               strtab = NULL;
3278               nsyms = 0;
3279               if (section->sh_link)
3280                 {
3281                   Elf32_Internal_Shdr * symsec;
3282
3283                   symsec = section_headers + section->sh_link;
3284                   nsyms = symsec->sh_size / symsec->sh_entsize;
3285                   symtab = GET_ELF_SYMBOLS (file, symsec->sh_offset, nsyms);
3286
3287                   if (symtab == NULL)
3288                     continue;
3289
3290                   strsec = section_headers + symsec->sh_link;
3291
3292                   strtab = (char *) get_data (NULL, file, strsec->sh_offset,
3293                                               strsec->sh_size,
3294                                               _("string table"));
3295                 }
3296               is_rela = section->sh_type == SHT_RELA;
3297
3298               dump_relocations (file, rel_offset, rel_size,
3299                                 symtab, nsyms, strtab, is_rela);
3300
3301               if (strtab)
3302                 free (strtab);
3303               if (symtab)
3304                 free (symtab);
3305
3306               found = 1;
3307             }
3308         }
3309
3310       if (! found)
3311         printf (_("\nThere are no relocations in this file.\n"));
3312     }
3313
3314   return 1;
3315 }
3316
3317 #include "unwind-ia64.h"
3318
3319 /* An absolute address consists of a section and an offset.  If the
3320    section is NULL, the offset itself is the address, otherwise, the
3321    address equals to LOAD_ADDRESS(section) + offset.  */
3322
3323 struct absaddr
3324   {
3325     unsigned short section;
3326     bfd_vma offset;
3327   };
3328
3329 struct unw_aux_info
3330   {
3331     struct unw_table_entry
3332       {
3333         struct absaddr    start;
3334         struct absaddr    end;
3335         struct absaddr    info;
3336       }
3337     *table;                             /* Unwind table.  */
3338     unsigned long         table_len;    /* Length of unwind table.  */
3339     unsigned char *       info;         /* Unwind info.  */
3340     unsigned long         info_size;    /* Size of unwind info.  */
3341     bfd_vma               info_addr;    /* starting address of unwind info.  */
3342     bfd_vma               seg_base;     /* Starting address of segment.  */
3343     Elf_Internal_Sym *    symtab;       /* The symbol table.  */
3344     unsigned              long nsyms;   /* Number of symbols.  */
3345     char *                strtab;       /* The string table.  */
3346     unsigned long         strtab_size;  /* Size of string table.  */
3347   };
3348
3349 static void find_symbol_for_address PARAMS ((struct unw_aux_info *,
3350                                              struct absaddr, const char **,
3351                                              bfd_vma *));
3352 static void dump_ia64_unwind PARAMS ((struct unw_aux_info *));
3353 static int  slurp_ia64_unwind_table PARAMS ((FILE *, struct unw_aux_info *,
3354                                             Elf32_Internal_Shdr *));
3355
3356 static void
3357 find_symbol_for_address (aux, addr, symname, offset)
3358      struct unw_aux_info *aux;
3359      struct absaddr addr;
3360      const char **symname;
3361      bfd_vma *offset;
3362 {
3363   bfd_vma dist = (bfd_vma) 0x100000;
3364   Elf_Internal_Sym *sym, *best = NULL;
3365   unsigned long i;
3366
3367   for (i = 0, sym = aux->symtab; i < aux->nsyms; ++i, ++sym)
3368     {
3369       if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
3370           && sym->st_name != 0
3371           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
3372           && addr.offset >= sym->st_value
3373           && addr.offset - sym->st_value < dist)
3374         {
3375           best = sym;
3376           dist = addr.offset - sym->st_value;
3377           if (!dist)
3378             break;
3379         }
3380     }
3381   if (best)
3382     {
3383       *symname = (best->st_name >= aux->strtab_size
3384                   ? "<corrupt>" : aux->strtab + best->st_name);
3385       *offset = dist;
3386       return;
3387     }
3388   *symname = NULL;
3389   *offset = addr.offset;
3390 }
3391
3392 static void
3393 dump_ia64_unwind (aux)
3394      struct unw_aux_info *aux;
3395 {
3396   bfd_vma addr_size;
3397   struct unw_table_entry * tp;
3398   int in_body;
3399
3400   addr_size = is_32bit_elf ? 4 : 8;
3401
3402   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
3403     {
3404       bfd_vma stamp;
3405       bfd_vma offset;
3406       const unsigned char * dp;
3407       const unsigned char * head;
3408       const char * procname;
3409
3410       find_symbol_for_address (aux, tp->start, &procname, &offset);
3411
3412       fputs ("\n<", stdout);
3413
3414       if (procname)
3415         {
3416           fputs (procname, stdout);
3417
3418           if (offset)
3419             printf ("+%lx", (unsigned long) offset);
3420         }
3421
3422       fputs (">: [", stdout);
3423       print_vma (tp->start.offset, PREFIX_HEX);
3424       fputc ('-', stdout);
3425       print_vma (tp->end.offset, PREFIX_HEX);
3426       printf ("), info at +0x%lx\n",
3427               (unsigned long) (tp->info.offset - aux->seg_base));
3428
3429       head = aux->info + (tp->info.offset - aux->info_addr);
3430       stamp = BYTE_GET8 ((unsigned char *) head);
3431
3432       printf ("  v%u, flags=0x%lx (%s%s ), len=%lu bytes\n",
3433               (unsigned) UNW_VER (stamp),
3434               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
3435               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
3436               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
3437               (unsigned long) (addr_size * UNW_LENGTH (stamp)));
3438
3439       if (UNW_VER (stamp) != 1)
3440         {
3441           printf ("\tUnknown version.\n");
3442           continue;
3443         }
3444
3445       in_body = 0;
3446       for (dp = head + 8; dp < head + 8 + addr_size * UNW_LENGTH (stamp);)
3447         dp = unw_decode (dp, in_body, & in_body);
3448     }
3449 }
3450
3451 static int
3452 slurp_ia64_unwind_table (file, aux, sec)
3453      FILE *file;
3454      struct unw_aux_info *aux;
3455      Elf32_Internal_Shdr *sec;
3456 {
3457   unsigned long size, addr_size, nrelas, i;
3458   Elf_Internal_Phdr *prog_hdrs, *seg;
3459   struct unw_table_entry *tep;
3460   Elf32_Internal_Shdr *relsec;
3461   Elf_Internal_Rela *rela, *rp;
3462   unsigned char *table, *tp;
3463   Elf_Internal_Sym *sym;
3464   const char *relname;
3465   int result;
3466
3467   addr_size = is_32bit_elf ? 4 : 8;
3468
3469   /* First, find the starting address of the segment that includes
3470      this section: */
3471
3472   if (elf_header.e_phnum)
3473     {
3474       prog_hdrs = (Elf_Internal_Phdr *)
3475         xmalloc (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
3476
3477       if (is_32bit_elf)
3478         result = get_32bit_program_headers (file, prog_hdrs);
3479       else
3480         result = get_64bit_program_headers (file, prog_hdrs);
3481
3482       if (!result)
3483         {
3484           free (prog_hdrs);
3485           return 0;
3486         }
3487
3488       for (seg = prog_hdrs; seg < prog_hdrs + elf_header.e_phnum; ++seg)
3489         {
3490           if (seg->p_type != PT_LOAD)
3491             continue;
3492
3493           if (sec->sh_addr >= seg->p_vaddr
3494               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
3495             {
3496               aux->seg_base = seg->p_vaddr;
3497               break;
3498             }
3499         }
3500
3501       free (prog_hdrs);
3502     }
3503
3504   /* Second, build the unwind table from the contents of the unwind section:  */
3505   size = sec->sh_size;
3506   table = (char *) get_data (NULL, file, sec->sh_offset,
3507                              size, _("unwind table"));
3508   if (!table)
3509     return 0;
3510
3511   tep = aux->table = xmalloc (size / (3 * addr_size) * sizeof (aux->table[0]));
3512   for (tp = table; tp < table + size; tp += 3 * addr_size, ++ tep)
3513     {
3514       tep->start.section = SHN_UNDEF;
3515       tep->end.section   = SHN_UNDEF;
3516       tep->info.section  = SHN_UNDEF;
3517       if (is_32bit_elf)
3518         {
3519           tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
3520           tep->end.offset   = byte_get ((unsigned char *) tp + 4, 4);
3521           tep->info.offset  = byte_get ((unsigned char *) tp + 8, 4);
3522         }
3523       else
3524         {
3525           tep->start.offset = BYTE_GET8 ((unsigned char *) tp +  0);
3526           tep->end.offset   = BYTE_GET8 ((unsigned char *) tp +  8);
3527           tep->info.offset  = BYTE_GET8 ((unsigned char *) tp + 16);
3528         }
3529       tep->start.offset += aux->seg_base;
3530       tep->end.offset   += aux->seg_base;
3531       tep->info.offset  += aux->seg_base;
3532     }
3533   free (table);
3534
3535   /* Third, apply any relocations to the unwind table: */
3536
3537   for (relsec = section_headers;
3538        relsec < section_headers + elf_header.e_shnum;
3539        ++relsec)
3540     {
3541       if (relsec->sh_type != SHT_RELA
3542           || section_headers + relsec->sh_info != sec)
3543         continue;
3544
3545       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
3546                               & rela, & nrelas))
3547         return 0;
3548
3549       for (rp = rela; rp < rela + nrelas; ++rp)
3550         {
3551           if (is_32bit_elf)
3552             {
3553               relname = elf_ia64_reloc_type (ELF32_R_TYPE (rp->r_info));
3554               sym = aux->symtab + ELF32_R_SYM (rp->r_info);
3555
3556               if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
3557                 {
3558                   warn (_("Skipping unexpected symbol type %u"),
3559                         ELF32_ST_TYPE (sym->st_info));
3560                   continue;
3561                 }
3562             }
3563           else
3564             {
3565               relname = elf_ia64_reloc_type (ELF64_R_TYPE (rp->r_info));
3566               sym = aux->symtab + ELF64_R_SYM (rp->r_info);
3567
3568               if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
3569                 {
3570                   warn (_("Skipping unexpected symbol type %u"),
3571                         ELF64_ST_TYPE (sym->st_info));
3572                   continue;
3573                 }
3574             }
3575
3576           if (strncmp (relname, "R_IA64_SEGREL", 13) != 0)
3577             {
3578               warn (_("Skipping unexpected relocation type %s"), relname);
3579               continue;
3580             }
3581
3582           i = rp->r_offset / (3 * addr_size);
3583
3584           switch (rp->r_offset/addr_size % 3)
3585             {
3586             case 0:
3587               aux->table[i].start.section = sym->st_shndx;
3588               aux->table[i].start.offset += rp->r_addend;
3589               break;
3590             case 1:
3591               aux->table[i].end.section   = sym->st_shndx;
3592               aux->table[i].end.offset   += rp->r_addend;
3593               break;
3594             case 2:
3595               aux->table[i].info.section  = sym->st_shndx;
3596               aux->table[i].info.offset  += rp->r_addend;
3597               break;
3598             default:
3599               break;
3600             }
3601         }
3602
3603       free (rela);
3604     }
3605
3606   aux->table_len = size / (3 * addr_size);
3607   return 1;
3608 }
3609
3610 static int
3611 process_unwind (file)
3612      FILE * file;
3613 {
3614   Elf32_Internal_Shdr *sec, *unwsec = NULL, *strsec;
3615   unsigned long i, addr_size, unwcount = 0, unwstart = 0;
3616   struct unw_aux_info aux;
3617
3618   if (!do_unwind)
3619     return 1;
3620
3621   if (elf_header.e_machine != EM_IA_64)
3622     {
3623       printf (_("\nThere are no unwind sections in this file.\n"));
3624       return 1;
3625     }
3626
3627   memset (& aux, 0, sizeof (aux));
3628
3629   addr_size = is_32bit_elf ? 4 : 8;
3630
3631   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
3632     {
3633       if (sec->sh_type == SHT_SYMTAB)
3634         {
3635           aux.nsyms = sec->sh_size / sec->sh_entsize;
3636           aux.symtab = GET_ELF_SYMBOLS (file, sec->sh_offset, aux.nsyms);
3637
3638           strsec = section_headers + sec->sh_link;
3639           aux.strtab_size = strsec->sh_size;
3640           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
3641                                           aux.strtab_size, _("string table"));
3642         }
3643       else if (sec->sh_type == SHT_IA_64_UNWIND)
3644         unwcount++;
3645     }
3646
3647   if (!unwcount)
3648     printf (_("\nThere are no unwind sections in this file.\n"));
3649
3650   while (unwcount-- > 0)
3651     {
3652       char *suffix;
3653       size_t len, len2;
3654
3655       for (i = unwstart, sec = section_headers + unwstart;
3656            i < elf_header.e_shnum; ++i, ++sec)
3657         if (sec->sh_type == SHT_IA_64_UNWIND)
3658           {
3659             unwsec = sec;
3660             break;
3661           }
3662
3663       unwstart = i + 1;
3664       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
3665
3666       if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once,
3667                    len) == 0)
3668         {
3669           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
3670           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
3671           suffix = SECTION_NAME (unwsec) + len;
3672           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
3673                ++i, ++sec)
3674             if (strncmp (SECTION_NAME (sec),
3675                          ELF_STRING_ia64_unwind_info_once, len2) == 0
3676                 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
3677               break;
3678         }
3679       else
3680         {
3681           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
3682              .IA_64.unwind or BAR -> .IA_64.unwind_info */
3683           len = sizeof (ELF_STRING_ia64_unwind) - 1;
3684           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
3685           suffix = "";
3686           if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind,
3687                        len) == 0)
3688             suffix = SECTION_NAME (unwsec) + len;
3689           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
3690                ++i, ++sec)
3691             if (strncmp (SECTION_NAME (sec),
3692                          ELF_STRING_ia64_unwind_info, len2) == 0
3693                 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
3694               break;
3695         }
3696
3697       if (i == elf_header.e_shnum)
3698         {
3699           printf (_("\nCould not find unwind info section for "));
3700
3701           if (string_table == NULL)
3702             printf ("%d", unwsec->sh_name);
3703           else
3704             printf ("'%s'", SECTION_NAME (unwsec));
3705         }
3706       else
3707         {
3708           aux.info_size = sec->sh_size;
3709           aux.info_addr = sec->sh_addr;
3710           aux.info = (char *) get_data (NULL, file, sec->sh_offset,
3711                                         aux.info_size, _("unwind info"));
3712
3713           printf (_("\nUnwind section "));
3714
3715           if (string_table == NULL)
3716             printf ("%d", unwsec->sh_name);
3717           else
3718             printf ("'%s'", SECTION_NAME (unwsec));
3719
3720           printf (_(" at offset 0x%lx contains %lu entries:\n"),
3721                   (unsigned long) unwsec->sh_offset,
3722                   (unsigned long) (unwsec->sh_size / (3 * addr_size)));
3723
3724           (void) slurp_ia64_unwind_table (file, & aux, unwsec);
3725
3726           if (aux.table_len > 0)
3727             dump_ia64_unwind (& aux);
3728
3729           if (aux.table)
3730             free ((char *) aux.table);
3731           if (aux.info)
3732             free ((char *) aux.info);
3733           aux.table = NULL;
3734           aux.info = NULL;
3735         }
3736     }
3737
3738   if (aux.symtab)
3739     free (aux.symtab);
3740   if (aux.strtab)
3741     free ((char *) aux.strtab);
3742
3743   return 1;
3744 }
3745
3746 static void
3747 dynamic_segment_mips_val (entry)
3748      Elf_Internal_Dyn * entry;
3749 {
3750   switch (entry->d_tag)
3751     {
3752     case DT_MIPS_FLAGS:
3753       if (entry->d_un.d_val == 0)
3754         printf ("NONE\n");
3755       else
3756         {
3757           static const char * opts[] =
3758           {
3759             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
3760             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
3761             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
3762             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
3763             "RLD_ORDER_SAFE"
3764           };
3765           unsigned int cnt;
3766           int first = 1;
3767           for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
3768             if (entry->d_un.d_val & (1 << cnt))
3769               {
3770                 printf ("%s%s", first ? "" : " ", opts[cnt]);
3771                 first = 0;
3772               }
3773           puts ("");
3774         }
3775       break;
3776
3777     case DT_MIPS_IVERSION:
3778       if (dynamic_strings != NULL)
3779         printf ("Interface Version: %s\n",
3780                 dynamic_strings + entry->d_un.d_val);
3781       else
3782         printf ("%ld\n", (long) entry->d_un.d_ptr);
3783       break;
3784
3785     case DT_MIPS_TIME_STAMP:
3786       {
3787         char timebuf[20];
3788         struct tm * tmp;
3789
3790         time_t time = entry->d_un.d_val;
3791         tmp = gmtime (&time);
3792         sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
3793                  tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
3794                  tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
3795         printf ("Time Stamp: %s\n", timebuf);
3796       }
3797       break;
3798
3799     case DT_MIPS_RLD_VERSION:
3800     case DT_MIPS_LOCAL_GOTNO:
3801     case DT_MIPS_CONFLICTNO:
3802     case DT_MIPS_LIBLISTNO:
3803     case DT_MIPS_SYMTABNO:
3804     case DT_MIPS_UNREFEXTNO:
3805     case DT_MIPS_HIPAGENO:
3806     case DT_MIPS_DELTA_CLASS_NO:
3807     case DT_MIPS_DELTA_INSTANCE_NO:
3808     case DT_MIPS_DELTA_RELOC_NO:
3809     case DT_MIPS_DELTA_SYM_NO:
3810     case DT_MIPS_DELTA_CLASSSYM_NO:
3811     case DT_MIPS_COMPACT_SIZE:
3812       printf ("%ld\n", (long) entry->d_un.d_ptr);
3813       break;
3814
3815     default:
3816       printf ("%#lx\n", (long) entry->d_un.d_ptr);
3817     }
3818 }
3819
3820
3821 static void
3822 dynamic_segment_parisc_val (entry)
3823      Elf_Internal_Dyn * entry;
3824 {
3825   switch (entry->d_tag)
3826     {
3827     case DT_HP_DLD_FLAGS:
3828       {
3829         static struct
3830         {
3831           long int bit;
3832           const char * str;
3833         }
3834         flags[] =
3835         {
3836           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
3837           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
3838           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
3839           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
3840           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
3841           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
3842           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
3843           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
3844           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
3845           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
3846           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
3847         };
3848         int first = 1;
3849         size_t cnt;
3850         bfd_vma val = entry->d_un.d_val;
3851
3852         for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
3853           if (val & flags[cnt].bit)
3854             {
3855               if (! first)
3856                 putchar (' ');
3857               fputs (flags[cnt].str, stdout);
3858               first = 0;
3859               val ^= flags[cnt].bit;
3860             }
3861
3862         if (val != 0 || first)
3863           {
3864             if (! first)
3865               putchar (' ');
3866             print_vma (val, HEX);
3867           }
3868       }
3869       break;
3870
3871     default:
3872       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
3873       break;
3874     }
3875 }
3876
3877 static int
3878 get_32bit_dynamic_segment (file)
3879      FILE * file;
3880 {
3881   Elf32_External_Dyn * edyn;
3882   Elf_Internal_Dyn *   entry;
3883   bfd_size_type        i;
3884
3885   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr,
3886                                           dynamic_size, _("dynamic segment"));
3887   if (!edyn)
3888     return 0;
3889
3890   /* SGI's ELF has more than one section in the DYNAMIC segment.  Determine
3891      how large this .dynamic is now.  We can do this even before the byte
3892      swapping since the DT_NULL tag is recognizable.  */
3893   dynamic_size = 0;
3894   while (*(Elf32_Word *) edyn [dynamic_size++].d_tag != DT_NULL)
3895     ;
3896
3897   dynamic_segment = (Elf_Internal_Dyn *)
3898     malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3899
3900   if (dynamic_segment == NULL)
3901     {
3902       error (_("Out of memory\n"));
3903       free (edyn);
3904       return 0;
3905     }
3906
3907   for (i = 0, entry = dynamic_segment;
3908        i < dynamic_size;
3909        i ++, entry ++)
3910     {
3911       entry->d_tag      = BYTE_GET (edyn [i].d_tag);
3912       entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
3913     }
3914
3915   free (edyn);
3916
3917   return 1;
3918 }
3919
3920 static int
3921 get_64bit_dynamic_segment (file)
3922      FILE * file;
3923 {
3924   Elf64_External_Dyn * edyn;
3925   Elf_Internal_Dyn *   entry;
3926   bfd_size_type        i;
3927
3928   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr,
3929                                           dynamic_size, _("dynamic segment"));
3930   if (!edyn)
3931     return 0;
3932
3933   /* SGI's ELF has more than one section in the DYNAMIC segment.  Determine
3934      how large this .dynamic is now.  We can do this even before the byte
3935      swapping since the DT_NULL tag is recognizable.  */
3936   dynamic_size = 0;
3937   while (*(bfd_vma *) edyn [dynamic_size ++].d_tag != DT_NULL)
3938     ;
3939
3940   dynamic_segment = (Elf_Internal_Dyn *)
3941     malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3942
3943   if (dynamic_segment == NULL)
3944     {
3945       error (_("Out of memory\n"));
3946       free (edyn);
3947       return 0;
3948     }
3949
3950   for (i = 0, entry = dynamic_segment;
3951        i < dynamic_size;
3952        i ++, entry ++)
3953     {
3954       entry->d_tag      = BYTE_GET8 (edyn [i].d_tag);
3955       entry->d_un.d_val = BYTE_GET8 (edyn [i].d_un.d_val);
3956     }
3957
3958   free (edyn);
3959
3960   return 1;
3961 }
3962
3963 static const char *
3964 get_dynamic_flags (flags)
3965      bfd_vma flags;
3966 {
3967   static char buff [64];
3968   while (flags)
3969     {
3970       bfd_vma flag;
3971
3972       flag = flags & - flags;
3973       flags &= ~ flag;
3974
3975       switch (flag)
3976         {
3977         case DF_ORIGIN:   strcat (buff, "ORIGIN "); break;
3978         case DF_SYMBOLIC: strcat (buff, "SYMBOLIC "); break;
3979         case DF_TEXTREL:  strcat (buff, "TEXTREL "); break;
3980         case DF_BIND_NOW: strcat (buff, "BIND_NOW "); break;
3981         default:          strcat (buff, "unknown "); break;
3982         }
3983     }
3984   return buff;
3985 }
3986
3987 /* Parse and display the contents of the dynamic segment.  */
3988 static int
3989 process_dynamic_segment (file)
3990      FILE * file;
3991 {
3992   Elf_Internal_Dyn * entry;
3993   bfd_size_type      i;
3994
3995   if (dynamic_size == 0)
3996     {
3997       if (do_dynamic)
3998         printf (_("\nThere is no dynamic segment in this file.\n"));
3999
4000       return 1;
4001     }
4002
4003   if (is_32bit_elf)
4004     {
4005       if (! get_32bit_dynamic_segment (file))
4006         return 0;
4007     }
4008   else if (! get_64bit_dynamic_segment (file))
4009     return 0;
4010
4011   /* Find the appropriate symbol table.  */
4012   if (dynamic_symbols == NULL)
4013     {
4014       for (i = 0, entry = dynamic_segment;
4015            i < dynamic_size;
4016            ++i, ++ entry)
4017         {
4018           unsigned long        offset;
4019
4020           if (entry->d_tag != DT_SYMTAB)
4021             continue;
4022
4023           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
4024
4025           /* Since we do not know how big the symbol table is,
4026              we default to reading in the entire file (!) and
4027              processing that.  This is overkill, I know, but it
4028              should work. */
4029           offset = entry->d_un.d_val - loadaddr;
4030
4031           if (fseek (file, 0, SEEK_END))
4032             error (_("Unable to seek to end of file!"));
4033
4034           if (is_32bit_elf)
4035             num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf32_External_Sym);
4036           else
4037             num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf64_External_Sym);
4038
4039           if (num_dynamic_syms < 1)
4040             {
4041               error (_("Unable to determine the number of symbols to load\n"));
4042               continue;
4043             }
4044
4045           dynamic_symbols = GET_ELF_SYMBOLS (file, offset, num_dynamic_syms);
4046         }
4047     }
4048
4049   /* Similarly find a string table.  */
4050   if (dynamic_strings == NULL)
4051     {
4052       for (i = 0, entry = dynamic_segment;
4053            i < dynamic_size;
4054            ++i, ++ entry)
4055         {
4056           unsigned long offset;
4057           long          str_tab_len;
4058
4059           if (entry->d_tag != DT_STRTAB)
4060             continue;
4061
4062           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
4063
4064           /* Since we do not know how big the string table is,
4065              we default to reading in the entire file (!) and
4066              processing that.  This is overkill, I know, but it
4067              should work. */
4068
4069           offset = entry->d_un.d_val - loadaddr;
4070           if (fseek (file, 0, SEEK_END))
4071             error (_("Unable to seek to end of file\n"));
4072           str_tab_len = ftell (file) - offset;
4073
4074           if (str_tab_len < 1)
4075             {
4076               error
4077                 (_("Unable to determine the length of the dynamic string table\n"));
4078               continue;
4079             }
4080
4081           dynamic_strings = (char *) get_data (NULL, file, offset, str_tab_len,
4082                                                _("dynamic string table"));
4083
4084           break;
4085         }
4086     }
4087
4088   /* And find the syminfo section if available.  */
4089   if (dynamic_syminfo == NULL)
4090     {
4091       unsigned int syminsz = 0;
4092
4093       for (i = 0, entry = dynamic_segment;
4094            i < dynamic_size;
4095            ++i, ++ entry)
4096         {
4097           if (entry->d_tag == DT_SYMINENT)
4098             {
4099               /* Note: these braces are necessary to avoid a syntax
4100                  error from the SunOS4 C compiler.  */
4101               assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
4102             }
4103           else if (entry->d_tag == DT_SYMINSZ)
4104             syminsz = entry->d_un.d_val;
4105           else if (entry->d_tag == DT_SYMINFO)
4106             dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
4107         }
4108
4109       if (dynamic_syminfo_offset != 0 && syminsz != 0)
4110         {
4111           Elf_External_Syminfo * extsyminfo;
4112           Elf_Internal_Syminfo * syminfo;
4113
4114           /* There is a syminfo section.  Read the data.  */
4115           extsyminfo = ((Elf_External_Syminfo *)
4116                         get_data (NULL, file, dynamic_syminfo_offset,
4117                                   syminsz, _("symbol information")));
4118           if (!extsyminfo)
4119             return 0;
4120
4121           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
4122           if (dynamic_syminfo == NULL)
4123             {
4124               error (_("Out of memory\n"));
4125               return 0;
4126             }
4127
4128           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
4129           for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
4130                ++i, ++syminfo)
4131             {
4132               syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
4133               syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
4134             }
4135
4136           free (extsyminfo);
4137         }
4138     }
4139
4140   if (do_dynamic && dynamic_addr)
4141     printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
4142             dynamic_addr, (long) dynamic_size);
4143   if (do_dynamic)
4144     printf (_("  Tag        Type                         Name/Value\n"));
4145
4146   for (i = 0, entry = dynamic_segment;
4147        i < dynamic_size;
4148        i++, entry ++)
4149     {
4150       if (do_dynamic)
4151         {
4152           const char * dtype;
4153
4154           putchar (' ');
4155           print_vma (entry->d_tag, FULL_HEX);
4156           dtype = get_dynamic_type (entry->d_tag);
4157           printf (" (%s)%*s", dtype,
4158                   ((is_32bit_elf ? 27 : 19)
4159                    - (int) strlen (dtype)),
4160                   " ");
4161         }
4162
4163       switch (entry->d_tag)
4164         {
4165         case DT_FLAGS:
4166           if (do_dynamic)
4167             printf ("%s", get_dynamic_flags (entry->d_un.d_val));
4168           break;
4169
4170         case DT_AUXILIARY:
4171         case DT_FILTER:
4172         case DT_CONFIG:
4173         case DT_DEPAUDIT:
4174         case DT_AUDIT:
4175           if (do_dynamic)
4176             {
4177               switch (entry->d_tag)
4178                 {
4179                 case DT_AUXILIARY:
4180                   printf (_("Auxiliary library"));
4181                   break;
4182
4183                 case DT_FILTER:
4184                   printf (_("Filter library"));
4185                   break;
4186
4187                 case DT_CONFIG:
4188                   printf (_("Configuration file"));
4189                   break;
4190
4191                 case DT_DEPAUDIT:
4192                   printf (_("Dependency audit library"));
4193                   break;
4194
4195                 case DT_AUDIT:
4196                   printf (_("Audit library"));
4197                   break;
4198                 }
4199
4200               if (dynamic_strings)
4201                 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
4202               else
4203                 {
4204                   printf (": ");
4205                   print_vma (entry->d_un.d_val, PREFIX_HEX);
4206                   putchar ('\n');
4207                 }
4208             }
4209           break;
4210
4211         case DT_FEATURE:
4212           if (do_dynamic)
4213             {
4214               printf (_("Flags:"));
4215               if (entry->d_un.d_val == 0)
4216                 printf (_(" None\n"));
4217               else
4218                 {
4219                   unsigned long int val = entry->d_un.d_val;
4220                   if (val & DTF_1_PARINIT)
4221                     {
4222                       printf (" PARINIT");
4223                       val ^= DTF_1_PARINIT;
4224                     }
4225                   if (val & DTF_1_CONFEXP)
4226                     {
4227                       printf (" CONFEXP");
4228                       val ^= DTF_1_CONFEXP;
4229                     }
4230                   if (val != 0)
4231                     printf (" %lx", val);
4232                   puts ("");
4233                 }
4234             }
4235           break;
4236
4237         case DT_POSFLAG_1:
4238           if (do_dynamic)
4239             {
4240               printf (_("Flags:"));
4241               if (entry->d_un.d_val == 0)
4242                 printf (_(" None\n"));
4243               else
4244                 {
4245                   unsigned long int val = entry->d_un.d_val;
4246                   if (val & DF_P1_LAZYLOAD)
4247                     {
4248                       printf (" LAZYLOAD");
4249                       val ^= DF_P1_LAZYLOAD;
4250                     }
4251                   if (val & DF_P1_GROUPPERM)
4252                     {
4253                       printf (" GROUPPERM");
4254                       val ^= DF_P1_GROUPPERM;
4255                     }
4256                   if (val != 0)
4257                     printf (" %lx", val);
4258                   puts ("");
4259                 }
4260             }
4261           break;
4262
4263         case DT_FLAGS_1:
4264           if (do_dynamic)
4265             {
4266               printf (_("Flags:"));
4267               if (entry->d_un.d_val == 0)
4268                 printf (_(" None\n"));
4269               else
4270                 {
4271                   unsigned long int val = entry->d_un.d_val;
4272                   if (val & DF_1_NOW)
4273                     {
4274                       printf (" NOW");
4275                       val ^= DF_1_NOW;
4276                     }
4277                   if (val & DF_1_GLOBAL)
4278                     {
4279                       printf (" GLOBAL");
4280                       val ^= DF_1_GLOBAL;
4281                     }
4282                   if (val & DF_1_GROUP)
4283                     {
4284                       printf (" GROUP");
4285                       val ^= DF_1_GROUP;
4286                     }
4287                   if (val & DF_1_NODELETE)
4288                     {
4289                       printf (" NODELETE");
4290                       val ^= DF_1_NODELETE;
4291                     }
4292                   if (val & DF_1_LOADFLTR)
4293                     {
4294                       printf (" LOADFLTR");
4295                       val ^= DF_1_LOADFLTR;
4296                     }
4297                   if (val & DF_1_INITFIRST)
4298                     {
4299                       printf (" INITFIRST");
4300                       val ^= DF_1_INITFIRST;
4301                     }
4302                   if (val & DF_1_NOOPEN)
4303                     {
4304                       printf (" NOOPEN");
4305                       val ^= DF_1_NOOPEN;
4306                     }
4307                   if (val & DF_1_ORIGIN)
4308                     {
4309                       printf (" ORIGIN");
4310                       val ^= DF_1_ORIGIN;
4311                     }
4312                   if (val & DF_1_DIRECT)
4313                     {
4314                       printf (" DIRECT");
4315                       val ^= DF_1_DIRECT;
4316                     }
4317                   if (val & DF_1_TRANS)
4318                     {
4319                       printf (" TRANS");
4320                       val ^= DF_1_TRANS;
4321                     }
4322                   if (val & DF_1_INTERPOSE)
4323                     {
4324                       printf (" INTERPOSE");
4325                       val ^= DF_1_INTERPOSE;
4326                     }
4327                   if (val & DF_1_NODEFLIB)
4328                     {
4329                       printf (" NODEFLIB");
4330                       val ^= DF_1_NODEFLIB;
4331                     }
4332                   if (val & DF_1_NODUMP)
4333                     {
4334                       printf (" NODUMP");
4335                       val ^= DF_1_NODUMP;
4336                     }
4337                   if (val & DF_1_CONLFAT)
4338                     {
4339                       printf (" CONLFAT");
4340                       val ^= DF_1_CONLFAT;
4341                     }
4342                   if (val != 0)
4343                     printf (" %lx", val);
4344                   puts ("");
4345                 }
4346             }
4347           break;
4348
4349         case DT_PLTREL:
4350           if (do_dynamic)
4351             puts (get_dynamic_type (entry->d_un.d_val));
4352           break;
4353
4354         case DT_NULL    :
4355         case DT_NEEDED  :
4356         case DT_PLTGOT  :
4357         case DT_HASH    :
4358         case DT_STRTAB  :
4359         case DT_SYMTAB  :
4360         case DT_RELA    :
4361         case DT_INIT    :
4362         case DT_FINI    :
4363         case DT_SONAME  :
4364         case DT_RPATH   :
4365         case DT_SYMBOLIC:
4366         case DT_REL     :
4367         case DT_DEBUG   :
4368         case DT_TEXTREL :
4369         case DT_JMPREL  :
4370         case DT_RUNPATH :
4371           dynamic_info[entry->d_tag] = entry->d_un.d_val;
4372
4373           if (do_dynamic)
4374             {
4375               char * name;
4376
4377               if (dynamic_strings == NULL)
4378                 name = NULL;
4379               else
4380                 name = dynamic_strings + entry->d_un.d_val;
4381
4382               if (name)
4383                 {
4384                   switch (entry->d_tag)
4385                     {
4386                     case DT_NEEDED:
4387                       printf (_("Shared library: [%s]"), name);
4388
4389                       if (strcmp (name, program_interpreter) == 0)
4390                         printf (_(" program interpreter"));
4391                       break;
4392
4393                     case DT_SONAME:
4394                       printf (_("Library soname: [%s]"), name);
4395                       break;
4396
4397                     case DT_RPATH:
4398                       printf (_("Library rpath: [%s]"), name);
4399                       break;
4400
4401                     case DT_RUNPATH:
4402                       printf (_("Library runpath: [%s]"), name);
4403                       break;
4404
4405                     default:
4406                       print_vma (entry->d_un.d_val, PREFIX_HEX);
4407                       break;
4408                     }
4409                 }
4410               else
4411                 print_vma (entry->d_un.d_val, PREFIX_HEX);
4412
4413               putchar ('\n');
4414             }
4415           break;
4416
4417         case DT_PLTRELSZ:
4418         case DT_RELASZ  :
4419         case DT_STRSZ   :
4420         case DT_RELSZ   :
4421         case DT_RELAENT :
4422         case DT_SYMENT  :
4423         case DT_RELENT  :
4424         case DT_PLTPADSZ:
4425         case DT_MOVEENT :
4426         case DT_MOVESZ  :
4427         case DT_INIT_ARRAYSZ:
4428         case DT_FINI_ARRAYSZ:
4429           if (do_dynamic)
4430             {
4431               print_vma (entry->d_un.d_val, UNSIGNED);
4432               printf (" (bytes)\n");
4433             }
4434           break;
4435
4436         case DT_VERDEFNUM:
4437         case DT_VERNEEDNUM:
4438         case DT_RELACOUNT:
4439         case DT_RELCOUNT:
4440           if (do_dynamic)
4441             {
4442               print_vma (entry->d_un.d_val, UNSIGNED);
4443               putchar ('\n');
4444             }
4445           break;
4446
4447         case DT_SYMINSZ:
4448         case DT_SYMINENT:
4449         case DT_SYMINFO:
4450         case DT_USED:
4451         case DT_INIT_ARRAY:
4452         case DT_FINI_ARRAY:
4453           if (do_dynamic)
4454             {
4455               if (dynamic_strings != NULL && entry->d_tag == DT_USED)
4456                 {
4457                   char * name;
4458
4459                   name = dynamic_strings + entry->d_un.d_val;
4460
4461                   if (* name)
4462                     {
4463                       printf (_("Not needed object: [%s]\n"), name);
4464                       break;
4465                     }
4466                 }
4467
4468               print_vma (entry->d_un.d_val, PREFIX_HEX);
4469               putchar ('\n');
4470             }
4471           break;
4472
4473         case DT_BIND_NOW:
4474           /* The value of this entry is ignored.  */
4475           break;
4476
4477         default:
4478           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
4479             version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
4480               entry->d_un.d_val;
4481
4482           if (do_dynamic)
4483             {
4484               switch (elf_header.e_machine)
4485                 {
4486                 case EM_MIPS:
4487                 case EM_MIPS_RS3_LE:
4488                   dynamic_segment_mips_val (entry);
4489                   break;
4490                 case EM_PARISC:
4491                   dynamic_segment_parisc_val (entry);
4492                   break;
4493                 default:
4494                   print_vma (entry->d_un.d_val, PREFIX_HEX);
4495                   putchar ('\n');
4496                 }
4497             }
4498           break;
4499         }
4500     }
4501
4502   return 1;
4503 }
4504
4505 static char *
4506 get_ver_flags (flags)
4507      unsigned int flags;
4508 {
4509   static char buff [32];
4510
4511   buff[0] = 0;
4512
4513   if (flags == 0)
4514     return _("none");
4515
4516   if (flags & VER_FLG_BASE)
4517     strcat (buff, "BASE ");
4518
4519   if (flags & VER_FLG_WEAK)
4520     {
4521       if (flags & VER_FLG_BASE)
4522         strcat (buff, "| ");
4523
4524       strcat (buff, "WEAK ");
4525     }
4526
4527   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
4528     strcat (buff, "| <unknown>");
4529
4530   return buff;
4531 }
4532
4533 /* Display the contents of the version sections.  */
4534 static int
4535 process_version_sections (file)
4536      FILE * file;
4537 {
4538   Elf32_Internal_Shdr * section;
4539   unsigned   i;
4540   int        found = 0;
4541
4542   if (! do_version)
4543     return 1;
4544
4545   for (i = 0, section = section_headers;
4546        i < elf_header.e_shnum;
4547        i++, section ++)
4548     {
4549       switch (section->sh_type)
4550         {
4551         case SHT_GNU_verdef:
4552           {
4553             Elf_External_Verdef * edefs;
4554             unsigned int          idx;
4555             unsigned int          cnt;
4556
4557             found = 1;
4558
4559             printf
4560               (_("\nVersion definition section '%s' contains %ld entries:\n"),
4561                SECTION_NAME (section), section->sh_info);
4562
4563             printf (_("  Addr: 0x"));
4564             printf_vma (section->sh_addr);
4565             printf (_("  Offset: %#08lx  Link: %lx (%s)\n"),
4566                     (unsigned long) section->sh_offset, section->sh_link,
4567                     SECTION_NAME (section_headers + section->sh_link));
4568
4569             edefs = ((Elf_External_Verdef *)
4570                      get_data (NULL, file, section->sh_offset,
4571                                section->sh_size,
4572                                _("version definition section")));
4573             if (!edefs)
4574               break;
4575
4576             for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
4577               {
4578                 char *                 vstart;
4579                 Elf_External_Verdef *  edef;
4580                 Elf_Internal_Verdef    ent;
4581                 Elf_External_Verdaux * eaux;
4582                 Elf_Internal_Verdaux   aux;
4583                 int                    j;
4584                 int                    isum;
4585
4586                 vstart = ((char *) edefs) + idx;
4587
4588                 edef = (Elf_External_Verdef *) vstart;
4589
4590                 ent.vd_version = BYTE_GET (edef->vd_version);
4591                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
4592                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
4593                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
4594                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
4595                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
4596                 ent.vd_next    = BYTE_GET (edef->vd_next);
4597
4598                 printf (_("  %#06x: Rev: %d  Flags: %s"),
4599                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
4600
4601                 printf (_("  Index: %d  Cnt: %d  "),
4602                         ent.vd_ndx, ent.vd_cnt);
4603
4604                 vstart += ent.vd_aux;
4605
4606                 eaux = (Elf_External_Verdaux *) vstart;
4607
4608                 aux.vda_name = BYTE_GET (eaux->vda_name);
4609                 aux.vda_next = BYTE_GET (eaux->vda_next);
4610
4611                 if (dynamic_strings)
4612                   printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
4613                 else
4614                   printf (_("Name index: %ld\n"), aux.vda_name);
4615
4616                 isum = idx + ent.vd_aux;
4617
4618                 for (j = 1; j < ent.vd_cnt; j ++)
4619                   {
4620                     isum   += aux.vda_next;
4621                     vstart += aux.vda_next;
4622
4623                     eaux = (Elf_External_Verdaux *) vstart;
4624
4625                     aux.vda_name = BYTE_GET (eaux->vda_name);
4626                     aux.vda_next = BYTE_GET (eaux->vda_next);
4627
4628                     if (dynamic_strings)
4629                       printf (_("  %#06x: Parent %d: %s\n"),
4630                               isum, j, dynamic_strings + aux.vda_name);
4631                     else
4632                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
4633                               isum, j, aux.vda_name);
4634                   }
4635
4636                 idx += ent.vd_next;
4637               }
4638
4639             free (edefs);
4640           }
4641           break;
4642
4643         case SHT_GNU_verneed:
4644           {
4645             Elf_External_Verneed *  eneed;
4646             unsigned int            idx;
4647             unsigned int            cnt;
4648
4649             found = 1;
4650
4651             printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
4652                     SECTION_NAME (section), section->sh_info);
4653
4654             printf (_(" Addr: 0x"));
4655             printf_vma (section->sh_addr);
4656             printf (_("  Offset: %#08lx  Link to section: %ld (%s)\n"),
4657                     (unsigned long) section->sh_offset, section->sh_link,
4658                     SECTION_NAME (section_headers + section->sh_link));
4659
4660             eneed = ((Elf_External_Verneed *)
4661                      get_data (NULL, file, section->sh_offset,
4662                                section->sh_size, _("version need section")));
4663             if (!eneed)
4664               break;
4665
4666             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
4667               {
4668                 Elf_External_Verneed * entry;
4669                 Elf_Internal_Verneed     ent;
4670                 int                      j;
4671                 int                      isum;
4672                 char *                   vstart;
4673
4674                 vstart = ((char *) eneed) + idx;
4675
4676                 entry = (Elf_External_Verneed *) vstart;
4677
4678                 ent.vn_version = BYTE_GET (entry->vn_version);
4679                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
4680                 ent.vn_file    = BYTE_GET (entry->vn_file);
4681                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
4682                 ent.vn_next    = BYTE_GET (entry->vn_next);
4683
4684                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
4685
4686                 if (dynamic_strings)
4687                   printf (_("  File: %s"), dynamic_strings + ent.vn_file);
4688                 else
4689                   printf (_("  File: %lx"), ent.vn_file);
4690
4691                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
4692
4693                 vstart += ent.vn_aux;
4694
4695                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
4696                   {
4697                     Elf_External_Vernaux * eaux;
4698                     Elf_Internal_Vernaux   aux;
4699
4700                     eaux = (Elf_External_Vernaux *) vstart;
4701
4702                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
4703                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
4704                     aux.vna_other = BYTE_GET (eaux->vna_other);
4705                     aux.vna_name  = BYTE_GET (eaux->vna_name);
4706                     aux.vna_next  = BYTE_GET (eaux->vna_next);
4707
4708                     if (dynamic_strings)
4709                       printf (_("  %#06x: Name: %s"),
4710                               isum, dynamic_strings + aux.vna_name);
4711                     else
4712                       printf (_("  %#06x: Name index: %lx"),
4713                               isum, aux.vna_name);
4714
4715                     printf (_("  Flags: %s  Version: %d\n"),
4716                             get_ver_flags (aux.vna_flags), aux.vna_other);
4717
4718                     isum   += aux.vna_next;
4719                     vstart += aux.vna_next;
4720                   }
4721
4722                 idx += ent.vn_next;
4723               }
4724
4725             free (eneed);
4726           }
4727           break;
4728
4729         case SHT_GNU_versym:
4730           {
4731             Elf32_Internal_Shdr *       link_section;
4732             int         total;
4733             int         cnt;
4734             unsigned char *             edata;
4735             unsigned short *            data;
4736             char *              strtab;
4737             Elf_Internal_Sym *          symbols;
4738             Elf32_Internal_Shdr *       string_sec;
4739
4740             link_section = section_headers + section->sh_link;
4741             total = section->sh_size / section->sh_entsize;
4742
4743             found = 1;
4744
4745             symbols = GET_ELF_SYMBOLS (file, link_section->sh_offset,
4746                                        link_section->sh_size / link_section->sh_entsize);
4747
4748             string_sec = section_headers + link_section->sh_link;
4749
4750             strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
4751                                         string_sec->sh_size,
4752                                         _("version string table"));
4753             if (!strtab)
4754               break;
4755
4756             printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
4757                     SECTION_NAME (section), total);
4758
4759             printf (_(" Addr: "));
4760             printf_vma (section->sh_addr);
4761             printf (_("  Offset: %#08lx  Link: %lx (%s)\n"),
4762                     (unsigned long) section->sh_offset, section->sh_link,
4763                     SECTION_NAME (link_section));
4764
4765             edata =
4766               ((unsigned char *)
4767                get_data (NULL, file,
4768                          version_info[DT_VERSIONTAGIDX (DT_VERSYM)] - loadaddr,
4769                          total * sizeof (short), _("version symbol data")));
4770             if (!edata)
4771               {
4772                 free (strtab);
4773                 break;
4774               }
4775
4776             data = (unsigned short *) malloc (total * sizeof (short));
4777
4778             for (cnt = total; cnt --;)
4779               data [cnt] = byte_get (edata + cnt * sizeof (short),
4780                                      sizeof (short));
4781
4782             free (edata);
4783
4784             for (cnt = 0; cnt < total; cnt += 4)
4785               {
4786                 int j, nn;
4787                 int check_def, check_need;
4788                 char * name;
4789
4790                 printf ("  %03x:", cnt);
4791
4792                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
4793                   switch (data [cnt + j])
4794                     {
4795                     case 0:
4796                       fputs (_("   0 (*local*)    "), stdout);
4797                       break;
4798
4799                     case 1:
4800                       fputs (_("   1 (*global*)   "), stdout);
4801                       break;
4802
4803                     default:
4804                       nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
4805                                    data [cnt + j] & 0x8000 ? 'h' : ' ');
4806
4807                       check_def = 1;
4808                       check_need = 1;
4809                       if (symbols [cnt + j].st_shndx >= SHN_LORESERVE
4810                           || section_headers[symbols [cnt + j].st_shndx].sh_type
4811                           != SHT_NOBITS)
4812                         {
4813                           if (symbols [cnt + j].st_shndx == SHN_UNDEF)
4814                             check_def = 0;
4815                           else
4816                             check_need = 0;
4817                         }
4818
4819                       if (check_need
4820                           && version_info [DT_VERSIONTAGIDX (DT_VERNEED)])
4821                         {
4822                           Elf_Internal_Verneed     ivn;
4823                           unsigned long            offset;
4824
4825                           offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4826                             - loadaddr;
4827
4828                           do
4829                             {
4830                               Elf_Internal_Vernaux   ivna;
4831                               Elf_External_Verneed   evn;
4832                               Elf_External_Vernaux   evna;
4833                               unsigned long          a_off;
4834
4835                               get_data (&evn, file, offset, sizeof (evn),
4836                                         _("version need"));
4837
4838                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
4839                               ivn.vn_next = BYTE_GET (evn.vn_next);
4840
4841                               a_off = offset + ivn.vn_aux;
4842
4843                               do
4844                                 {
4845                                   get_data (&evna, file, a_off, sizeof (evna),
4846                                             _("version need aux (2)"));
4847
4848                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
4849                                   ivna.vna_other = BYTE_GET (evna.vna_other);
4850
4851                                   a_off += ivna.vna_next;
4852                                 }
4853                               while (ivna.vna_other != data [cnt + j]
4854                                      && ivna.vna_next != 0);
4855
4856                               if (ivna.vna_other == data [cnt + j])
4857                                 {
4858                                   ivna.vna_name = BYTE_GET (evna.vna_name);
4859
4860                                   name = strtab + ivna.vna_name;
4861                                   nn += printf ("(%s%-*s",
4862                                                 name,
4863                                                 12 - (int) strlen (name),
4864                                                 ")");
4865                                   check_def = 0;
4866                                   break;
4867                                 }
4868
4869                               offset += ivn.vn_next;
4870                             }
4871                           while (ivn.vn_next);
4872                         }
4873
4874                       if (check_def && data [cnt + j] != 0x8001
4875                           && version_info [DT_VERSIONTAGIDX (DT_VERDEF)])
4876                         {
4877                           Elf_Internal_Verdef  ivd;
4878                           Elf_External_Verdef  evd;
4879                           unsigned long        offset;
4880
4881                           offset = version_info
4882                             [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
4883
4884                           do
4885                             {
4886                               get_data (&evd, file, offset, sizeof (evd),
4887                                         _("version def"));
4888
4889                               ivd.vd_next = BYTE_GET (evd.vd_next);
4890                               ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
4891
4892                               offset += ivd.vd_next;
4893                             }
4894                           while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
4895                                  && ivd.vd_next != 0);
4896
4897                           if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
4898                             {
4899                               Elf_External_Verdaux  evda;
4900                               Elf_Internal_Verdaux  ivda;
4901
4902                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
4903
4904                               get_data (&evda, file,
4905                                         offset - ivd.vd_next + ivd.vd_aux,
4906                                         sizeof (evda), _("version def aux"));
4907
4908                               ivda.vda_name = BYTE_GET (evda.vda_name);
4909
4910                               name = strtab + ivda.vda_name;
4911                               nn += printf ("(%s%-*s",
4912                                             name,
4913                                             12 - (int) strlen (name),
4914                                             ")");
4915                             }
4916                         }
4917
4918                       if (nn < 18)
4919                         printf ("%*c", 18 - nn, ' ');
4920                     }
4921
4922                 putchar ('\n');
4923               }
4924
4925             free (data);
4926             free (strtab);
4927             free (symbols);
4928           }
4929           break;
4930
4931         default:
4932           break;
4933         }
4934     }
4935
4936   if (! found)
4937     printf (_("\nNo version information found in this file.\n"));
4938
4939   return 1;
4940 }
4941
4942 static const char *
4943 get_symbol_binding (binding)
4944      unsigned int binding;
4945 {
4946   static char buff [32];
4947
4948   switch (binding)
4949     {
4950     case STB_LOCAL:  return "LOCAL";
4951     case STB_GLOBAL: return "GLOBAL";
4952     case STB_WEAK:   return "WEAK";
4953     default:
4954       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
4955         sprintf (buff, _("<processor specific>: %d"), binding);
4956       else if (binding >= STB_LOOS && binding <= STB_HIOS)
4957         sprintf (buff, _("<OS specific>: %d"), binding);
4958       else
4959         sprintf (buff, _("<unknown>: %d"), binding);
4960       return buff;
4961     }
4962 }
4963
4964 static const char *
4965 get_symbol_type (type)
4966      unsigned int type;
4967 {
4968   static char buff [32];
4969
4970   switch (type)
4971     {
4972     case STT_NOTYPE:   return "NOTYPE";
4973     case STT_OBJECT:   return "OBJECT";
4974     case STT_FUNC:     return "FUNC";
4975     case STT_SECTION:  return "SECTION";
4976     case STT_FILE:     return "FILE";
4977     case STT_COMMON:   return "COMMON";
4978     default:
4979       if (type >= STT_LOPROC && type <= STT_HIPROC)
4980         {
4981           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
4982             return "THUMB_FUNC";
4983
4984           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
4985             return "REGISTER";
4986
4987           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
4988             return "PARISC_MILLI";
4989
4990           sprintf (buff, _("<processor specific>: %d"), type);
4991         }
4992       else if (type >= STT_LOOS && type <= STT_HIOS)
4993         {
4994           if (elf_header.e_machine == EM_PARISC)
4995             {
4996               if (type == STT_HP_OPAQUE)
4997                 return "HP_OPAQUE";
4998               if (type == STT_HP_STUB)
4999                 return "HP_STUB";
5000             }
5001
5002           sprintf (buff, _("<OS specific>: %d"), type);
5003         }
5004       else
5005         sprintf (buff, _("<unknown>: %d"), type);
5006       return buff;
5007     }
5008 }
5009
5010 static const char *
5011 get_symbol_visibility (visibility)
5012      unsigned int visibility;
5013 {
5014   switch (visibility)
5015     {
5016     case STV_DEFAULT:   return "DEFAULT";
5017     case STV_INTERNAL:  return "INTERNAL";
5018     case STV_HIDDEN:    return "HIDDEN";
5019     case STV_PROTECTED: return "PROTECTED";
5020     default: abort ();
5021     }
5022 }
5023
5024 static const char *
5025 get_symbol_index_type (type)
5026      unsigned int type;
5027 {
5028   switch (type)
5029     {
5030     case SHN_UNDEF:  return "UND";
5031     case SHN_ABS:    return "ABS";
5032     case SHN_COMMON: return "COM";
5033     default:
5034       if (type >= SHN_LOPROC && type <= SHN_HIPROC)
5035         return "PRC";
5036       else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
5037         return "RSV";
5038       else if (type >= SHN_LOOS && type <= SHN_HIOS)
5039         return "OS ";
5040       else
5041         {
5042           static char buff [32];
5043
5044           sprintf (buff, "%3d", type);
5045           return buff;
5046         }
5047     }
5048 }
5049
5050 static int *
5051 get_dynamic_data (file, number)
5052      FILE *       file;
5053      unsigned int number;
5054 {
5055   unsigned char * e_data;
5056   int *  i_data;
5057
5058   e_data = (unsigned char *) malloc (number * 4);
5059
5060   if (e_data == NULL)
5061     {
5062       error (_("Out of memory\n"));
5063       return NULL;
5064     }
5065
5066   if (fread (e_data, 4, number, file) != number)
5067     {
5068       error (_("Unable to read in dynamic data\n"));
5069       return NULL;
5070     }
5071
5072   i_data = (int *) malloc (number * sizeof (* i_data));
5073
5074   if (i_data == NULL)
5075     {
5076       error (_("Out of memory\n"));
5077       free (e_data);
5078       return NULL;
5079     }
5080
5081   while (number--)
5082     i_data [number] = byte_get (e_data + number * 4, 4);
5083
5084   free (e_data);
5085
5086   return i_data;
5087 }
5088
5089 /* Dump the symbol table */
5090 static int
5091 process_symbol_table (file)
5092      FILE * file;
5093 {
5094   Elf32_Internal_Shdr *   section;
5095   unsigned char   nb [4];
5096   unsigned char   nc [4];
5097   int    nbuckets = 0;
5098   int    nchains = 0;
5099   int *  buckets = NULL;
5100   int *  chains = NULL;
5101
5102   if (! do_syms && !do_histogram)
5103     return 1;
5104
5105   if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
5106                                 || do_histogram))
5107     {
5108       if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
5109         {
5110           error (_("Unable to seek to start of dynamic information"));
5111           return 0;
5112         }
5113
5114       if (fread (nb, sizeof (nb), 1, file) != 1)
5115         {
5116           error (_("Failed to read in number of buckets\n"));
5117           return 0;
5118         }
5119
5120       if (fread (nc, sizeof (nc), 1, file) != 1)
5121         {
5122           error (_("Failed to read in number of chains\n"));
5123           return 0;
5124         }
5125
5126       nbuckets = byte_get (nb, 4);
5127       nchains  = byte_get (nc, 4);
5128
5129       buckets = get_dynamic_data (file, nbuckets);
5130       chains  = get_dynamic_data (file, nchains);
5131
5132       if (buckets == NULL || chains == NULL)
5133         return 0;
5134     }
5135
5136   if (do_syms
5137       && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
5138     {
5139       int    hn;
5140       int    si;
5141
5142       printf (_("\nSymbol table for image:\n"));
5143       if (is_32bit_elf)
5144         printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
5145       else
5146         printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
5147
5148       for (hn = 0; hn < nbuckets; hn++)
5149         {
5150           if (! buckets [hn])
5151             continue;
5152
5153           for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
5154             {
5155               Elf_Internal_Sym * psym;
5156
5157               psym = dynamic_symbols + si;
5158
5159               printf ("  %3d %3d: ", si, hn);
5160               print_vma (psym->st_value, LONG_HEX);
5161               putchar (' ' );
5162               print_vma (psym->st_size, DEC_5);
5163
5164               printf ("  %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
5165               printf (" %6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
5166               printf (" %3s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5167               printf (" %3.3s", get_symbol_index_type (psym->st_shndx));
5168               printf (" %s\n", dynamic_strings + psym->st_name);
5169             }
5170         }
5171     }
5172   else if (do_syms && !do_using_dynamic)
5173     {
5174       unsigned int     i;
5175
5176       for (i = 0, section = section_headers;
5177            i < elf_header.e_shnum;
5178            i++, section++)
5179         {
5180           unsigned int          si;
5181           char *                strtab;
5182           Elf_Internal_Sym *    symtab;
5183           Elf_Internal_Sym *    psym;
5184
5185
5186           if (   section->sh_type != SHT_SYMTAB
5187               && section->sh_type != SHT_DYNSYM)
5188             continue;
5189
5190           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5191                   SECTION_NAME (section),
5192                   (unsigned long) (section->sh_size / section->sh_entsize));
5193           if (is_32bit_elf)
5194             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
5195           else
5196             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
5197
5198           symtab = GET_ELF_SYMBOLS (file, section->sh_offset,
5199                                     section->sh_size / section->sh_entsize);
5200           if (symtab == NULL)
5201             continue;
5202
5203           if (section->sh_link == elf_header.e_shstrndx)
5204             strtab = string_table;
5205           else
5206             {
5207               Elf32_Internal_Shdr * string_sec;
5208
5209               string_sec = section_headers + section->sh_link;
5210
5211               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
5212                                           string_sec->sh_size,
5213                                           _("string table"));
5214             }
5215
5216           for (si = 0, psym = symtab;
5217                si < section->sh_size / section->sh_entsize;
5218                si ++, psym ++)
5219             {
5220               printf ("%6d: ", si);
5221               print_vma (psym->st_value, LONG_HEX);
5222               putchar (' ');
5223               print_vma (psym->st_size, DEC_5);
5224               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
5225               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
5226               printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5227               printf (" %4s", get_symbol_index_type (psym->st_shndx));
5228               printf (" %s", strtab + psym->st_name);
5229
5230               if (section->sh_type == SHT_DYNSYM &&
5231                   version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
5232                 {
5233                   unsigned char   data[2];
5234                   unsigned short  vers_data;
5235                   unsigned long   offset;
5236                   int             is_nobits;
5237                   int             check_def;
5238
5239                   offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
5240                     - loadaddr;
5241
5242                   get_data (&data, file, offset + si * sizeof (vers_data),
5243                             sizeof (data), _("version data"));
5244
5245                   vers_data = byte_get (data, 2);
5246
5247                   is_nobits = psym->st_shndx < SHN_LORESERVE ?
5248                     (section_headers [psym->st_shndx].sh_type == SHT_NOBITS)
5249                     : 0;
5250
5251                   check_def = (psym->st_shndx != SHN_UNDEF);
5252
5253                   if ((vers_data & 0x8000) || vers_data > 1)
5254                     {
5255                       if (version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
5256                           && (is_nobits || ! check_def))
5257                         {
5258                           Elf_External_Verneed  evn;
5259                           Elf_Internal_Verneed  ivn;
5260                           Elf_Internal_Vernaux  ivna;
5261
5262                           /* We must test both.  */
5263                           offset = version_info
5264                             [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
5265
5266                           do
5267                             {
5268                               unsigned long  vna_off;
5269
5270                               get_data (&evn, file, offset, sizeof (evn),
5271                                         _("version need"));
5272
5273                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
5274                               ivn.vn_next = BYTE_GET (evn.vn_next);
5275
5276                               vna_off = offset + ivn.vn_aux;
5277
5278                               do
5279                                 {
5280                                   Elf_External_Vernaux  evna;
5281
5282                                   get_data (&evna, file, vna_off,
5283                                             sizeof (evna),
5284                                             _("version need aux (3)"));
5285
5286                                   ivna.vna_other = BYTE_GET (evna.vna_other);
5287                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
5288                                   ivna.vna_name  = BYTE_GET (evna.vna_name);
5289
5290                                   vna_off += ivna.vna_next;
5291                                 }
5292                               while (ivna.vna_other != vers_data
5293                                      && ivna.vna_next != 0);
5294
5295                               if (ivna.vna_other == vers_data)
5296                                 break;
5297
5298                               offset += ivn.vn_next;
5299                             }
5300                           while (ivn.vn_next != 0);
5301
5302                           if (ivna.vna_other == vers_data)
5303                             {
5304                               printf ("@%s (%d)",
5305                                       strtab + ivna.vna_name, ivna.vna_other);
5306                               check_def = 0;
5307                             }
5308                           else if (! is_nobits)
5309                             error (_("bad dynamic symbol"));
5310                           else
5311                             check_def = 1;
5312                         }
5313
5314                       if (check_def)
5315                         {
5316                           if (vers_data != 0x8001
5317                               && version_info [DT_VERSIONTAGIDX (DT_VERDEF)])
5318                             {
5319                               Elf_Internal_Verdef     ivd;
5320                               Elf_Internal_Verdaux    ivda;
5321                               Elf_External_Verdaux  evda;
5322                               unsigned long           offset;
5323
5324                               offset =
5325                                 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
5326                                 - loadaddr;
5327
5328                               do
5329                                 {
5330                                   Elf_External_Verdef   evd;
5331
5332                                   get_data (&evd, file, offset, sizeof (evd),
5333                                             _("version def"));
5334
5335                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
5336                                   ivd.vd_aux  = BYTE_GET (evd.vd_aux);
5337                                   ivd.vd_next = BYTE_GET (evd.vd_next);
5338
5339                                   offset += ivd.vd_next;
5340                                 }
5341                               while (ivd.vd_ndx != (vers_data & 0x7fff)
5342                                      && ivd.vd_next != 0);
5343
5344                               offset -= ivd.vd_next;
5345                               offset += ivd.vd_aux;
5346
5347                               get_data (&evda, file, offset, sizeof (evda),
5348                                         _("version def aux"));
5349
5350                               ivda.vda_name = BYTE_GET (evda.vda_name);
5351
5352                               if (psym->st_name != ivda.vda_name)
5353                                 printf ((vers_data & 0x8000)
5354                                         ? "@%s" : "@@%s",
5355                                         strtab + ivda.vda_name);
5356                             }
5357                         }
5358                     }
5359                 }
5360
5361               putchar ('\n');
5362             }
5363
5364           free (symtab);
5365           if (strtab != string_table)
5366             free (strtab);
5367         }
5368     }
5369   else if (do_syms)
5370     printf
5371       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5372
5373   if (do_histogram && buckets != NULL)
5374     {
5375       int * lengths;
5376       int * counts;
5377       int   hn;
5378       int   si;
5379       int   maxlength = 0;
5380       int   nzero_counts = 0;
5381       int   nsyms = 0;
5382
5383       printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5384               nbuckets);
5385       printf (_(" Length  Number     %% of total  Coverage\n"));
5386
5387       lengths = (int *) calloc (nbuckets, sizeof (int));
5388       if (lengths == NULL)
5389         {
5390           error (_("Out of memory"));
5391           return 0;
5392         }
5393       for (hn = 0; hn < nbuckets; ++hn)
5394         {
5395           if (! buckets [hn])
5396             continue;
5397
5398           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
5399             {
5400               ++ nsyms;
5401               if (maxlength < ++lengths[hn])
5402                 ++ maxlength;
5403             }
5404         }
5405
5406       counts = (int *) calloc (maxlength + 1, sizeof (int));
5407       if (counts == NULL)
5408         {
5409           error (_("Out of memory"));
5410           return 0;
5411         }
5412
5413       for (hn = 0; hn < nbuckets; ++hn)
5414         ++ counts [lengths [hn]];
5415
5416       if (nbuckets > 0)
5417         {
5418           printf ("      0  %-10d (%5.1f%%)\n",
5419                   counts[0], (counts[0] * 100.0) / nbuckets);
5420           for (si = 1; si <= maxlength; ++si)
5421             {
5422               nzero_counts += counts[si] * si;
5423               printf ("%7d  %-10d (%5.1f%%)    %5.1f%%\n",
5424                       si, counts[si], (counts[si] * 100.0) / nbuckets,
5425                       (nzero_counts * 100.0) / nsyms);
5426             }
5427         }
5428
5429       free (counts);
5430       free (lengths);
5431     }
5432
5433   if (buckets != NULL)
5434     {
5435       free (buckets);
5436       free (chains);
5437     }
5438
5439   return 1;
5440 }
5441
5442 static int
5443 process_syminfo (file)
5444      FILE * file ATTRIBUTE_UNUSED;
5445 {
5446   unsigned int i;
5447
5448   if (dynamic_syminfo == NULL
5449       || !do_dynamic)
5450     /* No syminfo, this is ok.  */
5451     return 1;
5452
5453   /* There better should be a dynamic symbol section.  */
5454   if (dynamic_symbols == NULL || dynamic_strings == NULL)
5455     return 0;
5456
5457   if (dynamic_addr)
5458     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5459             dynamic_syminfo_offset, dynamic_syminfo_nent);
5460
5461   printf (_(" Num: Name                           BoundTo     Flags\n"));
5462   for (i = 0; i < dynamic_syminfo_nent; ++i)
5463     {
5464       unsigned short int flags = dynamic_syminfo[i].si_flags;
5465
5466       printf ("%4d: %-30s ", i,
5467               dynamic_strings + dynamic_symbols[i].st_name);
5468
5469       switch (dynamic_syminfo[i].si_boundto)
5470         {
5471         case SYMINFO_BT_SELF:
5472           fputs ("SELF       ", stdout);
5473           break;
5474         case SYMINFO_BT_PARENT:
5475           fputs ("PARENT     ", stdout);
5476           break;
5477         default:
5478           if (dynamic_syminfo[i].si_boundto > 0
5479               && dynamic_syminfo[i].si_boundto < dynamic_size)
5480             printf ("%-10s ",
5481                     dynamic_strings
5482                     + dynamic_segment[dynamic_syminfo[i].si_boundto].d_un.d_val);
5483           else
5484             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
5485           break;
5486         }
5487
5488       if (flags & SYMINFO_FLG_DIRECT)
5489         printf (" DIRECT");
5490       if (flags & SYMINFO_FLG_PASSTHRU)
5491         printf (" PASSTHRU");
5492       if (flags & SYMINFO_FLG_COPY)
5493         printf (" COPY");
5494       if (flags & SYMINFO_FLG_LAZYLOAD)
5495         printf (" LAZYLOAD");
5496
5497       puts ("");
5498     }
5499
5500   return 1;
5501 }
5502
5503 #ifdef SUPPORT_DISASSEMBLY
5504 static void
5505 disassemble_section (section, file)
5506      Elf32_Internal_Shdr * section;
5507      FILE * file;
5508 {
5509   printf (_("\nAssembly dump of section %s\n"),
5510           SECTION_NAME (section));
5511
5512   /* XXX -- to be done --- XXX */
5513
5514   return 1;
5515 }
5516 #endif
5517
5518 static int
5519 dump_section (section, file)
5520      Elf32_Internal_Shdr * section;
5521      FILE * file;
5522 {
5523   bfd_size_type   bytes;
5524   bfd_vma         addr;
5525   unsigned char * data;
5526   unsigned char * start;
5527
5528   bytes = section->sh_size;
5529
5530   if (bytes == 0)
5531     {
5532       printf (_("\nSection '%s' has no data to dump.\n"),
5533               SECTION_NAME (section));
5534       return 0;
5535     }
5536   else
5537     printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
5538
5539   addr = section->sh_addr;
5540
5541   start = (unsigned char *) get_data (NULL, file, section->sh_offset, bytes,
5542                                       _("section data"));
5543   if (!start)
5544     return 0;
5545
5546   data = start;
5547
5548   while (bytes)
5549     {
5550       int j;
5551       int k;
5552       int lbytes;
5553
5554       lbytes = (bytes > 16 ? 16 : bytes);
5555
5556       printf ("  0x%8.8lx ", (unsigned long) addr);
5557
5558       switch (elf_header.e_ident [EI_DATA])
5559         {
5560         default:
5561         case ELFDATA2LSB:
5562           for (j = 15; j >= 0; j --)
5563             {
5564               if (j < lbytes)
5565                 printf ("%2.2x", data [j]);
5566               else
5567                 printf ("  ");
5568
5569               if (!(j & 0x3))
5570                 printf (" ");
5571             }
5572           break;
5573
5574         case ELFDATA2MSB:
5575           for (j = 0; j < 16; j++)
5576             {
5577               if (j < lbytes)
5578                 printf ("%2.2x", data [j]);
5579               else
5580                 printf ("  ");
5581
5582               if ((j & 3) == 3)
5583                 printf (" ");
5584             }
5585           break;
5586         }
5587
5588       for (j = 0; j < lbytes; j++)
5589         {
5590           k = data [j];
5591           if (k >= ' ' && k < 0x80)
5592             printf ("%c", k);
5593           else
5594             printf (".");
5595         }
5596
5597       putchar ('\n');
5598
5599       data  += lbytes;
5600       addr  += lbytes;
5601       bytes -= lbytes;
5602     }
5603
5604   free (start);
5605
5606   return 1;
5607 }
5608
5609
5610 static unsigned long int
5611 read_leb128 (data, length_return, sign)
5612      unsigned char * data;
5613      int *           length_return;
5614      int             sign;
5615 {
5616   unsigned long int result = 0;
5617   unsigned int      num_read = 0;
5618   int               shift = 0;
5619   unsigned char     byte;
5620
5621   do
5622     {
5623       byte = * data ++;
5624       num_read ++;
5625
5626       result |= (byte & 0x7f) << shift;
5627
5628       shift += 7;
5629
5630     }
5631   while (byte & 0x80);
5632
5633   if (length_return != NULL)
5634     * length_return = num_read;
5635
5636   if (sign && (shift < 32) && (byte & 0x40))
5637     result |= -1 << shift;
5638
5639   return result;
5640 }
5641
5642 typedef struct State_Machine_Registers
5643 {
5644   unsigned long address;
5645   unsigned int  file;
5646   unsigned int  line;
5647   unsigned int  column;
5648   int           is_stmt;
5649   int           basic_block;
5650   int           end_sequence;
5651 /* This variable hold the number of the last entry seen
5652    in the File Table.  */
5653   unsigned int  last_file_entry;
5654 } SMR;
5655
5656 static SMR state_machine_regs;
5657
5658 static void
5659 reset_state_machine (is_stmt)
5660      int is_stmt;
5661 {
5662   state_machine_regs.address = 0;
5663   state_machine_regs.file = 1;
5664   state_machine_regs.line = 1;
5665   state_machine_regs.column = 0;
5666   state_machine_regs.is_stmt = is_stmt;
5667   state_machine_regs.basic_block = 0;
5668   state_machine_regs.end_sequence = 0;
5669   state_machine_regs.last_file_entry = 0;
5670 }
5671
5672 /* Handled an extend line op.  Returns true if this is the end
5673    of sequence.  */
5674 static int
5675 process_extended_line_op (data, is_stmt, pointer_size)
5676      unsigned char * data;
5677      int is_stmt;
5678      int pointer_size;
5679 {
5680   unsigned char   op_code;
5681   int             bytes_read;
5682   unsigned int    len;
5683   unsigned char * name;
5684   unsigned long   adr;
5685
5686   len = read_leb128 (data, & bytes_read, 0);
5687   data += bytes_read;
5688
5689   if (len == 0)
5690     {
5691       warn (_("badly formed extended line op encountered!"));
5692       return bytes_read;
5693     }
5694
5695   len += bytes_read;
5696   op_code = * data ++;
5697
5698   printf (_("  Extended opcode %d: "), op_code);
5699
5700   switch (op_code)
5701     {
5702     case DW_LNE_end_sequence:
5703       printf (_("End of Sequence\n\n"));
5704       reset_state_machine (is_stmt);
5705       break;
5706
5707     case DW_LNE_set_address:
5708       adr = byte_get (data, pointer_size);
5709       printf (_("set Address to 0x%lx\n"), adr);
5710       state_machine_regs.address = adr;
5711       break;
5712
5713     case DW_LNE_define_file:
5714       printf (_("  define new File Table entry\n"));
5715       printf (_("  Entry\tDir\tTime\tSize\tName\n"));
5716
5717       printf (_("   %d\t"), ++ state_machine_regs.last_file_entry);
5718       name = data;
5719       data += strlen ((char *) data) + 1;
5720       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5721       data += bytes_read;
5722       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5723       data += bytes_read;
5724       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5725       printf (_("%s\n\n"), name);
5726       break;
5727
5728     default:
5729       printf (_("UNKNOWN: length %d\n"), len - bytes_read);
5730       break;
5731     }
5732
5733   return len;
5734 }
5735
5736 /* Size of pointers in the .debug_line section.  This information is not
5737    really present in that section.  It's obtained before dumping the debug
5738    sections by doing some pre-scan of the .debug_info section.  */
5739 static int debug_line_pointer_size = 4;
5740
5741 static int
5742 display_debug_lines (section, start, file)
5743      Elf32_Internal_Shdr * section;
5744      unsigned char *       start;
5745      FILE *                file ATTRIBUTE_UNUSED;
5746 {
5747   DWARF2_External_LineInfo * external;
5748   DWARF2_Internal_LineInfo   info;
5749   unsigned char *            standard_opcodes;
5750   unsigned char *            data = start;
5751   unsigned char *            end  = start + section->sh_size;
5752   unsigned char *            end_of_sequence;
5753   int                        i;
5754
5755   printf (_("\nDump of debug contents of section %s:\n\n"),
5756           SECTION_NAME (section));
5757
5758   while (data < end)
5759     {
5760       external = (DWARF2_External_LineInfo *) data;
5761
5762       /* Check the length of the block.  */
5763       info.li_length = BYTE_GET (external->li_length);
5764
5765       if (info.li_length == 0xffffffff)
5766         {
5767           warn (_("64-bit DWARF line info is not supported yet.\n"));
5768           break;
5769         }
5770
5771       if (info.li_length + sizeof (external->li_length) > section->sh_size)
5772         {
5773           warn
5774             (_("The line info appears to be corrupt - the section is too small\n"));
5775           return 0;
5776         }
5777
5778       /* Check its version number.  */
5779       info.li_version = BYTE_GET (external->li_version);
5780       if (info.li_version != 2)
5781         {
5782           warn (_("Only DWARF version 2 line info is currently supported.\n"));
5783           return 0;
5784         }
5785
5786       info.li_prologue_length = BYTE_GET (external->li_prologue_length);
5787       info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
5788       info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
5789       info.li_line_base       = BYTE_GET (external->li_line_base);
5790       info.li_line_range      = BYTE_GET (external->li_line_range);
5791       info.li_opcode_base     = BYTE_GET (external->li_opcode_base);
5792
5793       /* Sign extend the line base field.  */
5794       info.li_line_base <<= 24;
5795       info.li_line_base >>= 24;
5796
5797       printf (_("  Length:                      %ld\n"), info.li_length);
5798       printf (_("  DWARF Version:               %d\n"), info.li_version);
5799       printf (_("  Prologue Length:             %d\n"), info.li_prologue_length);
5800       printf (_("  Minimum Instruction Length:  %d\n"), info.li_min_insn_length);
5801       printf (_("  Initial value of 'is_stmt':  %d\n"), info.li_default_is_stmt);
5802       printf (_("  Line Base:                   %d\n"), info.li_line_base);
5803       printf (_("  Line Range:                  %d\n"), info.li_line_range);
5804       printf (_("  Opcode Base:                 %d\n"), info.li_opcode_base);
5805
5806       end_of_sequence = data + info.li_length + sizeof (external->li_length);
5807
5808       reset_state_machine (info.li_default_is_stmt);
5809
5810       /* Display the contents of the Opcodes table.  */
5811       standard_opcodes = data + sizeof (* external);
5812
5813       printf (_("\n Opcodes:\n"));
5814
5815       for (i = 1; i < info.li_opcode_base; i++)
5816         printf (_("  Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
5817
5818       /* Display the contents of the Directory table.  */
5819       data = standard_opcodes + info.li_opcode_base - 1;
5820
5821       if (* data == 0)
5822         printf (_("\n The Directory Table is empty.\n"));
5823       else
5824         {
5825           printf (_("\n The Directory Table:\n"));
5826
5827           while (* data != 0)
5828             {
5829               printf (_("  %s\n"), data);
5830
5831               data += strlen ((char *) data) + 1;
5832             }
5833         }
5834
5835       /* Skip the NUL at the end of the table.  */
5836       data ++;
5837
5838       /* Display the contents of the File Name table.  */
5839       if (* data == 0)
5840         printf (_("\n The File Name Table is empty.\n"));
5841       else
5842         {
5843           printf (_("\n The File Name Table:\n"));
5844           printf (_("  Entry\tDir\tTime\tSize\tName\n"));
5845
5846           while (* data != 0)
5847             {
5848               unsigned char * name;
5849               int bytes_read;
5850
5851               printf (_("  %d\t"), ++ state_machine_regs.last_file_entry);
5852               name = data;
5853
5854               data += strlen ((char *) data) + 1;
5855
5856               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5857               data += bytes_read;
5858               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5859               data += bytes_read;
5860               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5861               data += bytes_read;
5862               printf (_("%s\n"), name);
5863             }
5864         }
5865
5866       /* Skip the NUL at the end of the table.  */
5867       data ++;
5868
5869       /* Now display the statements.  */
5870       printf (_("\n Line Number Statements:\n"));
5871
5872
5873       while (data < end_of_sequence)
5874         {
5875           unsigned char op_code;
5876           int           adv;
5877           int           bytes_read;
5878
5879           op_code = * data ++;
5880
5881           switch (op_code)
5882             {
5883             case DW_LNS_extended_op:
5884               data += process_extended_line_op (data, info.li_default_is_stmt,
5885                                                 debug_line_pointer_size);
5886               break;
5887
5888             case DW_LNS_copy:
5889               printf (_("  Copy\n"));
5890               break;
5891
5892             case DW_LNS_advance_pc:
5893               adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
5894               data += bytes_read;
5895               state_machine_regs.address += adv;
5896               printf (_("  Advance PC by %d to %lx\n"), adv,
5897                       state_machine_regs.address);
5898               break;
5899
5900             case DW_LNS_advance_line:
5901               adv = read_leb128 (data, & bytes_read, 1);
5902               data += bytes_read;
5903               state_machine_regs.line += adv;
5904               printf (_("  Advance Line by %d to %d\n"), adv,
5905                       state_machine_regs.line);
5906               break;
5907
5908             case DW_LNS_set_file:
5909               adv = read_leb128 (data, & bytes_read, 0);
5910               data += bytes_read;
5911               printf (_("  Set File Name to entry %d in the File Name Table\n"),
5912                       adv);
5913               state_machine_regs.file = adv;
5914               break;
5915
5916             case DW_LNS_set_column:
5917               adv = read_leb128 (data, & bytes_read, 0);
5918               data += bytes_read;
5919               printf (_("  Set column to %d\n"), adv);
5920               state_machine_regs.column = adv;
5921               break;
5922
5923             case DW_LNS_negate_stmt:
5924               adv = state_machine_regs.is_stmt;
5925               adv = ! adv;
5926               printf (_("  Set is_stmt to %d\n"), adv);
5927               state_machine_regs.is_stmt = adv;
5928               break;
5929
5930             case DW_LNS_set_basic_block:
5931               printf (_("  Set basic block\n"));
5932               state_machine_regs.basic_block = 1;
5933               break;
5934
5935             case DW_LNS_const_add_pc:
5936               adv = (((255 - info.li_opcode_base) / info.li_line_range)
5937                      * info.li_min_insn_length);
5938               state_machine_regs.address += adv;
5939               printf (_("  Advance PC by constant %d to 0x%lx\n"), adv,
5940                       state_machine_regs.address);
5941               break;
5942
5943             case DW_LNS_fixed_advance_pc:
5944               adv = byte_get (data, 2);
5945               data += 2;
5946               state_machine_regs.address += adv;
5947               printf (_("  Advance PC by fixed size amount %d to 0x%lx\n"),
5948                       adv, state_machine_regs.address);
5949               break;
5950
5951             default:
5952               op_code -= info.li_opcode_base;
5953               adv      = (op_code / info.li_line_range) * info.li_min_insn_length;
5954               state_machine_regs.address += adv;
5955               printf (_("  Special opcode %d: advance Address by %d to 0x%lx"),
5956                       op_code, adv, state_machine_regs.address);
5957               adv = (op_code % info.li_line_range) + info.li_line_base;
5958               state_machine_regs.line += adv;
5959               printf (_(" and Line by %d to %d\n"),
5960                       adv, state_machine_regs.line);
5961               break;
5962             }
5963         }
5964       printf ("\n");
5965     }
5966
5967   return 1;
5968 }
5969
5970 static int
5971 display_debug_pubnames (section, start, file)
5972      Elf32_Internal_Shdr * section;
5973      unsigned char *       start;
5974      FILE *                file ATTRIBUTE_UNUSED;
5975 {
5976   DWARF2_External_PubNames * external;
5977   DWARF2_Internal_PubNames   pubnames;
5978   unsigned char *            end;
5979
5980   end = start + section->sh_size;
5981
5982   printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5983
5984   while (start < end)
5985     {
5986       unsigned char * data;
5987       unsigned long   offset;
5988
5989       external = (DWARF2_External_PubNames *) start;
5990
5991       pubnames.pn_length  = BYTE_GET (external->pn_length);
5992       pubnames.pn_version = BYTE_GET (external->pn_version);
5993       pubnames.pn_offset  = BYTE_GET (external->pn_offset);
5994       pubnames.pn_size    = BYTE_GET (external->pn_size);
5995
5996       data   = start + sizeof (* external);
5997       start += pubnames.pn_length + sizeof (external->pn_length);
5998
5999       if (pubnames.pn_length == 0xffffffff)
6000         {
6001           warn (_("64-bit DWARF pubnames are not supported yet.\n"));
6002           break;
6003         }
6004
6005       if (pubnames.pn_version != 2)
6006         {
6007           static int warned = 0;
6008
6009           if (! warned)
6010             {
6011               warn (_("Only DWARF 2 pubnames are currently supported\n"));
6012               warned = 1;
6013             }
6014
6015           continue;
6016         }
6017
6018       printf (_("  Length:                              %ld\n"),
6019               pubnames.pn_length);
6020       printf (_("  Version:                             %d\n"),
6021               pubnames.pn_version);
6022       printf (_("  Offset into .debug_info section:     %ld\n"),
6023               pubnames.pn_offset);
6024       printf (_("  Size of area in .debug_info section: %ld\n"),
6025               pubnames.pn_size);
6026
6027       printf (_("\n    Offset\tName\n"));
6028
6029       do
6030         {
6031           offset = byte_get (data, 4);
6032
6033           if (offset != 0)
6034             {
6035               data += 4;
6036               printf ("    %ld\t\t%s\n", offset, data);
6037               data += strlen ((char *) data) + 1;
6038             }
6039         }
6040       while (offset != 0);
6041     }
6042
6043   printf ("\n");
6044   return 1;
6045 }
6046
6047 static char *
6048 get_TAG_name (tag)
6049      unsigned long tag;
6050 {
6051   switch (tag)
6052     {
6053     case DW_TAG_padding:                return "DW_TAG_padding";
6054     case DW_TAG_array_type:             return "DW_TAG_array_type";
6055     case DW_TAG_class_type:             return "DW_TAG_class_type";
6056     case DW_TAG_entry_point:            return "DW_TAG_entry_point";
6057     case DW_TAG_enumeration_type:       return "DW_TAG_enumeration_type";
6058     case DW_TAG_formal_parameter:       return "DW_TAG_formal_parameter";
6059     case DW_TAG_imported_declaration:   return "DW_TAG_imported_declaration";
6060     case DW_TAG_label:                  return "DW_TAG_label";
6061     case DW_TAG_lexical_block:          return "DW_TAG_lexical_block";
6062     case DW_TAG_member:                 return "DW_TAG_member";
6063     case DW_TAG_pointer_type:           return "DW_TAG_pointer_type";
6064     case DW_TAG_reference_type:         return "DW_TAG_reference_type";
6065     case DW_TAG_compile_unit:           return "DW_TAG_compile_unit";
6066     case DW_TAG_string_type:            return "DW_TAG_string_type";
6067     case DW_TAG_structure_type:         return "DW_TAG_structure_type";
6068     case DW_TAG_subroutine_type:        return "DW_TAG_subroutine_type";
6069     case DW_TAG_typedef:                return "DW_TAG_typedef";
6070     case DW_TAG_union_type:             return "DW_TAG_union_type";
6071     case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
6072     case DW_TAG_variant:                return "DW_TAG_variant";
6073     case DW_TAG_common_block:           return "DW_TAG_common_block";
6074     case DW_TAG_common_inclusion:       return "DW_TAG_common_inclusion";
6075     case DW_TAG_inheritance:            return "DW_TAG_inheritance";
6076     case DW_TAG_inlined_subroutine:     return "DW_TAG_inlined_subroutine";
6077     case DW_TAG_module:                 return "DW_TAG_module";
6078     case DW_TAG_ptr_to_member_type:     return "DW_TAG_ptr_to_member_type";
6079     case DW_TAG_set_type:               return "DW_TAG_set_type";
6080     case DW_TAG_subrange_type:          return "DW_TAG_subrange_type";
6081     case DW_TAG_with_stmt:              return "DW_TAG_with_stmt";
6082     case DW_TAG_access_declaration:     return "DW_TAG_access_declaration";
6083     case DW_TAG_base_type:              return "DW_TAG_base_type";
6084     case DW_TAG_catch_block:            return "DW_TAG_catch_block";
6085     case DW_TAG_const_type:             return "DW_TAG_const_type";
6086     case DW_TAG_constant:               return "DW_TAG_constant";
6087     case DW_TAG_enumerator:             return "DW_TAG_enumerator";
6088     case DW_TAG_file_type:              return "DW_TAG_file_type";
6089     case DW_TAG_friend:                 return "DW_TAG_friend";
6090     case DW_TAG_namelist:               return "DW_TAG_namelist";
6091     case DW_TAG_namelist_item:          return "DW_TAG_namelist_item";
6092     case DW_TAG_packed_type:            return "DW_TAG_packed_type";
6093     case DW_TAG_subprogram:             return "DW_TAG_subprogram";
6094     case DW_TAG_template_type_param:    return "DW_TAG_template_type_param";
6095     case DW_TAG_template_value_param:   return "DW_TAG_template_value_param";
6096     case DW_TAG_thrown_type:            return "DW_TAG_thrown_type";
6097     case DW_TAG_try_block:              return "DW_TAG_try_block";
6098     case DW_TAG_variant_part:           return "DW_TAG_variant_part";
6099     case DW_TAG_variable:               return "DW_TAG_variable";
6100     case DW_TAG_volatile_type:          return "DW_TAG_volatile_type";
6101     case DW_TAG_MIPS_loop:              return "DW_TAG_MIPS_loop";
6102     case DW_TAG_format_label:           return "DW_TAG_format_label";
6103     case DW_TAG_function_template:      return "DW_TAG_function_template";
6104     case DW_TAG_class_template:         return "DW_TAG_class_template";
6105       /* DWARF 2.1 values.  */
6106     case DW_TAG_dwarf_procedure:        return "DW_TAG_dwarf_procedure";
6107     case DW_TAG_restrict_type:          return "DW_TAG_restrict_type";
6108     case DW_TAG_interface_type:         return "DW_TAG_interface_type";
6109     case DW_TAG_namespace:              return "DW_TAG_namespace";
6110     case DW_TAG_imported_module:        return "DW_TAG_imported_module";
6111     case DW_TAG_unspecified_type:       return "DW_TAG_unspecified_type";
6112     case DW_TAG_partial_unit:           return "DW_TAG_partial_unit";
6113     case DW_TAG_imported_unit:          return "DW_TAG_imported_unit";
6114     default:
6115       {
6116         static char buffer [100];
6117
6118         sprintf (buffer, _("Unknown TAG value: %lx"), tag);
6119         return buffer;
6120       }
6121     }
6122 }
6123
6124 static char *
6125 get_AT_name (attribute)
6126      unsigned long attribute;
6127 {
6128   switch (attribute)
6129     {
6130     case DW_AT_sibling:              return "DW_AT_sibling";
6131     case DW_AT_location:             return "DW_AT_location";
6132     case DW_AT_name:                 return "DW_AT_name";
6133     case DW_AT_ordering:             return "DW_AT_ordering";
6134     case DW_AT_subscr_data:          return "DW_AT_subscr_data";
6135     case DW_AT_byte_size:            return "DW_AT_byte_size";
6136     case DW_AT_bit_offset:           return "DW_AT_bit_offset";
6137     case DW_AT_bit_size:             return "DW_AT_bit_size";
6138     case DW_AT_element_list:         return "DW_AT_element_list";
6139     case DW_AT_stmt_list:            return "DW_AT_stmt_list";
6140     case DW_AT_low_pc:               return "DW_AT_low_pc";
6141     case DW_AT_high_pc:              return "DW_AT_high_pc";
6142     case DW_AT_language:             return "DW_AT_language";
6143     case DW_AT_member:               return "DW_AT_member";
6144     case DW_AT_discr:                return "DW_AT_discr";
6145     case DW_AT_discr_value:          return "DW_AT_discr_value";
6146     case DW_AT_visibility:           return "DW_AT_visibility";
6147     case DW_AT_import:               return "DW_AT_import";
6148     case DW_AT_string_length:        return "DW_AT_string_length";
6149     case DW_AT_common_reference:     return "DW_AT_common_reference";
6150     case DW_AT_comp_dir:             return "DW_AT_comp_dir";
6151     case DW_AT_const_value:          return "DW_AT_const_value";
6152     case DW_AT_containing_type:      return "DW_AT_containing_type";
6153     case DW_AT_default_value:        return "DW_AT_default_value";
6154     case DW_AT_inline:               return "DW_AT_inline";
6155     case DW_AT_is_optional:          return "DW_AT_is_optional";
6156     case DW_AT_lower_bound:          return "DW_AT_lower_bound";
6157     case DW_AT_producer:             return "DW_AT_producer";
6158     case DW_AT_prototyped:           return "DW_AT_prototyped";
6159     case DW_AT_return_addr:          return "DW_AT_return_addr";
6160     case DW_AT_start_scope:          return "DW_AT_start_scope";
6161     case DW_AT_stride_size:          return "DW_AT_stride_size";
6162     case DW_AT_upper_bound:          return "DW_AT_upper_bound";
6163     case DW_AT_abstract_origin:      return "DW_AT_abstract_origin";
6164     case DW_AT_accessibility:        return "DW_AT_accessibility";
6165     case DW_AT_address_class:        return "DW_AT_address_class";
6166     case DW_AT_artificial:           return "DW_AT_artificial";
6167     case DW_AT_base_types:           return "DW_AT_base_types";
6168     case DW_AT_calling_convention:   return "DW_AT_calling_convention";
6169     case DW_AT_count:                return "DW_AT_count";
6170     case DW_AT_data_member_location: return "DW_AT_data_member_location";
6171     case DW_AT_decl_column:          return "DW_AT_decl_column";
6172     case DW_AT_decl_file:            return "DW_AT_decl_file";
6173     case DW_AT_decl_line:            return "DW_AT_decl_line";
6174     case DW_AT_declaration:          return "DW_AT_declaration";
6175     case DW_AT_discr_list:           return "DW_AT_discr_list";
6176     case DW_AT_encoding:             return "DW_AT_encoding";
6177     case DW_AT_external:             return "DW_AT_external";
6178     case DW_AT_frame_base:           return "DW_AT_frame_base";
6179     case DW_AT_friend:               return "DW_AT_friend";
6180     case DW_AT_identifier_case:      return "DW_AT_identifier_case";
6181     case DW_AT_macro_info:           return "DW_AT_macro_info";
6182     case DW_AT_namelist_items:       return "DW_AT_namelist_items";
6183     case DW_AT_priority:             return "DW_AT_priority";
6184     case DW_AT_segment:              return "DW_AT_segment";
6185     case DW_AT_specification:        return "DW_AT_specification";
6186     case DW_AT_static_link:          return "DW_AT_static_link";
6187     case DW_AT_type:                 return "DW_AT_type";
6188     case DW_AT_use_location:         return "DW_AT_use_location";
6189     case DW_AT_variable_parameter:   return "DW_AT_variable_parameter";
6190     case DW_AT_virtuality:           return "DW_AT_virtuality";
6191     case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
6192       /* DWARF 2.1 values.  */
6193     case DW_AT_allocated:            return "DW_AT_allocated";
6194     case DW_AT_associated:           return "DW_AT_associated";
6195     case DW_AT_data_location:        return "DW_AT_data_location";
6196     case DW_AT_stride:               return "DW_AT_stride";
6197     case DW_AT_entry_pc:             return "DW_AT_entry_pc";
6198     case DW_AT_use_UTF8:             return "DW_AT_use_UTF8";
6199     case DW_AT_extension:            return "DW_AT_extension";
6200     case DW_AT_ranges:               return "DW_AT_ranges";
6201     case DW_AT_trampoline:           return "DW_AT_trampoline";
6202     case DW_AT_call_column:          return "DW_AT_call_column";
6203     case DW_AT_call_file:            return "DW_AT_call_file";
6204     case DW_AT_call_line:            return "DW_AT_call_line";
6205       /* SGI/MIPS extensions.  */
6206     case DW_AT_MIPS_fde:             return "DW_AT_MIPS_fde";
6207     case DW_AT_MIPS_loop_begin:      return "DW_AT_MIPS_loop_begin";
6208     case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
6209     case DW_AT_MIPS_epilog_begin:    return "DW_AT_MIPS_epilog_begin";
6210     case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
6211     case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
6212     case DW_AT_MIPS_linkage_name:    return "DW_AT_MIPS_linkage_name";
6213     case DW_AT_MIPS_stride:          return "DW_AT_MIPS_stride";
6214     case DW_AT_MIPS_abstract_name:   return "DW_AT_MIPS_abstract_name";
6215     case DW_AT_MIPS_clone_origin:    return "DW_AT_MIPS_clone_origin";
6216     case DW_AT_MIPS_has_inlines:     return "DW_AT_MIPS_has_inlines";
6217       /* GNU extensions.  */
6218     case DW_AT_sf_names:             return "DW_AT_sf_names";
6219     case DW_AT_src_info:             return "DW_AT_src_info";
6220     case DW_AT_mac_info:             return "DW_AT_mac_info";
6221     case DW_AT_src_coords:           return "DW_AT_src_coords";
6222     case DW_AT_body_begin:           return "DW_AT_body_begin";
6223     case DW_AT_body_end:             return "DW_AT_body_end";
6224     default:
6225       {
6226         static char buffer [100];
6227
6228         sprintf (buffer, _("Unknown AT value: %lx"), attribute);
6229         return buffer;
6230       }
6231     }
6232 }
6233
6234 static char *
6235 get_FORM_name (form)
6236      unsigned long form;
6237 {
6238   switch (form)
6239     {
6240     case DW_FORM_addr:      return "DW_FORM_addr";
6241     case DW_FORM_block2:    return "DW_FORM_block2";
6242     case DW_FORM_block4:    return "DW_FORM_block4";
6243     case DW_FORM_data2:     return "DW_FORM_data2";
6244     case DW_FORM_data4:     return "DW_FORM_data4";
6245     case DW_FORM_data8:     return "DW_FORM_data8";
6246     case DW_FORM_string:    return "DW_FORM_string";
6247     case DW_FORM_block:     return "DW_FORM_block";
6248     case DW_FORM_block1:    return "DW_FORM_block1";
6249     case DW_FORM_data1:     return "DW_FORM_data1";
6250     case DW_FORM_flag:      return "DW_FORM_flag";
6251     case DW_FORM_sdata:     return "DW_FORM_sdata";
6252     case DW_FORM_strp:      return "DW_FORM_strp";
6253     case DW_FORM_udata:     return "DW_FORM_udata";
6254     case DW_FORM_ref_addr:  return "DW_FORM_ref_addr";
6255     case DW_FORM_ref1:      return "DW_FORM_ref1";
6256     case DW_FORM_ref2:      return "DW_FORM_ref2";
6257     case DW_FORM_ref4:      return "DW_FORM_ref4";
6258     case DW_FORM_ref8:      return "DW_FORM_ref8";
6259     case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
6260     case DW_FORM_indirect:  return "DW_FORM_indirect";
6261     default:
6262       {
6263         static char buffer [100];
6264
6265         sprintf (buffer, _("Unknown FORM value: %lx"), form);
6266         return buffer;
6267       }
6268     }
6269 }
6270
6271 /* FIXME:  There are better and more effiecint ways to handle
6272    these structures.  For now though, I just want something that
6273    is simple to implement.  */
6274 typedef struct abbrev_attr
6275 {
6276   unsigned long        attribute;
6277   unsigned long        form;
6278   struct abbrev_attr * next;
6279 }
6280 abbrev_attr;
6281
6282 typedef struct abbrev_entry
6283 {
6284   unsigned long          entry;
6285   unsigned long          tag;
6286   int                    children;
6287   struct abbrev_attr *   first_attr;
6288   struct abbrev_attr *   last_attr;
6289   struct abbrev_entry *  next;
6290 }
6291 abbrev_entry;
6292
6293 static abbrev_entry * first_abbrev = NULL;
6294 static abbrev_entry * last_abbrev = NULL;
6295
6296 static void
6297 free_abbrevs PARAMS ((void))
6298 {
6299   abbrev_entry * abbrev;
6300
6301   for (abbrev = first_abbrev; abbrev;)
6302     {
6303       abbrev_entry * next = abbrev->next;
6304       abbrev_attr  * attr;
6305
6306       for (attr = abbrev->first_attr; attr;)
6307         {
6308           abbrev_attr * next = attr->next;
6309
6310           free (attr);
6311           attr = next;
6312         }
6313
6314       free (abbrev);
6315       abbrev = next;
6316     }
6317
6318   last_abbrev = first_abbrev = NULL;
6319 }
6320
6321 static void
6322 add_abbrev (number, tag, children)
6323      unsigned long number;
6324      unsigned long tag;
6325      int           children;
6326 {
6327   abbrev_entry * entry;
6328
6329   entry = (abbrev_entry *) malloc (sizeof (* entry));
6330
6331   if (entry == NULL)
6332     /* ugg */
6333     return;
6334
6335   entry->entry      = number;
6336   entry->tag        = tag;
6337   entry->children   = children;
6338   entry->first_attr = NULL;
6339   entry->last_attr  = NULL;
6340   entry->next       = NULL;
6341
6342   if (first_abbrev == NULL)
6343     first_abbrev = entry;
6344   else
6345     last_abbrev->next = entry;
6346
6347   last_abbrev = entry;
6348 }
6349
6350 static void
6351 add_abbrev_attr (attribute, form)
6352      unsigned long attribute;
6353      unsigned long form;
6354 {
6355   abbrev_attr * attr;
6356
6357   attr = (abbrev_attr *) malloc (sizeof (* attr));
6358
6359   if (attr == NULL)
6360     /* ugg */
6361     return;
6362
6363   attr->attribute = attribute;
6364   attr->form      = form;
6365   attr->next      = NULL;
6366
6367   if (last_abbrev->first_attr == NULL)
6368     last_abbrev->first_attr = attr;
6369   else
6370     last_abbrev->last_attr->next = attr;
6371
6372   last_abbrev->last_attr = attr;
6373 }
6374
6375 /* Processes the (partial) contents of a .debug_abbrev section.
6376    Returns NULL if the end of the section was encountered.
6377    Returns the address after the last byte read if the end of
6378    an abbreviation set was found.  */
6379
6380 static unsigned char *
6381 process_abbrev_section (start, end)
6382      unsigned char * start;
6383      unsigned char * end;
6384 {
6385   if (first_abbrev != NULL)
6386     return NULL;
6387
6388   while (start < end)
6389     {
6390       int           bytes_read;
6391       unsigned long entry;
6392       unsigned long tag;
6393       unsigned long attribute;
6394       int           children;
6395
6396       entry = read_leb128 (start, & bytes_read, 0);
6397       start += bytes_read;
6398
6399       /* A single zero is supposed to end the section according
6400          to the standard.  If there's more, then signal that to
6401          the caller.  */
6402       if (entry == 0)
6403         return start == end ? NULL : start;
6404
6405       tag = read_leb128 (start, & bytes_read, 0);
6406       start += bytes_read;
6407
6408       children = * start ++;
6409
6410       add_abbrev (entry, tag, children);
6411
6412       do
6413         {
6414           unsigned long form;
6415
6416           attribute = read_leb128 (start, & bytes_read, 0);
6417           start += bytes_read;
6418
6419           form = read_leb128 (start, & bytes_read, 0);
6420           start += bytes_read;
6421
6422           if (attribute != 0)
6423             add_abbrev_attr (attribute, form);
6424         }
6425       while (attribute != 0);
6426     }
6427
6428   return NULL;
6429 }
6430
6431
6432 static int
6433 display_debug_macinfo (section, start, file)
6434      Elf32_Internal_Shdr * section;
6435      unsigned char *       start;
6436      FILE *                file ATTRIBUTE_UNUSED;
6437 {
6438   unsigned char * end = start + section->sh_size;
6439   unsigned char * curr = start;
6440   unsigned int bytes_read;
6441   enum dwarf_macinfo_record_type op;
6442
6443   printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6444
6445   while (curr < end)
6446     {
6447       unsigned int lineno;
6448       const char * string;
6449
6450       op = * curr;
6451       curr ++;
6452
6453       switch (op)
6454         {
6455         case DW_MACINFO_start_file:
6456           {
6457             unsigned int filenum;
6458
6459             lineno = read_leb128 (curr, & bytes_read, 0);
6460             curr += bytes_read;
6461             filenum = read_leb128 (curr, & bytes_read, 0);
6462             curr += bytes_read;
6463
6464             printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno, filenum);
6465           }
6466           break;
6467
6468         case DW_MACINFO_end_file:
6469           printf (_(" DW_MACINFO_end_file\n"));
6470           break;
6471
6472         case DW_MACINFO_define:
6473           lineno = read_leb128 (curr, & bytes_read, 0);
6474           curr += bytes_read;
6475           string = curr;
6476           curr += strlen (string) + 1;
6477           printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno, string);
6478           break;
6479
6480         case DW_MACINFO_undef:
6481           lineno = read_leb128 (curr, & bytes_read, 0);
6482           curr += bytes_read;
6483           string = curr;
6484           curr += strlen (string) + 1;
6485           printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno, string);
6486           break;
6487
6488         case DW_MACINFO_vendor_ext:
6489           {
6490             unsigned int constant;
6491
6492             constant = read_leb128 (curr, & bytes_read, 0);
6493             curr += bytes_read;
6494             string = curr;
6495             curr += strlen (string) + 1;
6496             printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant, string);
6497           }
6498           break;
6499         }
6500     }
6501
6502   return 1;
6503 }
6504
6505
6506 static int
6507 display_debug_abbrev (section, start, file)
6508      Elf32_Internal_Shdr * section;
6509      unsigned char *       start;
6510      FILE *                file ATTRIBUTE_UNUSED;
6511 {
6512   abbrev_entry *  entry;
6513   unsigned char * end = start + section->sh_size;
6514
6515   printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6516
6517   do
6518     {
6519       start = process_abbrev_section (start, end);
6520
6521       printf (_("  Number TAG\n"));
6522
6523       for (entry = first_abbrev; entry; entry = entry->next)
6524         {
6525           abbrev_attr * attr;
6526
6527           printf (_("   %ld      %s    [%s]\n"),
6528                   entry->entry,
6529                   get_TAG_name (entry->tag),
6530                   entry->children ? _("has children") : _("no children"));
6531
6532           for (attr = entry->first_attr; attr; attr = attr->next)
6533             {
6534               printf (_("    %-18s %s\n"),
6535                       get_AT_name (attr->attribute),
6536                       get_FORM_name (attr->form));
6537             }
6538         }
6539     }
6540   while (start);
6541
6542   printf ("\n");
6543
6544   return 1;
6545 }
6546
6547
6548 static unsigned char *
6549 display_block (data, length)
6550      unsigned char * data;
6551      unsigned long   length;
6552 {
6553   printf (_(" %lu byte block: "), length);
6554
6555   while (length --)
6556     printf ("%lx ", (unsigned long) byte_get (data ++, 1));
6557
6558   return data;
6559 }
6560
6561 static void
6562 decode_location_expression (data, pointer_size, length)
6563      unsigned char * data;
6564      unsigned int    pointer_size;
6565      unsigned long   length;
6566 {
6567   unsigned        op;
6568   int             bytes_read;
6569   unsigned long   uvalue;
6570   unsigned char * end = data + length;
6571
6572   while (data < end)
6573     {
6574       op = * data ++;
6575
6576       switch (op)
6577         {
6578         case DW_OP_addr:
6579           printf ("DW_OP_addr: %lx",
6580                   (unsigned long) byte_get (data, pointer_size));
6581           data += pointer_size;
6582           break;
6583         case DW_OP_deref:
6584           printf ("DW_OP_deref");
6585           break;
6586         case DW_OP_const1u:
6587           printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
6588           break;
6589         case DW_OP_const1s:
6590           printf ("DW_OP_const1s: %ld", (long) byte_get (data++, 1));
6591           break;
6592         case DW_OP_const2u:
6593           printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
6594           data += 2;
6595           break;
6596         case DW_OP_const2s:
6597           printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
6598           data += 2;
6599           break;
6600         case DW_OP_const4u:
6601           printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
6602           data += 4;
6603           break;
6604         case DW_OP_const4s:
6605           printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
6606           data += 4;
6607           break;
6608         case DW_OP_const8u:
6609           printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
6610                   (unsigned long) byte_get (data + 4, 4));
6611           data += 8;
6612           break;
6613         case DW_OP_const8s:
6614           printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
6615                   (long) byte_get (data + 4, 4));
6616           data += 8;
6617           break;
6618         case DW_OP_constu:
6619           printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
6620           data += bytes_read;
6621           break;
6622         case DW_OP_consts:
6623           printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
6624           data += bytes_read;
6625           break;
6626         case DW_OP_dup:
6627           printf ("DW_OP_dup");
6628           break;
6629         case DW_OP_drop:
6630           printf ("DW_OP_drop");
6631           break;
6632         case DW_OP_over:
6633           printf ("DW_OP_over");
6634           break;
6635         case DW_OP_pick:
6636           printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
6637           break;
6638         case DW_OP_swap:
6639           printf ("DW_OP_swap");
6640           break;
6641         case DW_OP_rot:
6642           printf ("DW_OP_rot");
6643           break;
6644         case DW_OP_xderef:
6645           printf ("DW_OP_xderef");
6646           break;
6647         case DW_OP_abs:
6648           printf ("DW_OP_abs");
6649           break;
6650         case DW_OP_and:
6651           printf ("DW_OP_and");
6652           break;
6653         case DW_OP_div:
6654           printf ("DW_OP_div");
6655           break;
6656         case DW_OP_minus:
6657           printf ("DW_OP_minus");
6658           break;
6659         case DW_OP_mod:
6660           printf ("DW_OP_mod");
6661           break;
6662         case DW_OP_mul:
6663           printf ("DW_OP_mul");
6664           break;
6665         case DW_OP_neg:
6666           printf ("DW_OP_neg");
6667           break;
6668         case DW_OP_not:
6669           printf ("DW_OP_not");
6670           break;
6671         case DW_OP_or:
6672           printf ("DW_OP_or");
6673           break;
6674         case DW_OP_plus:
6675           printf ("DW_OP_plus");
6676           break;
6677         case DW_OP_plus_uconst:
6678           printf ("DW_OP_plus_uconst: %lu",
6679                   read_leb128 (data, &bytes_read, 0));
6680           data += bytes_read;
6681           break;
6682         case DW_OP_shl:
6683           printf ("DW_OP_shl");
6684           break;
6685         case DW_OP_shr:
6686           printf ("DW_OP_shr");
6687           break;
6688         case DW_OP_shra:
6689           printf ("DW_OP_shra");
6690           break;
6691         case DW_OP_xor:
6692           printf ("DW_OP_xor");
6693           break;
6694         case DW_OP_bra:
6695           printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
6696           data += 2;
6697           break;
6698         case DW_OP_eq:
6699           printf ("DW_OP_eq");
6700           break;
6701         case DW_OP_ge:
6702           printf ("DW_OP_ge");
6703           break;
6704         case DW_OP_gt:
6705           printf ("DW_OP_gt");
6706           break;
6707         case DW_OP_le:
6708           printf ("DW_OP_le");
6709           break;
6710         case DW_OP_lt:
6711           printf ("DW_OP_lt");
6712           break;
6713         case DW_OP_ne:
6714           printf ("DW_OP_ne");
6715           break;
6716         case DW_OP_skip:
6717           printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
6718           data += 2;
6719           break;
6720
6721         case DW_OP_lit0:
6722         case DW_OP_lit1:
6723         case DW_OP_lit2:
6724         case DW_OP_lit3:
6725         case DW_OP_lit4:
6726         case DW_OP_lit5:
6727         case DW_OP_lit6:
6728         case DW_OP_lit7:
6729         case DW_OP_lit8:
6730         case DW_OP_lit9:
6731         case DW_OP_lit10:
6732         case DW_OP_lit11:
6733         case DW_OP_lit12:
6734         case DW_OP_lit13:
6735         case DW_OP_lit14:
6736         case DW_OP_lit15:
6737         case DW_OP_lit16:
6738         case DW_OP_lit17:
6739         case DW_OP_lit18:
6740         case DW_OP_lit19:
6741         case DW_OP_lit20:
6742         case DW_OP_lit21:
6743         case DW_OP_lit22:
6744         case DW_OP_lit23:
6745         case DW_OP_lit24:
6746         case DW_OP_lit25:
6747         case DW_OP_lit26:
6748         case DW_OP_lit27:
6749         case DW_OP_lit28:
6750         case DW_OP_lit29:
6751         case DW_OP_lit30:
6752         case DW_OP_lit31:
6753           printf ("DW_OP_lit%d", op - DW_OP_lit0);
6754           break;
6755
6756         case DW_OP_reg0:
6757         case DW_OP_reg1:
6758         case DW_OP_reg2:
6759         case DW_OP_reg3:
6760         case DW_OP_reg4:
6761         case DW_OP_reg5:
6762         case DW_OP_reg6:
6763         case DW_OP_reg7:
6764         case DW_OP_reg8:
6765         case DW_OP_reg9:
6766         case DW_OP_reg10:
6767         case DW_OP_reg11:
6768         case DW_OP_reg12:
6769         case DW_OP_reg13:
6770         case DW_OP_reg14:
6771         case DW_OP_reg15:
6772         case DW_OP_reg16:
6773         case DW_OP_reg17:
6774         case DW_OP_reg18:
6775         case DW_OP_reg19:
6776         case DW_OP_reg20:
6777         case DW_OP_reg21:
6778         case DW_OP_reg22:
6779         case DW_OP_reg23:
6780         case DW_OP_reg24:
6781         case DW_OP_reg25:
6782         case DW_OP_reg26:
6783         case DW_OP_reg27:
6784         case DW_OP_reg28:
6785         case DW_OP_reg29:
6786         case DW_OP_reg30:
6787         case DW_OP_reg31:
6788           printf ("DW_OP_reg%d", op - DW_OP_reg0);
6789           break;
6790
6791         case DW_OP_breg0:
6792         case DW_OP_breg1:
6793         case DW_OP_breg2:
6794         case DW_OP_breg3:
6795         case DW_OP_breg4:
6796         case DW_OP_breg5:
6797         case DW_OP_breg6:
6798         case DW_OP_breg7:
6799         case DW_OP_breg8:
6800         case DW_OP_breg9:
6801         case DW_OP_breg10:
6802         case DW_OP_breg11:
6803         case DW_OP_breg12:
6804         case DW_OP_breg13:
6805         case DW_OP_breg14:
6806         case DW_OP_breg15:
6807         case DW_OP_breg16:
6808         case DW_OP_breg17:
6809         case DW_OP_breg18:
6810         case DW_OP_breg19:
6811         case DW_OP_breg20:
6812         case DW_OP_breg21:
6813         case DW_OP_breg22:
6814         case DW_OP_breg23:
6815         case DW_OP_breg24:
6816         case DW_OP_breg25:
6817         case DW_OP_breg26:
6818         case DW_OP_breg27:
6819         case DW_OP_breg28:
6820         case DW_OP_breg29:
6821         case DW_OP_breg30:
6822         case DW_OP_breg31:
6823           printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
6824                   read_leb128 (data, &bytes_read, 1));
6825           data += bytes_read;
6826           break;
6827
6828         case DW_OP_regx:
6829           printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
6830           data += bytes_read;
6831           break;
6832         case DW_OP_fbreg:
6833           printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
6834           data += bytes_read;
6835           break;
6836         case DW_OP_bregx:
6837           uvalue = read_leb128 (data, &bytes_read, 0);
6838           data += bytes_read;
6839           printf ("DW_OP_bregx: %lu %ld", uvalue,
6840                   read_leb128 (data, &bytes_read, 1));
6841           data += bytes_read;
6842           break;
6843         case DW_OP_piece:
6844           printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
6845           data += bytes_read;
6846           break;
6847         case DW_OP_deref_size:
6848           printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
6849           break;
6850         case DW_OP_xderef_size:
6851           printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
6852           break;
6853         case DW_OP_nop:
6854           printf ("DW_OP_nop");
6855           break;
6856
6857           /* DWARF 2.1 extensions.  */
6858         case DW_OP_push_object_address:
6859           printf ("DW_OP_push_object_address");
6860           break;
6861         case DW_OP_call2:
6862           printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2));
6863           data += 2;
6864           break;
6865         case DW_OP_call4:
6866           printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4));
6867           data += 4;
6868           break;
6869         case DW_OP_calli:
6870           printf ("DW_OP_calli");
6871           break;
6872
6873         default:
6874           if (op >= DW_OP_lo_user
6875               && op <= DW_OP_hi_user)
6876             printf (_("(User defined location op)"));
6877           else
6878             printf (_("(Unknown location op)"));
6879           /* No way to tell where the next op is, so just bail.  */
6880           return;
6881         }
6882
6883       /* Separate the ops.  */
6884       printf ("; ");
6885     }
6886 }
6887
6888
6889 static unsigned char *
6890 read_and_display_attr (attribute, form, data, cu_offset, pointer_size)
6891      unsigned long   attribute;
6892      unsigned long   form;
6893      unsigned char * data;
6894      unsigned long   cu_offset;
6895      unsigned long   pointer_size;
6896 {
6897   unsigned long   uvalue = 0;
6898   unsigned char * block_start = NULL;
6899   int             bytes_read;
6900
6901   printf ("     %-18s:", get_AT_name (attribute));
6902
6903   switch (form)
6904     {
6905     default:
6906       break;
6907
6908     case DW_FORM_ref_addr:
6909     case DW_FORM_addr:
6910       uvalue = byte_get (data, pointer_size);
6911       data += pointer_size;
6912       break;
6913
6914     case DW_FORM_ref1:
6915     case DW_FORM_flag:
6916     case DW_FORM_data1:
6917       uvalue = byte_get (data ++, 1);
6918       break;
6919
6920     case DW_FORM_ref2:
6921     case DW_FORM_data2:
6922       uvalue = byte_get (data, 2);
6923       data += 2;
6924       break;
6925
6926     case DW_FORM_ref4:
6927     case DW_FORM_data4:
6928       uvalue = byte_get (data, 4);
6929       data += 4;
6930       break;
6931
6932     case DW_FORM_sdata:
6933       uvalue = read_leb128 (data, & bytes_read, 1);
6934       data += bytes_read;
6935       break;
6936
6937     case DW_FORM_ref_udata:
6938     case DW_FORM_udata:
6939       uvalue = read_leb128 (data, & bytes_read, 0);
6940       data += bytes_read;
6941       break;
6942     }
6943
6944   switch (form)
6945     {
6946     case DW_FORM_ref_addr:
6947       printf (" <#%lx>", uvalue);
6948       break;
6949
6950     case DW_FORM_ref1:
6951     case DW_FORM_ref2:
6952     case DW_FORM_ref4:
6953     case DW_FORM_ref_udata:
6954       printf (" <%lx>", uvalue + cu_offset);
6955       break;
6956
6957     case DW_FORM_addr:
6958       printf (" %#lx", uvalue);
6959
6960     case DW_FORM_flag:
6961     case DW_FORM_data1:
6962     case DW_FORM_data2:
6963     case DW_FORM_data4:
6964     case DW_FORM_sdata:
6965     case DW_FORM_udata:
6966       printf (" %ld", uvalue);
6967       break;
6968
6969     case DW_FORM_ref8:
6970     case DW_FORM_data8:
6971       uvalue = byte_get (data, 4);
6972       printf (" %lx", uvalue);
6973       printf (" %lx", (unsigned long) byte_get (data + 4, 4));
6974       data += 8;
6975       break;
6976
6977     case DW_FORM_string:
6978       printf (" %s", data);
6979       data += strlen ((char *) data) + 1;
6980       break;
6981
6982     case DW_FORM_block:
6983       uvalue = read_leb128 (data, & bytes_read, 0);
6984       block_start = data + bytes_read;
6985       data = display_block (block_start, uvalue);
6986       break;
6987
6988     case DW_FORM_block1:
6989       uvalue = byte_get (data, 1);
6990       block_start = data + 1;
6991       data = display_block (block_start, uvalue);
6992       break;
6993
6994     case DW_FORM_block2:
6995       uvalue = byte_get (data, 2);
6996       block_start = data + 2;
6997       data = display_block (block_start, uvalue);
6998       break;
6999
7000     case DW_FORM_block4:
7001       uvalue = byte_get (data, 4);
7002       block_start = data + 4;
7003       data = display_block (block_start, uvalue);
7004       break;
7005
7006     case DW_FORM_strp:
7007     case DW_FORM_indirect:
7008       warn (_("Unable to handle FORM: %d"), form);
7009       break;
7010
7011     default:
7012       warn (_("Unrecognised form: %d"), form);
7013       break;
7014     }
7015
7016   /* For some attributes we can display futher information.  */
7017
7018   printf ("\t");
7019
7020   switch (attribute)
7021     {
7022     case DW_AT_inline:
7023       switch (uvalue)
7024         {
7025         case DW_INL_not_inlined:          printf (_("(not inlined)")); break;
7026         case DW_INL_inlined:              printf (_("(inlined)")); break;
7027         case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
7028         case DW_INL_declared_inlined:     printf (_("(declared as inline and inlined)")); break;
7029         default: printf (_("  (Unknown inline attribute value: %lx)"), uvalue); break;
7030         }
7031       break;
7032
7033     case DW_AT_language:
7034       switch (uvalue)
7035         {
7036         case DW_LANG_C:              printf ("(non-ANSI C)"); break;
7037         case DW_LANG_C89:            printf ("(ANSI C)"); break;
7038         case DW_LANG_C_plus_plus:    printf ("(C++)"); break;
7039         case DW_LANG_Fortran77:      printf ("(FORTRAN 77)"); break;
7040         case DW_LANG_Fortran90:      printf ("(Fortran 90)"); break;
7041         case DW_LANG_Modula2:        printf ("(Modula 2)"); break;
7042         case DW_LANG_Pascal83:       printf ("(ANSI Pascal)"); break;
7043         case DW_LANG_Ada83:          printf ("(Ada)"); break;
7044         case DW_LANG_Cobol74:        printf ("(Cobol 74)"); break;
7045         case DW_LANG_Cobol85:        printf ("(Cobol 85)"); break;
7046           /* DWARF 2.1 values.  */
7047         case DW_LANG_C99:            printf ("(ANSI C99)"); break;
7048         case DW_LANG_Ada95:          printf ("(ADA 95)"); break;
7049         case DW_LANG_Fortran95:       printf ("(Fortran 95)"); break;
7050           /* MIPS extension.  */
7051         case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
7052         default:                     printf ("(Unknown: %lx)", uvalue); break;
7053         }
7054       break;
7055
7056     case DW_AT_encoding:
7057       switch (uvalue)
7058         {
7059         case DW_ATE_void:            printf ("(void)"); break;
7060         case DW_ATE_address:         printf ("(machine address)"); break;
7061         case DW_ATE_boolean:         printf ("(boolean)"); break;
7062         case DW_ATE_complex_float:   printf ("(complex float)"); break;
7063         case DW_ATE_float:           printf ("(float)"); break;
7064         case DW_ATE_signed:          printf ("(signed)"); break;
7065         case DW_ATE_signed_char:     printf ("(signed char)"); break;
7066         case DW_ATE_unsigned:        printf ("(unsigned)"); break;
7067         case DW_ATE_unsigned_char:   printf ("(unsigned char)"); break;
7068           /* DWARF 2.1 value.  */
7069         case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
7070         default:
7071           if (uvalue >= DW_ATE_lo_user
7072               && uvalue <= DW_ATE_hi_user)
7073             printf ("(user defined type)");
7074           else
7075             printf ("(unknown type)");
7076           break;
7077         }
7078       break;
7079
7080     case DW_AT_accessibility:
7081       switch (uvalue)
7082         {
7083         case DW_ACCESS_public:          printf ("(public)"); break;
7084         case DW_ACCESS_protected:       printf ("(protected)"); break;
7085         case DW_ACCESS_private:         printf ("(private)"); break;
7086         default:                        printf ("(unknown accessibility)"); break;
7087         }
7088       break;
7089
7090     case DW_AT_visibility:
7091       switch (uvalue)
7092         {
7093         case DW_VIS_local:      printf ("(local)"); break;
7094         case DW_VIS_exported:   printf ("(exported)"); break;
7095         case DW_VIS_qualified:  printf ("(qualified)"); break;
7096         default:                printf ("(unknown visibility)"); break;
7097         }
7098       break;
7099
7100     case DW_AT_virtuality:
7101       switch (uvalue)
7102         {
7103         case DW_VIRTUALITY_none:        printf ("(none)"); break;
7104         case DW_VIRTUALITY_virtual:     printf ("(virtual)"); break;
7105         case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
7106         default:                        printf ("(unknown virtuality)"); break;
7107         }
7108       break;
7109
7110     case DW_AT_identifier_case:
7111       switch (uvalue)
7112         {
7113         case DW_ID_case_sensitive:      printf ("(case_sensitive)"); break;
7114         case DW_ID_up_case:             printf ("(up_case)"); break;
7115         case DW_ID_down_case:           printf ("(down_case)"); break;
7116         case DW_ID_case_insensitive:    printf ("(case_insensitive)"); break;
7117         default:                        printf ("(unknown case)"); break;
7118         }
7119       break;
7120
7121     case DW_AT_calling_convention:
7122       switch (uvalue)
7123         {
7124         case DW_CC_normal:      printf ("(normal)"); break;
7125         case DW_CC_program:     printf ("(program)"); break;
7126         case DW_CC_nocall:      printf ("(nocall)"); break;
7127         default:
7128           if (uvalue >= DW_CC_lo_user
7129               && uvalue <= DW_CC_hi_user)
7130             printf ("(user defined)");
7131           else
7132             printf ("(unknown convention)");
7133         }
7134       break;
7135
7136     case DW_AT_ordering:
7137       switch (uvalue)
7138         {
7139         case -1: printf ("(undefined)"); break;
7140         case 0:  printf ("(row major)"); break;
7141         case 1:  printf ("(column major)"); break;
7142         }
7143       break;
7144
7145     case DW_AT_frame_base:
7146     case DW_AT_location:
7147     case DW_AT_data_member_location:
7148     case DW_AT_vtable_elem_location:
7149     case DW_AT_allocated:
7150     case DW_AT_associated:
7151     case DW_AT_data_location:
7152     case DW_AT_stride:
7153     case DW_AT_upper_bound:
7154     case DW_AT_lower_bound:
7155       if (block_start)
7156         {
7157           printf ("(");
7158           decode_location_expression (block_start, pointer_size, uvalue);
7159           printf (")");
7160         }
7161       break;
7162
7163     default:
7164       break;
7165     }
7166
7167   printf ("\n");
7168   return data;
7169 }
7170
7171 static int
7172 display_debug_info (section, start, file)
7173      Elf32_Internal_Shdr * section;
7174      unsigned char *       start;
7175      FILE *                file;
7176 {
7177   unsigned char * end = start + section->sh_size;
7178   unsigned char * section_begin = start;
7179
7180   printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
7181
7182   while (start < end)
7183     {
7184       DWARF2_External_CompUnit * external;
7185       DWARF2_Internal_CompUnit   compunit;
7186       Elf32_Internal_Shdr *      relsec;
7187       unsigned char *            tags;
7188       int                        i;
7189       int                        level;
7190       unsigned long              cu_offset;
7191
7192       external = (DWARF2_External_CompUnit *) start;
7193
7194       compunit.cu_length        = BYTE_GET (external->cu_length);
7195       compunit.cu_version       = BYTE_GET (external->cu_version);
7196       compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
7197       compunit.cu_pointer_size  = BYTE_GET (external->cu_pointer_size);
7198
7199       if (compunit.cu_length == 0xffffffff)
7200         {
7201           warn (_("64-bit DWARF debug info is not supported yet.\n"));
7202           break;
7203         }
7204
7205       /* Check for RELA relocations in the abbrev_offset address, and
7206          apply them.  */
7207       for (relsec = section_headers;
7208            relsec < section_headers + elf_header.e_shnum;
7209            ++relsec)
7210         {
7211           unsigned long nrelas, nsyms;
7212           Elf_Internal_Rela *rela, *rp;
7213           Elf32_Internal_Shdr *symsec;
7214           Elf_Internal_Sym *symtab;
7215           Elf_Internal_Sym *sym;
7216
7217           if (relsec->sh_type != SHT_RELA
7218               || section_headers + relsec->sh_info != section)
7219             continue;
7220
7221           if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7222                                   & rela, & nrelas))
7223             return 0;
7224
7225           symsec = section_headers + relsec->sh_link;
7226           nsyms = symsec->sh_size / symsec->sh_entsize;
7227           symtab = GET_ELF_SYMBOLS (file, symsec->sh_offset, nsyms);
7228
7229           for (rp = rela; rp < rela + nrelas; ++rp)
7230             {
7231               if (rp->r_offset
7232                   != (bfd_vma) ((unsigned char *) &external->cu_abbrev_offset
7233                                 - section_begin))
7234                 continue;
7235
7236               if (is_32bit_elf)
7237                 {
7238                   sym = symtab + ELF32_R_SYM (rp->r_info);
7239
7240                   if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
7241                     {
7242                       warn (_("Skipping unexpected symbol type %u"),
7243                             ELF32_ST_TYPE (sym->st_info));
7244                       continue;
7245                     }
7246                 }
7247               else
7248                 {
7249                   sym = symtab + ELF64_R_SYM (rp->r_info);
7250
7251                   if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
7252                     {
7253                       warn (_("Skipping unexpected symbol type %u"),
7254                             ELF64_ST_TYPE (sym->st_info));
7255                       continue;
7256                     }
7257                 }
7258
7259               compunit.cu_abbrev_offset += rp->r_addend;
7260               break;
7261             }
7262
7263           free (rela);
7264           break;
7265         }
7266
7267       tags = start + sizeof (* external);
7268       cu_offset = start - section_begin;
7269       start += compunit.cu_length + sizeof (external->cu_length);
7270
7271       printf (_("  Compilation Unit @ %lx:\n"), cu_offset);
7272       printf (_("   Length:        %ld\n"), compunit.cu_length);
7273       printf (_("   Version:       %d\n"), compunit.cu_version);
7274       printf (_("   Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
7275       printf (_("   Pointer Size:  %d\n"), compunit.cu_pointer_size);
7276
7277       if (compunit.cu_version != 2)
7278         {
7279           warn (_("Only version 2 DWARF debug information is currently supported.\n"));
7280           continue;
7281         }
7282
7283       if (first_abbrev != NULL)
7284         free_abbrevs ();
7285
7286       /* Read in the abbrevs used by this compilation unit.  */
7287
7288       {
7289         Elf32_Internal_Shdr * sec;
7290         unsigned char *       begin;
7291
7292         /* Locate the .debug_abbrev section and process it.  */
7293         for (i = 0, sec = section_headers;
7294              i < elf_header.e_shnum;
7295              i ++, sec ++)
7296           if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
7297             break;
7298
7299         if (i == -1 || sec->sh_size == 0)
7300           {
7301             warn (_("Unable to locate .debug_abbrev section!\n"));
7302             return 0;
7303           }
7304
7305         begin = ((unsigned char *)
7306                  get_data (NULL, file, sec->sh_offset, sec->sh_size,
7307                            _("debug_abbrev section data")));
7308         if (!begin)
7309           return 0;
7310
7311         process_abbrev_section (begin + compunit.cu_abbrev_offset,
7312                                 begin + sec->sh_size);
7313
7314         free (begin);
7315       }
7316
7317       level = 0;
7318       while (tags < start)
7319         {
7320           int            bytes_read;
7321           unsigned long  abbrev_number;
7322           abbrev_entry * entry;
7323           abbrev_attr  * attr;
7324
7325           abbrev_number = read_leb128 (tags, & bytes_read, 0);
7326           tags += bytes_read;
7327
7328           /* A null DIE marks the end of a list of children.  */
7329           if (abbrev_number == 0)
7330             {
7331               --level;
7332               continue;
7333             }
7334
7335           /* Scan through the abbreviation list until we reach the
7336              correct entry.  */
7337           for (entry = first_abbrev;
7338                entry && entry->entry != abbrev_number;
7339                entry = entry->next)
7340             continue;
7341
7342           if (entry == NULL)
7343             {
7344               warn (_("Unable to locate entry %lu in the abbreviation table\n"),
7345                     abbrev_number);
7346               return 0;
7347             }
7348
7349           printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
7350                   level,
7351                   (unsigned long) (tags - section_begin - bytes_read),
7352                   abbrev_number,
7353                   get_TAG_name (entry->tag));
7354
7355           for (attr = entry->first_attr; attr; attr = attr->next)
7356             tags = read_and_display_attr (attr->attribute,
7357                                           attr->form,
7358                                           tags, cu_offset,
7359                                           compunit.cu_pointer_size);
7360
7361           if (entry->children)
7362             ++level;
7363         }
7364     }
7365
7366   printf ("\n");
7367
7368   return 1;
7369 }
7370
7371 static int
7372 display_debug_aranges (section, start, file)
7373      Elf32_Internal_Shdr * section;
7374      unsigned char *       start;
7375      FILE *                file ATTRIBUTE_UNUSED;
7376 {
7377   unsigned char * end = start + section->sh_size;
7378
7379   printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
7380
7381   while (start < end)
7382     {
7383       DWARF2_External_ARange * external;
7384       DWARF2_Internal_ARange   arange;
7385       unsigned char *          ranges;
7386       unsigned long            length;
7387       unsigned long            address;
7388       int                      excess;
7389
7390       external = (DWARF2_External_ARange *) start;
7391
7392       arange.ar_length       = BYTE_GET (external->ar_length);
7393       arange.ar_version      = BYTE_GET (external->ar_version);
7394       arange.ar_info_offset  = BYTE_GET (external->ar_info_offset);
7395       arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
7396       arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
7397
7398       if (arange.ar_length == 0xffffffff)
7399         {
7400           warn (_("64-bit DWARF aranges are not supported yet.\n"));
7401           break;
7402         }
7403
7404       if (arange.ar_version != 2)
7405         {
7406           warn (_("Only DWARF 2 aranges are currently supported.\n"));
7407           break;
7408         }
7409
7410       printf (_("  Length:                   %ld\n"), arange.ar_length);
7411       printf (_("  Version:                  %d\n"), arange.ar_version);
7412       printf (_("  Offset into .debug_info:  %lx\n"), arange.ar_info_offset);
7413       printf (_("  Pointer Size:             %d\n"), arange.ar_pointer_size);
7414       printf (_("  Segment Size:             %d\n"), arange.ar_segment_size);
7415
7416       printf (_("\n    Address  Length\n"));
7417
7418       ranges = start + sizeof (* external);
7419
7420       /* Must pad to an alignment boundary that is twice the pointer size.  */
7421       excess = sizeof (* external) % (2 * arange.ar_pointer_size);
7422       if (excess)
7423         ranges += (2 * arange.ar_pointer_size) - excess;
7424
7425       for (;;)
7426         {
7427           address = byte_get (ranges, arange.ar_pointer_size);
7428
7429           ranges += arange.ar_pointer_size;
7430
7431           length  = byte_get (ranges, arange.ar_pointer_size);
7432
7433           ranges += arange.ar_pointer_size;
7434
7435           /* A pair of zeros marks the end of the list.  */
7436           if (address == 0 && length == 0)
7437             break;
7438
7439           printf ("    %8.8lx %lu\n", address, length);
7440         }
7441
7442       start += arange.ar_length + sizeof (external->ar_length);
7443     }
7444
7445   printf ("\n");
7446
7447   return 1;
7448 }
7449
7450 typedef struct Frame_Chunk
7451 {
7452   struct Frame_Chunk * next;
7453   unsigned char *      chunk_start;
7454   int                  ncols;
7455   /* DW_CFA_{undefined,same_value,offset,register,unreferenced}  */
7456   short int *          col_type;
7457   int *                col_offset;
7458   char *               augmentation;
7459   unsigned int         code_factor;
7460   int                  data_factor;
7461   unsigned long        pc_begin;
7462   unsigned long        pc_range;
7463   int                  cfa_reg;
7464   int                  cfa_offset;
7465   int                  ra;
7466   unsigned char        fde_encoding;
7467 }
7468 Frame_Chunk;
7469
7470 /* A marker for a col_type that means this column was never referenced
7471    in the frame info.  */
7472 #define DW_CFA_unreferenced (-1)
7473
7474 static void frame_need_space PARAMS ((Frame_Chunk *, int));
7475 static void frame_display_row PARAMS ((Frame_Chunk *, int *, int *));
7476 static int size_of_encoded_value PARAMS ((int));
7477
7478 static void
7479 frame_need_space (fc, reg)
7480      Frame_Chunk * fc;
7481      int reg;
7482 {
7483   int prev = fc->ncols;
7484
7485   if (reg < fc->ncols)
7486     return;
7487
7488   fc->ncols = reg + 1;
7489   fc->col_type = (short int *) xrealloc (fc->col_type,
7490                                          fc->ncols * sizeof (short int));
7491   fc->col_offset = (int *) xrealloc (fc->col_offset,
7492                                      fc->ncols * sizeof (int));
7493
7494   while (prev < fc->ncols)
7495     {
7496       fc->col_type[prev] = DW_CFA_unreferenced;
7497       fc->col_offset[prev] = 0;
7498       prev++;
7499     }
7500 }
7501
7502 static void
7503 frame_display_row (fc, need_col_headers, max_regs)
7504      Frame_Chunk * fc;
7505      int *         need_col_headers;
7506      int *         max_regs;
7507 {
7508   int r;
7509   char tmp[100];
7510
7511   if (* max_regs < fc->ncols)
7512     * max_regs = fc->ncols;
7513
7514   if (* need_col_headers)
7515     {
7516       * need_col_headers = 0;
7517
7518       printf ("   LOC   CFA      ");
7519
7520       for (r = 0; r < * max_regs; r++)
7521         if (fc->col_type[r] != DW_CFA_unreferenced)
7522           {
7523             if (r == fc->ra)
7524               printf ("ra   ");
7525             else
7526               printf ("r%-4d", r);
7527           }
7528
7529       printf ("\n");
7530     }
7531
7532   printf ("%08lx ", fc->pc_begin);
7533   sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
7534   printf ("%-8s ", tmp);
7535
7536   for (r = 0; r < fc->ncols; r++)
7537     {
7538       if (fc->col_type[r] != DW_CFA_unreferenced)
7539         {
7540           switch (fc->col_type[r])
7541             {
7542             case DW_CFA_undefined:
7543               strcpy (tmp, "u");
7544               break;
7545             case DW_CFA_same_value:
7546               strcpy (tmp, "s");
7547               break;
7548             case DW_CFA_offset:
7549               sprintf (tmp, "c%+d", fc->col_offset[r]);
7550               break;
7551             case DW_CFA_register:
7552               sprintf (tmp, "r%d", fc->col_offset[r]);
7553               break;
7554             default:
7555               strcpy (tmp, "n/a");
7556               break;
7557             }
7558           printf ("%-5s", tmp);
7559         }
7560     }
7561   printf ("\n");
7562 }
7563
7564 static int
7565 size_of_encoded_value (encoding)
7566      int encoding;
7567 {
7568   switch (encoding & 0x7)
7569     {
7570     default:    /* ??? */
7571     case 0:     return is_32bit_elf ? 4 : 8;
7572     case 2:     return 2;
7573     case 3:     return 4;
7574     case 4:     return 8;
7575     }
7576 }
7577
7578 #define GET(N)  byte_get (start, N); start += N
7579 #define LEB()   read_leb128 (start, & length_return, 0); start += length_return
7580 #define SLEB()  read_leb128 (start, & length_return, 1); start += length_return
7581
7582 static int
7583 display_debug_frames (section, start, file)
7584      Elf32_Internal_Shdr * section;
7585      unsigned char *       start;
7586      FILE *                file ATTRIBUTE_UNUSED;
7587 {
7588   unsigned char * end = start + section->sh_size;
7589   unsigned char * section_start = start;
7590   Frame_Chunk *   chunks = 0;
7591   Frame_Chunk *   remembered_state = 0;
7592   Frame_Chunk *   rs;
7593   int             is_eh = (strcmp (SECTION_NAME (section), ".eh_frame") == 0);
7594   int             length_return;
7595   int             max_regs = 0;
7596   int             addr_size = is_32bit_elf ? 4 : 8;
7597
7598   printf (_("The section %s contains:\n"), SECTION_NAME (section));
7599
7600   while (start < end)
7601     {
7602       unsigned char * saved_start;
7603       unsigned char * block_end;
7604       unsigned long   length;
7605       unsigned long   cie_id;
7606       Frame_Chunk *   fc;
7607       Frame_Chunk *   cie;
7608       int             need_col_headers = 1;
7609       unsigned char * augmentation_data = NULL;
7610       unsigned long   augmentation_data_len = 0;
7611       int             encoded_ptr_size = addr_size;
7612
7613       saved_start = start;
7614       length = byte_get (start, 4); start += 4;
7615
7616       if (length == 0)
7617         return 1;
7618
7619       if (length == 0xffffffff)
7620         {
7621           warn (_("64-bit DWARF format frames are not supported yet.\n"));
7622           break;
7623         }
7624
7625       block_end = saved_start + length + 4;
7626       cie_id = byte_get (start, 4); start += 4;
7627
7628       if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
7629         {
7630           int version;
7631
7632           fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
7633           memset (fc, 0, sizeof (Frame_Chunk));
7634
7635           fc->next = chunks;
7636           chunks = fc;
7637           fc->chunk_start = saved_start;
7638           fc->ncols = 0;
7639           fc->col_type = (short int *) xmalloc (sizeof (short int));
7640           fc->col_offset = (int *) xmalloc (sizeof (int));
7641           frame_need_space (fc, max_regs-1);
7642
7643           version = *start++;
7644
7645           fc->augmentation = start;
7646           start = strchr (start, '\0') + 1;
7647
7648           if (fc->augmentation[0] == 'z')
7649             {
7650               fc->code_factor = LEB ();
7651               fc->data_factor = SLEB ();
7652               fc->ra = byte_get (start, 1); start += 1;
7653               augmentation_data_len = LEB ();
7654               augmentation_data = start;
7655               start += augmentation_data_len;
7656             }
7657           else if (strcmp (fc->augmentation, "eh") == 0)
7658             {
7659               start += addr_size;
7660               fc->code_factor = LEB ();
7661               fc->data_factor = SLEB ();
7662               fc->ra = byte_get (start, 1); start += 1;
7663             }
7664           else
7665             {
7666               fc->code_factor = LEB ();
7667               fc->data_factor = SLEB ();
7668               fc->ra = byte_get (start, 1); start += 1;
7669             }
7670           cie = fc;
7671
7672           if (do_debug_frames_interp)
7673             printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
7674                     (unsigned long)(saved_start - section_start), length, cie_id,
7675                     fc->augmentation, fc->code_factor, fc->data_factor,
7676                     fc->ra);
7677           else
7678             {
7679               printf ("\n%08lx %08lx %08lx CIE\n",
7680                       (unsigned long)(saved_start - section_start), length, cie_id);
7681               printf ("  Version:               %d\n", version);
7682               printf ("  Augmentation:          \"%s\"\n", fc->augmentation);
7683               printf ("  Code alignment factor: %u\n", fc->code_factor);
7684               printf ("  Data alignment factor: %d\n", fc->data_factor);
7685               printf ("  Return address column: %d\n", fc->ra);
7686
7687               if (augmentation_data_len)
7688                 {
7689                   unsigned long i;
7690                   printf ("  Augmentation data:    ");
7691                   for (i = 0; i < augmentation_data_len; ++i)
7692                     printf (" %02x", augmentation_data[i]);
7693                   putchar ('\n');
7694                 }
7695               putchar ('\n');
7696             }
7697
7698           if (augmentation_data_len)
7699             {
7700               unsigned char *p, *q;
7701               p = fc->augmentation + 1;
7702               q = augmentation_data;
7703
7704               while (1)
7705                 {
7706                   if (*p == 'L')
7707                     q++;
7708                   else if (*p == 'P')
7709                     q += 1 + size_of_encoded_value (*q);
7710                   else if (*p == 'R')
7711                     fc->fde_encoding = *q++;
7712                   else
7713                     break;
7714                   p++;
7715                 }
7716
7717               if (fc->fde_encoding)
7718                 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
7719             }
7720
7721           frame_need_space (fc, fc->ra);
7722         }
7723       else
7724         {
7725           unsigned char *    look_for;
7726           static Frame_Chunk fde_fc;
7727
7728           fc = & fde_fc;
7729           memset (fc, 0, sizeof (Frame_Chunk));
7730
7731           look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
7732
7733           for (cie = chunks; cie ; cie = cie->next)
7734             if (cie->chunk_start == look_for)
7735               break;
7736
7737           if (!cie)
7738             {
7739               warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
7740                     cie_id, saved_start);
7741               start = block_end;
7742               fc->ncols = 0;
7743               fc->col_type = (short int *) xmalloc (sizeof (short int));
7744               fc->col_offset = (int *) xmalloc (sizeof (int));
7745               frame_need_space (fc, max_regs - 1);
7746               cie = fc;
7747               fc->augmentation = "";
7748               fc->fde_encoding = 0;
7749             }
7750           else
7751             {
7752               fc->ncols = cie->ncols;
7753               fc->col_type = (short int *) xmalloc (fc->ncols * sizeof (short int));
7754               fc->col_offset = (int *) xmalloc (fc->ncols * sizeof (int));
7755               memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
7756               memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
7757               fc->augmentation = cie->augmentation;
7758               fc->code_factor = cie->code_factor;
7759               fc->data_factor = cie->data_factor;
7760               fc->cfa_reg = cie->cfa_reg;
7761               fc->cfa_offset = cie->cfa_offset;
7762               fc->ra = cie->ra;
7763               frame_need_space (fc, max_regs-1);
7764               fc->fde_encoding = cie->fde_encoding;
7765             }
7766
7767           if (fc->fde_encoding)
7768             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
7769
7770           fc->pc_begin = byte_get (start, encoded_ptr_size);
7771           start += encoded_ptr_size;
7772           fc->pc_range = byte_get (start, encoded_ptr_size);
7773           start += encoded_ptr_size;
7774
7775           if (cie->augmentation[0] == 'z')
7776             {
7777               augmentation_data_len = LEB ();
7778               augmentation_data = start;
7779               start += augmentation_data_len;
7780             }
7781
7782           printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
7783                   (unsigned long)(saved_start - section_start), length, cie_id,
7784                   (unsigned long)(cie->chunk_start - section_start),
7785                   fc->pc_begin, fc->pc_begin + fc->pc_range);
7786           if (! do_debug_frames_interp && augmentation_data_len)
7787             {
7788               unsigned long i;
7789               printf ("  Augmentation data:    ");
7790               for (i = 0; i < augmentation_data_len; ++i)
7791                 printf (" %02x", augmentation_data[i]);
7792               putchar ('\n');
7793               putchar ('\n');
7794             }
7795         }
7796
7797       /* At this point, fc is the current chunk, cie (if any) is set, and we're
7798          about to interpret instructions for the chunk.  */
7799
7800       if (do_debug_frames_interp)
7801       {
7802         /* Start by making a pass over the chunk, allocating storage
7803            and taking note of what registers are used.  */
7804         unsigned char * tmp = start;
7805
7806         while (start < block_end)
7807           {
7808             unsigned op, opa;
7809             unsigned long reg;
7810
7811             op = * start ++;
7812             opa = op & 0x3f;
7813             if (op & 0xc0)
7814               op &= 0xc0;
7815
7816             /* Warning: if you add any more cases to this switch, be
7817                sure to add them to the corresponding switch below.  */
7818             switch (op)
7819               {
7820               case DW_CFA_advance_loc:
7821                 break;
7822               case DW_CFA_offset:
7823                 LEB ();
7824                 frame_need_space (fc, opa);
7825                 fc->col_type[opa] = DW_CFA_undefined;
7826                 break;
7827               case DW_CFA_restore:
7828                 frame_need_space (fc, opa);
7829                 fc->col_type[opa] = DW_CFA_undefined;
7830                 break;
7831               case DW_CFA_set_loc:
7832                 start += encoded_ptr_size;
7833                 break;
7834               case DW_CFA_advance_loc1:
7835                 start += 1;
7836                 break;
7837               case DW_CFA_advance_loc2:
7838                 start += 2;
7839                 break;
7840               case DW_CFA_advance_loc4:
7841                 start += 4;
7842                 break;
7843               case DW_CFA_offset_extended:
7844                 reg = LEB (); LEB ();
7845                 frame_need_space (fc, reg);
7846                 fc->col_type[reg] = DW_CFA_undefined;
7847                 break;
7848               case DW_CFA_restore_extended:
7849                 reg = LEB ();
7850                 frame_need_space (fc, reg);
7851                 fc->col_type[reg] = DW_CFA_undefined;
7852                 break;
7853               case DW_CFA_undefined:
7854                 reg = LEB ();
7855                 frame_need_space (fc, reg);
7856                 fc->col_type[reg] = DW_CFA_undefined;
7857                 break;
7858               case DW_CFA_same_value:
7859                 reg = LEB ();
7860                 frame_need_space (fc, reg);
7861                 fc->col_type[reg] = DW_CFA_undefined;
7862                 break;
7863               case DW_CFA_register:
7864                 reg = LEB (); LEB ();
7865                 frame_need_space (fc, reg);
7866                 fc->col_type[reg] = DW_CFA_undefined;
7867                 break;
7868               case DW_CFA_def_cfa:
7869                 LEB (); LEB ();
7870                 break;
7871               case DW_CFA_def_cfa_register:
7872                 LEB ();
7873                 break;
7874               case DW_CFA_def_cfa_offset:
7875                 LEB ();
7876                 break;
7877 #ifndef DW_CFA_GNU_args_size
7878 #define DW_CFA_GNU_args_size 0x2e
7879 #endif
7880               case DW_CFA_GNU_args_size:
7881                 LEB ();
7882                 break;
7883 #ifndef DW_CFA_GNU_negative_offset_extended
7884 #define DW_CFA_GNU_negative_offset_extended 0x2f
7885 #endif
7886               case DW_CFA_GNU_negative_offset_extended:
7887                 reg = LEB (); LEB ();
7888                 frame_need_space (fc, reg);
7889                 fc->col_type[reg] = DW_CFA_undefined;
7890
7891               default:
7892                 break;
7893               }
7894           }
7895         start = tmp;
7896       }
7897
7898       /* Now we know what registers are used, make a second pass over
7899          the chunk, this time actually printing out the info.  */
7900
7901       while (start < block_end)
7902         {
7903           unsigned op, opa;
7904           unsigned long ul, reg, roffs;
7905           long l, ofs;
7906           bfd_vma vma;
7907
7908           op = * start ++;
7909           opa = op & 0x3f;
7910           if (op & 0xc0)
7911             op &= 0xc0;
7912
7913             /* Warning: if you add any more cases to this switch, be
7914                sure to add them to the corresponding switch above.  */
7915           switch (op)
7916             {
7917             case DW_CFA_advance_loc:
7918               if (do_debug_frames_interp)
7919                 frame_display_row (fc, &need_col_headers, &max_regs);
7920               else
7921                 printf ("  DW_CFA_advance_loc: %d to %08lx\n",
7922                         opa * fc->code_factor,
7923                         fc->pc_begin + opa * fc->code_factor);
7924               fc->pc_begin += opa * fc->code_factor;
7925               break;
7926
7927             case DW_CFA_offset:
7928               roffs = LEB ();
7929               if (! do_debug_frames_interp)
7930                 printf ("  DW_CFA_offset: r%d at cfa%+ld\n",
7931                         opa, roffs * fc->data_factor);
7932               fc->col_type[opa] = DW_CFA_offset;
7933               fc->col_offset[opa] = roffs * fc->data_factor;
7934               break;
7935
7936             case DW_CFA_restore:
7937               if (! do_debug_frames_interp)
7938                 printf ("  DW_CFA_restore: r%d\n", opa);
7939               fc->col_type[opa] = cie->col_type[opa];
7940               fc->col_offset[opa] = cie->col_offset[opa];
7941               break;
7942
7943             case DW_CFA_set_loc:
7944               vma = byte_get (start, encoded_ptr_size);
7945               start += encoded_ptr_size;
7946               if (do_debug_frames_interp)
7947                 frame_display_row (fc, &need_col_headers, &max_regs);
7948               else
7949                 printf ("  DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
7950               fc->pc_begin = vma;
7951               break;
7952
7953             case DW_CFA_advance_loc1:
7954               ofs = byte_get (start, 1); start += 1;
7955               if (do_debug_frames_interp)
7956                 frame_display_row (fc, &need_col_headers, &max_regs);
7957               else
7958                 printf ("  DW_CFA_advance_loc1: %ld to %08lx\n",
7959                         ofs * fc->code_factor,
7960                         fc->pc_begin + ofs * fc->code_factor);
7961               fc->pc_begin += ofs * fc->code_factor;
7962               break;
7963
7964             case DW_CFA_advance_loc2:
7965               ofs = byte_get (start, 2); start += 2;
7966               if (do_debug_frames_interp)
7967                 frame_display_row (fc, &need_col_headers, &max_regs);
7968               else
7969                 printf ("  DW_CFA_advance_loc2: %ld to %08lx\n",
7970                         ofs * fc->code_factor,
7971                         fc->pc_begin + ofs * fc->code_factor);
7972               fc->pc_begin += ofs * fc->code_factor;
7973               break;
7974
7975             case DW_CFA_advance_loc4:
7976               ofs = byte_get (start, 4); start += 4;
7977               if (do_debug_frames_interp)
7978                 frame_display_row (fc, &need_col_headers, &max_regs);
7979               else
7980                 printf ("  DW_CFA_advance_loc4: %ld to %08lx\n",
7981                         ofs * fc->code_factor,
7982                         fc->pc_begin + ofs * fc->code_factor);
7983               fc->pc_begin += ofs * fc->code_factor;
7984               break;
7985
7986             case DW_CFA_offset_extended:
7987               reg = LEB ();
7988               roffs = LEB ();
7989               if (! do_debug_frames_interp)
7990                 printf ("  DW_CFA_offset_extended: r%ld at cfa%+ld\n",
7991                         reg, roffs * fc->data_factor);
7992               fc->col_type[reg] = DW_CFA_offset;
7993               fc->col_offset[reg] = roffs * fc->data_factor;
7994               break;
7995
7996             case DW_CFA_restore_extended:
7997               reg = LEB ();
7998               if (! do_debug_frames_interp)
7999                 printf ("  DW_CFA_restore_extended: r%ld\n", reg);
8000               fc->col_type[reg] = cie->col_type[reg];
8001               fc->col_offset[reg] = cie->col_offset[reg];
8002               break;
8003
8004             case DW_CFA_undefined:
8005               reg = LEB ();
8006               if (! do_debug_frames_interp)
8007                 printf ("  DW_CFA_undefined: r%ld\n", reg);
8008               fc->col_type[reg] = DW_CFA_undefined;
8009               fc->col_offset[reg] = 0;
8010               break;
8011
8012             case DW_CFA_same_value:
8013               reg = LEB ();
8014               if (! do_debug_frames_interp)
8015                 printf ("  DW_CFA_same_value: r%ld\n", reg);
8016               fc->col_type[reg] = DW_CFA_same_value;
8017               fc->col_offset[reg] = 0;
8018               break;
8019
8020             case DW_CFA_register:
8021               reg = LEB ();
8022               roffs = LEB ();
8023               if (! do_debug_frames_interp)
8024                 printf ("  DW_CFA_register: r%ld\n", reg);
8025               fc->col_type[reg] = DW_CFA_register;
8026               fc->col_offset[reg] = roffs;
8027               break;
8028
8029             case DW_CFA_remember_state:
8030               if (! do_debug_frames_interp)
8031                 printf ("  DW_CFA_remember_state\n");
8032               rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
8033               rs->ncols = fc->ncols;
8034               rs->col_type = (short int *) xmalloc (rs->ncols * sizeof (short int));
8035               rs->col_offset = (int *) xmalloc (rs->ncols * sizeof (int));
8036               memcpy (rs->col_type, fc->col_type, rs->ncols);
8037               memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
8038               rs->next = remembered_state;
8039               remembered_state = rs;
8040               break;
8041
8042             case DW_CFA_restore_state:
8043               if (! do_debug_frames_interp)
8044                 printf ("  DW_CFA_restore_state\n");
8045               rs = remembered_state;
8046               remembered_state = rs->next;
8047               frame_need_space (fc, rs->ncols-1);
8048               memcpy (fc->col_type, rs->col_type, rs->ncols);
8049               memcpy (fc->col_offset, rs->col_offset, rs->ncols * sizeof (int));
8050               free (rs->col_type);
8051               free (rs->col_offset);
8052               free (rs);
8053               break;
8054
8055             case DW_CFA_def_cfa:
8056               fc->cfa_reg = LEB ();
8057               fc->cfa_offset = LEB ();
8058               if (! do_debug_frames_interp)
8059                 printf ("  DW_CFA_def_cfa: r%d ofs %d\n",
8060                         fc->cfa_reg, fc->cfa_offset);
8061               break;
8062
8063             case DW_CFA_def_cfa_register:
8064               fc->cfa_reg = LEB ();
8065               if (! do_debug_frames_interp)
8066                 printf ("  DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
8067               break;
8068
8069             case DW_CFA_def_cfa_offset:
8070               fc->cfa_offset = LEB ();
8071               if (! do_debug_frames_interp)
8072                 printf ("  DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
8073               break;
8074
8075             case DW_CFA_nop:
8076               if (! do_debug_frames_interp)
8077                 printf ("  DW_CFA_nop\n");
8078               break;
8079
8080 #ifndef DW_CFA_GNU_window_save
8081 #define DW_CFA_GNU_window_save 0x2d
8082 #endif
8083             case DW_CFA_GNU_window_save:
8084               if (! do_debug_frames_interp)
8085                 printf ("  DW_CFA_GNU_window_save\n");
8086               break;
8087
8088             case DW_CFA_GNU_args_size:
8089               ul = LEB ();
8090               if (! do_debug_frames_interp)
8091                 printf ("  DW_CFA_GNU_args_size: %ld\n", ul);
8092               break;
8093
8094             case DW_CFA_GNU_negative_offset_extended:
8095               reg = LEB ();
8096               l = - LEB ();
8097               frame_need_space (fc, reg);
8098               if (! do_debug_frames_interp)
8099                 printf ("  DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
8100                         reg, l * fc->data_factor);
8101               fc->col_type[reg] = DW_CFA_offset;
8102               fc->col_offset[reg] = l * fc->data_factor;
8103               break;
8104
8105             default:
8106               fprintf (stderr, "unsupported or unknown DW_CFA_%d\n", op);
8107               start = block_end;
8108             }
8109         }
8110
8111       if (do_debug_frames_interp)
8112         frame_display_row (fc, &need_col_headers, &max_regs);
8113
8114       start = block_end;
8115     }
8116
8117   printf ("\n");
8118
8119   return 1;
8120 }
8121
8122 #undef GET
8123 #undef LEB
8124 #undef SLEB
8125
8126 static int
8127 display_debug_not_supported (section, start, file)
8128      Elf32_Internal_Shdr * section;
8129      unsigned char *       start ATTRIBUTE_UNUSED;
8130      FILE *                file ATTRIBUTE_UNUSED;
8131 {
8132   printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
8133             SECTION_NAME (section));
8134
8135   return 1;
8136 }
8137
8138 /* Pre-scan the .debug_info section to record the size of address.
8139    When dumping the .debug_line, we use that size information, assuming
8140    that all compilation units have the same address size.  */
8141 static int
8142 prescan_debug_info (section, start, file)
8143      Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
8144      unsigned char *       start;
8145      FILE *                file ATTRIBUTE_UNUSED;
8146 {
8147   DWARF2_External_CompUnit * external;
8148
8149   external = (DWARF2_External_CompUnit *) start;
8150
8151   debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
8152   return 0;
8153 }
8154
8155   /* A structure containing the name of a debug section and a pointer
8156      to a function that can decode it.  The third field is a prescan
8157      function to be run over the section before displaying any of the
8158      sections.  */
8159 struct
8160 {
8161   char * name;
8162   int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
8163   int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
8164 }
8165 debug_displays[] =
8166 {
8167   { ".debug_info",        display_debug_info, prescan_debug_info },
8168   { ".debug_abbrev",      display_debug_abbrev, NULL },
8169   { ".debug_line",        display_debug_lines, NULL },
8170   { ".debug_aranges",     display_debug_aranges, NULL },
8171   { ".debug_pubnames",    display_debug_pubnames, NULL },
8172   { ".debug_frame",       display_debug_frames, NULL },
8173   { ".eh_frame",          display_debug_frames, NULL },
8174   { ".debug_macinfo",     display_debug_macinfo, NULL },
8175   { ".debug_pubtypes",    display_debug_not_supported, NULL },
8176   { ".debug_str",         display_debug_not_supported, NULL },
8177   { ".debug_static_func", display_debug_not_supported, NULL },
8178   { ".debug_static_vars", display_debug_not_supported, NULL },
8179   { ".debug_types",       display_debug_not_supported, NULL },
8180   { ".debug_weaknames",   display_debug_not_supported, NULL }
8181 };
8182
8183 static int
8184 display_debug_section (section, file)
8185      Elf32_Internal_Shdr * section;
8186      FILE * file;
8187 {
8188   char *          name = SECTION_NAME (section);
8189   bfd_size_type   length;
8190   unsigned char * start;
8191   int             i;
8192
8193   length = section->sh_size;
8194   if (length == 0)
8195     {
8196       printf (_("\nSection '%s' has no debugging data.\n"), name);
8197       return 0;
8198     }
8199
8200   start = (unsigned char *) get_data (NULL, file, section->sh_offset, length,
8201                                       _("debug section data"));
8202   if (!start)
8203     return 0;
8204
8205   /* See if we know how to display the contents of this section.  */
8206   if (strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
8207     name = ".debug_info";
8208
8209   for (i = NUM_ELEM (debug_displays); i--;)
8210     if (strcmp (debug_displays[i].name, name) == 0)
8211       {
8212         debug_displays[i].display (section, start, file);
8213         break;
8214       }
8215
8216   if (i == -1)
8217     printf (_("Unrecognised debug section: %s\n"), name);
8218
8219   free (start);
8220
8221   /* If we loaded in the abbrev section at some point,
8222      we must release it here.  */
8223   if (first_abbrev != NULL)
8224     free_abbrevs ();
8225
8226   return 1;
8227 }
8228
8229 static int
8230 process_section_contents (file)
8231      FILE * file;
8232 {
8233   Elf32_Internal_Shdr * section;
8234   unsigned int  i;
8235
8236   if (! do_dump)
8237     return 1;
8238
8239   /* Pre-scan the debug sections to find some debug information not
8240      present in some of them.  For the .debug_line, we must find out the
8241      size of address (specified in .debug_info and .debug_aranges).  */
8242   for (i = 0, section = section_headers;
8243        i < elf_header.e_shnum && i < num_dump_sects;
8244        i ++, section ++)
8245     {
8246       char *    name = SECTION_NAME (section);
8247       int       j;
8248
8249       if (section->sh_size == 0)
8250         continue;
8251
8252       /* See if there is some pre-scan operation for this section.  */
8253       for (j = NUM_ELEM (debug_displays); j--;)
8254         if (strcmp (debug_displays[j].name, name) == 0)
8255           {
8256             if (debug_displays[j].prescan != NULL)
8257               {
8258                 bfd_size_type   length;
8259                 unsigned char * start;
8260
8261                 length = section->sh_size;
8262                 start = ((unsigned char *)
8263                          get_data (NULL, file, section->sh_offset, length,
8264                                    _("debug section data")));
8265                 if (!start)
8266                   return 0;
8267
8268                 debug_displays[j].prescan (section, start, file);
8269                 free (start);
8270               }
8271
8272             break;
8273           }
8274     }
8275
8276   for (i = 0, section = section_headers;
8277        i < elf_header.e_shnum && i < num_dump_sects;
8278        i ++, section ++)
8279     {
8280 #ifdef SUPPORT_DISASSEMBLY
8281       if (dump_sects[i] & DISASS_DUMP)
8282         disassemble_section (section, file);
8283 #endif
8284       if (dump_sects[i] & HEX_DUMP)
8285         dump_section (section, file);
8286
8287       if (dump_sects[i] & DEBUG_DUMP)
8288         display_debug_section (section, file);
8289     }
8290
8291   if (i < num_dump_sects)
8292     warn (_("Some sections were not dumped because they do not exist!\n"));
8293
8294   return 1;
8295 }
8296
8297 static void
8298 process_mips_fpe_exception (mask)
8299      int mask;
8300 {
8301   if (mask)
8302     {
8303       int first = 1;
8304       if (mask & OEX_FPU_INEX)
8305         fputs ("INEX", stdout), first = 0;
8306       if (mask & OEX_FPU_UFLO)
8307         printf ("%sUFLO", first ? "" : "|"), first = 0;
8308       if (mask & OEX_FPU_OFLO)
8309         printf ("%sOFLO", first ? "" : "|"), first = 0;
8310       if (mask & OEX_FPU_DIV0)
8311         printf ("%sDIV0", first ? "" : "|"), first = 0;
8312       if (mask & OEX_FPU_INVAL)
8313         printf ("%sINVAL", first ? "" : "|");
8314     }
8315   else
8316     fputs ("0", stdout);
8317 }
8318
8319 static int
8320 process_mips_specific (file)
8321      FILE * file;
8322 {
8323   Elf_Internal_Dyn * entry;
8324   size_t liblist_offset = 0;
8325   size_t liblistno = 0;
8326   size_t conflictsno = 0;
8327   size_t options_offset = 0;
8328   size_t conflicts_offset = 0;
8329
8330   /* We have a lot of special sections.  Thanks SGI!  */
8331   if (dynamic_segment == NULL)
8332     /* No information available.  */
8333     return 0;
8334
8335   for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
8336     switch (entry->d_tag)
8337       {
8338       case DT_MIPS_LIBLIST:
8339         liblist_offset = entry->d_un.d_val - loadaddr;
8340         break;
8341       case DT_MIPS_LIBLISTNO:
8342         liblistno = entry->d_un.d_val;
8343         break;
8344       case DT_MIPS_OPTIONS:
8345         options_offset = entry->d_un.d_val - loadaddr;
8346         break;
8347       case DT_MIPS_CONFLICT:
8348         conflicts_offset = entry->d_un.d_val - loadaddr;
8349         break;
8350       case DT_MIPS_CONFLICTNO:
8351         conflictsno = entry->d_un.d_val;
8352         break;
8353       default:
8354         break;
8355       }
8356
8357   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
8358     {
8359       Elf32_External_Lib * elib;
8360       size_t cnt;
8361
8362       elib = ((Elf32_External_Lib *)
8363               get_data (NULL, file, liblist_offset,
8364                         liblistno * sizeof (Elf32_External_Lib),
8365                         _("liblist")));
8366       if (elib)
8367         {
8368           printf ("\nSection '.liblist' contains %lu entries:\n",
8369                   (unsigned long) liblistno);
8370           fputs ("     Library              Time Stamp          Checksum   Version Flags\n",
8371                  stdout);
8372
8373           for (cnt = 0; cnt < liblistno; ++cnt)
8374             {
8375               Elf32_Lib liblist;
8376               time_t time;
8377               char timebuf[20];
8378               struct tm * tmp;
8379
8380               liblist.l_name = BYTE_GET (elib[cnt].l_name);
8381               time = BYTE_GET (elib[cnt].l_time_stamp);
8382               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
8383               liblist.l_version = BYTE_GET (elib[cnt].l_version);
8384               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
8385
8386               tmp = gmtime (&time);
8387               sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
8388                        tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8389                        tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8390
8391               printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt,
8392                       dynamic_strings + liblist.l_name, timebuf,
8393                       liblist.l_checksum, liblist.l_version);
8394
8395               if (liblist.l_flags == 0)
8396                 puts (" NONE");
8397               else
8398                 {
8399                   static const struct
8400                   {
8401                     const char * name;
8402                     int bit;
8403                   }
8404                   l_flags_vals[] =
8405                   {
8406                     { " EXACT_MATCH", LL_EXACT_MATCH },
8407                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
8408                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
8409                     { " EXPORTS", LL_EXPORTS },
8410                     { " DELAY_LOAD", LL_DELAY_LOAD },
8411                     { " DELTA", LL_DELTA }
8412                   };
8413                   int flags = liblist.l_flags;
8414                   size_t fcnt;
8415
8416                   for (fcnt = 0;
8417                        fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
8418                        ++fcnt)
8419                     if ((flags & l_flags_vals[fcnt].bit) != 0)
8420                       {
8421                         fputs (l_flags_vals[fcnt].name, stdout);
8422                         flags ^= l_flags_vals[fcnt].bit;
8423                       }
8424                   if (flags != 0)
8425                     printf (" %#x", (unsigned int) flags);
8426
8427                   puts ("");
8428                 }
8429             }
8430
8431           free (elib);
8432         }
8433     }
8434
8435   if (options_offset != 0)
8436     {
8437       Elf_External_Options * eopt;
8438       Elf_Internal_Shdr *    sect = section_headers;
8439       Elf_Internal_Options * iopt;
8440       Elf_Internal_Options * option;
8441       size_t offset;
8442       int cnt;
8443
8444       /* Find the section header so that we get the size.  */
8445       while (sect->sh_type != SHT_MIPS_OPTIONS)
8446         ++ sect;
8447
8448       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset,
8449                                                 sect->sh_size, _("options"));
8450       if (eopt)
8451         {
8452           iopt = ((Elf_Internal_Options *)
8453                   malloc ((sect->sh_size / sizeof (eopt)) * sizeof (* iopt)));
8454           if (iopt == NULL)
8455             {
8456               error (_("Out of memory"));
8457               return 0;
8458             }
8459
8460           offset = cnt = 0;
8461           option = iopt;
8462
8463           while (offset < sect->sh_size)
8464             {
8465               Elf_External_Options * eoption;
8466
8467               eoption = (Elf_External_Options *) ((char *) eopt + offset);
8468
8469               option->kind = BYTE_GET (eoption->kind);
8470               option->size = BYTE_GET (eoption->size);
8471               option->section = BYTE_GET (eoption->section);
8472               option->info = BYTE_GET (eoption->info);
8473
8474               offset += option->size;
8475
8476               ++option;
8477               ++cnt;
8478             }
8479
8480           printf (_("\nSection '%s' contains %d entries:\n"),
8481                   SECTION_NAME (sect), cnt);
8482
8483           option = iopt;
8484
8485           while (cnt-- > 0)
8486             {
8487               size_t len;
8488
8489               switch (option->kind)
8490                 {
8491                 case ODK_NULL:
8492                   /* This shouldn't happen.  */
8493                   printf (" NULL       %d %lx", option->section, option->info);
8494                   break;
8495                 case ODK_REGINFO:
8496                   printf (" REGINFO    ");
8497                   if (elf_header.e_machine == EM_MIPS)
8498                     {
8499                       /* 32bit form.  */
8500                       Elf32_External_RegInfo * ereg;
8501                       Elf32_RegInfo            reginfo;
8502
8503                       ereg = (Elf32_External_RegInfo *) (option + 1);
8504                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
8505                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
8506                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
8507                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
8508                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
8509                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
8510
8511                       printf ("GPR %08lx  GP 0x%lx\n",
8512                               reginfo.ri_gprmask,
8513                               (unsigned long) reginfo.ri_gp_value);
8514                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
8515                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
8516                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
8517                     }
8518                   else
8519                     {
8520                       /* 64 bit form.  */
8521                       Elf64_External_RegInfo * ereg;
8522                       Elf64_Internal_RegInfo reginfo;
8523
8524                       ereg = (Elf64_External_RegInfo *) (option + 1);
8525                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
8526                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
8527                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
8528                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
8529                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
8530                       reginfo.ri_gp_value   = BYTE_GET8 (ereg->ri_gp_value);
8531
8532                       printf ("GPR %08lx  GP 0x",
8533                               reginfo.ri_gprmask);
8534                       printf_vma (reginfo.ri_gp_value);
8535                       printf ("\n");
8536
8537                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
8538                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
8539                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
8540                     }
8541                   ++option;
8542                   continue;
8543                 case ODK_EXCEPTIONS:
8544                   fputs (" EXCEPTIONS fpe_min(", stdout);
8545                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
8546                   fputs (") fpe_max(", stdout);
8547                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
8548                   fputs (")", stdout);
8549
8550                   if (option->info & OEX_PAGE0)
8551                     fputs (" PAGE0", stdout);
8552                   if (option->info & OEX_SMM)
8553                     fputs (" SMM", stdout);
8554                   if (option->info & OEX_FPDBUG)
8555                     fputs (" FPDBUG", stdout);
8556                   if (option->info & OEX_DISMISS)
8557                     fputs (" DISMISS", stdout);
8558                   break;
8559                 case ODK_PAD:
8560                   fputs (" PAD       ", stdout);
8561                   if (option->info & OPAD_PREFIX)
8562                     fputs (" PREFIX", stdout);
8563                   if (option->info & OPAD_POSTFIX)
8564                     fputs (" POSTFIX", stdout);
8565                   if (option->info & OPAD_SYMBOL)
8566                     fputs (" SYMBOL", stdout);
8567                   break;
8568                 case ODK_HWPATCH:
8569                   fputs (" HWPATCH   ", stdout);
8570                   if (option->info & OHW_R4KEOP)
8571                     fputs (" R4KEOP", stdout);
8572                   if (option->info & OHW_R8KPFETCH)
8573                     fputs (" R8KPFETCH", stdout);
8574                   if (option->info & OHW_R5KEOP)
8575                     fputs (" R5KEOP", stdout);
8576                   if (option->info & OHW_R5KCVTL)
8577                     fputs (" R5KCVTL", stdout);
8578                   break;
8579                 case ODK_FILL:
8580                   fputs (" FILL       ", stdout);
8581                   /* XXX Print content of info word?  */
8582                   break;
8583                 case ODK_TAGS:
8584                   fputs (" TAGS       ", stdout);
8585                   /* XXX Print content of info word?  */
8586                   break;
8587                 case ODK_HWAND:
8588                   fputs (" HWAND     ", stdout);
8589                   if (option->info & OHWA0_R4KEOP_CHECKED)
8590                     fputs (" R4KEOP_CHECKED", stdout);
8591                   if (option->info & OHWA0_R4KEOP_CLEAN)
8592                     fputs (" R4KEOP_CLEAN", stdout);
8593                   break;
8594                 case ODK_HWOR:
8595                   fputs (" HWOR      ", stdout);
8596                   if (option->info & OHWA0_R4KEOP_CHECKED)
8597                     fputs (" R4KEOP_CHECKED", stdout);
8598                   if (option->info & OHWA0_R4KEOP_CLEAN)
8599                     fputs (" R4KEOP_CLEAN", stdout);
8600                   break;
8601                 case ODK_GP_GROUP:
8602                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
8603                           option->info & OGP_GROUP,
8604                           (option->info & OGP_SELF) >> 16);
8605                   break;
8606                 case ODK_IDENT:
8607                   printf (" IDENT     %#06lx  self-contained %#06lx",
8608                           option->info & OGP_GROUP,
8609                           (option->info & OGP_SELF) >> 16);
8610                   break;
8611                 default:
8612                   /* This shouldn't happen.  */
8613                   printf (" %3d ???     %d %lx",
8614                           option->kind, option->section, option->info);
8615                   break;
8616                 }
8617
8618               len = sizeof (* eopt);
8619               while (len < option->size)
8620                 if (((char *) option)[len] >= ' '
8621                     && ((char *) option)[len] < 0x7f)
8622                   printf ("%c", ((char *) option)[len++]);
8623                 else
8624                   printf ("\\%03o", ((char *) option)[len++]);
8625
8626               fputs ("\n", stdout);
8627               ++option;
8628             }
8629
8630           free (eopt);
8631         }
8632     }
8633
8634   if (conflicts_offset != 0 && conflictsno != 0)
8635     {
8636       Elf32_Conflict * iconf;
8637       size_t cnt;
8638
8639       if (dynamic_symbols == NULL)
8640         {
8641           error (_("conflict list with without table"));
8642           return 0;
8643         }
8644
8645       iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (* iconf));
8646       if (iconf == NULL)
8647         {
8648           error (_("Out of memory"));
8649           return 0;
8650         }
8651
8652       if (is_32bit_elf)
8653         {
8654           Elf32_External_Conflict * econf32;
8655
8656           econf32 = ((Elf32_External_Conflict *)
8657                      get_data (NULL, file, conflicts_offset,
8658                                conflictsno * sizeof (* econf32),
8659                                _("conflict")));
8660           if (!econf32)
8661             return 0;
8662
8663           for (cnt = 0; cnt < conflictsno; ++cnt)
8664             iconf[cnt] = BYTE_GET (econf32[cnt]);
8665
8666           free (econf32);
8667         }
8668       else
8669         {
8670           Elf64_External_Conflict * econf64;
8671
8672           econf64 = ((Elf64_External_Conflict *)
8673                      get_data (NULL, file, conflicts_offset,
8674                                conflictsno * sizeof (* econf64),
8675                                _("conflict")));
8676           if (!econf64)
8677             return 0;
8678
8679           for (cnt = 0; cnt < conflictsno; ++cnt)
8680             iconf[cnt] = BYTE_GET (econf64[cnt]);
8681
8682           free (econf64);
8683         }
8684
8685       printf (_("\nSection '.conflict' contains %ld entries:\n"),
8686               (long) conflictsno);
8687       puts (_("  Num:    Index       Value  Name"));
8688
8689       for (cnt = 0; cnt < conflictsno; ++cnt)
8690         {
8691           Elf_Internal_Sym * psym = &dynamic_symbols[iconf[cnt]];
8692
8693           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
8694           print_vma (psym->st_value, FULL_HEX);
8695           printf ("  %s\n", dynamic_strings + psym->st_name);
8696         }
8697
8698       free (iconf);
8699     }
8700
8701   return 1;
8702 }
8703
8704 static char *
8705 get_note_type (e_type)
8706      unsigned e_type;
8707 {
8708   static char buff[64];
8709
8710   switch (e_type)
8711     {
8712     case NT_PRSTATUS:   return _("NT_PRSTATUS (prstatus structure)");
8713     case NT_FPREGSET:   return _("NT_FPREGSET (floating point registers)");
8714     case NT_PRPSINFO:   return _("NT_PRPSINFO (prpsinfo structure)");
8715     case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
8716     case NT_PRXFPREG:   return _("NT_PRXFPREG (user_xfpregs structure)");
8717     case NT_PSTATUS:    return _("NT_PSTATUS (pstatus structure)");
8718     case NT_FPREGS:     return _("NT_FPREGS (floating point registers)");
8719     case NT_PSINFO:     return _("NT_PSINFO (psinfo structure)");
8720     case NT_LWPSTATUS:  return _("NT_LWPSTATUS (lwpstatus_t structure)");
8721     case NT_LWPSINFO:   return _("NT_LWPSINFO (lwpsinfo_t structure)");
8722     case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
8723     default:
8724       sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
8725       return buff;
8726     }
8727 }
8728
8729 /* Note that by the ELF standard, the name field is already null byte
8730    terminated, and namesz includes the terminating null byte.
8731    I.E. the value of namesz for the name "FSF" is 4.
8732
8733    If the value of namesz is zero, there is no name present. */
8734 static int
8735 process_note (pnote)
8736   Elf32_Internal_Note * pnote;
8737 {
8738   printf ("  %s\t\t0x%08lx\t%s\n",
8739           pnote->namesz ? pnote->namedata : "(NONE)",
8740           pnote->descsz, get_note_type (pnote->type));
8741   return 1;
8742 }
8743
8744
8745 static int
8746 process_corefile_note_segment (file, offset, length)
8747      FILE * file;
8748      bfd_vma offset;
8749      bfd_vma length;
8750 {
8751   Elf_External_Note *  pnotes;
8752   Elf_External_Note *  external;
8753   int                  res = 1;
8754
8755   if (length <= 0)
8756     return 0;
8757
8758   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, length,
8759                                            _("notes"));
8760   if (!pnotes)
8761     return 0;
8762
8763   external = pnotes;
8764
8765   printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
8766           (unsigned long) offset, (unsigned long) length);
8767   printf (_("  Owner\t\tData size\tDescription\n"));
8768
8769   while (external < (Elf_External_Note *)((char *) pnotes + length))
8770     {
8771       Elf32_Internal_Note inote;
8772       char * temp = NULL;
8773
8774       inote.type     = BYTE_GET (external->type);
8775       inote.namesz   = BYTE_GET (external->namesz);
8776       inote.namedata = external->name;
8777       inote.descsz   = BYTE_GET (external->descsz);
8778       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
8779       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
8780
8781       external = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
8782
8783       /* Verify that name is null terminated.  It appears that at least
8784          one version of Linux (RedHat 6.0) generates corefiles that don't
8785          comply with the ELF spec by failing to include the null byte in
8786          namesz.  */
8787       if (inote.namedata[inote.namesz] != '\0')
8788         {
8789           temp = malloc (inote.namesz + 1);
8790
8791           if (temp == NULL)
8792             {
8793               error (_("Out of memory\n"));
8794               res = 0;
8795               break;
8796             }
8797
8798           strncpy (temp, inote.namedata, inote.namesz);
8799           temp[inote.namesz] = 0;
8800
8801           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
8802           inote.namedata = temp;
8803         }
8804
8805       res &= process_note (& inote);
8806
8807       if (temp != NULL)
8808         {
8809           free (temp);
8810           temp = NULL;
8811         }
8812     }
8813
8814   free (pnotes);
8815
8816   return res;
8817 }
8818
8819 static int
8820 process_corefile_note_segments (file)
8821      FILE * file;
8822 {
8823   Elf_Internal_Phdr * program_headers;
8824   Elf_Internal_Phdr * segment;
8825   unsigned int        i;
8826   int                 res = 1;
8827
8828   program_headers = (Elf_Internal_Phdr *) malloc
8829     (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
8830
8831   if (program_headers == NULL)
8832     {
8833       error (_("Out of memory\n"));
8834       return 0;
8835     }
8836
8837   if (is_32bit_elf)
8838     i = get_32bit_program_headers (file, program_headers);
8839   else
8840     i = get_64bit_program_headers (file, program_headers);
8841
8842   if (i == 0)
8843     {
8844       free (program_headers);
8845       return 0;
8846     }
8847
8848   for (i = 0, segment = program_headers;
8849        i < elf_header.e_phnum;
8850        i ++, segment ++)
8851     {
8852       if (segment->p_type == PT_NOTE)
8853         res &= process_corefile_note_segment (file,
8854                                               (bfd_vma) segment->p_offset,
8855                                               (bfd_vma) segment->p_filesz);
8856     }
8857
8858   free (program_headers);
8859
8860   return res;
8861 }
8862
8863 static int
8864 process_corefile_contents (file)
8865      FILE * file;
8866 {
8867   /* If we have not been asked to display the notes then do nothing.  */
8868   if (! do_notes)
8869     return 1;
8870
8871   /* If file is not a core file then exit.  */
8872   if (elf_header.e_type != ET_CORE)
8873     return 1;
8874
8875   /* No program headers means no NOTE segment.  */
8876   if (elf_header.e_phnum == 0)
8877     {
8878       printf (_("No note segments present in the core file.\n"));
8879       return 1;
8880    }
8881
8882   return process_corefile_note_segments (file);
8883 }
8884
8885 static int
8886 process_arch_specific (file)
8887      FILE * file;
8888 {
8889   if (! do_arch)
8890     return 1;
8891
8892   switch (elf_header.e_machine)
8893     {
8894     case EM_MIPS:
8895     case EM_MIPS_RS3_LE:
8896       return process_mips_specific (file);
8897       break;
8898     default:
8899       break;
8900     }
8901   return 1;
8902 }
8903
8904 static int
8905 get_file_header (file)
8906      FILE * file;
8907 {
8908   /* Read in the identity array.  */
8909   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
8910     return 0;
8911
8912   /* Determine how to read the rest of the header.  */
8913   switch (elf_header.e_ident [EI_DATA])
8914     {
8915     default: /* fall through */
8916     case ELFDATANONE: /* fall through */
8917     case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
8918     case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
8919     }
8920
8921   /* For now we only support 32 bit and 64 bit ELF files.  */
8922   is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
8923
8924   /* Read in the rest of the header.  */
8925   if (is_32bit_elf)
8926     {
8927       Elf32_External_Ehdr ehdr32;
8928
8929       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
8930         return 0;
8931
8932       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
8933       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
8934       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
8935       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
8936       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
8937       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
8938       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
8939       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
8940       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
8941       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
8942       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
8943       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
8944       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
8945     }
8946   else
8947     {
8948       Elf64_External_Ehdr ehdr64;
8949
8950       /* If we have been compiled with sizeof (bfd_vma) == 4, then
8951          we will not be able to cope with the 64bit data found in
8952          64 ELF files.  Detect this now and abort before we start
8953          overwritting things.  */
8954       if (sizeof (bfd_vma) < 8)
8955         {
8956           error (_("This instance of readelf has been built without support for a\n"));
8957           error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
8958           return 0;
8959         }
8960
8961       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
8962         return 0;
8963
8964       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
8965       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
8966       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
8967       elf_header.e_entry     = BYTE_GET8 (ehdr64.e_entry);
8968       elf_header.e_phoff     = BYTE_GET8 (ehdr64.e_phoff);
8969       elf_header.e_shoff     = BYTE_GET8 (ehdr64.e_shoff);
8970       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
8971       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
8972       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
8973       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
8974       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
8975       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
8976       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
8977     }
8978
8979   return 1;
8980 }
8981
8982 static int
8983 process_file (file_name)
8984      char * file_name;
8985 {
8986   FILE *       file;
8987   struct stat  statbuf;
8988   unsigned int i;
8989
8990   if (stat (file_name, & statbuf) < 0)
8991     {
8992       error (_("Cannot stat input file %s.\n"), file_name);
8993       return 1;
8994     }
8995
8996   file = fopen (file_name, "rb");
8997   if (file == NULL)
8998     {
8999       error (_("Input file %s not found.\n"), file_name);
9000       return 1;
9001     }
9002
9003   if (! get_file_header (file))
9004     {
9005       error (_("%s: Failed to read file header\n"), file_name);
9006       fclose (file);
9007       return 1;
9008     }
9009
9010   /* Initialise per file variables.  */
9011   for (i = NUM_ELEM (version_info); i--;)
9012     version_info[i] = 0;
9013
9014   for (i = NUM_ELEM (dynamic_info); i--;)
9015     dynamic_info[i] = 0;
9016
9017   /* Process the file.  */
9018   if (show_name)
9019     printf (_("\nFile: %s\n"), file_name);
9020
9021   if (! process_file_header ())
9022     {
9023       fclose (file);
9024       return 1;
9025     }
9026
9027   process_section_headers (file);
9028
9029   process_program_headers (file);
9030
9031   process_dynamic_segment (file);
9032
9033   process_relocs (file);
9034
9035   process_unwind (file);
9036
9037   process_symbol_table (file);
9038
9039   process_syminfo (file);
9040
9041   process_version_sections (file);
9042
9043   process_section_contents (file);
9044
9045   process_corefile_contents (file);
9046
9047   process_arch_specific (file);
9048
9049   fclose (file);
9050
9051   if (section_headers)
9052     {
9053       free (section_headers);
9054       section_headers = NULL;
9055     }
9056
9057   if (string_table)
9058     {
9059       free (string_table);
9060       string_table = NULL;
9061       string_table_length = 0;
9062     }
9063
9064   if (dynamic_strings)
9065     {
9066       free (dynamic_strings);
9067       dynamic_strings = NULL;
9068     }
9069
9070   if (dynamic_symbols)
9071     {
9072       free (dynamic_symbols);
9073       dynamic_symbols = NULL;
9074       num_dynamic_syms = 0;
9075     }
9076
9077   if (dynamic_syminfo)
9078     {
9079       free (dynamic_syminfo);
9080       dynamic_syminfo = NULL;
9081     }
9082
9083   return 0;
9084 }
9085
9086 #ifdef SUPPORT_DISASSEMBLY
9087 /* Needed by the i386 disassembler.  For extra credit, someone could
9088    fix this so that we insert symbolic addresses here, esp for GOT/PLT
9089    symbols */
9090
9091 void
9092 print_address (unsigned int addr, FILE * outfile)
9093 {
9094   fprintf (outfile,"0x%8.8x", addr);
9095 }
9096
9097 /* Needed by the i386 disassembler. */
9098 void
9099 db_task_printsym (unsigned int addr)
9100 {
9101   print_address (addr, stderr);
9102 }
9103 #endif
9104
9105 int main PARAMS ((int, char **));
9106
9107 int
9108 main (argc, argv)
9109      int     argc;
9110      char ** argv;
9111 {
9112   int err;
9113
9114 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
9115   setlocale (LC_MESSAGES, "");
9116 #endif
9117 #if defined (HAVE_SETLOCALE)
9118   setlocale (LC_CTYPE, "");
9119 #endif
9120   bindtextdomain (PACKAGE, LOCALEDIR);
9121   textdomain (PACKAGE);
9122
9123   parse_args (argc, argv);
9124
9125   if (optind < (argc - 1))
9126     show_name = 1;
9127
9128   err = 0;
9129   while (optind < argc)
9130     err |= process_file (argv [optind ++]);
9131
9132   if (dump_sects != NULL)
9133     free (dump_sects);
9134
9135   return err;
9136 }