binutils/readelf.c

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