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