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