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