binutils/readelf.c

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