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