binutils/readelf.c

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