binutils/readelf.c

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