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