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