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
1465           switch ((e_flags & EF_MIPS_MACH))
1466             {
1467             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
1468             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
1469             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
1470             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
1471             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
1472             case E_MIPS_MACH_MIPS32: strcat (buf, ", mips32"); break;
1473             }
1474           break;
1475
1476         case EM_SPARCV9:
1477           if (e_flags & EF_SPARC_32PLUS)
1478             strcat (buf, ", v8+");
1479
1480           if (e_flags & EF_SPARC_SUN_US1)
1481             strcat (buf, ", ultrasparcI");
1482
1483           if (e_flags & EF_SPARC_SUN_US3)
1484             strcat (buf, ", ultrasparcIII");
1485
1486           if (e_flags & EF_SPARC_HAL_R1)
1487             strcat (buf, ", halr1");
1488
1489           if (e_flags & EF_SPARC_LEDATA)
1490             strcat (buf, ", ledata");
1491
1492           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
1493             strcat (buf, ", tso");
1494
1495           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
1496             strcat (buf, ", pso");
1497
1498           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
1499             strcat (buf, ", rmo");
1500           break;
1501
1502         case EM_PARISC:
1503           switch (e_flags & EF_PARISC_ARCH)
1504             {
1505             case EFA_PARISC_1_0:
1506               strcpy (buf, ", PA-RISC 1.0");
1507               break;
1508             case EFA_PARISC_1_1:
1509               strcpy (buf, ", PA-RISC 1.1");
1510               break;
1511             case EFA_PARISC_2_0:
1512               strcpy (buf, ", PA-RISC 2.0");
1513               break;
1514             default:
1515               break;
1516             }
1517           if (e_flags & EF_PARISC_TRAPNIL)
1518             strcat (buf, ", trapnil");
1519           if (e_flags & EF_PARISC_EXT)
1520             strcat (buf, ", ext");
1521           if (e_flags & EF_PARISC_LSB)
1522             strcat (buf, ", lsb");
1523           if (e_flags & EF_PARISC_WIDE)
1524             strcat (buf, ", wide");
1525           if (e_flags & EF_PARISC_NO_KABP)
1526             strcat (buf, ", no kabp");
1527           if (e_flags & EF_PARISC_LAZYSWAP)
1528             strcat (buf, ", lazyswap");
1529           break;
1530
1531         case EM_PJ:
1532           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
1533             strcat (buf, ", new calling convention");
1534
1535           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
1536             strcat (buf, ", gnu calling convention");
1537           break;
1538         }
1539     }
1540
1541   return buf;
1542 }
1543
1544 static const char *
1545 get_mips_segment_type (type)
1546      unsigned long type;
1547 {
1548   switch (type)
1549     {
1550     case PT_MIPS_REGINFO:
1551       return "REGINFO";
1552     case PT_MIPS_RTPROC:
1553       return "RTPROC";
1554     case PT_MIPS_OPTIONS:
1555       return "OPTIONS";
1556     default:
1557       break;
1558     }
1559
1560   return NULL;
1561 }
1562
1563 static const char *
1564 get_parisc_segment_type (type)
1565      unsigned long type;
1566 {
1567   switch (type)
1568     {
1569     case PT_HP_TLS:             return "HP_TLS";
1570     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
1571     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
1572     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
1573     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
1574     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
1575     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
1576     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
1577     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
1578     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
1579     case PT_HP_PARALLEL:        return "HP_PARALLEL";
1580     case PT_HP_FASTBIND:        return "HP_FASTBIND";
1581     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
1582     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
1583     default:
1584       break;
1585     }
1586
1587   return NULL;
1588 }
1589
1590 static const char *
1591 get_segment_type (p_type)
1592      unsigned long p_type;
1593 {
1594   static char buff [32];
1595
1596   switch (p_type)
1597     {
1598     case PT_NULL:       return "NULL";
1599     case PT_LOAD:       return "LOAD";
1600     case PT_DYNAMIC:    return "DYNAMIC";
1601     case PT_INTERP:     return "INTERP";
1602     case PT_NOTE:       return "NOTE";
1603     case PT_SHLIB:      return "SHLIB";
1604     case PT_PHDR:       return "PHDR";
1605
1606     default:
1607       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
1608         {
1609           const char * result;
1610
1611           switch (elf_header.e_machine)
1612             {
1613             case EM_MIPS:
1614             case EM_MIPS_RS4_BE:
1615               result = get_mips_segment_type (p_type);
1616               break;
1617             case EM_PARISC:
1618               result = get_parisc_segment_type (p_type);
1619               break;
1620             default:
1621               result = NULL;
1622               break;
1623             }
1624
1625           if (result != NULL)
1626             return result;
1627
1628           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
1629         }
1630       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
1631         {
1632           const char * result;
1633
1634           switch (elf_header.e_machine)
1635             {
1636             case EM_PARISC:
1637               result = get_parisc_segment_type (p_type);
1638               break;
1639             default:
1640               result = NULL;
1641               break;
1642             }
1643
1644           if (result != NULL)
1645             return result;
1646
1647           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
1648         }
1649       else
1650         sprintf (buff, _("<unknown>: %lx"), p_type);
1651
1652       return buff;
1653     }
1654 }
1655
1656 static const char *
1657 get_mips_section_type_name (sh_type)
1658      unsigned int sh_type;
1659 {
1660   switch (sh_type)
1661     {
1662     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
1663     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
1664     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
1665     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
1666     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
1667     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
1668     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
1669     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
1670     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
1671     case SHT_MIPS_RELD:          return "MIPS_RELD";
1672     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
1673     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
1674     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
1675     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
1676     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
1677     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
1678     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
1679     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
1680     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
1681     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
1682     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
1683     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
1684     case SHT_MIPS_LINE:          return "MIPS_LINE";
1685     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
1686     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
1687     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
1688     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
1689     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
1690     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
1691     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
1692     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
1693     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
1694     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
1695     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
1696     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
1697     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
1698     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
1699     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
1700     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
1701     default:
1702       break;
1703     }
1704   return NULL;
1705 }
1706
1707 static const char *
1708 get_parisc_section_type_name (sh_type)
1709      unsigned int sh_type;
1710 {
1711   switch (sh_type)
1712     {
1713     case SHT_PARISC_EXT:        return "PARISC_EXT";
1714     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
1715     case SHT_PARISC_DOC:        return "PARISC_DOC";
1716     default:
1717       break;
1718     }
1719   return NULL;
1720 }
1721
1722 static const char *
1723 get_section_type_name (sh_type)
1724      unsigned int sh_type;
1725 {
1726   static char buff [32];
1727
1728   switch (sh_type)
1729     {
1730     case SHT_NULL:              return "NULL";
1731     case SHT_PROGBITS:          return "PROGBITS";
1732     case SHT_SYMTAB:            return "SYMTAB";
1733     case SHT_STRTAB:            return "STRTAB";
1734     case SHT_RELA:              return "RELA";
1735     case SHT_HASH:              return "HASH";
1736     case SHT_DYNAMIC:           return "DYNAMIC";
1737     case SHT_NOTE:              return "NOTE";
1738     case SHT_NOBITS:            return "NOBITS";
1739     case SHT_REL:               return "REL";
1740     case SHT_SHLIB:             return "SHLIB";
1741     case SHT_DYNSYM:            return "DYNSYM";
1742     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
1743     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
1744     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
1745     case SHT_GNU_verdef:        return "VERDEF";
1746     case SHT_GNU_verneed:       return "VERNEED";
1747     case SHT_GNU_versym:        return "VERSYM";
1748     case 0x6ffffff0:            return "VERSYM";
1749     case 0x6ffffffc:            return "VERDEF";
1750     case 0x7ffffffd:            return "AUXILIARY";
1751     case 0x7fffffff:            return "FILTER";
1752
1753     default:
1754       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
1755         {
1756           const char * result;
1757
1758           switch (elf_header.e_machine)
1759             {
1760             case EM_MIPS:
1761             case EM_MIPS_RS4_BE:
1762               result = get_mips_section_type_name (sh_type);
1763               break;
1764             case EM_PARISC:
1765               result = get_parisc_section_type_name (sh_type);
1766               break;
1767             default:
1768               result = NULL;
1769               break;
1770             }
1771
1772           if (result != NULL)
1773             return result;
1774
1775           sprintf (buff, "SHT_LOPROC+%x", sh_type - SHT_LOPROC);
1776         }
1777       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
1778         sprintf (buff, "SHT_LOOS+%x", sh_type - SHT_LOOS);
1779       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
1780         sprintf (buff, "SHT_LOUSER+%x", sh_type - SHT_LOUSER);
1781       else
1782         sprintf (buff, _("<unknown>: %x"), sh_type);
1783
1784       return buff;
1785     }
1786 }
1787
1788 struct option options [] =
1789 {
1790   {"all",              no_argument, 0, 'a'},
1791   {"file-header",      no_argument, 0, 'h'},
1792   {"program-headers",  no_argument, 0, 'l'},
1793   {"headers",          no_argument, 0, 'e'},
1794   {"histogram",        no_argument, 0, 'I'},
1795   {"segments",         no_argument, 0, 'l'},
1796   {"sections",         no_argument, 0, 'S'},
1797   {"section-headers",  no_argument, 0, 'S'},
1798   {"symbols",          no_argument, 0, 's'},
1799   {"syms",             no_argument, 0, 's'},
1800   {"relocs",           no_argument, 0, 'r'},
1801   {"notes",            no_argument, 0, 'n'},
1802   {"dynamic",          no_argument, 0, 'd'},
1803   {"arch-specific",    no_argument, 0, 'A'},
1804   {"version-info",     no_argument, 0, 'V'},
1805   {"use-dynamic",      no_argument, 0, 'D'},
1806   {"hex-dump",         required_argument, 0, 'x'},
1807   {"debug-dump",       optional_argument, 0, 'w'},
1808 #ifdef SUPPORT_DISASSEMBLY
1809   {"instruction-dump", required_argument, 0, 'i'},
1810 #endif
1811
1812   {"version",          no_argument, 0, 'v'},
1813   {"help",             no_argument, 0, 'H'},
1814   {0,                  no_argument, 0, 0}
1815 };
1816
1817 static void
1818 usage ()
1819 {
1820   fprintf (stdout, _("Usage: readelf {options} elf-file(s)\n"));
1821   fprintf (stdout, _("  Options are:\n"));
1822   fprintf (stdout, _("  -a or --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
1823   fprintf (stdout, _("  -h or --file-header       Display the ELF file header\n"));
1824   fprintf (stdout, _("  -l or --program-headers or --segments\n"));
1825   fprintf (stdout, _("                            Display the program headers\n"));
1826   fprintf (stdout, _("  -S or --section-headers or --sections\n"));
1827   fprintf (stdout, _("                            Display the sections' header\n"));
1828   fprintf (stdout, _("  -e or --headers           Equivalent to: -h -l -S\n"));
1829   fprintf (stdout, _("  -s or --syms or --symbols Display the symbol table\n"));
1830   fprintf (stdout, _("  -n or --notes             Display the core notes (if present)\n"));
1831   fprintf (stdout, _("  -r or --relocs            Display the relocations (if present)\n"));
1832   fprintf (stdout, _("  -d or --dynamic           Display the dynamic segment (if present)\n"));
1833   fprintf (stdout, _("  -V or --version-info      Display the version sections (if present)\n"));
1834   fprintf (stdout, _("  -A or --arch-specific     Display architecture specific information (if any).\n"));
1835   fprintf (stdout, _("  -D or --use-dynamic       Use the dynamic section info when displaying symbols\n"));
1836   fprintf (stdout, _("  -x <number> or --hex-dump=<number>\n"));
1837   fprintf (stdout, _("                            Dump the contents of section <number>\n"));
1838   fprintf (stdout, _("  -w[liapr] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges]\n"));
1839   fprintf (stdout, _("                            Display the contents of DWARF2 debug sections\n"));
1840 #ifdef SUPPORT_DISASSEMBLY
1841   fprintf (stdout, _("  -i <number> or --instruction-dump=<number>\n"));
1842   fprintf (stdout, _("                            Disassemble the contents of section <number>\n"));
1843 #endif
1844   fprintf (stdout, _("  -I or --histogram         Display histogram of bucket list lengths\n"));
1845   fprintf (stdout, _("  -v or --version           Display the version number of readelf\n"));
1846   fprintf (stdout, _("  -H or --help              Display this information\n"));
1847   fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
1848
1849   exit (0);
1850 }
1851
1852 static void
1853 request_dump (section, type)
1854      unsigned int section;
1855      char         type;
1856 {
1857   if (section >= num_dump_sects)
1858     {
1859       char * new_dump_sects;
1860
1861       new_dump_sects = (char *) calloc (section + 1, 1);
1862
1863       if (new_dump_sects == NULL)
1864         error (_("Out of memory allocating dump request table."));
1865       else
1866         {
1867           /* Copy current flag settings.  */
1868           memcpy (new_dump_sects, dump_sects, num_dump_sects);
1869
1870           free (dump_sects);
1871
1872           dump_sects = new_dump_sects;
1873           num_dump_sects = section + 1;
1874         }
1875     }
1876
1877   if (dump_sects)
1878     dump_sects [section] |= type;
1879
1880   return;
1881 }
1882
1883 static void
1884 parse_args (argc, argv)
1885      int argc;
1886      char ** argv;
1887 {
1888   int c;
1889
1890   if (argc < 2)
1891     usage ();
1892
1893   while ((c = getopt_long
1894           (argc, argv, "ersahnldSDAIw::x:i:vV", options, NULL)) != EOF)
1895     {
1896       char *    cp;
1897       int       section;
1898
1899       switch (c)
1900         {
1901         case 0:
1902           /* Long options.  */
1903           break;
1904         case 'H':
1905           usage ();
1906           break;
1907
1908         case 'a':
1909           do_syms ++;
1910           do_reloc ++;
1911           do_dynamic ++;
1912           do_header ++;
1913           do_sections ++;
1914           do_segments ++;
1915           do_version ++;
1916           do_histogram ++;
1917           do_arch ++;
1918           do_notes ++;
1919           break;
1920         case 'e':
1921           do_header ++;
1922           do_sections ++;
1923           do_segments ++;
1924           break;
1925         case 'A':
1926           do_arch ++;
1927           break;
1928         case 'D':
1929           do_using_dynamic ++;
1930           break;
1931         case 'r':
1932           do_reloc ++;
1933           break;
1934         case 'h':
1935           do_header ++;
1936           break;
1937         case 'l':
1938           do_segments ++;
1939           break;
1940         case 's':
1941           do_syms ++;
1942           break;
1943         case 'S':
1944           do_sections ++;
1945           break;
1946         case 'd':
1947           do_dynamic ++;
1948           break;
1949         case 'I':
1950           do_histogram ++;
1951           break;
1952         case 'n':
1953           do_notes ++;
1954           break;
1955         case 'x':
1956           do_dump ++;
1957           section = strtoul (optarg, & cp, 0);
1958           if (! * cp && section >= 0)
1959             {
1960               request_dump (section, HEX_DUMP);
1961               break;
1962             }
1963           goto oops;
1964         case 'w':
1965           do_dump ++;
1966           if (optarg == 0)
1967             do_debugging = 1;
1968           else
1969             {
1970               do_debugging = 0;
1971               switch (optarg[0])
1972                 {
1973                 case 'i':
1974                 case 'I':
1975                   do_debug_info = 1;
1976                   break;
1977
1978                 case 'a':
1979                 case 'A':
1980                   do_debug_abbrevs = 1;
1981                   break;
1982
1983                 case 'l':
1984                 case 'L':
1985                   do_debug_lines = 1;
1986                   break;
1987
1988                 case 'p':
1989                 case 'P':
1990                   do_debug_pubnames = 1;
1991                   break;
1992
1993                 case 'r':
1994                 case 'R':
1995                   do_debug_aranges = 1;
1996                   break;
1997
1998                 default:
1999                   warn (_("Unrecognised debug option '%s'\n"), optarg);
2000                   break;
2001                 }
2002             }
2003           break;
2004 #ifdef SUPPORT_DISASSEMBLY
2005         case 'i':
2006           do_dump ++;
2007           section = strtoul (optarg, & cp, 0);
2008           if (! * cp && section >= 0)
2009             {
2010               request_dump (section, DISASS_DUMP);
2011               break;
2012             }
2013           goto oops;
2014 #endif
2015         case 'v':
2016           print_version (program_name);
2017           break;
2018         case 'V':
2019           do_version ++;
2020           break;
2021         default:
2022         oops:
2023           /* xgettext:c-format */
2024           error (_("Invalid option '-%c'\n"), c);
2025           /* Drop through.  */
2026         case '?':
2027           usage ();
2028         }
2029     }
2030
2031   if (!do_dynamic && !do_syms && !do_reloc && !do_sections
2032       && !do_segments && !do_header && !do_dump && !do_version
2033       && !do_histogram && !do_debugging && !do_arch && !do_notes)
2034     usage ();
2035   else if (argc < 3)
2036     {
2037       warn (_("Nothing to do.\n"));
2038       usage();
2039     }
2040 }
2041
2042 static const char *
2043 get_elf_class (elf_class)
2044      unsigned char elf_class;
2045 {
2046   static char buff [32];
2047
2048   switch (elf_class)
2049     {
2050     case ELFCLASSNONE: return _("none");
2051     case ELFCLASS32:   return _("ELF32");
2052     case ELFCLASS64:   return _("ELF64");
2053     default:
2054       sprintf (buff, _("<unknown: %x>"), elf_class);
2055       return buff;
2056     }
2057 }
2058
2059 static const char *
2060 get_data_encoding (encoding)
2061      unsigned char encoding;
2062 {
2063   static char buff [32];
2064
2065   switch (encoding)
2066     {
2067     case ELFDATANONE: return _("none");
2068     case ELFDATA2LSB: return _("2's complement, little endian");
2069     case ELFDATA2MSB: return _("2's complement, big endian");
2070     default:
2071       sprintf (buff, _("<unknown: %x>"), encoding);
2072       return buff;
2073     }
2074 }
2075
2076 static const char *
2077 get_osabi_name (osabi)
2078      unsigned char osabi;
2079 {
2080   static char buff [32];
2081
2082   switch (osabi)
2083     {
2084     case ELFOSABI_NONE:       return _("UNIX - System V");
2085     case ELFOSABI_HPUX:       return _("UNIX - HP-UX");
2086     case ELFOSABI_NETBSD:     return _("UNIX - NetBSD");
2087     case ELFOSABI_LINUX:      return _("UNIX - Linux");
2088     case ELFOSABI_HURD:       return _("GNU/Hurd");
2089     case ELFOSABI_SOLARIS:    return _("UNIX - Solaris");
2090     case ELFOSABI_MONTEREY:   return _("UNIX - Monterey");
2091     case ELFOSABI_IRIX:       return _("UNIX - IRIX");
2092     case ELFOSABI_FREEBSD:    return _("UNIX - FreeBSD");
2093     case ELFOSABI_TRU64:      return _("UNIX - TRU64");
2094     case ELFOSABI_MODESTO:    return _("Novell - Modesto");
2095     case ELFOSABI_OPENBSD:    return _("UNIX - OpenBSD");
2096     case ELFOSABI_STANDALONE: return _("Standalone App");
2097     case ELFOSABI_ARM:        return _("ARM");
2098     default:
2099       sprintf (buff, _("<unknown: %x>"), osabi);
2100       return buff;
2101     }
2102 }
2103
2104 /* Decode the data held in 'elf_header'.  */
2105 static int
2106 process_file_header ()
2107 {
2108   if (   elf_header.e_ident [EI_MAG0] != ELFMAG0
2109       || elf_header.e_ident [EI_MAG1] != ELFMAG1
2110       || elf_header.e_ident [EI_MAG2] != ELFMAG2
2111       || elf_header.e_ident [EI_MAG3] != ELFMAG3)
2112     {
2113       error
2114         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2115       return 0;
2116     }
2117
2118   if (do_header)
2119     {
2120       int i;
2121
2122       printf (_("ELF Header:\n"));
2123       printf (_("  Magic:   "));
2124       for (i = 0; i < EI_NIDENT; i ++)
2125         printf ("%2.2x ", elf_header.e_ident [i]);
2126       printf ("\n");
2127       printf (_("  Class:                             %s\n"),
2128               get_elf_class (elf_header.e_ident [EI_CLASS]));
2129       printf (_("  Data:                              %s\n"),
2130               get_data_encoding (elf_header.e_ident [EI_DATA]));
2131       printf (_("  Version:                           %d %s\n"),
2132               elf_header.e_ident [EI_VERSION],
2133               (elf_header.e_ident [EI_VERSION] == EV_CURRENT
2134                ? "(current)"
2135                : (elf_header.e_ident [EI_VERSION] != EV_NONE
2136                   ? "<unknown: %lx>"
2137                   : "")));
2138       printf (_("  OS/ABI:                            %s\n"),
2139               get_osabi_name (elf_header.e_ident [EI_OSABI]));
2140       printf (_("  ABI Version:                       %d\n"),
2141               elf_header.e_ident [EI_ABIVERSION]);
2142       printf (_("  Type:                              %s\n"),
2143               get_file_type (elf_header.e_type));
2144       printf (_("  Machine:                           %s\n"),
2145               get_machine_name (elf_header.e_machine));
2146       printf (_("  Version:                           0x%lx\n"),
2147               (unsigned long) elf_header.e_version);
2148
2149       printf (_("  Entry point address:               "));
2150       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2151       printf (_("\n  Start of program headers:          "));
2152       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2153       printf (_(" (bytes into file)\n  Start of section headers:          "));
2154       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
2155       printf (_(" (bytes into file)\n"));
2156
2157       printf (_("  Flags:                             0x%lx%s\n"),
2158               (unsigned long) elf_header.e_flags,
2159               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2160       printf (_("  Size of this header:               %ld (bytes)\n"),
2161               (long) elf_header.e_ehsize);
2162       printf (_("  Size of program headers:           %ld (bytes)\n"),
2163               (long) elf_header.e_phentsize);
2164       printf (_("  Number of program headers:         %ld\n"),
2165               (long) elf_header.e_phnum);
2166       printf (_("  Size of section headers:           %ld (bytes)\n"),
2167               (long) elf_header.e_shentsize);
2168       printf (_("  Number of section headers:         %ld\n"),
2169               (long) elf_header.e_shnum);
2170       printf (_("  Section header string table index: %ld\n"),
2171               (long) elf_header.e_shstrndx);
2172     }
2173
2174   return 1;
2175 }
2176
2177
2178 static int
2179 get_32bit_program_headers (file, program_headers)
2180      FILE * file;
2181      Elf_Internal_Phdr * program_headers;
2182 {
2183   Elf32_External_Phdr * phdrs;
2184   Elf32_External_Phdr * external;
2185   Elf32_Internal_Phdr * internal;
2186   unsigned int          i;
2187
2188   GET_DATA_ALLOC (elf_header.e_phoff,
2189                   elf_header.e_phentsize * elf_header.e_phnum,
2190                   phdrs, Elf32_External_Phdr *, "program headers");
2191
2192   for (i = 0, internal = program_headers, external = phdrs;
2193        i < elf_header.e_phnum;
2194        i ++, internal ++, external ++)
2195     {
2196       internal->p_type   = BYTE_GET (external->p_type);
2197       internal->p_offset = BYTE_GET (external->p_offset);
2198       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
2199       internal->p_paddr  = BYTE_GET (external->p_paddr);
2200       internal->p_filesz = BYTE_GET (external->p_filesz);
2201       internal->p_memsz  = BYTE_GET (external->p_memsz);
2202       internal->p_flags  = BYTE_GET (external->p_flags);
2203       internal->p_align  = BYTE_GET (external->p_align);
2204     }
2205
2206   free (phdrs);
2207
2208   return 1;
2209 }
2210
2211 static int
2212 get_64bit_program_headers (file, program_headers)
2213      FILE * file;
2214      Elf_Internal_Phdr * program_headers;
2215 {
2216   Elf64_External_Phdr * phdrs;
2217   Elf64_External_Phdr * external;
2218   Elf64_Internal_Phdr * internal;
2219   unsigned int          i;
2220
2221   GET_DATA_ALLOC (elf_header.e_phoff,
2222                   elf_header.e_phentsize * elf_header.e_phnum,
2223                   phdrs, Elf64_External_Phdr *, "program headers");
2224
2225   for (i = 0, internal = program_headers, external = phdrs;
2226        i < elf_header.e_phnum;
2227        i ++, internal ++, external ++)
2228     {
2229       internal->p_type   = BYTE_GET (external->p_type);
2230       internal->p_flags  = BYTE_GET (external->p_flags);
2231       internal->p_offset = BYTE_GET8 (external->p_offset);
2232       internal->p_vaddr  = BYTE_GET8 (external->p_vaddr);
2233       internal->p_paddr  = BYTE_GET8 (external->p_paddr);
2234       internal->p_filesz = BYTE_GET8 (external->p_filesz);
2235       internal->p_memsz  = BYTE_GET8 (external->p_memsz);
2236       internal->p_align  = BYTE_GET8 (external->p_align);
2237     }
2238
2239   free (phdrs);
2240
2241   return 1;
2242 }
2243
2244 static int
2245 process_program_headers (file)
2246      FILE * file;
2247 {
2248   Elf_Internal_Phdr * program_headers;
2249   Elf_Internal_Phdr * segment;
2250   unsigned int        i;
2251
2252   if (elf_header.e_phnum == 0)
2253     {
2254       if (do_segments)
2255         printf (_("\nThere are no program headers in this file.\n"));
2256       return 1;
2257     }
2258
2259   if (do_segments && !do_header)
2260     {
2261       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
2262       printf (_("Entry point "));
2263       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2264       printf (_("\nThere are %d program headers, starting at offset "),
2265               elf_header.e_phnum);
2266       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2267       printf ("\n");
2268     }
2269
2270   program_headers = (Elf_Internal_Phdr *) malloc
2271     (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
2272
2273   if (program_headers == NULL)
2274     {
2275       error (_("Out of memory\n"));
2276       return 0;
2277     }
2278
2279   if (is_32bit_elf)
2280     i = get_32bit_program_headers (file, program_headers);
2281   else
2282     i = get_64bit_program_headers (file, program_headers);
2283
2284   if (i == 0)
2285     {
2286       free (program_headers);
2287       return 0;
2288     }
2289
2290   if (do_segments)
2291     {
2292       printf
2293         (_("\nProgram Header%s:\n"), elf_header.e_phnum > 1 ? "s" : "");
2294
2295       if (is_32bit_elf)
2296         printf
2297           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
2298       else
2299         {
2300           printf
2301             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
2302           printf
2303             (_("                 FileSiz            MemSiz              Flags  Align\n"));
2304         }
2305     }
2306
2307   loadaddr = -1;
2308   dynamic_addr = 0;
2309   dynamic_size = 0;
2310
2311   for (i = 0, segment = program_headers;
2312        i < elf_header.e_phnum;
2313        i ++, segment ++)
2314     {
2315       if (do_segments)
2316         {
2317           printf ("  %-14.14s ", get_segment_type (segment->p_type));
2318
2319           if (is_32bit_elf)
2320             {
2321               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2322               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
2323               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
2324               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
2325               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
2326               printf ("%c%c%c ",
2327                       (segment->p_flags & PF_R ? 'R' : ' '),
2328                       (segment->p_flags & PF_W ? 'W' : ' '),
2329                       (segment->p_flags & PF_X ? 'E' : ' '));
2330               printf ("%#lx", (unsigned long) segment->p_align);
2331             }
2332           else
2333             {
2334               print_vma (segment->p_offset, FULL_HEX);
2335               putchar (' ');
2336               print_vma (segment->p_vaddr, FULL_HEX);
2337               putchar (' ');
2338               print_vma (segment->p_paddr, FULL_HEX);
2339               printf ("\n                 ");
2340               print_vma (segment->p_filesz, FULL_HEX);
2341               putchar (' ');
2342               print_vma (segment->p_memsz, FULL_HEX);
2343               printf ("  %c%c%c    ",
2344                       (segment->p_flags & PF_R ? 'R' : ' '),
2345                       (segment->p_flags & PF_W ? 'W' : ' '),
2346                       (segment->p_flags & PF_X ? 'E' : ' '));
2347               print_vma (segment->p_align, HEX);
2348             }
2349         }
2350
2351       switch (segment->p_type)
2352         {
2353         case PT_LOAD:
2354           if (loadaddr == -1)
2355             loadaddr = (segment->p_vaddr & 0xfffff000)
2356               - (segment->p_offset & 0xfffff000);
2357           break;
2358
2359         case PT_DYNAMIC:
2360           if (dynamic_addr)
2361             error (_("more than one dynamic segment\n"));
2362
2363           dynamic_addr = segment->p_offset;
2364           dynamic_size = segment->p_filesz;
2365           break;
2366
2367         case PT_INTERP:
2368           if (fseek (file, (long) segment->p_offset, SEEK_SET))
2369             error (_("Unable to find program interpreter name\n"));
2370           else
2371             {
2372               program_interpreter[0] = 0;
2373               fscanf (file, "%63s", program_interpreter);
2374
2375               if (do_segments)
2376                 printf (_("\n      [Requesting program interpreter: %s]"),
2377                     program_interpreter);
2378             }
2379           break;
2380         }
2381
2382       if (do_segments)
2383         putc ('\n', stdout);
2384     }
2385
2386   if (loadaddr == -1)
2387     {
2388       /* Very strange. */
2389       loadaddr = 0;
2390     }
2391
2392   if (do_segments && section_headers != NULL)
2393     {
2394       printf (_("\n Section to Segment mapping:\n"));
2395       printf (_("  Segment Sections...\n"));
2396
2397       assert (string_table != NULL);
2398
2399       for (i = 0; i < elf_header.e_phnum; i++)
2400         {
2401           int                 j;
2402           Elf_Internal_Shdr * section;
2403
2404           segment = program_headers + i;
2405           section = section_headers;
2406
2407           printf ("   %2.2d     ", i);
2408
2409           for (j = 0; j < elf_header.e_shnum; j++, section ++)
2410             {
2411               if (section->sh_size > 0
2412                   /* Compare allocated sections by VMA, unallocated
2413                      sections by file offset.  */
2414                   && (section->sh_flags & SHF_ALLOC
2415                       ? (section->sh_addr >= segment->p_vaddr
2416                          && section->sh_addr + section->sh_size
2417                          <= segment->p_vaddr + segment->p_memsz)
2418                       : ((bfd_vma) section->sh_offset >= segment->p_offset
2419                          && (section->sh_offset + section->sh_size
2420                              <= segment->p_offset + segment->p_filesz))))
2421                 printf ("%s ", SECTION_NAME (section));
2422             }
2423
2424           putc ('\n',stdout);
2425         }
2426     }
2427
2428   free (program_headers);
2429
2430   return 1;
2431 }
2432
2433
2434 static int
2435 get_32bit_section_headers (file)
2436      FILE * file;
2437 {
2438   Elf32_External_Shdr * shdrs;
2439   Elf32_Internal_Shdr * internal;
2440   unsigned int          i;
2441
2442   GET_DATA_ALLOC (elf_header.e_shoff,
2443                   elf_header.e_shentsize * elf_header.e_shnum,
2444                   shdrs, Elf32_External_Shdr *, "section headers");
2445
2446   section_headers = (Elf_Internal_Shdr *) malloc
2447     (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2448
2449   if (section_headers == NULL)
2450     {
2451       error (_("Out of memory\n"));
2452       return 0;
2453     }
2454
2455   for (i = 0, internal = section_headers;
2456        i < elf_header.e_shnum;
2457        i ++, internal ++)
2458     {
2459       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
2460       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
2461       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
2462       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
2463       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
2464       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
2465       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
2466       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
2467       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2468       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
2469     }
2470
2471   free (shdrs);
2472
2473   return 1;
2474 }
2475
2476 static int
2477 get_64bit_section_headers (file)
2478      FILE * file;
2479 {
2480   Elf64_External_Shdr * shdrs;
2481   Elf64_Internal_Shdr * internal;
2482   unsigned int          i;
2483
2484   GET_DATA_ALLOC (elf_header.e_shoff,
2485                   elf_header.e_shentsize * elf_header.e_shnum,
2486                   shdrs, Elf64_External_Shdr *, "section headers");
2487
2488   section_headers = (Elf_Internal_Shdr *) malloc
2489     (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2490
2491   if (section_headers == NULL)
2492     {
2493       error (_("Out of memory\n"));
2494       return 0;
2495     }
2496
2497   for (i = 0, internal = section_headers;
2498        i < elf_header.e_shnum;
2499        i ++, internal ++)
2500     {
2501       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
2502       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
2503       internal->sh_flags     = BYTE_GET8 (shdrs[i].sh_flags);
2504       internal->sh_addr      = BYTE_GET8 (shdrs[i].sh_addr);
2505       internal->sh_size      = BYTE_GET8 (shdrs[i].sh_size);
2506       internal->sh_entsize   = BYTE_GET8 (shdrs[i].sh_entsize);
2507       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
2508       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
2509       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
2510       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2511     }
2512
2513   free (shdrs);
2514
2515   return 1;
2516 }
2517
2518 static Elf_Internal_Sym *
2519 get_32bit_elf_symbols (file, offset, number)
2520      FILE * file;
2521      unsigned long offset;
2522      unsigned long number;
2523 {
2524   Elf32_External_Sym * esyms;
2525   Elf_Internal_Sym *   isyms;
2526   Elf_Internal_Sym *   psym;
2527   unsigned int         j;
2528
2529   GET_DATA_ALLOC (offset, number * sizeof (Elf32_External_Sym),
2530                   esyms, Elf32_External_Sym *, "symbols");
2531
2532   isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2533
2534   if (isyms == NULL)
2535     {
2536       error (_("Out of memory\n"));
2537       free (esyms);
2538
2539       return NULL;
2540     }
2541
2542   for (j = 0, psym = isyms;
2543        j < number;
2544        j ++, psym ++)
2545     {
2546       psym->st_name  = BYTE_GET (esyms[j].st_name);
2547       psym->st_value = BYTE_GET (esyms[j].st_value);
2548       psym->st_size  = BYTE_GET (esyms[j].st_size);
2549       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2550       psym->st_info  = BYTE_GET (esyms[j].st_info);
2551       psym->st_other = BYTE_GET (esyms[j].st_other);
2552     }
2553
2554   free (esyms);
2555
2556   return isyms;
2557 }
2558
2559 static Elf_Internal_Sym *
2560 get_64bit_elf_symbols (file, offset, number)
2561      FILE * file;
2562      unsigned long offset;
2563      unsigned long number;
2564 {
2565   Elf64_External_Sym * esyms;
2566   Elf_Internal_Sym *   isyms;
2567   Elf_Internal_Sym *   psym;
2568   unsigned int         j;
2569
2570   GET_DATA_ALLOC (offset, number * sizeof (Elf64_External_Sym),
2571                   esyms, Elf64_External_Sym *, "symbols");
2572
2573   isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2574
2575   if (isyms == NULL)
2576     {
2577       error (_("Out of memory\n"));
2578       free (esyms);
2579
2580       return NULL;
2581     }
2582
2583   for (j = 0, psym = isyms;
2584        j < number;
2585        j ++, psym ++)
2586     {
2587       psym->st_name  = BYTE_GET (esyms[j].st_name);
2588       psym->st_info  = BYTE_GET (esyms[j].st_info);
2589       psym->st_other = BYTE_GET (esyms[j].st_other);
2590       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2591       psym->st_value = BYTE_GET8 (esyms[j].st_value);
2592       psym->st_size  = BYTE_GET8 (esyms[j].st_size);
2593     }
2594
2595   free (esyms);
2596
2597   return isyms;
2598 }
2599
2600 static const char *
2601 get_elf_section_flags (sh_flags)
2602      bfd_vma sh_flags;
2603 {
2604   static char buff [32];
2605
2606   * buff = 0;
2607
2608   while (sh_flags)
2609     {
2610       bfd_vma flag;
2611
2612       flag = sh_flags & - sh_flags;
2613       sh_flags &= ~ flag;
2614
2615       switch (flag)
2616         {
2617         case SHF_WRITE:            strcat (buff, "W"); break;
2618         case SHF_ALLOC:            strcat (buff, "A"); break;
2619         case SHF_EXECINSTR:        strcat (buff, "X"); break;
2620         case SHF_MERGE:            strcat (buff, "M"); break;
2621         case SHF_STRINGS:          strcat (buff, "S"); break;
2622         case SHF_INFO_LINK:        strcat (buff, "I"); break;
2623         case SHF_LINK_ORDER:       strcat (buff, "L"); break;
2624         case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
2625
2626         default:
2627           if (flag & SHF_MASKOS)
2628             {
2629               strcat (buff, "o");
2630               sh_flags &= ~ SHF_MASKOS;
2631             }
2632           else if (flag & SHF_MASKPROC)
2633             {
2634               strcat (buff, "p");
2635               sh_flags &= ~ SHF_MASKPROC;
2636             }
2637           else
2638             strcat (buff, "x");
2639           break;
2640         }
2641     }
2642
2643   return buff;
2644 }
2645
2646 static int
2647 process_section_headers (file)
2648      FILE * file;
2649 {
2650   Elf_Internal_Shdr * section;
2651   int                 i;
2652
2653   section_headers = NULL;
2654
2655   if (elf_header.e_shnum == 0)
2656     {
2657       if (do_sections)
2658         printf (_("\nThere are no sections in this file.\n"));
2659
2660       return 1;
2661     }
2662
2663   if (do_sections && !do_header)
2664     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2665             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
2666
2667   if (is_32bit_elf)
2668     {
2669       if (! get_32bit_section_headers (file))
2670         return 0;
2671     }
2672   else if (! get_64bit_section_headers (file))
2673     return 0;
2674
2675   /* Read in the string table, so that we have names to display.  */
2676   section = section_headers + elf_header.e_shstrndx;
2677
2678   if (section->sh_size != 0)
2679     {
2680       unsigned long string_table_offset;
2681
2682       string_table_offset = section->sh_offset;
2683
2684       GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2685                       string_table, char *, "string table");
2686     }
2687
2688   /* Scan the sections for the dynamic symbol table
2689      and dynamic string table and debug sections. */
2690   dynamic_symbols = NULL;
2691   dynamic_strings = NULL;
2692   dynamic_syminfo = NULL;
2693
2694   for (i = 0, section = section_headers;
2695        i < elf_header.e_shnum;
2696        i ++, section ++)
2697     {
2698       char * name = SECTION_NAME (section);
2699
2700       if (section->sh_type == SHT_DYNSYM)
2701         {
2702           if (dynamic_symbols != NULL)
2703             {
2704               error (_("File contains multiple dynamic symbol tables\n"));
2705               continue;
2706             }
2707
2708           num_dynamic_syms = section->sh_size / section->sh_entsize;
2709           dynamic_symbols =
2710             GET_ELF_SYMBOLS (file, section->sh_offset, num_dynamic_syms);
2711         }
2712       else if (section->sh_type == SHT_STRTAB
2713                && strcmp (name, ".dynstr") == 0)
2714         {
2715           if (dynamic_strings != NULL)
2716             {
2717               error (_("File contains multiple dynamic string tables\n"));
2718               continue;
2719             }
2720
2721           GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2722                           dynamic_strings, char *, "dynamic strings");
2723         }
2724       else if ((do_debugging || do_debug_info || do_debug_abbrevs
2725                 || do_debug_lines || do_debug_pubnames || do_debug_aranges)
2726                && strncmp (name, ".debug_", 7) == 0)
2727         {
2728           name += 7;
2729
2730           if (do_debugging
2731               || (do_debug_info     && (strcmp (name, "info") == 0))
2732               || (do_debug_abbrevs  && (strcmp (name, "abbrev") == 0))
2733               || (do_debug_lines    && (strcmp (name, "line") == 0))
2734               || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
2735               || (do_debug_aranges  && (strcmp (name, "aranges") == 0))
2736               )
2737             request_dump (i, DEBUG_DUMP);
2738         }
2739     }
2740
2741   if (! do_sections)
2742     return 1;
2743
2744   printf (_("\nSection Header%s:\n"), elf_header.e_shnum > 1 ? "s" : "");
2745
2746   if (is_32bit_elf)
2747     printf
2748       (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
2749   else
2750     {
2751       printf (_("  [Nr] Name              Type             Address           Offset\n"));
2752       printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
2753     }
2754
2755   for (i = 0, section = section_headers;
2756        i < elf_header.e_shnum;
2757        i ++, section ++)
2758     {
2759       printf ("  [%2d] %-17.17s %-15.15s ",
2760               i,
2761               SECTION_NAME (section),
2762               get_section_type_name (section->sh_type));
2763
2764       if (is_32bit_elf)
2765         {
2766           print_vma (section->sh_addr, LONG_HEX);
2767
2768           printf ( " %6.6lx %6.6lx %2.2lx",
2769                    (unsigned long) section->sh_offset,
2770                    (unsigned long) section->sh_size,
2771                    (unsigned long) section->sh_entsize);
2772
2773           printf (" %3s ", get_elf_section_flags (section->sh_flags));
2774
2775           printf (" %2ld %3lx %ld\n",
2776                   (unsigned long) section->sh_link,
2777                   (unsigned long) section->sh_info,
2778                   (unsigned long) section->sh_addralign);
2779         }
2780       else
2781         {
2782           putchar (' ');
2783           print_vma (section->sh_addr, LONG_HEX);
2784           printf ("  %8.8lx", section->sh_offset);
2785           printf ("\n       ");
2786           print_vma (section->sh_size, LONG_HEX);
2787           printf ("  ");
2788           print_vma (section->sh_entsize, LONG_HEX);
2789
2790           printf (" %3s ", get_elf_section_flags (section->sh_flags));
2791
2792           printf ("     %2ld   %3lx     %ld\n",
2793                   (unsigned long) section->sh_link,
2794                   (unsigned long) section->sh_info,
2795                   (unsigned long) section->sh_addralign);
2796         }
2797     }
2798
2799   printf (_("Key to Flags: W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
2800   printf (_("              I (info), L (link order), O (extra OS processing required)\n"));
2801   printf (_("              o (os specific), p (processor specific) x (unknown)\n"));
2802
2803   return 1;
2804 }
2805
2806 /* Process the reloc section.  */
2807 static int
2808 process_relocs (file)
2809      FILE * file;
2810 {
2811   unsigned long    rel_size;
2812   unsigned long    rel_offset;
2813
2814
2815   if (!do_reloc)
2816     return 1;
2817
2818   if (do_using_dynamic)
2819     {
2820       int is_rela = FALSE;
2821
2822       rel_size   = 0;
2823       rel_offset = 0;
2824
2825       if (dynamic_info[DT_REL])
2826         {
2827           rel_offset = dynamic_info[DT_REL];
2828           rel_size   = dynamic_info[DT_RELSZ];
2829           is_rela    = FALSE;
2830         }
2831       else if (dynamic_info [DT_RELA])
2832         {
2833           rel_offset = dynamic_info[DT_RELA];
2834           rel_size   = dynamic_info[DT_RELASZ];
2835           is_rela    = TRUE;
2836         }
2837       else if (dynamic_info[DT_JMPREL])
2838         {
2839           rel_offset = dynamic_info[DT_JMPREL];
2840           rel_size   = dynamic_info[DT_PLTRELSZ];
2841
2842           switch (dynamic_info[DT_PLTREL])
2843             {
2844             case DT_REL:
2845               is_rela = FALSE;
2846               break;
2847             case DT_RELA:
2848               is_rela = TRUE;
2849               break;
2850             default:
2851               is_rela = UNKNOWN;
2852               break;
2853             }
2854         }
2855
2856       if (rel_size)
2857         {
2858           printf
2859             (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
2860              rel_offset, rel_size);
2861
2862           dump_relocations (file, rel_offset - loadaddr, rel_size,
2863                             dynamic_symbols, num_dynamic_syms, dynamic_strings, is_rela);
2864         }
2865       else
2866         printf (_("\nThere are no dynamic relocations in this file.\n"));
2867     }
2868   else
2869     {
2870       Elf32_Internal_Shdr *     section;
2871       unsigned long             i;
2872       int                       found = 0;
2873
2874       for (i = 0, section = section_headers;
2875            i < elf_header.e_shnum;
2876            i++, section ++)
2877         {
2878           if (   section->sh_type != SHT_RELA
2879               && section->sh_type != SHT_REL)
2880             continue;
2881
2882           rel_offset = section->sh_offset;
2883           rel_size   = section->sh_size;
2884
2885           if (rel_size)
2886             {
2887               Elf32_Internal_Shdr * strsec;
2888               Elf32_Internal_Shdr * symsec;
2889               Elf_Internal_Sym *    symtab;
2890               char *                strtab;
2891               int                   is_rela;
2892               unsigned long         nsyms;
2893
2894               printf (_("\nRelocation section "));
2895
2896               if (string_table == NULL)
2897                 printf ("%d", section->sh_name);
2898               else
2899                 printf ("'%s'", SECTION_NAME (section));
2900
2901               printf (_(" at offset 0x%lx contains %lu entries:\n"),
2902                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
2903
2904               symsec = section_headers + section->sh_link;
2905
2906               nsyms = symsec->sh_size / symsec->sh_entsize;
2907               symtab = GET_ELF_SYMBOLS (file, symsec->sh_offset, nsyms);
2908
2909               if (symtab == NULL)
2910                 continue;
2911
2912               strsec = section_headers + symsec->sh_link;
2913
2914               GET_DATA_ALLOC (strsec->sh_offset, strsec->sh_size, strtab,
2915                               char *, "string table");
2916
2917               is_rela = section->sh_type == SHT_RELA;
2918
2919               dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela);
2920
2921               free (strtab);
2922               free (symtab);
2923
2924               found = 1;
2925             }
2926         }
2927
2928       if (! found)
2929         printf (_("\nThere are no relocations in this file.\n"));
2930     }
2931
2932   return 1;
2933 }
2934
2935
2936 static void
2937 dynamic_segment_mips_val (entry)
2938      Elf_Internal_Dyn * entry;
2939 {
2940   switch (entry->d_tag)
2941     {
2942     case DT_MIPS_FLAGS:
2943       if (entry->d_un.d_val == 0)
2944         printf ("NONE\n");
2945       else
2946         {
2947           static const char * opts[] =
2948           {
2949             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
2950             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
2951             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
2952             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
2953             "RLD_ORDER_SAFE"
2954           };
2955           unsigned int cnt;
2956           int first = 1;
2957           for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
2958             if (entry->d_un.d_val & (1 << cnt))
2959               {
2960                 printf ("%s%s", first ? "" : " ", opts[cnt]);
2961                 first = 0;
2962               }
2963           puts ("");
2964         }
2965       break;
2966
2967     case DT_MIPS_IVERSION:
2968       if (dynamic_strings != NULL)
2969         printf ("Interface Version: %s\n",
2970                 dynamic_strings + entry->d_un.d_val);
2971       else
2972         printf ("%ld\n", (long) entry->d_un.d_ptr);
2973       break;
2974
2975     case DT_MIPS_TIME_STAMP:
2976       {
2977         char timebuf[20];
2978         struct tm * tmp;
2979
2980         time_t time = entry->d_un.d_val;
2981         tmp = gmtime (&time);
2982         sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
2983                  tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
2984                  tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
2985         printf ("Time Stamp: %s\n", timebuf);
2986       }
2987       break;
2988
2989     case DT_MIPS_RLD_VERSION:
2990     case DT_MIPS_LOCAL_GOTNO:
2991     case DT_MIPS_CONFLICTNO:
2992     case DT_MIPS_LIBLISTNO:
2993     case DT_MIPS_SYMTABNO:
2994     case DT_MIPS_UNREFEXTNO:
2995     case DT_MIPS_HIPAGENO:
2996     case DT_MIPS_DELTA_CLASS_NO:
2997     case DT_MIPS_DELTA_INSTANCE_NO:
2998     case DT_MIPS_DELTA_RELOC_NO:
2999     case DT_MIPS_DELTA_SYM_NO:
3000     case DT_MIPS_DELTA_CLASSSYM_NO:
3001     case DT_MIPS_COMPACT_SIZE:
3002       printf ("%ld\n", (long) entry->d_un.d_ptr);
3003       break;
3004
3005     default:
3006       printf ("%#lx\n", (long) entry->d_un.d_ptr);
3007     }
3008 }
3009
3010
3011 static void
3012 dynamic_segment_parisc_val (entry)
3013      Elf_Internal_Dyn * entry;
3014 {
3015   switch (entry->d_tag)
3016     {
3017     case DT_HP_DLD_FLAGS:
3018       {
3019         static struct
3020         {
3021           long int bit;
3022           const char * str;
3023         }
3024         flags[] =
3025         {
3026           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
3027           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
3028           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
3029           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
3030           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
3031           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
3032           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
3033           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
3034           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
3035           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
3036           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
3037         };
3038         int first = 1;
3039         size_t cnt;
3040         bfd_vma val = entry->d_un.d_val;
3041
3042         for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
3043           if (val & flags[cnt].bit)
3044             {
3045               if (! first)
3046                 putchar (' ');
3047               fputs (flags[cnt].str, stdout);
3048               first = 0;
3049               val ^= flags[cnt].bit;
3050             }
3051
3052         if (val != 0 || first)
3053           {
3054             if (! first)
3055               putchar (' ');
3056             print_vma (val, HEX);
3057           }
3058       }
3059       break;
3060
3061     default:
3062       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
3063       break;
3064     }
3065 }
3066
3067 static int
3068 get_32bit_dynamic_segment (file)
3069      FILE * file;
3070 {
3071   Elf32_External_Dyn * edyn;
3072   Elf_Internal_Dyn *   entry;
3073   bfd_size_type        i;
3074
3075   GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3076                   edyn, Elf32_External_Dyn *, "dynamic segment");
3077
3078   /* SGI's ELF has more than one section in the DYNAMIC segment.  Determine
3079      how large this .dynamic is now.  We can do this even before the byte
3080      swapping since the DT_NULL tag is recognizable.  */
3081   dynamic_size = 0;
3082   while (*(Elf32_Word *) edyn [dynamic_size++].d_tag != DT_NULL)
3083     ;
3084
3085   dynamic_segment = (Elf_Internal_Dyn *)
3086     malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3087
3088   if (dynamic_segment == NULL)
3089     {
3090       error (_("Out of memory\n"));
3091       free (edyn);
3092       return 0;
3093     }
3094
3095   for (i = 0, entry = dynamic_segment;
3096        i < dynamic_size;
3097        i ++, entry ++)
3098     {
3099       entry->d_tag      = BYTE_GET (edyn [i].d_tag);
3100       entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
3101     }
3102
3103   free (edyn);
3104
3105   return 1;
3106 }
3107
3108 static int
3109 get_64bit_dynamic_segment (file)
3110      FILE * file;
3111 {
3112   Elf64_External_Dyn * edyn;
3113   Elf_Internal_Dyn *   entry;
3114   bfd_size_type        i;
3115
3116   GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3117                   edyn, Elf64_External_Dyn *, "dynamic segment");
3118
3119   /* SGI's ELF has more than one section in the DYNAMIC segment.  Determine
3120      how large this .dynamic is now.  We can do this even before the byte
3121      swapping since the DT_NULL tag is recognizable.  */
3122   dynamic_size = 0;
3123   while (*(bfd_vma *) edyn [dynamic_size ++].d_tag != DT_NULL)
3124     ;
3125
3126   dynamic_segment = (Elf_Internal_Dyn *)
3127     malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3128
3129   if (dynamic_segment == NULL)
3130     {
3131       error (_("Out of memory\n"));
3132       free (edyn);
3133       return 0;
3134     }
3135
3136   for (i = 0, entry = dynamic_segment;
3137        i < dynamic_size;
3138        i ++, entry ++)
3139     {
3140       entry->d_tag      = BYTE_GET8 (edyn [i].d_tag);
3141       entry->d_un.d_val = BYTE_GET8 (edyn [i].d_un.d_val);
3142     }
3143
3144   free (edyn);
3145
3146   return 1;
3147 }
3148
3149 static const char *
3150 get_dynamic_flags (flags)
3151      bfd_vma flags;
3152 {
3153   static char buff [64];
3154   while (flags)
3155     {
3156       bfd_vma flag;
3157
3158       flag = flags & - flags;
3159       flags &= ~ flag;
3160
3161       switch (flag)
3162         {
3163         case DF_ORIGIN:   strcat (buff, "ORIGIN "); break;
3164         case DF_SYMBOLIC: strcat (buff, "SYMBOLIC "); break;
3165         case DF_TEXTREL:  strcat (buff, "TEXTREL "); break;
3166         case DF_BIND_NOW: strcat (buff, "BIND_NOW "); break;
3167         default:          strcat (buff, "unknown "); break;
3168         }
3169     }
3170   return buff;
3171 }
3172
3173 /* Parse and display the contents of the dynamic segment.  */
3174 static int
3175 process_dynamic_segment (file)
3176      FILE * file;
3177 {
3178   Elf_Internal_Dyn * entry;
3179   bfd_size_type      i;
3180
3181   if (dynamic_size == 0)
3182     {
3183       if (do_dynamic)
3184         printf (_("\nThere is no dynamic segment in this file.\n"));
3185
3186       return 1;
3187     }
3188
3189   if (is_32bit_elf)
3190     {
3191       if (! get_32bit_dynamic_segment (file))
3192         return 0;
3193     }
3194   else if (! get_64bit_dynamic_segment (file))
3195     return 0;
3196
3197   /* Find the appropriate symbol table.  */
3198   if (dynamic_symbols == NULL)
3199     {
3200       for (i = 0, entry = dynamic_segment;
3201            i < dynamic_size;
3202            ++i, ++ entry)
3203         {
3204           unsigned long        offset;
3205
3206           if (entry->d_tag != DT_SYMTAB)
3207             continue;
3208
3209           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
3210
3211           /* Since we do not know how big the symbol table is,
3212              we default to reading in the entire file (!) and
3213              processing that.  This is overkill, I know, but it
3214              should work. */
3215           offset = entry->d_un.d_val - loadaddr;
3216
3217           if (fseek (file, 0, SEEK_END))
3218             error (_("Unable to seek to end of file!"));
3219
3220           if (is_32bit_elf)
3221             num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf32_External_Sym);
3222           else
3223             num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf64_External_Sym);
3224
3225           if (num_dynamic_syms < 1)
3226             {
3227               error (_("Unable to determine the number of symbols to load\n"));
3228               continue;
3229             }
3230
3231           dynamic_symbols = GET_ELF_SYMBOLS (file, offset, num_dynamic_syms);
3232         }
3233     }
3234
3235   /* Similarly find a string table.  */
3236   if (dynamic_strings == NULL)
3237     {
3238       for (i = 0, entry = dynamic_segment;
3239            i < dynamic_size;
3240            ++i, ++ entry)
3241         {
3242           unsigned long offset;
3243           long          str_tab_len;
3244
3245           if (entry->d_tag != DT_STRTAB)
3246             continue;
3247
3248           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
3249
3250           /* Since we do not know how big the string table is,
3251              we default to reading in the entire file (!) and
3252              processing that.  This is overkill, I know, but it
3253              should work. */
3254
3255           offset = entry->d_un.d_val - loadaddr;
3256           if (fseek (file, 0, SEEK_END))
3257             error (_("Unable to seek to end of file\n"));
3258           str_tab_len = ftell (file) - offset;
3259
3260           if (str_tab_len < 1)
3261             {
3262               error
3263                 (_("Unable to determine the length of the dynamic string table\n"));
3264               continue;
3265             }
3266
3267           GET_DATA_ALLOC (offset, str_tab_len, dynamic_strings, char *,
3268                           "dynamic string table");
3269
3270           break;
3271         }
3272     }
3273
3274   /* And find the syminfo section if available.  */
3275   if (dynamic_syminfo == NULL)
3276     {
3277       unsigned int syminsz = 0;
3278
3279       for (i = 0, entry = dynamic_segment;
3280            i < dynamic_size;
3281            ++i, ++ entry)
3282         {
3283           if (entry->d_tag == DT_SYMINENT)
3284             {
3285               /* Note: these braces are necessary to avoid a syntax
3286                  error from the SunOS4 C compiler.  */
3287               assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
3288             }
3289           else if (entry->d_tag == DT_SYMINSZ)
3290             syminsz = entry->d_un.d_val;
3291           else if (entry->d_tag == DT_SYMINFO)
3292             dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
3293         }
3294
3295       if (dynamic_syminfo_offset != 0 && syminsz != 0)
3296         {
3297           Elf_External_Syminfo * extsyminfo;
3298           Elf_Internal_Syminfo * syminfo;
3299
3300           /* There is a syminfo section.  Read the data.  */
3301           GET_DATA_ALLOC (dynamic_syminfo_offset, syminsz, extsyminfo,
3302                           Elf_External_Syminfo *, "symbol information");
3303
3304           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
3305           if (dynamic_syminfo == NULL)
3306             {
3307               error (_("Out of memory\n"));
3308               return 0;
3309             }
3310
3311           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
3312           for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
3313                ++i, ++syminfo)
3314             {
3315               syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
3316               syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
3317             }
3318
3319           free (extsyminfo);
3320         }
3321     }
3322
3323   if (do_dynamic && dynamic_addr)
3324     printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3325             dynamic_addr, (long) dynamic_size);
3326   if (do_dynamic)
3327     printf (_("  Tag        Type                         Name/Value\n"));
3328
3329   for (i = 0, entry = dynamic_segment;
3330        i < dynamic_size;
3331        i++, entry ++)
3332     {
3333       if (do_dynamic)
3334         {
3335           const char * dtype;
3336
3337           putchar (' ');
3338           print_vma (entry->d_tag, FULL_HEX);
3339           dtype = get_dynamic_type (entry->d_tag);
3340           printf (" (%s)%*s", dtype,
3341                   ((is_32bit_elf ? 27 : 19)
3342                    - (int) strlen (dtype)),
3343                   " ");
3344         }
3345
3346       switch (entry->d_tag)
3347         {
3348         case DT_FLAGS:
3349           if (do_dynamic)
3350             printf ("%s", get_dynamic_flags (entry->d_un.d_val));
3351           break;
3352
3353         case DT_AUXILIARY:
3354         case DT_FILTER:
3355         case DT_CONFIG:
3356         case DT_DEPAUDIT:
3357         case DT_AUDIT:
3358           if (do_dynamic)
3359             {
3360               switch (entry->d_tag)
3361                 {
3362                 case DT_AUXILIARY:
3363                   printf (_("Auxiliary library"));
3364                   break;
3365
3366                 case DT_FILTER:
3367                   printf (_("Filter library"));
3368                   break;
3369
3370                 case DT_CONFIG:
3371                   printf (_("Configuration file"));
3372                   break;
3373
3374                 case DT_DEPAUDIT:
3375                   printf (_("Dependency audit library"));
3376                   break;
3377
3378                 case DT_AUDIT:
3379                   printf (_("Audit library"));
3380                   break;
3381                 }
3382
3383               if (dynamic_strings)
3384                 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
3385               else
3386                 {
3387                   printf (": ");
3388                   print_vma (entry->d_un.d_val, PREFIX_HEX);
3389                   putchar ('\n');
3390                 }
3391             }
3392           break;
3393
3394         case DT_FEATURE:
3395           if (do_dynamic)
3396             {
3397               printf (_("Flags:"));
3398               if (entry->d_un.d_val == 0)
3399                 printf (_(" None\n"));
3400               else
3401                 {
3402                   unsigned long int val = entry->d_un.d_val;
3403                   if (val & DTF_1_PARINIT)
3404                     {
3405                       printf (" PARINIT");
3406                       val ^= DTF_1_PARINIT;
3407                     }
3408                   if (val & DTF_1_CONFEXP)
3409                     {
3410                       printf (" CONFEXP");
3411                       val ^= DTF_1_CONFEXP;
3412                     }
3413                   if (val != 0)
3414                     printf (" %lx", val);
3415                   puts ("");
3416                 }
3417             }
3418           break;
3419
3420         case DT_POSFLAG_1:
3421           if (do_dynamic)
3422             {
3423               printf (_("Flags:"));
3424               if (entry->d_un.d_val == 0)
3425                 printf (_(" None\n"));
3426               else
3427                 {
3428                   unsigned long int val = entry->d_un.d_val;
3429                   if (val & DF_P1_LAZYLOAD)
3430                     {
3431                       printf (" LAZYLOAD");
3432                       val ^= DF_P1_LAZYLOAD;
3433                     }
3434                   if (val & DF_P1_GROUPPERM)
3435                     {
3436                       printf (" GROUPPERM");
3437                       val ^= DF_P1_GROUPPERM;
3438                     }
3439                   if (val != 0)
3440                     printf (" %lx", val);
3441                   puts ("");
3442                 }
3443             }
3444           break;
3445
3446         case DT_FLAGS_1:
3447           if (do_dynamic)
3448             {
3449               printf (_("Flags:"));
3450               if (entry->d_un.d_val == 0)
3451                 printf (_(" None\n"));
3452               else
3453                 {
3454                   unsigned long int val = entry->d_un.d_val;
3455                   if (val & DF_1_NOW)
3456                     {
3457                       printf (" NOW");
3458                       val ^= DF_1_NOW;
3459                     }
3460                   if (val & DF_1_GLOBAL)
3461                     {
3462                       printf (" GLOBAL");
3463                       val ^= DF_1_GLOBAL;
3464                     }
3465                   if (val & DF_1_GROUP)
3466                     {
3467                       printf (" GROUP");
3468                       val ^= DF_1_GROUP;
3469                     }
3470                   if (val & DF_1_NODELETE)
3471                     {
3472                       printf (" NODELETE");
3473                       val ^= DF_1_NODELETE;
3474                     }
3475                   if (val & DF_1_LOADFLTR)
3476                     {
3477                       printf (" LOADFLTR");
3478                       val ^= DF_1_LOADFLTR;
3479                     }
3480                   if (val & DF_1_INITFIRST)
3481                     {
3482                       printf (" INITFIRST");
3483                       val ^= DF_1_INITFIRST;
3484                     }
3485                   if (val & DF_1_NOOPEN)
3486                     {
3487                       printf (" NOOPEN");
3488                       val ^= DF_1_NOOPEN;
3489                     }
3490                   if (val & DF_1_ORIGIN)
3491                     {
3492                       printf (" ORIGIN");
3493                       val ^= DF_1_ORIGIN;
3494                     }
3495                   if (val & DF_1_DIRECT)
3496                     {
3497                       printf (" DIRECT");
3498                       val ^= DF_1_DIRECT;
3499                     }
3500                   if (val & DF_1_TRANS)
3501                     {
3502                       printf (" TRANS");
3503                       val ^= DF_1_TRANS;
3504                     }
3505                   if (val & DF_1_INTERPOSE)
3506                     {
3507                       printf (" INTERPOSE");
3508                       val ^= DF_1_INTERPOSE;
3509                     }
3510                   if (val & DF_1_NODEFLIB)
3511                     {
3512                       printf (" NODEFLIB");
3513                       val ^= DF_1_NODEFLIB;
3514                     }
3515                   if (val & DF_1_NODUMP)
3516                     {
3517                       printf (" NODUMP");
3518                       val ^= DF_1_NODUMP;
3519                     }
3520                   if (val & DF_1_CONLFAT)
3521                     {
3522                       printf (" CONLFAT");
3523                       val ^= DF_1_CONLFAT;
3524                     }
3525                   if (val != 0)
3526                     printf (" %lx", val);
3527                   puts ("");
3528                 }
3529             }
3530           break;
3531
3532         case DT_PLTREL:
3533           if (do_dynamic)
3534             puts (get_dynamic_type (entry->d_un.d_val));
3535           break;
3536
3537         case DT_NULL    :
3538         case DT_NEEDED  :
3539         case DT_PLTGOT  :
3540         case DT_HASH    :
3541         case DT_STRTAB  :
3542         case DT_SYMTAB  :
3543         case DT_RELA    :
3544         case DT_INIT    :
3545         case DT_FINI    :
3546         case DT_SONAME  :
3547         case DT_RPATH   :
3548         case DT_SYMBOLIC:
3549         case DT_REL     :
3550         case DT_DEBUG   :
3551         case DT_TEXTREL :
3552         case DT_JMPREL  :
3553         case DT_RUNPATH :
3554           dynamic_info[entry->d_tag] = entry->d_un.d_val;
3555
3556           if (do_dynamic)
3557             {
3558               char * name;
3559
3560               if (dynamic_strings == NULL)
3561                 name = NULL;
3562               else
3563                 name = dynamic_strings + entry->d_un.d_val;
3564
3565               if (name)
3566                 {
3567                   switch (entry->d_tag)
3568                     {
3569                     case DT_NEEDED:
3570                       printf (_("Shared library: [%s]"), name);
3571
3572                       if (strcmp (name, program_interpreter) == 0)
3573                         printf (_(" program interpreter"));
3574                       break;
3575
3576                     case DT_SONAME:
3577                       printf (_("Library soname: [%s]"), name);
3578                       break;
3579
3580                     case DT_RPATH:
3581                       printf (_("Library rpath: [%s]"), name);
3582                       break;
3583
3584                     case DT_RUNPATH:
3585                       printf (_("Library runpath: [%s]"), name);
3586                       break;
3587
3588                     default:
3589                       print_vma (entry->d_un.d_val, PREFIX_HEX);
3590                       break;
3591                     }
3592                 }
3593               else
3594                 print_vma (entry->d_un.d_val, PREFIX_HEX);
3595
3596               putchar ('\n');
3597             }
3598           break;
3599
3600         case DT_PLTRELSZ:
3601         case DT_RELASZ  :
3602         case DT_STRSZ   :
3603         case DT_RELSZ   :
3604         case DT_RELAENT :
3605         case DT_SYMENT  :
3606         case DT_RELENT  :
3607         case DT_PLTPADSZ:
3608         case DT_MOVEENT :
3609         case DT_MOVESZ  :
3610         case DT_INIT_ARRAYSZ:
3611         case DT_FINI_ARRAYSZ:
3612           if (do_dynamic)
3613             {
3614               print_vma (entry->d_un.d_val, UNSIGNED);
3615               printf (" (bytes)\n");
3616             }
3617           break;
3618
3619         case DT_VERDEFNUM:
3620         case DT_VERNEEDNUM:
3621         case DT_RELACOUNT:
3622         case DT_RELCOUNT:
3623           if (do_dynamic)
3624             {
3625               print_vma (entry->d_un.d_val, UNSIGNED);
3626               putchar ('\n');
3627             }
3628           break;
3629
3630         case DT_SYMINSZ:
3631         case DT_SYMINENT:
3632         case DT_SYMINFO:
3633         case DT_USED:
3634         case DT_INIT_ARRAY:
3635         case DT_FINI_ARRAY:
3636           if (do_dynamic)
3637             {
3638               if (dynamic_strings != NULL && entry->d_tag == DT_USED)
3639                 {
3640                   char * name;
3641
3642                   name = dynamic_strings + entry->d_un.d_val;
3643
3644                   if (* name)
3645                     {
3646                       printf (_("Not needed object: [%s]\n"), name);
3647                       break;
3648                     }
3649                 }
3650
3651               print_vma (entry->d_un.d_val, PREFIX_HEX);
3652               putchar ('\n');
3653             }
3654           break;
3655
3656         case DT_BIND_NOW:
3657           /* The value of this entry is ignored.  */
3658           break;
3659
3660         default:
3661           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
3662             version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
3663               entry->d_un.d_val;
3664
3665           if (do_dynamic)
3666             {
3667               switch (elf_header.e_machine)
3668                 {
3669                 case EM_MIPS:
3670                 case EM_MIPS_RS4_BE:
3671                   dynamic_segment_mips_val (entry);
3672                   break;
3673                 case EM_PARISC:
3674                   dynamic_segment_parisc_val (entry);
3675                   break;
3676                 default:
3677                   print_vma (entry->d_un.d_val, PREFIX_HEX);
3678                   putchar ('\n');
3679                 }
3680             }
3681           break;
3682         }
3683     }
3684
3685   return 1;
3686 }
3687
3688 static char *
3689 get_ver_flags (flags)
3690      unsigned int flags;
3691 {
3692   static char buff [32];
3693
3694   buff[0] = 0;
3695
3696   if (flags == 0)
3697     return _("none");
3698
3699   if (flags & VER_FLG_BASE)
3700     strcat (buff, "BASE ");
3701
3702   if (flags & VER_FLG_WEAK)
3703     {
3704       if (flags & VER_FLG_BASE)
3705         strcat (buff, "| ");
3706
3707       strcat (buff, "WEAK ");
3708     }
3709
3710   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
3711     strcat (buff, "| <unknown>");
3712
3713   return buff;
3714 }
3715
3716 /* Display the contents of the version sections.  */
3717 static int
3718 process_version_sections (file)
3719      FILE * file;
3720 {
3721   Elf32_Internal_Shdr * section;
3722   unsigned   i;
3723   int        found = 0;
3724
3725   if (! do_version)
3726     return 1;
3727
3728   for (i = 0, section = section_headers;
3729        i < elf_header.e_shnum;
3730        i++, section ++)
3731     {
3732       switch (section->sh_type)
3733         {
3734         case SHT_GNU_verdef:
3735           {
3736             Elf_External_Verdef * edefs;
3737             unsigned int          idx;
3738             unsigned int          cnt;
3739
3740             found = 1;
3741
3742             printf
3743               (_("\nVersion definition section '%s' contains %ld entries:\n"),
3744                SECTION_NAME (section), section->sh_info);
3745
3746             printf (_("  Addr: 0x"));
3747             printf_vma (section->sh_addr);
3748             printf (_("  Offset: %#08lx  Link: %lx (%s)\n"),
3749                     (unsigned long) section->sh_offset, section->sh_link,
3750                     SECTION_NAME (section_headers + section->sh_link));
3751
3752             GET_DATA_ALLOC (section->sh_offset, section->sh_size,
3753                             edefs, Elf_External_Verdef *,
3754                             "version definition section");
3755
3756             for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
3757               {
3758                 char *                 vstart;
3759                 Elf_External_Verdef *  edef;
3760                 Elf_Internal_Verdef    ent;
3761                 Elf_External_Verdaux * eaux;
3762                 Elf_Internal_Verdaux   aux;
3763                 int                    j;
3764                 int                    isum;
3765
3766                 vstart = ((char *) edefs) + idx;
3767
3768                 edef = (Elf_External_Verdef *) vstart;
3769
3770                 ent.vd_version = BYTE_GET (edef->vd_version);
3771                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
3772                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
3773                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
3774                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
3775                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
3776                 ent.vd_next    = BYTE_GET (edef->vd_next);
3777
3778                 printf (_("  %#06x: Rev: %d  Flags: %s"),
3779                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
3780
3781                 printf (_("  Index: %d  Cnt: %d  "),
3782                         ent.vd_ndx, ent.vd_cnt);
3783
3784                 vstart += ent.vd_aux;
3785
3786                 eaux = (Elf_External_Verdaux *) vstart;
3787
3788                 aux.vda_name = BYTE_GET (eaux->vda_name);
3789                 aux.vda_next = BYTE_GET (eaux->vda_next);
3790
3791                 if (dynamic_strings)
3792                   printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
3793                 else
3794                   printf (_("Name index: %ld\n"), aux.vda_name);
3795
3796                 isum = idx + ent.vd_aux;
3797
3798                 for (j = 1; j < ent.vd_cnt; j ++)
3799                   {
3800                     isum   += aux.vda_next;
3801                     vstart += aux.vda_next;
3802
3803                     eaux = (Elf_External_Verdaux *) vstart;
3804
3805                     aux.vda_name = BYTE_GET (eaux->vda_name);
3806                     aux.vda_next = BYTE_GET (eaux->vda_next);
3807
3808                     if (dynamic_strings)
3809                       printf (_("  %#06x: Parent %d: %s\n"),
3810                               isum, j, dynamic_strings + aux.vda_name);
3811                     else
3812                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
3813                               isum, j, aux.vda_name);
3814                   }
3815
3816                 idx += ent.vd_next;
3817               }
3818
3819             free (edefs);
3820           }
3821           break;
3822
3823         case SHT_GNU_verneed:
3824           {
3825             Elf_External_Verneed *  eneed;
3826             unsigned int            idx;
3827             unsigned int            cnt;
3828
3829             found = 1;
3830
3831             printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
3832                     SECTION_NAME (section), section->sh_info);
3833
3834             printf (_(" Addr: 0x"));
3835             printf_vma (section->sh_addr);
3836             printf (_("  Offset: %#08lx  Link to section: %ld (%s)\n"),
3837                     (unsigned long) section->sh_offset, section->sh_link,
3838                     SECTION_NAME (section_headers + section->sh_link));
3839
3840             GET_DATA_ALLOC (section->sh_offset, section->sh_size,
3841                             eneed, Elf_External_Verneed *,
3842                             "version need section");
3843
3844             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
3845               {
3846                 Elf_External_Verneed * entry;
3847                 Elf_Internal_Verneed     ent;
3848                 int                      j;
3849                 int                      isum;
3850                 char *                   vstart;
3851
3852                 vstart = ((char *) eneed) + idx;
3853
3854                 entry = (Elf_External_Verneed *) vstart;
3855
3856                 ent.vn_version = BYTE_GET (entry->vn_version);
3857                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
3858                 ent.vn_file    = BYTE_GET (entry->vn_file);
3859                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
3860                 ent.vn_next    = BYTE_GET (entry->vn_next);
3861
3862                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
3863
3864                 if (dynamic_strings)
3865                   printf (_("  File: %s"), dynamic_strings + ent.vn_file);
3866                 else
3867                   printf (_("  File: %lx"), ent.vn_file);
3868
3869                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
3870
3871                 vstart += ent.vn_aux;
3872
3873                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
3874                   {
3875                     Elf_External_Vernaux * eaux;
3876                     Elf_Internal_Vernaux   aux;
3877
3878                     eaux = (Elf_External_Vernaux *) vstart;
3879
3880                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
3881                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
3882                     aux.vna_other = BYTE_GET (eaux->vna_other);
3883                     aux.vna_name  = BYTE_GET (eaux->vna_name);
3884                     aux.vna_next  = BYTE_GET (eaux->vna_next);
3885
3886                     if (dynamic_strings)
3887                       printf (_("  %#06x: Name: %s"),
3888                               isum, dynamic_strings + aux.vna_name);
3889                     else
3890                       printf (_("  %#06x: Name index: %lx"),
3891                               isum, aux.vna_name);
3892
3893                     printf (_("  Flags: %s  Version: %d\n"),
3894                             get_ver_flags (aux.vna_flags), aux.vna_other);
3895
3896                     isum   += aux.vna_next;
3897                     vstart += aux.vna_next;
3898                   }
3899
3900                 idx += ent.vn_next;
3901               }
3902
3903             free (eneed);
3904           }
3905           break;
3906
3907         case SHT_GNU_versym:
3908           {
3909             Elf32_Internal_Shdr *       link_section;
3910             int                         total;
3911             int                         cnt;
3912             unsigned char *             edata;
3913             unsigned short *            data;
3914             char *                      strtab;
3915             Elf_Internal_Sym *          symbols;
3916             Elf32_Internal_Shdr *       string_sec;
3917
3918             link_section = section_headers + section->sh_link;
3919             total = section->sh_size / section->sh_entsize;
3920
3921             found = 1;
3922
3923             symbols = GET_ELF_SYMBOLS (file, link_section->sh_offset,
3924                                        link_section->sh_size / link_section->sh_entsize);
3925
3926             string_sec = section_headers + link_section->sh_link;
3927
3928             GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
3929                             strtab, char *, "version string table");
3930
3931             printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
3932                     SECTION_NAME (section), total);
3933
3934             printf (_(" Addr: "));
3935             printf_vma (section->sh_addr);
3936             printf (_("  Offset: %#08lx  Link: %lx (%s)\n"),
3937                     (unsigned long) section->sh_offset, section->sh_link,
3938                     SECTION_NAME (link_section));
3939
3940             GET_DATA_ALLOC (version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
3941                             - loadaddr,
3942                             total * sizeof (short), edata,
3943                             unsigned char *, "version symbol data");
3944
3945             data = (unsigned short *) malloc (total * sizeof (short));
3946
3947             for (cnt = total; cnt --;)
3948               data [cnt] = byte_get (edata + cnt * sizeof (short),
3949                                      sizeof (short));
3950
3951             free (edata);
3952
3953             for (cnt = 0; cnt < total; cnt += 4)
3954               {
3955                 int j, nn;
3956                 char * name;
3957
3958                 printf ("  %03x:", cnt);
3959
3960                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
3961                   switch (data [cnt + j])
3962                     {
3963                     case 0:
3964                       fputs (_("   0 (*local*)    "), stdout);
3965                       break;
3966
3967                     case 1:
3968                       fputs (_("   1 (*global*)   "), stdout);
3969                       break;
3970
3971                     default:
3972                       nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
3973                                    data [cnt + j] & 0x8000 ? 'h' : ' ');
3974
3975                       if (symbols [cnt + j].st_shndx < SHN_LORESERVE
3976                           && section_headers[symbols [cnt + j].st_shndx].sh_type
3977                           == SHT_NOBITS)
3978                         {
3979                           /* We must test both.  */
3980                           Elf_Internal_Verneed     ivn;
3981                           unsigned long            offset;
3982
3983                           offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
3984                             - loadaddr;
3985
3986                           do
3987                             {
3988                               Elf_External_Verneed   evn;
3989                               Elf_External_Vernaux   evna;
3990                               Elf_Internal_Vernaux   ivna;
3991                               unsigned long          vna_off;
3992
3993                               GET_DATA (offset, evn, "version need");
3994
3995                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
3996                               ivn.vn_next = BYTE_GET (evn.vn_next);
3997
3998                               vna_off = offset + ivn.vn_aux;
3999
4000                               do
4001                                 {
4002                                   GET_DATA (vna_off, evna,
4003                                             "version need aux (1)");
4004
4005                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
4006                                   ivna.vna_other = BYTE_GET (evna.vna_other);
4007
4008                                   vna_off += ivna.vna_next;
4009                                 }
4010                               while (ivna.vna_other != data [cnt + j]
4011                                      && ivna.vna_next != 0);
4012
4013                               if (ivna.vna_other == data [cnt + j])
4014                                 {
4015                                   ivna.vna_name = BYTE_GET (evna.vna_name);
4016
4017                                   name = strtab + ivna.vna_name;
4018                                   nn += printf ("(%s%-*s",
4019                                                 name,
4020                                                 12 - (int) strlen (name),
4021                                                 ")");
4022                                   break;
4023                                 }
4024                               else if (ivn.vn_next == 0)
4025                                 {
4026                                   if (data [cnt + j] != 0x8001)
4027                                     {
4028                                       Elf_Internal_Verdef  ivd;
4029                                       Elf_External_Verdef  evd;
4030
4031                                       offset = version_info
4032                                         [DT_VERSIONTAGIDX (DT_VERDEF)]
4033                                         - loadaddr;
4034
4035                                       do
4036                                         {
4037                                           GET_DATA (offset, evd,
4038                                                     "version definition");
4039
4040                                           ivd.vd_next = BYTE_GET (evd.vd_next);
4041                                           ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
4042
4043                                           offset += ivd.vd_next;
4044                                         }
4045                                       while (ivd.vd_ndx
4046                                              != (data [cnt + j] & 0x7fff)
4047                                              && ivd.vd_next != 0);
4048
4049                                       if (ivd.vd_ndx
4050                                           == (data [cnt + j] & 0x7fff))
4051                                         {
4052                                           Elf_External_Verdaux  evda;
4053                                           Elf_Internal_Verdaux  ivda;
4054
4055                                           ivd.vd_aux = BYTE_GET (evd.vd_aux);
4056
4057                                           GET_DATA (offset + ivd.vd_aux, evda,
4058                                                     "version definition aux");
4059
4060                                           ivda.vda_name =
4061                                             BYTE_GET (evda.vda_name);
4062
4063                                           name = strtab + ivda.vda_name;
4064                                           nn +=
4065                                             printf ("(%s%-*s",
4066                                                     name,
4067                                                     12 - (int) strlen (name),
4068                                                     ")");
4069                                         }
4070                                     }
4071
4072                                   break;
4073                                 }
4074                               else
4075                                 offset += ivn.vn_next;
4076                             }
4077                           while (ivn.vn_next);
4078                         }
4079                       else if (symbols [cnt + j].st_shndx == SHN_UNDEF)
4080                         {
4081                           Elf_Internal_Verneed     ivn;
4082                           unsigned long            offset;
4083
4084                           offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4085                             - loadaddr;
4086
4087                           do
4088                             {
4089                               Elf_Internal_Vernaux   ivna;
4090                               Elf_External_Verneed   evn;
4091                               Elf_External_Vernaux   evna;
4092                               unsigned long          a_off;
4093
4094                               GET_DATA (offset, evn, "version need");
4095
4096                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
4097                               ivn.vn_next = BYTE_GET (evn.vn_next);
4098
4099                               a_off = offset + ivn.vn_aux;
4100
4101                               do
4102                                 {
4103                                   GET_DATA (a_off, evna,
4104                                             "version need aux (2)");
4105
4106                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
4107                                   ivna.vna_other = BYTE_GET (evna.vna_other);
4108
4109                                   a_off += ivna.vna_next;
4110                                 }
4111                               while (ivna.vna_other != data [cnt + j]
4112                                      && ivna.vna_next != 0);
4113
4114                               if (ivna.vna_other == data [cnt + j])
4115                                 {
4116                                   ivna.vna_name = BYTE_GET (evna.vna_name);
4117
4118                                   name = strtab + ivna.vna_name;
4119                                   nn += printf ("(%s%-*s",
4120                                                 name,
4121                                                 12 - (int) strlen (name),
4122                                                 ")");
4123                                   break;
4124                                 }
4125
4126                               offset += ivn.vn_next;
4127                             }
4128                           while (ivn.vn_next);
4129                         }
4130                       else if (data [cnt + j] != 0x8001)
4131                         {
4132                           Elf_Internal_Verdef  ivd;
4133                           Elf_External_Verdef  evd;
4134                           unsigned long        offset;
4135
4136                           offset = version_info
4137                             [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
4138
4139                           do
4140                             {
4141                               GET_DATA (offset, evd, "version def");
4142
4143                               ivd.vd_next = BYTE_GET (evd.vd_next);
4144                               ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
4145
4146                               offset += ivd.vd_next;
4147                             }
4148                           while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
4149                                  && ivd.vd_next != 0);
4150
4151                           if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
4152                             {
4153                               Elf_External_Verdaux  evda;
4154                               Elf_Internal_Verdaux  ivda;
4155
4156                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
4157
4158                               GET_DATA (offset - ivd.vd_next + ivd.vd_aux,
4159                                         evda, "version def aux");
4160
4161                               ivda.vda_name = BYTE_GET (evda.vda_name);
4162
4163                               name = strtab + ivda.vda_name;
4164                               nn += printf ("(%s%-*s",
4165                                             name,
4166                                             12 - (int) strlen (name),
4167                                             ")");
4168                             }
4169                         }
4170
4171                       if (nn < 18)
4172                         printf ("%*c", 18 - nn, ' ');
4173                     }
4174
4175                 putchar ('\n');
4176               }
4177
4178             free (data);
4179             free (strtab);
4180             free (symbols);
4181           }
4182           break;
4183
4184         default:
4185           break;
4186         }
4187     }
4188
4189   if (! found)
4190     printf (_("\nNo version information found in this file.\n"));
4191
4192   return 1;
4193 }
4194
4195 static const char *
4196 get_symbol_binding (binding)
4197      unsigned int binding;
4198 {
4199   static char buff [32];
4200
4201   switch (binding)
4202     {
4203     case STB_LOCAL:  return "LOCAL";
4204     case STB_GLOBAL: return "GLOBAL";
4205     case STB_WEAK:   return "WEAK";
4206     default:
4207       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
4208         sprintf (buff, _("<processor specific>: %d"), binding);
4209       else if (binding >= STB_LOOS && binding <= STB_HIOS)
4210         sprintf (buff, _("<OS specific>: %d"), binding);
4211       else
4212         sprintf (buff, _("<unknown>: %d"), binding);
4213       return buff;
4214     }
4215 }
4216
4217 static const char *
4218 get_symbol_type (type)
4219      unsigned int type;
4220 {
4221   static char buff [32];
4222
4223   switch (type)
4224     {
4225     case STT_NOTYPE:   return "NOTYPE";
4226     case STT_OBJECT:   return "OBJECT";
4227     case STT_FUNC:     return "FUNC";
4228     case STT_SECTION:  return "SECTION";
4229     case STT_FILE:     return "FILE";
4230     case STT_COMMON:   return "COMMON";
4231     default:
4232       if (type >= STT_LOPROC && type <= STT_HIPROC)
4233         {
4234           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
4235             return "THUMB_FUNC";
4236
4237           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
4238             return "REGISTER";
4239
4240           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
4241             return "PARISC_MILLI";
4242
4243           sprintf (buff, _("<processor specific>: %d"), type);
4244         }
4245       else if (type >= STT_LOOS && type <= STT_HIOS)
4246         {
4247           if (elf_header.e_machine == EM_PARISC)
4248             {
4249               if (type == STT_HP_OPAQUE)
4250                 return "HP_OPAQUE";
4251               if (type == STT_HP_STUB)
4252                 return "HP_STUB";
4253             }
4254
4255           sprintf (buff, _("<OS specific>: %d"), type);
4256         }
4257       else
4258         sprintf (buff, _("<unknown>: %d"), type);
4259       return buff;
4260     }
4261 }
4262
4263 static const char *
4264 get_symbol_visibility (visibility)
4265      unsigned int visibility;
4266 {
4267   switch (visibility)
4268     {
4269     case STV_DEFAULT:   return "DEFAULT";
4270     case STV_INTERNAL:  return "INTERNAL";
4271     case STV_HIDDEN:    return "HIDDEN";
4272     case STV_PROTECTED: return "PROTECTED";
4273     default: abort ();
4274     }
4275 }
4276
4277 static const char *
4278 get_symbol_index_type (type)
4279      unsigned int type;
4280 {
4281   switch (type)
4282     {
4283     case SHN_UNDEF:  return "UND";
4284     case SHN_ABS:    return "ABS";
4285     case SHN_COMMON: return "COM";
4286     default:
4287       if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4288         return "PRC";
4289       else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
4290         return "RSV";
4291       else if (type >= SHN_LOOS && type <= SHN_HIOS)
4292         return "OS ";
4293       else
4294         {
4295           static char buff [32];
4296
4297           sprintf (buff, "%3d", type);
4298           return buff;
4299         }
4300     }
4301 }
4302
4303 static int *
4304 get_dynamic_data (file, number)
4305      FILE *       file;
4306      unsigned int number;
4307 {
4308   unsigned char * e_data;
4309   int *  i_data;
4310
4311   e_data = (unsigned char *) malloc (number * 4);
4312
4313   if (e_data == NULL)
4314     {
4315       error (_("Out of memory\n"));
4316       return NULL;
4317     }
4318
4319   if (fread (e_data, 4, number, file) != number)
4320     {
4321       error (_("Unable to read in dynamic data\n"));
4322       return NULL;
4323     }
4324
4325   i_data = (int *) malloc (number * sizeof (* i_data));
4326
4327   if (i_data == NULL)
4328     {
4329       error (_("Out of memory\n"));
4330       free (e_data);
4331       return NULL;
4332     }
4333
4334   while (number--)
4335     i_data [number] = byte_get (e_data + number * 4, 4);
4336
4337   free (e_data);
4338
4339   return i_data;
4340 }
4341
4342 /* Dump the symbol table */
4343 static int
4344 process_symbol_table (file)
4345      FILE * file;
4346 {
4347   Elf32_Internal_Shdr *   section;
4348   unsigned char   nb [4];
4349   unsigned char   nc [4];
4350   int    nbuckets = 0;
4351   int    nchains = 0;
4352   int *  buckets = NULL;
4353   int *  chains = NULL;
4354
4355   if (! do_syms && !do_histogram)
4356     return 1;
4357
4358   if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
4359                                 || do_histogram))
4360     {
4361       if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
4362         {
4363           error (_("Unable to seek to start of dynamic information"));
4364           return 0;
4365         }
4366
4367       if (fread (nb, sizeof (nb), 1, file) != 1)
4368         {
4369           error (_("Failed to read in number of buckets\n"));
4370           return 0;
4371         }
4372
4373       if (fread (nc, sizeof (nc), 1, file) != 1)
4374         {
4375           error (_("Failed to read in number of chains\n"));
4376           return 0;
4377         }
4378
4379       nbuckets = byte_get (nb, 4);
4380       nchains  = byte_get (nc, 4);
4381
4382       buckets = get_dynamic_data (file, nbuckets);
4383       chains  = get_dynamic_data (file, nchains);
4384
4385       if (buckets == NULL || chains == NULL)
4386         return 0;
4387     }
4388
4389   if (do_syms
4390       && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
4391     {
4392       int    hn;
4393       int    si;
4394
4395       printf (_("\nSymbol table for image:\n"));
4396       if (is_32bit_elf)
4397         printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
4398       else
4399         printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
4400
4401       for (hn = 0; hn < nbuckets; hn++)
4402         {
4403           if (! buckets [hn])
4404             continue;
4405
4406           for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
4407             {
4408               Elf_Internal_Sym * psym;
4409
4410               psym = dynamic_symbols + si;
4411
4412               printf ("  %3d %3d: ", si, hn);
4413               print_vma (psym->st_value, LONG_HEX);
4414               putchar (' ' );
4415               print_vma (psym->st_size, DEC_5);
4416
4417               printf ("  %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4418               printf (" %6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4419               printf (" %3s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4420               printf (" %3.3s", get_symbol_index_type (psym->st_shndx));
4421               printf (" %s\n", dynamic_strings + psym->st_name);
4422             }
4423         }
4424     }
4425   else if (do_syms && !do_using_dynamic)
4426     {
4427       unsigned int     i;
4428
4429       for (i = 0, section = section_headers;
4430            i < elf_header.e_shnum;
4431            i++, section++)
4432         {
4433           unsigned int          si;
4434           char *                strtab;
4435           Elf_Internal_Sym *    symtab;
4436           Elf_Internal_Sym *    psym;
4437
4438
4439           if (   section->sh_type != SHT_SYMTAB
4440               && section->sh_type != SHT_DYNSYM)
4441             continue;
4442
4443           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4444                   SECTION_NAME (section),
4445                   (unsigned long) (section->sh_size / section->sh_entsize));
4446           if (is_32bit_elf)
4447             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
4448           else
4449             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
4450
4451           symtab = GET_ELF_SYMBOLS (file, section->sh_offset,
4452                                     section->sh_size / section->sh_entsize);
4453           if (symtab == NULL)
4454             continue;
4455
4456           if (section->sh_link == elf_header.e_shstrndx)
4457             strtab = string_table;
4458           else
4459             {
4460               Elf32_Internal_Shdr * string_sec;
4461
4462               string_sec = section_headers + section->sh_link;
4463
4464               GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
4465                               strtab, char *, "string table");
4466             }
4467
4468           for (si = 0, psym = symtab;
4469                si < section->sh_size / section->sh_entsize;
4470                si ++, psym ++)
4471             {
4472               printf ("%6d: ", si);
4473               print_vma (psym->st_value, LONG_HEX);
4474               putchar (' ');
4475               print_vma (psym->st_size, DEC_5);
4476               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4477               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4478               printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4479               printf (" %4s", get_symbol_index_type (psym->st_shndx));
4480               printf (" %s", strtab + psym->st_name);
4481
4482               if (section->sh_type == SHT_DYNSYM &&
4483                   version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
4484                 {
4485                   unsigned char   data[2];
4486                   unsigned short  vers_data;
4487                   unsigned long   offset;
4488                   int             is_nobits;
4489                   int             check_def;
4490
4491                   offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
4492                     - loadaddr;
4493
4494                   GET_DATA (offset + si * sizeof (vers_data), data,
4495                             "version data");
4496
4497                   vers_data = byte_get (data, 2);
4498
4499                   is_nobits = psym->st_shndx < SHN_LORESERVE ?
4500                     (section_headers [psym->st_shndx].sh_type == SHT_NOBITS)
4501                     : 0;
4502
4503                   check_def = (psym->st_shndx != SHN_UNDEF);
4504
4505                   if ((vers_data & 0x8000) || vers_data > 1)
4506                     {
4507                       if (is_nobits || ! check_def)
4508                         {
4509                           Elf_External_Verneed  evn;
4510                           Elf_Internal_Verneed  ivn;
4511                           Elf_Internal_Vernaux  ivna;
4512
4513                           /* We must test both.  */
4514                           offset = version_info
4515                             [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
4516
4517                           do
4518                             {
4519                               unsigned long  vna_off;
4520
4521                               GET_DATA (offset, evn, "version need");
4522
4523                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
4524                               ivn.vn_next = BYTE_GET (evn.vn_next);
4525
4526                               vna_off = offset + ivn.vn_aux;
4527
4528                               do
4529                                 {
4530                                   Elf_External_Vernaux  evna;
4531
4532                                   GET_DATA (vna_off, evna,
4533                                             "version need aux (3)");
4534
4535                                   ivna.vna_other = BYTE_GET (evna.vna_other);
4536                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
4537                                   ivna.vna_name  = BYTE_GET (evna.vna_name);
4538
4539                                   vna_off += ivna.vna_next;
4540                                 }
4541                               while (ivna.vna_other != vers_data
4542                                      && ivna.vna_next != 0);
4543
4544                               if (ivna.vna_other == vers_data)
4545                                 break;
4546
4547                               offset += ivn.vn_next;
4548                             }
4549                           while (ivn.vn_next != 0);
4550
4551                           if (ivna.vna_other == vers_data)
4552                             {
4553                               printf ("@%s (%d)",
4554                                       strtab + ivna.vna_name, ivna.vna_other);
4555                               check_def = 0;
4556                             }
4557                           else if (! is_nobits)
4558                             error (_("bad dynamic symbol"));
4559                           else
4560                             check_def = 1;
4561                         }
4562
4563                       if (check_def)
4564                         {
4565                           if (vers_data != 0x8001)
4566                             {
4567                               Elf_Internal_Verdef     ivd;
4568                               Elf_Internal_Verdaux    ivda;
4569                               Elf_External_Verdaux  evda;
4570                               unsigned long           offset;
4571
4572                               offset =
4573                                 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
4574                                 - loadaddr;
4575
4576                               do
4577                                 {
4578                                   Elf_External_Verdef   evd;
4579
4580                                   GET_DATA (offset, evd, "version def");
4581
4582                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
4583                                   ivd.vd_aux  = BYTE_GET (evd.vd_aux);
4584                                   ivd.vd_next = BYTE_GET (evd.vd_next);
4585
4586                                   offset += ivd.vd_next;
4587                                 }
4588                               while (ivd.vd_ndx != (vers_data & 0x7fff)
4589                                      && ivd.vd_next != 0);
4590
4591                               offset -= ivd.vd_next;
4592                               offset += ivd.vd_aux;
4593
4594                               GET_DATA (offset, evda, "version def aux");
4595
4596                               ivda.vda_name = BYTE_GET (evda.vda_name);
4597
4598                               if (psym->st_name != ivda.vda_name)
4599                                 printf ((vers_data & 0x8000)
4600                                         ? "@%s" : "@@%s",
4601                                         strtab + ivda.vda_name);
4602                             }
4603                         }
4604                     }
4605                 }
4606
4607               putchar ('\n');
4608             }
4609
4610           free (symtab);
4611           if (strtab != string_table)
4612             free (strtab);
4613         }
4614     }
4615   else if (do_syms)
4616     printf
4617       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
4618
4619   if (do_histogram && buckets != NULL)
4620     {
4621       int *lengths;
4622       int *counts;
4623       int hn;
4624       int si;
4625       int maxlength = 0;
4626       int nzero_counts = 0;
4627       int nsyms = 0;
4628
4629       printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
4630               nbuckets);
4631       printf (_(" Length  Number     %% of total  Coverage\n"));
4632
4633       lengths = (int *) calloc (nbuckets, sizeof (int));
4634       if (lengths == NULL)
4635         {
4636           error (_("Out of memory"));
4637           return 0;
4638         }
4639       for (hn = 0; hn < nbuckets; ++hn)
4640         {
4641           if (! buckets [hn])
4642             continue;
4643
4644           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
4645             {
4646               ++ nsyms;
4647               if (maxlength < ++lengths[hn])
4648                 ++ maxlength;
4649             }
4650         }
4651
4652       counts = (int *) calloc (maxlength + 1, sizeof (int));
4653       if (counts == NULL)
4654         {
4655           error (_("Out of memory"));
4656           return 0;
4657         }
4658
4659       for (hn = 0; hn < nbuckets; ++hn)
4660         ++ counts [lengths [hn]];
4661
4662       if (nbuckets > 0)
4663         {
4664           printf ("      0  %-10d (%5.1f%%)\n",
4665                   counts[0], (counts[0] * 100.0) / nbuckets);
4666           for (si = 1; si <= maxlength; ++si)
4667             {
4668               nzero_counts += counts[si] * si;
4669               printf ("%7d  %-10d (%5.1f%%)    %5.1f%%\n",
4670                       si, counts[si], (counts[si] * 100.0) / nbuckets,
4671                       (nzero_counts * 100.0) / nsyms);
4672             }
4673         }
4674
4675       free (counts);
4676       free (lengths);
4677     }
4678
4679   if (buckets != NULL)
4680     {
4681       free (buckets);
4682       free (chains);
4683     }
4684
4685   return 1;
4686 }
4687
4688 static int
4689 process_syminfo (file)
4690      FILE * file ATTRIBUTE_UNUSED;
4691 {
4692   unsigned int i;
4693
4694   if (dynamic_syminfo == NULL
4695       || !do_dynamic)
4696     /* No syminfo, this is ok.  */
4697     return 1;
4698
4699   /* There better should be a dynamic symbol section.  */
4700   if (dynamic_symbols == NULL || dynamic_strings == NULL)
4701     return 0;
4702
4703   if (dynamic_addr)
4704     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
4705             dynamic_syminfo_offset, dynamic_syminfo_nent);
4706
4707   printf (_(" Num: Name                           BoundTo     Flags\n"));
4708   for (i = 0; i < dynamic_syminfo_nent; ++i)
4709     {
4710       unsigned short int flags = dynamic_syminfo[i].si_flags;
4711
4712       printf ("%4d: %-30s ", i,
4713               dynamic_strings + dynamic_symbols[i].st_name);
4714
4715       switch (dynamic_syminfo[i].si_boundto)
4716         {
4717         case SYMINFO_BT_SELF:
4718           fputs ("SELF       ", stdout);
4719           break;
4720         case SYMINFO_BT_PARENT:
4721           fputs ("PARENT     ", stdout);
4722           break;
4723         default:
4724           if (dynamic_syminfo[i].si_boundto > 0
4725               && dynamic_syminfo[i].si_boundto < dynamic_size)
4726             printf ("%-10s ",
4727                     dynamic_strings
4728                     + dynamic_segment[dynamic_syminfo[i].si_boundto].d_un.d_val);
4729           else
4730             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
4731           break;
4732         }
4733
4734       if (flags & SYMINFO_FLG_DIRECT)
4735         printf (" DIRECT");
4736       if (flags & SYMINFO_FLG_PASSTHRU)
4737         printf (" PASSTHRU");
4738       if (flags & SYMINFO_FLG_COPY)
4739         printf (" COPY");
4740       if (flags & SYMINFO_FLG_LAZYLOAD)
4741         printf (" LAZYLOAD");
4742
4743       puts ("");
4744     }
4745
4746   return 1;
4747 }
4748
4749 #ifdef SUPPORT_DISASSEMBLY
4750 static void
4751 disassemble_section (section, file)
4752      Elf32_Internal_Shdr * section;
4753      FILE * file;
4754 {
4755   printf (_("\nAssembly dump of section %s\n"),
4756           SECTION_NAME (section));
4757
4758   /* XXX -- to be done --- XXX */
4759
4760   return 1;
4761 }
4762 #endif
4763
4764 static int
4765 dump_section (section, file)
4766      Elf32_Internal_Shdr * section;
4767      FILE * file;
4768 {
4769   bfd_size_type   bytes;
4770   bfd_vma         addr;
4771   unsigned char * data;
4772   unsigned char * start;
4773
4774   bytes = section->sh_size;
4775
4776   if (bytes == 0)
4777     {
4778       printf (_("\nSection '%s' has no data to dump.\n"),
4779               SECTION_NAME (section));
4780       return 0;
4781     }
4782   else
4783     printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
4784
4785   addr = section->sh_addr;
4786
4787   GET_DATA_ALLOC (section->sh_offset, bytes, start, unsigned char *,
4788                   "section data");
4789
4790   data = start;
4791
4792   while (bytes)
4793     {
4794       int j;
4795       int k;
4796       int lbytes;
4797
4798       lbytes = (bytes > 16 ? 16 : bytes);
4799
4800       printf ("  0x%8.8lx ", (unsigned long) addr);
4801
4802       switch (elf_header.e_ident [EI_DATA])
4803         {
4804         default:
4805         case ELFDATA2LSB:
4806           for (j = 15; j >= 0; j --)
4807             {
4808               if (j < lbytes)
4809                 printf ("%2.2x", data [j]);
4810               else
4811                 printf ("  ");
4812
4813               if (!(j & 0x3))
4814                 printf (" ");
4815             }
4816           break;
4817
4818         case ELFDATA2MSB:
4819           for (j = 0; j < 16; j++)
4820             {
4821               if (j < lbytes)
4822                 printf ("%2.2x", data [j]);
4823               else
4824                 printf ("  ");
4825
4826               if ((j & 3) == 3)
4827                 printf (" ");
4828             }
4829           break;
4830         }
4831
4832       for (j = 0; j < lbytes; j++)
4833         {
4834           k = data [j];
4835           if (k >= ' ' && k < 0x80)
4836             printf ("%c", k);
4837           else
4838             printf (".");
4839         }
4840
4841       putchar ('\n');
4842
4843       data  += lbytes;
4844       addr  += lbytes;
4845       bytes -= lbytes;
4846     }
4847
4848   free (start);
4849
4850   return 1;
4851 }
4852
4853
4854 static unsigned long int
4855 read_leb128 (data, length_return, sign)
4856      unsigned char * data;
4857      int *           length_return;
4858      int             sign;
4859 {
4860   unsigned long int result = 0;
4861   unsigned int      num_read = 0;
4862   int               shift = 0;
4863   unsigned char     byte;
4864
4865   do
4866     {
4867       byte = * data ++;
4868       num_read ++;
4869
4870       result |= (byte & 0x7f) << shift;
4871
4872       shift += 7;
4873
4874     }
4875   while (byte & 0x80);
4876
4877   if (length_return != NULL)
4878     * length_return = num_read;
4879
4880   if (sign && (shift < 32) && (byte & 0x40))
4881     result |= -1 << shift;
4882
4883   return result;
4884 }
4885
4886 typedef struct State_Machine_Registers
4887 {
4888   unsigned long address;
4889   unsigned int  file;
4890   unsigned int  line;
4891   unsigned int  column;
4892   int           is_stmt;
4893   int           basic_block;
4894   int           end_sequence;
4895 /* This variable hold the number of the last entry seen
4896    in the File Table.  */
4897   unsigned int  last_file_entry;
4898 } SMR;
4899
4900 static SMR state_machine_regs;
4901
4902 static void
4903 reset_state_machine (is_stmt)
4904      int is_stmt;
4905 {
4906   state_machine_regs.address = 0;
4907   state_machine_regs.file = 1;
4908   state_machine_regs.line = 1;
4909   state_machine_regs.column = 0;
4910   state_machine_regs.is_stmt = is_stmt;
4911   state_machine_regs.basic_block = 0;
4912   state_machine_regs.end_sequence = 0;
4913   state_machine_regs.last_file_entry = 0;
4914 }
4915
4916 /* Handled an extend line op.  Returns true if this is the end
4917    of sequence.  */
4918 static int
4919 process_extended_line_op (data, is_stmt, pointer_size)
4920      unsigned char * data;
4921      int is_stmt;
4922      int pointer_size;
4923 {
4924   unsigned char   op_code;
4925   int             bytes_read;
4926   unsigned int    len;
4927   unsigned char * name;
4928   unsigned long   adr;
4929
4930   len = read_leb128 (data, & bytes_read, 0);
4931   data += bytes_read;
4932
4933   if (len == 0)
4934     {
4935       warn (_("badly formed extended line op encountered!"));
4936       return bytes_read;
4937     }
4938
4939   len += bytes_read;
4940   op_code = * data ++;
4941
4942   printf (_("  Extended opcode %d: "), op_code);
4943
4944   switch (op_code)
4945     {
4946     case DW_LNE_end_sequence:
4947       printf (_("End of Sequence\n\n"));
4948       reset_state_machine (is_stmt);
4949       break;
4950
4951     case DW_LNE_set_address:
4952       adr = byte_get (data, pointer_size);
4953       printf (_("set Address to 0x%lx\n"), adr);
4954       state_machine_regs.address = adr;
4955       break;
4956
4957     case DW_LNE_define_file:
4958       printf (_("  define new File Table entry\n"));
4959       printf (_("  Entry\tDir\tTime\tSize\tName\n"));
4960
4961       printf (_("   %d\t"), ++ state_machine_regs.last_file_entry);
4962       name = data;
4963       data += strlen ((char *) data) + 1;
4964       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4965       data += bytes_read;
4966       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4967       data += bytes_read;
4968       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4969       printf (_("%s\n\n"), name);
4970       break;
4971
4972     default:
4973       printf (_("UNKNOWN: length %d\n"), len - bytes_read);
4974       break;
4975     }
4976
4977   return len;
4978 }
4979
4980 /* Size of pointers in the .debug_line section.  This information is not
4981    really present in that section.  It's obtained before dumping the debug
4982    sections by doing some pre-scan of the .debug_info section.  */
4983 static int debug_line_pointer_size = 4;
4984
4985 static int
4986 display_debug_lines (section, start, file)
4987      Elf32_Internal_Shdr * section;
4988      unsigned char *       start;
4989      FILE *                file ATTRIBUTE_UNUSED;
4990 {
4991   DWARF2_External_LineInfo * external;
4992   DWARF2_Internal_LineInfo   info;
4993   unsigned char *            standard_opcodes;
4994   unsigned char *            data = start;
4995   unsigned char *            end  = start + section->sh_size;
4996   unsigned char *            end_of_sequence;
4997   int                        i;
4998
4999   printf (_("\nDump of debug contents of section %s:\n\n"),
5000           SECTION_NAME (section));
5001
5002   while (data < end)
5003     {
5004       external = (DWARF2_External_LineInfo *) data;
5005
5006       /* Check the length of the block.  */
5007       info.li_length = BYTE_GET (external->li_length);
5008       if (info.li_length > section->sh_size)
5009         {
5010           warn
5011             (_("The line info appears to be corrupt - the section is too small\n"));
5012           return 0;
5013         }
5014
5015       /* Check its version number.  */
5016       info.li_version = BYTE_GET (external->li_version);
5017       if (info.li_version != 2)
5018         {
5019           warn (_("Only DWARF version 2 line info is currently supported.\n"));
5020           return 0;
5021         }
5022
5023       info.li_prologue_length = BYTE_GET (external->li_prologue_length);
5024       info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
5025       info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
5026       info.li_line_base       = BYTE_GET (external->li_line_base);
5027       info.li_line_range      = BYTE_GET (external->li_line_range);
5028       info.li_opcode_base     = BYTE_GET (external->li_opcode_base);
5029
5030       /* Sign extend the line base field.  */
5031       info.li_line_base <<= 24;
5032       info.li_line_base >>= 24;
5033
5034       printf (_("  Length:                      %ld\n"), info.li_length);
5035       printf (_("  DWARF Version:               %d\n"), info.li_version);
5036       printf (_("  Prolgue Length:              %d\n"), info.li_prologue_length);
5037       printf (_("  Minimum Instruction Length:  %d\n"), info.li_min_insn_length);
5038       printf (_("  Initial value of 'is_stmt':  %d\n"), info.li_default_is_stmt);
5039       printf (_("  Line Base:                   %d\n"), info.li_line_base);
5040       printf (_("  Line Range:                  %d\n"), info.li_line_range);
5041       printf (_("  Opcode Base:                 %d\n"), info.li_opcode_base);
5042
5043       end_of_sequence = data + info.li_length + sizeof (info.li_length);
5044
5045       reset_state_machine (info.li_default_is_stmt);
5046
5047       /* Display the contents of the Opcodes table.  */
5048       standard_opcodes = data + sizeof (* external);
5049
5050       printf (_("\n Opcodes:\n"));
5051
5052       for (i = 1; i < info.li_opcode_base; i++)
5053         printf (_("  Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
5054
5055       /* Display the contents of the Directory table.  */
5056       data = standard_opcodes + info.li_opcode_base - 1;
5057
5058       if (* data == 0)
5059         printf (_("\n The Directory Table is empty.\n"));
5060       else
5061         {
5062           printf (_("\n The Directory Table:\n"));
5063
5064           while (* data != 0)
5065             {
5066               printf (_("  %s\n"), data);
5067
5068               data += strlen ((char *) data) + 1;
5069             }
5070         }
5071
5072       /* Skip the NUL at the end of the table.  */
5073       data ++;
5074
5075       /* Display the contents of the File Name table.  */
5076       if (* data == 0)
5077         printf (_("\n The File Name Table is empty.\n"));
5078       else
5079         {
5080           printf (_("\n The File Name Table:\n"));
5081           printf (_("  Entry\tDir\tTime\tSize\tName\n"));
5082
5083           while (* data != 0)
5084             {
5085               unsigned char * name;
5086               int bytes_read;
5087
5088               printf (_("  %d\t"), ++ state_machine_regs.last_file_entry);
5089               name = data;
5090
5091               data += strlen ((char *) data) + 1;
5092
5093               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5094               data += bytes_read;
5095               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5096               data += bytes_read;
5097               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5098               data += bytes_read;
5099               printf (_("%s\n"), name);
5100             }
5101         }
5102
5103       /* Skip the NUL at the end of the table.  */
5104       data ++;
5105
5106       /* Now display the statements.  */
5107       printf (_("\n Line Number Statements:\n"));
5108
5109
5110       while (data < end_of_sequence)
5111         {
5112           unsigned char op_code;
5113           int           adv;
5114           int           bytes_read;
5115
5116           op_code = * data ++;
5117
5118           switch (op_code)
5119             {
5120             case DW_LNS_extended_op:
5121               data += process_extended_line_op (data, info.li_default_is_stmt,
5122                                                 debug_line_pointer_size);
5123               break;
5124
5125             case DW_LNS_copy:
5126               printf (_("  Copy\n"));
5127               break;
5128
5129             case DW_LNS_advance_pc:
5130               adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
5131               data += bytes_read;
5132               state_machine_regs.address += adv;
5133               printf (_("  Advance PC by %d to %lx\n"), adv,
5134                       state_machine_regs.address);
5135               break;
5136
5137             case DW_LNS_advance_line:
5138               adv = read_leb128 (data, & bytes_read, 1);
5139               data += bytes_read;
5140               state_machine_regs.line += adv;
5141               printf (_("  Advance Line by %d to %d\n"), adv,
5142                       state_machine_regs.line);
5143               break;
5144
5145             case DW_LNS_set_file:
5146               adv = read_leb128 (data, & bytes_read, 0);
5147               data += bytes_read;
5148               printf (_("  Set File Name to entry %d in the File Name Table\n"),
5149                       adv);
5150               state_machine_regs.file = adv;
5151               break;
5152
5153             case DW_LNS_set_column:
5154               adv = read_leb128 (data, & bytes_read, 0);
5155               data += bytes_read;
5156               printf (_("  Set column to %d\n"), adv);
5157               state_machine_regs.column = adv;
5158               break;
5159
5160             case DW_LNS_negate_stmt:
5161               adv = state_machine_regs.is_stmt;
5162               adv = ! adv;
5163               printf (_("  Set is_stmt to %d\n"), adv);
5164               state_machine_regs.is_stmt = adv;
5165               break;
5166
5167             case DW_LNS_set_basic_block:
5168               printf (_("  Set basic block\n"));
5169               state_machine_regs.basic_block = 1;
5170               break;
5171
5172             case DW_LNS_const_add_pc:
5173               adv = (((255 - info.li_opcode_base) / info.li_line_range)
5174                      * info.li_min_insn_length);
5175               state_machine_regs.address += adv;
5176               printf (_("  Advance PC by constant %d to 0x%lx\n"), adv,
5177                       state_machine_regs.address);
5178               break;
5179
5180             case DW_LNS_fixed_advance_pc:
5181               adv = byte_get (data, 2);
5182               data += 2;
5183               state_machine_regs.address += adv;
5184               printf (_("  Advance PC by fixed size amount %d to 0x%lx\n"),
5185                       adv, state_machine_regs.address);
5186               break;
5187
5188             default:
5189               op_code -= info.li_opcode_base;
5190               adv      = (op_code / info.li_line_range) * info.li_min_insn_length;
5191               state_machine_regs.address += adv;
5192               printf (_("  Special opcode %d: advance Address by %d to 0x%lx"),
5193                       op_code, adv, state_machine_regs.address);
5194               adv = (op_code % info.li_line_range) + info.li_line_base;
5195               state_machine_regs.line += adv;
5196               printf (_(" and Line by %d to %d\n"),
5197                       adv, state_machine_regs.line);
5198               break;
5199             }
5200         }
5201       printf ("\n");
5202     }
5203
5204   return 1;
5205 }
5206
5207 static int
5208 display_debug_pubnames (section, start, file)
5209      Elf32_Internal_Shdr * section;
5210      unsigned char *       start;
5211      FILE *                file ATTRIBUTE_UNUSED;
5212 {
5213   DWARF2_External_PubNames * external;
5214   DWARF2_Internal_PubNames   pubnames;
5215   unsigned char *            end;
5216
5217   end = start + section->sh_size;
5218
5219   printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5220
5221   while (start < end)
5222     {
5223       unsigned char * data;
5224       unsigned long   offset;
5225
5226       external = (DWARF2_External_PubNames *) start;
5227
5228       pubnames.pn_length  = BYTE_GET (external->pn_length);
5229       pubnames.pn_version = BYTE_GET (external->pn_version);
5230       pubnames.pn_offset  = BYTE_GET (external->pn_offset);
5231       pubnames.pn_size    = BYTE_GET (external->pn_size);
5232
5233       data   = start + sizeof (* external);
5234       start += pubnames.pn_length + sizeof (external->pn_length);
5235
5236       if (pubnames.pn_version != 2)
5237         {
5238           static int warned = 0;
5239
5240           if (! warned)
5241             {
5242               warn (_("Only DWARF 2 pubnames are currently supported\n"));
5243               warned = 1;
5244             }
5245
5246           continue;
5247         }
5248
5249       printf (_("  Length:                              %ld\n"),
5250               pubnames.pn_length);
5251       printf (_("  Version:                             %d\n"),
5252               pubnames.pn_version);
5253       printf (_("  Offset into .debug_info section:     %ld\n"),
5254               pubnames.pn_offset);
5255       printf (_("  Size of area in .debug_info section: %ld\n"),
5256               pubnames.pn_size);
5257
5258       printf (_("\n    Offset\tName\n"));
5259
5260       do
5261         {
5262           offset = byte_get (data, 4);
5263
5264           if (offset != 0)
5265             {
5266               data += 4;
5267               printf ("    %ld\t\t%s\n", offset, data);
5268               data += strlen ((char *) data) + 1;
5269             }
5270         }
5271       while (offset != 0);
5272     }
5273
5274   printf ("\n");
5275   return 1;
5276 }
5277
5278 static char *
5279 get_TAG_name (tag)
5280      unsigned long tag;
5281 {
5282   switch (tag)
5283     {
5284     case DW_TAG_padding: return "DW_TAG_padding";
5285     case DW_TAG_array_type: return "DW_TAG_array_type";
5286     case DW_TAG_class_type: return "DW_TAG_class_type";
5287     case DW_TAG_entry_point: return "DW_TAG_entry_point";
5288     case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
5289     case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
5290     case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
5291     case DW_TAG_label: return "DW_TAG_label";
5292     case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
5293     case DW_TAG_member: return "DW_TAG_member";
5294     case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
5295     case DW_TAG_reference_type: return "DW_TAG_reference_type";
5296     case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
5297     case DW_TAG_string_type: return "DW_TAG_string_type";
5298     case DW_TAG_structure_type: return "DW_TAG_structure_type";
5299     case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
5300     case DW_TAG_typedef: return "DW_TAG_typedef";
5301     case DW_TAG_union_type: return "DW_TAG_union_type";
5302     case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
5303     case DW_TAG_variant: return "DW_TAG_variant";
5304     case DW_TAG_common_block: return "DW_TAG_common_block";
5305     case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
5306     case DW_TAG_inheritance: return "DW_TAG_inheritance";
5307     case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
5308     case DW_TAG_module: return "DW_TAG_module";
5309     case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
5310     case DW_TAG_set_type: return "DW_TAG_set_type";
5311     case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
5312     case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
5313     case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
5314     case DW_TAG_base_type: return "DW_TAG_base_type";
5315     case DW_TAG_catch_block: return "DW_TAG_catch_block";
5316     case DW_TAG_const_type: return "DW_TAG_const_type";
5317     case DW_TAG_constant: return "DW_TAG_constant";
5318     case DW_TAG_enumerator: return "DW_TAG_enumerator";
5319     case DW_TAG_file_type: return "DW_TAG_file_type";
5320     case DW_TAG_friend: return "DW_TAG_friend";
5321     case DW_TAG_namelist: return "DW_TAG_namelist";
5322     case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
5323     case DW_TAG_packed_type: return "DW_TAG_packed_type";
5324     case DW_TAG_subprogram: return "DW_TAG_subprogram";
5325     case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
5326     case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
5327     case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
5328     case DW_TAG_try_block: return "DW_TAG_try_block";
5329     case DW_TAG_variant_part: return "DW_TAG_variant_part";
5330     case DW_TAG_variable: return "DW_TAG_variable";
5331     case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
5332     case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
5333     case DW_TAG_format_label: return "DW_TAG_format_label";
5334     case DW_TAG_function_template: return "DW_TAG_function_template";
5335     case DW_TAG_class_template: return "DW_TAG_class_template";
5336     default:
5337       {
5338         static char buffer [100];
5339
5340         sprintf (buffer, _("Unknown TAG value: %lx"), tag);
5341         return buffer;
5342       }
5343     }
5344 }
5345
5346 static char *
5347 get_AT_name (attribute)
5348      unsigned long attribute;
5349 {
5350   switch (attribute)
5351     {
5352     case DW_AT_sibling: return "DW_AT_sibling";
5353     case DW_AT_location: return "DW_AT_location";
5354     case DW_AT_name: return "DW_AT_name";
5355     case DW_AT_ordering: return "DW_AT_ordering";
5356     case DW_AT_subscr_data: return "DW_AT_subscr_data";
5357     case DW_AT_byte_size: return "DW_AT_byte_size";
5358     case DW_AT_bit_offset: return "DW_AT_bit_offset";
5359     case DW_AT_bit_size: return "DW_AT_bit_size";
5360     case DW_AT_element_list: return "DW_AT_element_list";
5361     case DW_AT_stmt_list: return "DW_AT_stmt_list";
5362     case DW_AT_low_pc: return "DW_AT_low_pc";
5363     case DW_AT_high_pc: return "DW_AT_high_pc";
5364     case DW_AT_language: return "DW_AT_language";
5365     case DW_AT_member: return "DW_AT_member";
5366     case DW_AT_discr: return "DW_AT_discr";
5367     case DW_AT_discr_value: return "DW_AT_discr_value";
5368     case DW_AT_visibility: return "DW_AT_visibility";
5369     case DW_AT_import: return "DW_AT_import";
5370     case DW_AT_string_length: return "DW_AT_string_length";
5371     case DW_AT_common_reference: return "DW_AT_common_reference";
5372     case DW_AT_comp_dir: return "DW_AT_comp_dir";
5373     case DW_AT_const_value: return "DW_AT_const_value";
5374     case DW_AT_containing_type: return "DW_AT_containing_type";
5375     case DW_AT_default_value: return "DW_AT_default_value";
5376     case DW_AT_inline: return "DW_AT_inline";
5377     case DW_AT_is_optional: return "DW_AT_is_optional";
5378     case DW_AT_lower_bound: return "DW_AT_lower_bound";
5379     case DW_AT_producer: return "DW_AT_producer";
5380     case DW_AT_prototyped: return "DW_AT_prototyped";
5381     case DW_AT_return_addr: return "DW_AT_return_addr";
5382     case DW_AT_start_scope: return "DW_AT_start_scope";
5383     case DW_AT_stride_size: return "DW_AT_stride_size";
5384     case DW_AT_upper_bound: return "DW_AT_upper_bound";
5385     case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
5386     case DW_AT_accessibility: return "DW_AT_accessibility";
5387     case DW_AT_address_class: return "DW_AT_address_class";
5388     case DW_AT_artificial: return "DW_AT_artificial";
5389     case DW_AT_base_types: return "DW_AT_base_types";
5390     case DW_AT_calling_convention: return "DW_AT_calling_convention";
5391     case DW_AT_count: return "DW_AT_count";
5392     case DW_AT_data_member_location: return "DW_AT_data_member_location";
5393     case DW_AT_decl_column: return "DW_AT_decl_column";
5394     case DW_AT_decl_file: return "DW_AT_decl_file";
5395     case DW_AT_decl_line: return "DW_AT_decl_line";
5396     case DW_AT_declaration: return "DW_AT_declaration";
5397     case DW_AT_discr_list: return "DW_AT_discr_list";
5398     case DW_AT_encoding: return "DW_AT_encoding";
5399     case DW_AT_external: return "DW_AT_external";
5400     case DW_AT_frame_base: return "DW_AT_frame_base";
5401     case DW_AT_friend: return "DW_AT_friend";
5402     case DW_AT_identifier_case: return "DW_AT_identifier_case";
5403     case DW_AT_macro_info: return "DW_AT_macro_info";
5404     case DW_AT_namelist_items: return "DW_AT_namelist_items";
5405     case DW_AT_priority: return "DW_AT_priority";
5406     case DW_AT_segment: return "DW_AT_segment";
5407     case DW_AT_specification: return "DW_AT_specification";
5408     case DW_AT_static_link: return "DW_AT_static_link";
5409     case DW_AT_type: return "DW_AT_type";
5410     case DW_AT_use_location: return "DW_AT_use_location";
5411     case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
5412     case DW_AT_virtuality: return "DW_AT_virtuality";
5413     case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
5414     case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
5415     case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
5416     case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
5417     case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
5418     case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
5419     case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
5420     case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
5421     case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
5422     case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
5423     case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
5424     case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
5425     case DW_AT_sf_names: return "DW_AT_sf_names";
5426     case DW_AT_src_info: return "DW_AT_src_info";
5427     case DW_AT_mac_info: return "DW_AT_mac_info";
5428     case DW_AT_src_coords: return "DW_AT_src_coords";
5429     case DW_AT_body_begin: return "DW_AT_body_begin";
5430     case DW_AT_body_end: return "DW_AT_body_end";
5431     default:
5432       {
5433         static char buffer [100];
5434
5435         sprintf (buffer, _("Unknown AT value: %lx"), attribute);
5436         return buffer;
5437       }
5438     }
5439 }
5440
5441 static char *
5442 get_FORM_name (form)
5443      unsigned long form;
5444 {
5445   switch (form)
5446     {
5447     case DW_FORM_addr: return "DW_FORM_addr";
5448     case DW_FORM_block2: return "DW_FORM_block2";
5449     case DW_FORM_block4: return "DW_FORM_block4";
5450     case DW_FORM_data2: return "DW_FORM_data2";
5451     case DW_FORM_data4: return "DW_FORM_data4";
5452     case DW_FORM_data8: return "DW_FORM_data8";
5453     case DW_FORM_string: return "DW_FORM_string";
5454     case DW_FORM_block: return "DW_FORM_block";
5455     case DW_FORM_block1: return "DW_FORM_block1";
5456     case DW_FORM_data1: return "DW_FORM_data1";
5457     case DW_FORM_flag: return "DW_FORM_flag";
5458     case DW_FORM_sdata: return "DW_FORM_sdata";
5459     case DW_FORM_strp: return "DW_FORM_strp";
5460     case DW_FORM_udata: return "DW_FORM_udata";
5461     case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
5462     case DW_FORM_ref1: return "DW_FORM_ref1";
5463     case DW_FORM_ref2: return "DW_FORM_ref2";
5464     case DW_FORM_ref4: return "DW_FORM_ref4";
5465     case DW_FORM_ref8: return "DW_FORM_ref8";
5466     case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
5467     case DW_FORM_indirect: return "DW_FORM_indirect";
5468     default:
5469       {
5470         static char buffer [100];
5471
5472         sprintf (buffer, _("Unknown FORM value: %lx"), form);
5473         return buffer;
5474       }
5475     }
5476 }
5477
5478 /* FIXME:  There are better and more effiecint ways to handle
5479    these structures.  For now though, I just want something that
5480    is simple to implement.  */
5481 typedef struct abbrev_attr
5482 {
5483   unsigned long        attribute;
5484   unsigned long        form;
5485   struct abbrev_attr * next;
5486 }
5487 abbrev_attr;
5488
5489 typedef struct abbrev_entry
5490 {
5491   unsigned long          entry;
5492   unsigned long          tag;
5493   int                    children;
5494   struct abbrev_attr *   first_attr;
5495   struct abbrev_attr *   last_attr;
5496   struct abbrev_entry *  next;
5497 }
5498 abbrev_entry;
5499
5500 static abbrev_entry * first_abbrev = NULL;
5501 static abbrev_entry * last_abbrev = NULL;
5502
5503 static void
5504 free_abbrevs PARAMS ((void))
5505 {
5506   abbrev_entry * abbrev;
5507
5508   for (abbrev = first_abbrev; abbrev;)
5509     {
5510       abbrev_entry * next = abbrev->next;
5511       abbrev_attr  * attr;
5512
5513       for (attr = abbrev->first_attr; attr;)
5514         {
5515           abbrev_attr * next = attr->next;
5516
5517           free (attr);
5518           attr = next;
5519         }
5520
5521       free (abbrev);
5522       abbrev = next;
5523     }
5524
5525   last_abbrev = first_abbrev = NULL;
5526 }
5527
5528 static void
5529 add_abbrev (number, tag, children)
5530      unsigned long number;
5531      unsigned long tag;
5532      int           children;
5533 {
5534   abbrev_entry * entry;
5535
5536   entry = (abbrev_entry *) malloc (sizeof (* entry));
5537
5538   if (entry == NULL)
5539     /* ugg */
5540     return;
5541
5542   entry->entry      = number;
5543   entry->tag        = tag;
5544   entry->children   = children;
5545   entry->first_attr = NULL;
5546   entry->last_attr  = NULL;
5547   entry->next       = NULL;
5548
5549   if (first_abbrev == NULL)
5550     first_abbrev = entry;
5551   else
5552     last_abbrev->next = entry;
5553
5554   last_abbrev = entry;
5555 }
5556
5557 static void
5558 add_abbrev_attr (attribute, form)
5559      unsigned long attribute;
5560      unsigned long form;
5561 {
5562   abbrev_attr * attr;
5563
5564   attr = (abbrev_attr *) malloc (sizeof (* attr));
5565
5566   if (attr == NULL)
5567     /* ugg */
5568     return;
5569
5570   attr->attribute = attribute;
5571   attr->form      = form;
5572   attr->next      = NULL;
5573
5574   if (last_abbrev->first_attr == NULL)
5575     last_abbrev->first_attr = attr;
5576   else
5577     last_abbrev->last_attr->next = attr;
5578
5579   last_abbrev->last_attr = attr;
5580 }
5581
5582 /* Processes the (partial) contents of a .debug_abbrev section.
5583    Returns NULL if the end of the section was encountered.
5584    Returns the address after the last byte read if the end of
5585    an abbreviation set was found.  */
5586
5587 static unsigned char *
5588 process_abbrev_section (start, end)
5589      unsigned char * start;
5590      unsigned char * end;
5591 {
5592   if (first_abbrev != NULL)
5593     return NULL;
5594
5595   while (start < end)
5596     {
5597       int           bytes_read;
5598       unsigned long entry;
5599       unsigned long tag;
5600       unsigned long attribute;
5601       int           children;
5602
5603       entry = read_leb128 (start, & bytes_read, 0);
5604       start += bytes_read;
5605
5606       /* A single zero is supposed to end the section according
5607          to the standard.  If there's more, then signal that to
5608          the caller.  */
5609       if (entry == 0)
5610         return start == end ? NULL : start;
5611
5612       tag = read_leb128 (start, & bytes_read, 0);
5613       start += bytes_read;
5614
5615       children = * start ++;
5616
5617       add_abbrev (entry, tag, children);
5618
5619       do
5620         {
5621           unsigned long form;
5622
5623           attribute = read_leb128 (start, & bytes_read, 0);
5624           start += bytes_read;
5625
5626           form = read_leb128 (start, & bytes_read, 0);
5627           start += bytes_read;
5628
5629           if (attribute != 0)
5630             add_abbrev_attr (attribute, form);
5631         }
5632       while (attribute != 0);
5633     }
5634
5635   return NULL;
5636 }
5637
5638
5639 static int
5640 display_debug_abbrev (section, start, file)
5641      Elf32_Internal_Shdr * section;
5642      unsigned char *       start;
5643      FILE *                file ATTRIBUTE_UNUSED;
5644 {
5645   abbrev_entry * entry;
5646   unsigned char * end = start + section->sh_size;
5647
5648   printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5649
5650   do
5651     {
5652       start = process_abbrev_section (start, end);
5653
5654       printf (_("  Number TAG\n"));
5655
5656       for (entry = first_abbrev; entry; entry = entry->next)
5657         {
5658           abbrev_attr * attr;
5659
5660           printf (_("   %ld      %s    [%s]\n"),
5661                   entry->entry,
5662                   get_TAG_name (entry->tag),
5663                   entry->children ? _("has children") : _("no children"));
5664
5665           for (attr = entry->first_attr; attr; attr = attr->next)
5666             {
5667               printf (_("    %-18s %s\n"),
5668                       get_AT_name (attr->attribute),
5669                       get_FORM_name (attr->form));
5670             }
5671         }
5672     }
5673   while (start);
5674
5675   printf ("\n");
5676
5677   return 1;
5678 }
5679
5680
5681 static unsigned char *
5682 display_block (data, length)
5683      unsigned char * data;
5684      unsigned long   length;
5685 {
5686   printf (_(" %lu byte block: "), length);
5687
5688   while (length --)
5689     printf ("%lx ", (unsigned long) byte_get (data ++, 1));
5690
5691   return data;
5692 }
5693
5694 static void
5695 decode_location_expression (data, pointer_size, length)
5696      unsigned char * data;
5697      unsigned int    pointer_size;
5698      unsigned long length;
5699 {
5700   unsigned op;
5701   int           bytes_read;
5702   unsigned long uvalue;
5703   unsigned char *end = data + length;
5704
5705   while (data < end)
5706     {
5707       op = * data ++;
5708
5709       switch (op)
5710         {
5711         case DW_OP_addr:
5712           printf ("DW_OP_addr: %lx",
5713                   (unsigned long) byte_get (data, pointer_size));
5714           data += pointer_size;
5715           break;
5716         case DW_OP_deref:
5717           printf ("DW_OP_deref");
5718           break;
5719         case DW_OP_const1u:
5720           printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
5721           break;
5722         case DW_OP_const1s:
5723           printf ("DW_OP_const1s: %ld", (long) byte_get (data++, 1));
5724           break;
5725         case DW_OP_const2u:
5726           printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
5727           data += 2;
5728           break;
5729         case DW_OP_const2s:
5730           printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
5731           data += 2;
5732           break;
5733         case DW_OP_const4u:
5734           printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
5735           data += 4;
5736           break;
5737         case DW_OP_const4s:
5738           printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
5739           data += 4;
5740           break;
5741         case DW_OP_const8u:
5742           printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
5743                   (unsigned long) byte_get (data + 4, 4));
5744           data += 8;
5745           break;
5746         case DW_OP_const8s:
5747           printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
5748                   (long) byte_get (data + 4, 4));
5749           data += 8;
5750           break;
5751         case DW_OP_constu:
5752           printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
5753           data += bytes_read;
5754           break;
5755         case DW_OP_consts:
5756           printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
5757           data += bytes_read;
5758           break;
5759         case DW_OP_dup:
5760           printf ("DW_OP_dup");
5761           break;
5762         case DW_OP_drop:
5763           printf ("DW_OP_drop");
5764           break;
5765         case DW_OP_over:
5766           printf ("DW_OP_over");
5767           break;
5768         case DW_OP_pick:
5769           printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
5770           break;
5771         case DW_OP_swap:
5772           printf ("DW_OP_swap");
5773           break;
5774         case DW_OP_rot:
5775           printf ("DW_OP_rot");
5776           break;
5777         case DW_OP_xderef:
5778           printf ("DW_OP_xderef");
5779           break;
5780         case DW_OP_abs:
5781           printf ("DW_OP_abs");
5782           break;
5783         case DW_OP_and:
5784           printf ("DW_OP_and");
5785           break;
5786         case DW_OP_div:
5787           printf ("DW_OP_div");
5788           break;
5789         case DW_OP_minus:
5790           printf ("DW_OP_minus");
5791           break;
5792         case DW_OP_mod:
5793           printf ("DW_OP_mod");
5794           break;
5795         case DW_OP_mul:
5796           printf ("DW_OP_mul");
5797           break;
5798         case DW_OP_neg:
5799           printf ("DW_OP_neg");
5800           break;
5801         case DW_OP_not:
5802           printf ("DW_OP_not");
5803           break;
5804         case DW_OP_or:
5805           printf ("DW_OP_or");
5806           break;
5807         case DW_OP_plus:
5808           printf ("DW_OP_plus");
5809           break;
5810         case DW_OP_plus_uconst:
5811           printf ("DW_OP_plus_uconst: %lu",
5812                   read_leb128 (data, &bytes_read, 0));
5813           data += bytes_read;
5814           break;
5815         case DW_OP_shl:
5816           printf ("DW_OP_shl");
5817           break;
5818         case DW_OP_shr:
5819           printf ("DW_OP_shr");
5820           break;
5821         case DW_OP_shra:
5822           printf ("DW_OP_shra");
5823           break;
5824         case DW_OP_xor:
5825           printf ("DW_OP_xor");
5826           break;
5827         case DW_OP_bra:
5828           printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
5829           data += 2;
5830           break;
5831         case DW_OP_eq:
5832           printf ("DW_OP_eq");
5833           break;
5834         case DW_OP_ge:
5835           printf ("DW_OP_ge");
5836           break;
5837         case DW_OP_gt:
5838           printf ("DW_OP_gt");
5839           break;
5840         case DW_OP_le:
5841           printf ("DW_OP_le");
5842           break;
5843         case DW_OP_lt:
5844           printf ("DW_OP_lt");
5845           break;
5846         case DW_OP_ne:
5847           printf ("DW_OP_ne");
5848           break;
5849         case DW_OP_skip:
5850           printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
5851           data += 2;
5852           break;
5853
5854         case DW_OP_lit0:
5855         case DW_OP_lit1:
5856         case DW_OP_lit2:
5857         case DW_OP_lit3:
5858         case DW_OP_lit4:
5859         case DW_OP_lit5:
5860         case DW_OP_lit6:
5861         case DW_OP_lit7:
5862         case DW_OP_lit8:
5863         case DW_OP_lit9:
5864         case DW_OP_lit10:
5865         case DW_OP_lit11:
5866         case DW_OP_lit12:
5867         case DW_OP_lit13:
5868         case DW_OP_lit14:
5869         case DW_OP_lit15:
5870         case DW_OP_lit16:
5871         case DW_OP_lit17:
5872         case DW_OP_lit18:
5873         case DW_OP_lit19:
5874         case DW_OP_lit20:
5875         case DW_OP_lit21:
5876         case DW_OP_lit22:
5877         case DW_OP_lit23:
5878         case DW_OP_lit24:
5879         case DW_OP_lit25:
5880         case DW_OP_lit26:
5881         case DW_OP_lit27:
5882         case DW_OP_lit28:
5883         case DW_OP_lit29:
5884         case DW_OP_lit30:
5885         case DW_OP_lit31:
5886           printf ("DW_OP_lit%d", op - DW_OP_lit0);
5887           break;
5888
5889         case DW_OP_reg0:
5890         case DW_OP_reg1:
5891         case DW_OP_reg2:
5892         case DW_OP_reg3:
5893         case DW_OP_reg4:
5894         case DW_OP_reg5:
5895         case DW_OP_reg6:
5896         case DW_OP_reg7:
5897         case DW_OP_reg8:
5898         case DW_OP_reg9:
5899         case DW_OP_reg10:
5900         case DW_OP_reg11:
5901         case DW_OP_reg12:
5902         case DW_OP_reg13:
5903         case DW_OP_reg14:
5904         case DW_OP_reg15:
5905         case DW_OP_reg16:
5906         case DW_OP_reg17:
5907         case DW_OP_reg18:
5908         case DW_OP_reg19:
5909         case DW_OP_reg20:
5910         case DW_OP_reg21:
5911         case DW_OP_reg22:
5912         case DW_OP_reg23:
5913         case DW_OP_reg24:
5914         case DW_OP_reg25:
5915         case DW_OP_reg26:
5916         case DW_OP_reg27:
5917         case DW_OP_reg28:
5918         case DW_OP_reg29:
5919         case DW_OP_reg30:
5920         case DW_OP_reg31:
5921           printf ("DW_OP_reg%d", op - DW_OP_reg0);
5922           break;
5923
5924         case DW_OP_breg0:
5925         case DW_OP_breg1:
5926         case DW_OP_breg2:
5927         case DW_OP_breg3:
5928         case DW_OP_breg4:
5929         case DW_OP_breg5:
5930         case DW_OP_breg6:
5931         case DW_OP_breg7:
5932         case DW_OP_breg8:
5933         case DW_OP_breg9:
5934         case DW_OP_breg10:
5935         case DW_OP_breg11:
5936         case DW_OP_breg12:
5937         case DW_OP_breg13:
5938         case DW_OP_breg14:
5939         case DW_OP_breg15:
5940         case DW_OP_breg16:
5941         case DW_OP_breg17:
5942         case DW_OP_breg18:
5943         case DW_OP_breg19:
5944         case DW_OP_breg20:
5945         case DW_OP_breg21:
5946         case DW_OP_breg22:
5947         case DW_OP_breg23:
5948         case DW_OP_breg24:
5949         case DW_OP_breg25:
5950         case DW_OP_breg26:
5951         case DW_OP_breg27:
5952         case DW_OP_breg28:
5953         case DW_OP_breg29:
5954         case DW_OP_breg30:
5955         case DW_OP_breg31:
5956           printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
5957                   read_leb128 (data, &bytes_read, 1));
5958           data += bytes_read;
5959           break;
5960
5961         case DW_OP_regx:
5962           printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
5963           data += bytes_read;
5964           break;
5965         case DW_OP_fbreg:
5966           printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
5967           data += bytes_read;
5968           break;
5969         case DW_OP_bregx:
5970           uvalue = read_leb128 (data, &bytes_read, 0);
5971           data += bytes_read;
5972           printf ("DW_OP_bregx: %lu %ld", uvalue,
5973                   read_leb128 (data, &bytes_read, 1));
5974           data += bytes_read;
5975           break;
5976         case DW_OP_piece:
5977           printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
5978           data += bytes_read;
5979           break;
5980         case DW_OP_deref_size:
5981           printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
5982           break;
5983         case DW_OP_xderef_size:
5984           printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
5985           break;
5986         case DW_OP_nop:
5987           printf ("DW_OP_nop");
5988           break;
5989
5990         default:
5991           if (op >= DW_OP_lo_user
5992               && op <= DW_OP_hi_user)
5993             printf (_("(User defined location op)"));
5994           else
5995             printf (_("(Unknown location op)"));
5996           /* No way to tell where the next op is, so just bail.  */
5997           return;
5998         }
5999     }
6000 }
6001
6002
6003 static unsigned char *
6004 read_and_display_attr (attribute, form, data, cu_offset, pointer_size)
6005      unsigned long   attribute;
6006      unsigned long   form;
6007      unsigned char * data;
6008      unsigned long   cu_offset;
6009      unsigned long   pointer_size;
6010 {
6011   unsigned long   uvalue = 0;
6012   unsigned char * block_start = NULL;
6013   int             bytes_read;
6014
6015   printf ("     %-18s:", get_AT_name (attribute));
6016
6017   switch (form)
6018     {
6019     default:
6020       break;
6021
6022     case DW_FORM_ref_addr:
6023     case DW_FORM_addr:
6024       uvalue = byte_get (data, pointer_size);
6025       data += pointer_size;
6026       break;
6027
6028     case DW_FORM_ref1:
6029     case DW_FORM_flag:
6030     case DW_FORM_data1:
6031       uvalue = byte_get (data ++, 1);
6032       break;
6033
6034     case DW_FORM_ref2:
6035     case DW_FORM_data2:
6036       uvalue = byte_get (data, 2);
6037       data += 2;
6038       break;
6039
6040     case DW_FORM_ref4:
6041     case DW_FORM_data4:
6042       uvalue = byte_get (data, 4);
6043       data += 4;
6044       break;
6045
6046     case DW_FORM_sdata:
6047       uvalue = read_leb128 (data, & bytes_read, 1);
6048       data += bytes_read;
6049       break;
6050
6051     case DW_FORM_ref_udata:
6052     case DW_FORM_udata:
6053       uvalue = read_leb128 (data, & bytes_read, 0);
6054       data += bytes_read;
6055       break;
6056     }
6057
6058   switch (form)
6059     {
6060     case DW_FORM_ref_addr:
6061       printf (" <#%lx>", uvalue);
6062       break;
6063
6064     case DW_FORM_ref1:
6065     case DW_FORM_ref2:
6066     case DW_FORM_ref4:
6067     case DW_FORM_ref_udata:
6068       printf (" <%lx>", uvalue + cu_offset);
6069       break;
6070
6071     case DW_FORM_addr:
6072       printf (" %#lx", uvalue);
6073
6074     case DW_FORM_flag:
6075     case DW_FORM_data1:
6076     case DW_FORM_data2:
6077     case DW_FORM_data4:
6078     case DW_FORM_sdata:
6079     case DW_FORM_udata:
6080       printf (" %ld", uvalue);
6081       break;
6082
6083     case DW_FORM_ref8:
6084     case DW_FORM_data8:
6085       uvalue = byte_get (data, 4);
6086       printf (" %lx", uvalue);
6087       printf (" %lx", (unsigned long) byte_get (data + 4, 4));
6088       data += 8;
6089       break;
6090
6091     case DW_FORM_string:
6092       printf (" %s", data);
6093       data += strlen ((char *) data) + 1;
6094       break;
6095
6096     case DW_FORM_block:
6097       uvalue = read_leb128 (data, & bytes_read, 0);
6098       block_start = data + bytes_read;
6099       data = display_block (block_start, uvalue);
6100       break;
6101
6102     case DW_FORM_block1:
6103       uvalue = byte_get (data, 1);
6104       block_start = data + 1;
6105       data = display_block (block_start, uvalue);
6106       break;
6107
6108     case DW_FORM_block2:
6109       uvalue = byte_get (data, 2);
6110       block_start = data + 2;
6111       data = display_block (block_start, uvalue);
6112       break;
6113
6114     case DW_FORM_block4:
6115       uvalue = byte_get (data, 4);
6116       block_start = data + 4;
6117       data = display_block (block_start, uvalue);
6118       break;
6119
6120     case DW_FORM_strp:
6121     case DW_FORM_indirect:
6122       warn (_("Unable to handle FORM: %d"), form);
6123       break;
6124
6125     default:
6126       warn (_("Unrecognised form: %d"), form);
6127       break;
6128     }
6129
6130   /* For some attributes we can display futher information.  */
6131
6132   printf ("\t");
6133
6134   switch (attribute)
6135     {
6136     case DW_AT_inline:
6137       switch (uvalue)
6138         {
6139         case DW_INL_not_inlined:          printf (_("(not inlined)")); break;
6140         case DW_INL_inlined:              printf (_("(inlined)")); break;
6141         case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
6142         case DW_INL_declared_inlined:     printf (_("(declared as inline and inlined)")); break;
6143         default: printf (_("  (Unknown inline attribute value: %lx)"), uvalue); break;
6144         }
6145       break;
6146
6147     case DW_AT_language:
6148       switch (uvalue)
6149         {
6150         case DW_LANG_C:              printf ("(non-ANSI C)"); break;
6151         case DW_LANG_C89:            printf ("(ANSI C)"); break;
6152         case DW_LANG_C_plus_plus:    printf ("(C++)"); break;
6153         case DW_LANG_Fortran77:      printf ("(FORTRAN 77)"); break;
6154         case DW_LANG_Fortran90:      printf ("(Fortran 90)"); break;
6155         case DW_LANG_Modula2:        printf ("(Modula 2)"); break;
6156         case DW_LANG_Pascal83:       printf ("(ANSI Pascal)"); break;
6157         case DW_LANG_Ada83:          printf ("(Ada)"); break;
6158         case DW_LANG_Cobol74:        printf ("(Cobol 74)"); break;
6159         case DW_LANG_Cobol85:        printf ("(Cobol 85)"); break;
6160         case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
6161         default:                     printf ("(Unknown: %lx)", uvalue); break;
6162         }
6163       break;
6164
6165     case DW_AT_encoding:
6166       switch (uvalue)
6167         {
6168         case DW_ATE_void:            printf ("(void)"); break;
6169         case DW_ATE_address:         printf ("(machine address)"); break;
6170         case DW_ATE_boolean:         printf ("(boolean)"); break;
6171         case DW_ATE_complex_float:   printf ("(complex float)"); break;
6172         case DW_ATE_float:           printf ("(float)"); break;
6173         case DW_ATE_signed:          printf ("(signed)"); break;
6174         case DW_ATE_signed_char:     printf ("(signed char)"); break;
6175         case DW_ATE_unsigned:        printf ("(unsigned)"); break;
6176         case DW_ATE_unsigned_char:   printf ("(unsigned char)"); break;
6177         default:
6178           if (uvalue >= DW_ATE_lo_user
6179               && uvalue <= DW_ATE_hi_user)
6180             printf ("(user defined type)");
6181           else
6182             printf ("(unknown type)");
6183           break;
6184         }
6185       break;
6186
6187     case DW_AT_accessibility:
6188       switch (uvalue)
6189         {
6190         case DW_ACCESS_public:          printf ("(public)"); break;
6191         case DW_ACCESS_protected:       printf ("(protected)"); break;
6192         case DW_ACCESS_private:         printf ("(private)"); break;
6193         default:                        printf ("(unknown accessibility)"); break;
6194         }
6195       break;
6196
6197     case DW_AT_visibility:
6198       switch (uvalue)
6199         {
6200         case DW_VIS_local:      printf ("(local)"); break;
6201         case DW_VIS_exported:   printf ("(exported)"); break;
6202         case DW_VIS_qualified:  printf ("(qualified)"); break;
6203         default:                printf ("(unknown visibility)"); break;
6204         }
6205       break;
6206
6207     case DW_AT_virtuality:
6208       switch (uvalue)
6209         {
6210         case DW_VIRTUALITY_none:        printf ("(none)"); break;
6211         case DW_VIRTUALITY_virtual:     printf ("(virtual)"); break;
6212         case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
6213         default:                        printf ("(unknown virtuality)"); break;
6214         }
6215       break;
6216
6217     case DW_AT_identifier_case:
6218       switch (uvalue)
6219         {
6220         case DW_ID_case_sensitive:      printf ("(case_sensitive)"); break;
6221         case DW_ID_up_case:             printf ("(up_case)"); break;
6222         case DW_ID_down_case:           printf ("(down_case)"); break;
6223         case DW_ID_case_insensitive:    printf ("(case_insensitive)"); break;
6224         default:                        printf ("(unknown case)"); break;
6225         }
6226       break;
6227
6228     case DW_AT_calling_convention:
6229       switch (uvalue)
6230         {
6231         case DW_CC_normal:      printf ("(normal)"); break;
6232         case DW_CC_program:     printf ("(program)"); break;
6233         case DW_CC_nocall:      printf ("(nocall)"); break;
6234         default:
6235           if (uvalue >= DW_CC_lo_user
6236               && uvalue <= DW_CC_hi_user)
6237             printf ("(user defined)");
6238           else
6239             printf ("(unknown convention)");
6240         }
6241       break;
6242
6243     case DW_AT_frame_base:
6244     case DW_AT_location:
6245     case DW_AT_data_member_location:
6246     case DW_AT_vtable_elem_location:
6247       if (block_start)
6248         {
6249           printf ("(");
6250           decode_location_expression (block_start, pointer_size, uvalue);
6251           printf (")");
6252         }
6253       break;
6254
6255     default:
6256       break;
6257     }
6258
6259   printf ("\n");
6260   return data;
6261 }
6262
6263 static int
6264 display_debug_info (section, start, file)
6265      Elf32_Internal_Shdr * section;
6266      unsigned char *       start;
6267      FILE *                file;
6268 {
6269   unsigned char * end = start + section->sh_size;
6270   unsigned char * section_begin = start;
6271
6272   printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6273
6274   while (start < end)
6275     {
6276       DWARF2_External_CompUnit * external;
6277       DWARF2_Internal_CompUnit   compunit;
6278       unsigned char *            tags;
6279       int                        i;
6280       int                        level;
6281       unsigned long              cu_offset;
6282
6283       external = (DWARF2_External_CompUnit *) start;
6284
6285       compunit.cu_length        = BYTE_GET (external->cu_length);
6286       compunit.cu_version       = BYTE_GET (external->cu_version);
6287       compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
6288       compunit.cu_pointer_size  = BYTE_GET (external->cu_pointer_size);
6289
6290       tags = start + sizeof (* external);
6291       cu_offset = start - section_begin;
6292       start += compunit.cu_length + sizeof (external->cu_length);
6293
6294       if (compunit.cu_version != 2)
6295         {
6296           warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6297           continue;
6298         }
6299
6300       printf (_("  Compilation Unit:\n"));
6301       printf (_("   Length:        %ld\n"), compunit.cu_length);
6302       printf (_("   Version:       %d\n"), compunit.cu_version);
6303       printf (_("   Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
6304       printf (_("   Pointer Size:  %d\n"), compunit.cu_pointer_size);
6305
6306       if (first_abbrev != NULL)
6307         free_abbrevs ();
6308
6309       /* Read in the abbrevs used by this compilation unit.  */
6310
6311       {
6312         Elf32_Internal_Shdr * sec;
6313         unsigned char *       begin;
6314
6315         /* Locate the .debug_abbrev section and process it.  */
6316         for (i = 0, sec = section_headers;
6317              i < elf_header.e_shnum;
6318              i ++, sec ++)
6319           if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
6320             break;
6321
6322         if (i == -1 || sec->sh_size == 0)
6323           {
6324             warn (_("Unable to locate .debug_abbrev section!\n"));
6325             return 0;
6326           }
6327
6328         GET_DATA_ALLOC (sec->sh_offset, sec->sh_size, begin, unsigned char *,
6329                         "debug_abbrev section data");
6330
6331         process_abbrev_section (begin + compunit.cu_abbrev_offset,
6332                                 begin + sec->sh_size);
6333
6334         free (begin);
6335       }
6336
6337       level = 0;
6338       while (tags < start)
6339         {
6340           int            bytes_read;
6341           unsigned long  abbrev_number;
6342           abbrev_entry * entry;
6343           abbrev_attr  * attr;
6344
6345           abbrev_number = read_leb128 (tags, & bytes_read, 0);
6346           tags += bytes_read;
6347
6348           /* A null DIE marks the end of a list of children.  */
6349           if (abbrev_number == 0)
6350             {
6351               --level;
6352               continue;
6353             }
6354
6355           /* Scan through the abbreviation list until we reach the
6356              correct entry.  */
6357           for (entry = first_abbrev;
6358                entry && entry->entry != abbrev_number;
6359                entry = entry->next)
6360             continue;
6361
6362           if (entry == NULL)
6363             {
6364               warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6365                     abbrev_number);
6366               return 0;
6367             }
6368
6369           printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6370                   level, tags - section_begin - bytes_read,
6371                   abbrev_number,
6372                   get_TAG_name (entry->tag));
6373
6374           for (attr = entry->first_attr; attr; attr = attr->next)
6375             tags = read_and_display_attr (attr->attribute,
6376                                           attr->form,
6377                                           tags, cu_offset,
6378                                           compunit.cu_pointer_size);
6379
6380           if (entry->children)
6381             ++level;
6382         }
6383     }
6384
6385   printf ("\n");
6386
6387   return 1;
6388 }
6389
6390 static int
6391 display_debug_aranges (section, start, file)
6392      Elf32_Internal_Shdr * section;
6393      unsigned char *       start;
6394      FILE *                file ATTRIBUTE_UNUSED;
6395 {
6396   unsigned char * end = start + section->sh_size;
6397
6398   printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6399
6400   while (start < end)
6401     {
6402       DWARF2_External_ARange * external;
6403       DWARF2_Internal_ARange   arange;
6404       unsigned char *          ranges;
6405       unsigned long            length;
6406       unsigned long            address;
6407       int                      excess;
6408
6409       external = (DWARF2_External_ARange *) start;
6410
6411       arange.ar_length       = BYTE_GET (external->ar_length);
6412       arange.ar_version      = BYTE_GET (external->ar_version);
6413       arange.ar_info_offset  = BYTE_GET (external->ar_info_offset);
6414       arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
6415       arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
6416
6417       if (arange.ar_version != 2)
6418         {
6419           warn (_("Only DWARF 2 aranges are currently supported.\n"));
6420           break;
6421         }
6422
6423       printf (_("  Length:                   %ld\n"), arange.ar_length);
6424       printf (_("  Version:                  %d\n"), arange.ar_version);
6425       printf (_("  Offset into .debug_info:  %lx\n"), arange.ar_info_offset);
6426       printf (_("  Pointer Size:             %d\n"), arange.ar_pointer_size);
6427       printf (_("  Segment Size:             %d\n"), arange.ar_segment_size);
6428
6429       printf (_("\n    Address  Length\n"));
6430
6431       ranges = start + sizeof (* external);
6432
6433       /* Must pad to an alignment boundary that is twice the pointer size.  */
6434       excess = sizeof (*external) % (2 * arange.ar_pointer_size);
6435       if (excess)
6436         ranges += (2 * arange.ar_pointer_size) - excess;
6437
6438       for (;;)
6439         {
6440           address = byte_get (ranges, arange.ar_pointer_size);
6441
6442           ranges += arange.ar_pointer_size;
6443
6444           length  = byte_get (ranges, arange.ar_pointer_size);
6445
6446           ranges += arange.ar_pointer_size;
6447
6448           /* A pair of zeros marks the end of the list.  */
6449           if (address == 0 && length == 0)
6450             break;
6451
6452           printf ("    %8.8lx %lu\n", address, length);
6453         }
6454
6455       start += arange.ar_length + sizeof (external->ar_length);
6456     }
6457
6458   printf ("\n");
6459
6460   return 1;
6461 }
6462
6463
6464 static int
6465 display_debug_not_supported (section, start, file)
6466      Elf32_Internal_Shdr * section;
6467      unsigned char *       start ATTRIBUTE_UNUSED;
6468      FILE *                file ATTRIBUTE_UNUSED;
6469 {
6470   printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6471             SECTION_NAME (section));
6472
6473   return 1;
6474 }
6475
6476 /* Pre-scan the .debug_info section to record the size of address.
6477    When dumping the .debug_line, we use that size information, assuming
6478    that all compilation units have the same address size.  */
6479 static int
6480 prescan_debug_info (section, start, file)
6481      Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
6482      unsigned char *       start;
6483      FILE *                file ATTRIBUTE_UNUSED;
6484 {
6485   DWARF2_External_CompUnit * external;
6486
6487   external = (DWARF2_External_CompUnit *) start;
6488
6489   debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
6490   return 0;
6491 }
6492
6493   /* A structure containing the name of a debug section and a pointer
6494      to a function that can decode it.  The third field is a prescan
6495      function to be run over the section before displaying any of the
6496      sections.  */
6497 struct
6498 {
6499   char * name;
6500   int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
6501   int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
6502 }
6503 debug_displays[] =
6504 {
6505   { ".debug_info",        display_debug_info, prescan_debug_info },
6506   { ".debug_abbrev",      display_debug_abbrev, NULL },
6507   { ".debug_line",        display_debug_lines, NULL },
6508   { ".debug_aranges",     display_debug_aranges, NULL },
6509   { ".debug_pubnames",    display_debug_pubnames, NULL },
6510   { ".debug_macinfo",     display_debug_not_supported, NULL },
6511   { ".debug_frame",       display_debug_not_supported, NULL },
6512   { ".debug_str",         display_debug_not_supported, NULL },
6513   { ".debug_static_func", display_debug_not_supported, NULL },
6514   { ".debug_static_vars", display_debug_not_supported, NULL },
6515   { ".debug_types",       display_debug_not_supported, NULL },
6516   { ".debug_weaknames",   display_debug_not_supported, NULL }
6517 };
6518
6519 static int
6520 display_debug_section (section, file)
6521      Elf32_Internal_Shdr * section;
6522      FILE * file;
6523 {
6524   char *          name = SECTION_NAME (section);
6525   bfd_size_type   length;
6526   unsigned char * start;
6527   int             i;
6528
6529   length = section->sh_size;
6530   if (length == 0)
6531     {
6532       printf (_("\nSection '%s' has no debugging data.\n"), name);
6533       return 0;
6534     }
6535
6536   GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
6537                   "debug section data");
6538
6539   /* See if we know how to display the contents of this section.  */
6540   for (i = NUM_ELEM (debug_displays); i--;)
6541     if (strcmp (debug_displays[i].name, name) == 0)
6542       {
6543         debug_displays[i].display (section, start, file);
6544         break;
6545       }
6546
6547   if (i == -1)
6548     printf (_("Unrecognised debug section: %s\n"), name);
6549
6550   free (start);
6551
6552   /* If we loaded in the abbrev section at some point,
6553      we must release it here.  */
6554   if (first_abbrev != NULL)
6555     free_abbrevs ();
6556
6557   return 1;
6558 }
6559
6560 static int
6561 process_section_contents (file)
6562      FILE * file;
6563 {
6564   Elf32_Internal_Shdr * section;
6565   unsigned int          i;
6566
6567   if (! do_dump)
6568     return 1;
6569
6570   /* Pre-scan the debug sections to find some debug information not
6571      present in some of them.  For the .debug_line, we must find out the
6572      size of address (specified in .debug_info and .debug_aranges).  */
6573   for (i = 0, section = section_headers;
6574        i < elf_header.e_shnum && i < num_dump_sects;
6575        i ++, section ++)
6576     {
6577       char *    name = SECTION_NAME (section);
6578       int       j;
6579
6580       if (section->sh_size == 0)
6581         continue;
6582
6583       /* See if there is some pre-scan operation for this section.  */
6584       for (j = NUM_ELEM (debug_displays); j--;)
6585         if (strcmp (debug_displays[j].name, name) == 0)
6586           {
6587             if (debug_displays[j].prescan != NULL)
6588               {
6589                 bfd_size_type   length;
6590                 unsigned char * start;
6591
6592                 length = section->sh_size;
6593                 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
6594                                 "debug section data");
6595
6596                 debug_displays[j].prescan (section, start, file);
6597                 free (start);
6598               }
6599
6600             break;
6601           }
6602     }
6603
6604   for (i = 0, section = section_headers;
6605        i < elf_header.e_shnum && i < num_dump_sects;
6606        i ++, section ++)
6607     {
6608 #ifdef SUPPORT_DISASSEMBLY
6609       if (dump_sects[i] & DISASS_DUMP)
6610         disassemble_section (section, file);
6611 #endif
6612       if (dump_sects[i] & HEX_DUMP)
6613         dump_section (section, file);
6614
6615       if (dump_sects[i] & DEBUG_DUMP)
6616         display_debug_section (section, file);
6617     }
6618
6619   if (i < num_dump_sects)
6620     warn (_("Some sections were not dumped because they do not exist!\n"));
6621
6622   return 1;
6623 }
6624
6625 static void
6626 process_mips_fpe_exception (mask)
6627      int mask;
6628 {
6629   if (mask)
6630     {
6631       int first = 1;
6632       if (mask & OEX_FPU_INEX)
6633         fputs ("INEX", stdout), first = 0;
6634       if (mask & OEX_FPU_UFLO)
6635         printf ("%sUFLO", first ? "" : "|"), first = 0;
6636       if (mask & OEX_FPU_OFLO)
6637         printf ("%sOFLO", first ? "" : "|"), first = 0;
6638       if (mask & OEX_FPU_DIV0)
6639         printf ("%sDIV0", first ? "" : "|"), first = 0;
6640       if (mask & OEX_FPU_INVAL)
6641         printf ("%sINVAL", first ? "" : "|");
6642     }
6643   else
6644     fputs ("0", stdout);
6645 }
6646
6647 static int
6648 process_mips_specific (file)
6649      FILE * file;
6650 {
6651   Elf_Internal_Dyn * entry;
6652   size_t liblist_offset = 0;
6653   size_t liblistno = 0;
6654   size_t conflictsno = 0;
6655   size_t options_offset = 0;
6656   size_t conflicts_offset = 0;
6657
6658   /* We have a lot of special sections.  Thanks SGI!  */
6659   if (dynamic_segment == NULL)
6660     /* No information available.  */
6661     return 0;
6662
6663   for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
6664     switch (entry->d_tag)
6665       {
6666       case DT_MIPS_LIBLIST:
6667         liblist_offset = entry->d_un.d_val - loadaddr;
6668         break;
6669       case DT_MIPS_LIBLISTNO:
6670         liblistno = entry->d_un.d_val;
6671         break;
6672       case DT_MIPS_OPTIONS:
6673         options_offset = entry->d_un.d_val - loadaddr;
6674         break;
6675       case DT_MIPS_CONFLICT:
6676         conflicts_offset = entry->d_un.d_val - loadaddr;
6677         break;
6678       case DT_MIPS_CONFLICTNO:
6679         conflictsno = entry->d_un.d_val;
6680         break;
6681       default:
6682         break;
6683       }
6684
6685   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
6686     {
6687       Elf32_External_Lib * elib;
6688       size_t cnt;
6689
6690       GET_DATA_ALLOC (liblist_offset, liblistno * sizeof (Elf32_External_Lib),
6691                       elib, Elf32_External_Lib *, "liblist");
6692
6693       printf ("\nSection '.liblist' contains %lu entries:\n",
6694               (unsigned long) liblistno);
6695       fputs ("     Library              Time Stamp          Checksum   Version Flags\n",
6696              stdout);
6697
6698       for (cnt = 0; cnt < liblistno; ++cnt)
6699         {
6700           Elf32_Lib liblist;
6701           time_t time;
6702           char timebuf[20];
6703           struct tm * tmp;
6704
6705           liblist.l_name = BYTE_GET (elib[cnt].l_name);
6706           time = BYTE_GET (elib[cnt].l_time_stamp);
6707           liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
6708           liblist.l_version = BYTE_GET (elib[cnt].l_version);
6709           liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
6710
6711           tmp = gmtime (&time);
6712           sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
6713                    tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
6714                    tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
6715
6716           printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt,
6717                   dynamic_strings + liblist.l_name, timebuf,
6718                   liblist.l_checksum, liblist.l_version);
6719
6720           if (liblist.l_flags == 0)
6721             puts (" NONE");
6722           else
6723             {
6724               static const struct
6725               {
6726                 const char * name;
6727                 int bit;
6728               }
6729               l_flags_vals[] =
6730               {
6731                 { " EXACT_MATCH", LL_EXACT_MATCH },
6732                 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
6733                 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
6734                 { " EXPORTS", LL_EXPORTS },
6735                 { " DELAY_LOAD", LL_DELAY_LOAD },
6736                 { " DELTA", LL_DELTA }
6737               };
6738               int flags = liblist.l_flags;
6739               size_t fcnt;
6740
6741               for (fcnt = 0;
6742                    fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
6743                    ++fcnt)
6744                 if ((flags & l_flags_vals[fcnt].bit) != 0)
6745                   {
6746                     fputs (l_flags_vals[fcnt].name, stdout);
6747                     flags ^= l_flags_vals[fcnt].bit;
6748                   }
6749               if (flags != 0)
6750                 printf (" %#x", (unsigned int) flags);
6751
6752               puts ("");
6753             }
6754         }
6755
6756       free (elib);
6757     }
6758
6759   if (options_offset != 0)
6760     {
6761       Elf_External_Options * eopt;
6762       Elf_Internal_Shdr *    sect = section_headers;
6763       Elf_Internal_Options * iopt;
6764       Elf_Internal_Options * option;
6765       size_t offset;
6766       int cnt;
6767
6768       /* Find the section header so that we get the size.  */
6769       while (sect->sh_type != SHT_MIPS_OPTIONS)
6770         ++ sect;
6771
6772       GET_DATA_ALLOC (options_offset, sect->sh_size, eopt,
6773                       Elf_External_Options *, "options");
6774
6775       iopt = (Elf_Internal_Options *) malloc ((sect->sh_size / sizeof (eopt))
6776                                               * sizeof (*iopt));
6777       if (iopt == NULL)
6778         {
6779           error (_("Out of memory"));
6780           return 0;
6781         }
6782
6783       offset = cnt = 0;
6784       option = iopt;
6785
6786       while (offset < sect->sh_size)
6787         {
6788           Elf_External_Options * eoption;
6789
6790           eoption = (Elf_External_Options *) ((char *) eopt + offset);
6791
6792           option->kind = BYTE_GET (eoption->kind);
6793           option->size = BYTE_GET (eoption->size);
6794           option->section = BYTE_GET (eoption->section);
6795           option->info = BYTE_GET (eoption->info);
6796
6797           offset += option->size;
6798
6799           ++option;
6800           ++cnt;
6801         }
6802
6803       printf (_("\nSection '%s' contains %d entries:\n"),
6804               string_table + sect->sh_name, cnt);
6805
6806       option = iopt;
6807
6808       while (cnt-- > 0)
6809         {
6810           size_t len;
6811
6812           switch (option->kind)
6813             {
6814             case ODK_NULL:
6815               /* This shouldn't happen.  */
6816               printf (" NULL       %d %lx", option->section, option->info);
6817               break;
6818             case ODK_REGINFO:
6819               printf (" REGINFO    ");
6820               if (elf_header.e_machine == EM_MIPS)
6821                 {
6822                   /* 32bit form.  */
6823                   Elf32_External_RegInfo *ereg;
6824                   Elf32_RegInfo reginfo;
6825
6826                   ereg = (Elf32_External_RegInfo *) (option + 1);
6827                   reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
6828                   reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
6829                   reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
6830                   reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
6831                   reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
6832                   reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
6833
6834                   printf ("GPR %08lx  GP 0x%lx\n",
6835                           reginfo.ri_gprmask,
6836                           (unsigned long) reginfo.ri_gp_value);
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               else
6842                 {
6843                   /* 64 bit form.  */
6844                   Elf64_External_RegInfo * ereg;
6845                   Elf64_Internal_RegInfo reginfo;
6846
6847                   ereg = (Elf64_External_RegInfo *) (option + 1);
6848                   reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
6849                   reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
6850                   reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
6851                   reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
6852                   reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
6853                   reginfo.ri_gp_value   = BYTE_GET8 (ereg->ri_gp_value);
6854
6855                   printf ("GPR %08lx  GP 0x",
6856                           reginfo.ri_gprmask);
6857                   printf_vma (reginfo.ri_gp_value);
6858                   printf ("\n");
6859
6860                   printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
6861                           reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
6862                           reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
6863                 }
6864               ++option;
6865               continue;
6866             case ODK_EXCEPTIONS:
6867               fputs (" EXCEPTIONS fpe_min(", stdout);
6868               process_mips_fpe_exception (option->info & OEX_FPU_MIN);
6869               fputs (") fpe_max(", stdout);
6870               process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
6871               fputs (")", stdout);
6872
6873               if (option->info & OEX_PAGE0)
6874                 fputs (" PAGE0", stdout);
6875               if (option->info & OEX_SMM)
6876                 fputs (" SMM", stdout);
6877               if (option->info & OEX_FPDBUG)
6878                 fputs (" FPDBUG", stdout);
6879               if (option->info & OEX_DISMISS)
6880                 fputs (" DISMISS", stdout);
6881               break;
6882             case ODK_PAD:
6883               fputs (" PAD       ", stdout);
6884               if (option->info & OPAD_PREFIX)
6885                 fputs (" PREFIX", stdout);
6886               if (option->info & OPAD_POSTFIX)
6887                 fputs (" POSTFIX", stdout);
6888               if (option->info & OPAD_SYMBOL)
6889                 fputs (" SYMBOL", stdout);
6890               break;
6891             case ODK_HWPATCH:
6892               fputs (" HWPATCH   ", stdout);
6893               if (option->info & OHW_R4KEOP)
6894                 fputs (" R4KEOP", stdout);
6895               if (option->info & OHW_R8KPFETCH)
6896                 fputs (" R8KPFETCH", stdout);
6897               if (option->info & OHW_R5KEOP)
6898                 fputs (" R5KEOP", stdout);
6899               if (option->info & OHW_R5KCVTL)
6900                 fputs (" R5KCVTL", stdout);
6901               break;
6902             case ODK_FILL:
6903               fputs (" FILL       ", stdout);
6904               /* XXX Print content of info word?  */
6905               break;
6906             case ODK_TAGS:
6907               fputs (" TAGS       ", stdout);
6908               /* XXX Print content of info word?  */
6909               break;
6910             case ODK_HWAND:
6911               fputs (" HWAND     ", stdout);
6912               if (option->info & OHWA0_R4KEOP_CHECKED)
6913                 fputs (" R4KEOP_CHECKED", stdout);
6914               if (option->info & OHWA0_R4KEOP_CLEAN)
6915                 fputs (" R4KEOP_CLEAN", stdout);
6916               break;
6917             case ODK_HWOR:
6918               fputs (" HWOR      ", stdout);
6919               if (option->info & OHWA0_R4KEOP_CHECKED)
6920                 fputs (" R4KEOP_CHECKED", stdout);
6921               if (option->info & OHWA0_R4KEOP_CLEAN)
6922                 fputs (" R4KEOP_CLEAN", stdout);
6923               break;
6924             case ODK_GP_GROUP:
6925               printf (" GP_GROUP  %#06lx  self-contained %#06lx",
6926                       option->info & OGP_GROUP,
6927                       (option->info & OGP_SELF) >> 16);
6928               break;
6929             case ODK_IDENT:
6930               printf (" IDENT     %#06lx  self-contained %#06lx",
6931                       option->info & OGP_GROUP,
6932                       (option->info & OGP_SELF) >> 16);
6933               break;
6934             default:
6935               /* This shouldn't happen.  */
6936               printf (" %3d ???     %d %lx",
6937                       option->kind, option->section, option->info);
6938               break;
6939             }
6940
6941           len = sizeof (*eopt);
6942           while (len < option->size)
6943             if (((char *) option)[len] >= ' '
6944                 && ((char *) option)[len] < 0x7f)
6945               printf ("%c", ((char *) option)[len++]);
6946             else
6947               printf ("\\%03o", ((char *) option)[len++]);
6948
6949           fputs ("\n", stdout);
6950           ++option;
6951         }
6952
6953       free (eopt);
6954     }
6955
6956   if (conflicts_offset != 0 && conflictsno != 0)
6957     {
6958       Elf32_External_Conflict * econf32;
6959       Elf64_External_Conflict * econf64;
6960       Elf32_Conflict * iconf;
6961       size_t cnt;
6962
6963       if (dynamic_symbols == NULL)
6964         {
6965           error (_("conflict list with without table"));
6966           return 0;
6967         }
6968
6969       iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (*iconf));
6970       if (iconf == NULL)
6971         {
6972           error (_("Out of memory"));
6973           return 0;
6974         }
6975
6976       if (is_32bit_elf)
6977         {
6978           GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (*econf32),
6979                           econf32, Elf32_External_Conflict *, "conflict");
6980
6981           for (cnt = 0; cnt < conflictsno; ++cnt)
6982             iconf[cnt] = BYTE_GET (econf32[cnt]);
6983         }
6984       else
6985         {
6986           GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (*econf64),
6987                           econf64, Elf64_External_Conflict *, "conflict");
6988
6989           for (cnt = 0; cnt < conflictsno; ++cnt)
6990             iconf[cnt] = BYTE_GET (econf64[cnt]);
6991         }
6992
6993       printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno);
6994       puts (_("  Num:    Index       Value  Name"));
6995
6996       for (cnt = 0; cnt < conflictsno; ++cnt)
6997         {
6998           Elf_Internal_Sym * psym = &dynamic_symbols[iconf[cnt]];
6999
7000           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
7001           print_vma (psym->st_value, FULL_HEX);
7002           printf ("  %s\n", dynamic_strings + psym->st_name);
7003         }
7004
7005       free (iconf);
7006     }
7007
7008   return 1;
7009 }
7010
7011 static char *
7012 get_note_type (e_type)
7013      unsigned e_type;
7014 {
7015   static char buff[64];
7016
7017   switch (e_type)
7018     {
7019     case NT_PRSTATUS:   return _("NT_PRSTATUS (prstatus structure)");
7020     case NT_FPREGSET:   return _("NT_FPREGSET (floating point registers)");
7021     case NT_PRPSINFO:   return _("NT_PRPSINFO (prpsinfo structure)");
7022     case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
7023     case NT_PRXFPREG:   return _("NT_PRXFPREG (user_xfpregs structure)");
7024     case NT_PSTATUS:    return _("NT_PSTATUS (pstatus structure)");
7025     case NT_FPREGS:     return _("NT_FPREGS (floating point registers)");
7026     case NT_PSINFO:     return _("NT_PSINFO (psinfo structure)");
7027     case NT_LWPSTATUS:  return _("NT_LWPSTATUS (lwpstatus_t structure)");
7028     case NT_LWPSINFO:   return _("NT_LWPSINFO (lwpsinfo_t structure)");
7029     case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
7030     default:
7031       sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
7032       return buff;
7033     }
7034 }
7035
7036 /* Note that by the ELF standard, the name field is already null byte
7037    terminated, and namesz includes the terminating null byte.
7038    I.E. the value of namesz for the name "FSF" is 4.
7039
7040    If the value of namesz is zero, there is no name present. */
7041 static int
7042 process_note (pnote)
7043   Elf32_Internal_Note * pnote;
7044 {
7045   printf ("  %s\t\t0x%08lx\t%s\n",
7046           pnote->namesz ? pnote->namedata : "(NONE)",
7047           pnote->descsz, get_note_type (pnote->type));
7048   return 1;
7049 }
7050
7051
7052 static int
7053 process_corefile_note_segment (file, offset, length)
7054      FILE * file;
7055      bfd_vma offset;
7056      bfd_vma length;
7057 {
7058   Elf_External_Note *  pnotes;
7059   Elf_External_Note *  external;
7060   int                  res = 1;
7061
7062   if (length <= 0)
7063     return 0;
7064
7065   GET_DATA_ALLOC (offset, length, pnotes, Elf_External_Note *, "notes");
7066
7067   external = pnotes;
7068
7069   printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
7070           (unsigned long) offset, (unsigned long) length);
7071   printf (_("  Owner\t\tData size\tDescription\n"));
7072
7073   while (external < (Elf_External_Note *)((char *) pnotes + length))
7074     {
7075       Elf32_Internal_Note inote;
7076       char * temp = NULL;
7077
7078       inote.type     = BYTE_GET (external->type);
7079       inote.namesz   = BYTE_GET (external->namesz);
7080       inote.namedata = external->name;
7081       inote.descsz   = BYTE_GET (external->descsz);
7082       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
7083       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
7084
7085       external = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
7086
7087       /* Verify that name is null terminated.  It appears that at least
7088          one version of Linux (RedHat 6.0) generates corefiles that don't
7089          comply with the ELF spec by failing to include the null byte in
7090          namesz.  */
7091       if (inote.namedata[inote.namesz] != '\0')
7092         {
7093           temp = malloc (inote.namesz + 1);
7094
7095           if (temp == NULL)
7096             {
7097               error (_("Out of memory\n"));
7098               res = 0;
7099               break;
7100             }
7101
7102           strncpy (temp, inote.namedata, inote.namesz);
7103           temp[inote.namesz] = 0;
7104
7105           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
7106           inote.namedata = temp;
7107         }
7108
7109       res &= process_note (& inote);
7110
7111       if (temp != NULL)
7112         {
7113           free (temp);
7114           temp = NULL;
7115         }
7116     }
7117
7118   free (pnotes);
7119
7120   return res;
7121 }
7122
7123 static int
7124 process_corefile_note_segments (file)
7125      FILE * file;
7126 {
7127   Elf_Internal_Phdr * program_headers;
7128   Elf_Internal_Phdr * segment;
7129   unsigned int        i;
7130   int                 res = 1;
7131
7132   program_headers = (Elf_Internal_Phdr *) malloc
7133     (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
7134
7135   if (program_headers == NULL)
7136     {
7137       error (_("Out of memory\n"));
7138       return 0;
7139     }
7140
7141   if (is_32bit_elf)
7142     i = get_32bit_program_headers (file, program_headers);
7143   else
7144     i = get_64bit_program_headers (file, program_headers);
7145
7146   if (i == 0)
7147     {
7148       free (program_headers);
7149       return 0;
7150     }
7151
7152   for (i = 0, segment = program_headers;
7153        i < elf_header.e_phnum;
7154        i ++, segment ++)
7155     {
7156       if (segment->p_type == PT_NOTE)
7157         res &= process_corefile_note_segment (file,
7158                                               (bfd_vma) segment->p_offset,
7159                                               (bfd_vma) segment->p_filesz);
7160     }
7161
7162   free (program_headers);
7163
7164   return res;
7165 }
7166
7167 static int
7168 process_corefile_contents (file)
7169      FILE * file;
7170 {
7171   /* If we have not been asked to display the notes then do nothing.  */
7172   if (! do_notes)
7173     return 1;
7174
7175   /* If file is not a core file then exit.  */
7176   if (elf_header.e_type != ET_CORE)
7177     return 1;
7178
7179   /* No program headers means no NOTE segment.  */
7180   if (elf_header.e_phnum == 0)
7181     {
7182       printf (_("No note segments present in the core file.\n"));
7183       return 1;
7184    }
7185
7186   return process_corefile_note_segments (file);
7187 }
7188
7189 static int
7190 process_arch_specific (file)
7191      FILE * file;
7192 {
7193   if (! do_arch)
7194     return 1;
7195
7196   switch (elf_header.e_machine)
7197     {
7198     case EM_MIPS:
7199     case EM_MIPS_RS4_BE:
7200       return process_mips_specific (file);
7201       break;
7202     default:
7203       break;
7204     }
7205   return 1;
7206 }
7207
7208 static int
7209 get_file_header (file)
7210      FILE * file;
7211 {
7212   /* Read in the identity array.  */
7213   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
7214     return 0;
7215
7216   /* Determine how to read the rest of the header.  */
7217   switch (elf_header.e_ident [EI_DATA])
7218     {
7219     default: /* fall through */
7220     case ELFDATANONE: /* fall through */
7221     case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
7222     case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
7223     }
7224
7225   /* For now we only support 32 bit and 64 bit ELF files.  */
7226   is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
7227
7228   /* Read in the rest of the header.  */
7229   if (is_32bit_elf)
7230     {
7231       Elf32_External_Ehdr ehdr32;
7232
7233       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
7234         return 0;
7235
7236       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
7237       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
7238       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
7239       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
7240       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
7241       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
7242       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
7243       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
7244       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
7245       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
7246       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
7247       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
7248       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
7249     }
7250   else
7251     {
7252       Elf64_External_Ehdr ehdr64;
7253
7254       /* If we have been compiled with sizeof (bfd_vma) == 4, then
7255          we will not be able to cope with the 64bit data found in
7256          64 ELF files.  Detect this now and abort before we start
7257          overwritting things.  */
7258       if (sizeof (bfd_vma) < 8)
7259         {
7260           error (_("This instance of readelf has been built without support for a\n"));
7261           error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
7262           return 0;
7263         }
7264
7265       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
7266         return 0;
7267
7268       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
7269       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
7270       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
7271       elf_header.e_entry     = BYTE_GET8 (ehdr64.e_entry);
7272       elf_header.e_phoff     = BYTE_GET8 (ehdr64.e_phoff);
7273       elf_header.e_shoff     = BYTE_GET8 (ehdr64.e_shoff);
7274       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
7275       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
7276       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
7277       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
7278       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
7279       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
7280       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
7281     }
7282
7283   return 1;
7284 }
7285
7286 static void
7287 process_file (file_name)
7288      char * file_name;
7289 {
7290   FILE *       file;
7291   struct stat  statbuf;
7292   unsigned int i;
7293
7294   if (stat (file_name, & statbuf) < 0)
7295     {
7296       error (_("Cannot stat input file %s.\n"), file_name);
7297       return;
7298     }
7299
7300   file = fopen (file_name, "rb");
7301   if (file == NULL)
7302     {
7303       error (_("Input file %s not found.\n"), file_name);
7304       return;
7305     }
7306
7307   if (! get_file_header (file))
7308     {
7309       error (_("%s: Failed to read file header\n"), file_name);
7310       fclose (file);
7311       return;
7312     }
7313
7314   /* Initialise per file variables.  */
7315   for (i = NUM_ELEM (version_info); i--;)
7316     version_info[i] = 0;
7317
7318   for (i = NUM_ELEM (dynamic_info); i--;)
7319     dynamic_info[i] = 0;
7320
7321   /* Process the file.  */
7322   if (show_name)
7323     printf (_("\nFile: %s\n"), file_name);
7324
7325   if (! process_file_header ())
7326     {
7327       fclose (file);
7328       return;
7329     }
7330
7331   process_section_headers (file);
7332
7333   process_program_headers (file);
7334
7335   process_dynamic_segment (file);
7336
7337   process_relocs (file);
7338
7339   process_symbol_table (file);
7340
7341   process_syminfo (file);
7342
7343   process_version_sections (file);
7344
7345   process_section_contents (file);
7346
7347   process_corefile_contents (file);
7348
7349   process_arch_specific (file);
7350
7351   fclose (file);
7352
7353   if (section_headers)
7354     {
7355       free (section_headers);
7356       section_headers = NULL;
7357     }
7358
7359   if (string_table)
7360     {
7361       free (string_table);
7362       string_table = NULL;
7363     }
7364
7365   if (dynamic_strings)
7366     {
7367       free (dynamic_strings);
7368       dynamic_strings = NULL;
7369     }
7370
7371   if (dynamic_symbols)
7372     {
7373       free (dynamic_symbols);
7374       dynamic_symbols = NULL;
7375       num_dynamic_syms = 0;
7376     }
7377
7378   if (dynamic_syminfo)
7379     {
7380       free (dynamic_syminfo);
7381       dynamic_syminfo = NULL;
7382     }
7383 }
7384
7385 #ifdef SUPPORT_DISASSEMBLY
7386 /* Needed by the i386 disassembler.  For extra credit, someone could
7387    fix this so that we insert symbolic addresses here, esp for GOT/PLT
7388    symbols */
7389
7390 void
7391 print_address (unsigned int addr, FILE * outfile)
7392 {
7393   fprintf (outfile,"0x%8.8x", addr);
7394 }
7395
7396 /* Needed by the i386 disassembler. */
7397 void
7398 db_task_printsym (unsigned int addr)
7399 {
7400   print_address (addr, stderr);
7401 }
7402 #endif
7403
7404 int
7405 main (argc, argv)
7406      int     argc;
7407      char ** argv;
7408 {
7409 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
7410   setlocale (LC_MESSAGES, "");
7411 #endif
7412   bindtextdomain (PACKAGE, LOCALEDIR);
7413   textdomain (PACKAGE);
7414
7415   parse_args (argc, argv);
7416
7417   if (optind < (argc - 1))
7418     show_name = 1;
7419
7420   while (optind < argc)
7421     process_file (argv [optind ++]);
7422
7423   if (dump_sects != NULL)
7424     free (dump_sects);
7425
7426   return 0;
7427 }