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