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