binutils/readelf.c

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