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