binutils/readelf.c

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