binutils/readelf.c

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