binutils/readelf.c

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