binutils/readelf.c

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