binutils/readelf.c

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