binutils/readelf.c

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