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