binutils/readelf.c

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