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
1991     case PT_GNU_EH_FRAME:
1992                         return "GNU_EH_FRAME";
1993
1994     default:
1995       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
1996         {
1997           const char * result;
1998
1999           switch (elf_header.e_machine)
2000             {
2001             case EM_MIPS:
2002             case EM_MIPS_RS3_LE:
2003               result = get_mips_segment_type (p_type);
2004               break;
2005             case EM_PARISC:
2006               result = get_parisc_segment_type (p_type);
2007               break;
2008             case EM_IA_64:
2009               result = get_ia64_segment_type (p_type);
2010               break;
2011             default:
2012               result = NULL;
2013               break;
2014             }
2015
2016           if (result != NULL)
2017             return result;
2018
2019           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2020         }
2021       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2022         {
2023           const char * result;
2024
2025           switch (elf_header.e_machine)
2026             {
2027             case EM_PARISC:
2028               result = get_parisc_segment_type (p_type);
2029               break;
2030             case EM_IA_64:
2031               result = get_ia64_segment_type (p_type);
2032               break;
2033             default:
2034               result = NULL;
2035               break;
2036             }
2037
2038           if (result != NULL)
2039             return result;
2040
2041           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2042         }
2043       else
2044         sprintf (buff, _("<unknown>: %lx"), p_type);
2045
2046       return buff;
2047     }
2048 }
2049
2050 static const char *
2051 get_mips_section_type_name (sh_type)
2052      unsigned int sh_type;
2053 {
2054   switch (sh_type)
2055     {
2056     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
2057     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
2058     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
2059     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
2060     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
2061     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
2062     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
2063     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
2064     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
2065     case SHT_MIPS_RELD:          return "MIPS_RELD";
2066     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
2067     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
2068     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
2069     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
2070     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
2071     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
2072     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
2073     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
2074     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
2075     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
2076     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
2077     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
2078     case SHT_MIPS_LINE:          return "MIPS_LINE";
2079     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
2080     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
2081     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
2082     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
2083     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
2084     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
2085     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
2086     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
2087     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
2088     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
2089     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
2090     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
2091     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
2092     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
2093     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
2094     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2095     default:
2096       break;
2097     }
2098   return NULL;
2099 }
2100
2101 static const char *
2102 get_parisc_section_type_name (sh_type)
2103      unsigned int sh_type;
2104 {
2105   switch (sh_type)
2106     {
2107     case SHT_PARISC_EXT:        return "PARISC_EXT";
2108     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
2109     case SHT_PARISC_DOC:        return "PARISC_DOC";
2110     default:
2111       break;
2112     }
2113   return NULL;
2114 }
2115
2116 static const char *
2117 get_ia64_section_type_name (sh_type)
2118      unsigned int sh_type;
2119 {
2120   switch (sh_type)
2121     {
2122     case SHT_IA_64_EXT:         return "IA_64_EXT";
2123     case SHT_IA_64_UNWIND:      return "IA_64_UNWIND";
2124     default:
2125       break;
2126     }
2127   return NULL;
2128 }
2129
2130 static const char *
2131 get_section_type_name (sh_type)
2132      unsigned int sh_type;
2133 {
2134   static char buff [32];
2135
2136   switch (sh_type)
2137     {
2138     case SHT_NULL:              return "NULL";
2139     case SHT_PROGBITS:          return "PROGBITS";
2140     case SHT_SYMTAB:            return "SYMTAB";
2141     case SHT_STRTAB:            return "STRTAB";
2142     case SHT_RELA:              return "RELA";
2143     case SHT_HASH:              return "HASH";
2144     case SHT_DYNAMIC:           return "DYNAMIC";
2145     case SHT_NOTE:              return "NOTE";
2146     case SHT_NOBITS:            return "NOBITS";
2147     case SHT_REL:               return "REL";
2148     case SHT_SHLIB:             return "SHLIB";
2149     case SHT_DYNSYM:            return "DYNSYM";
2150     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
2151     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
2152     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
2153     case SHT_GROUP:             return "GROUP";
2154     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
2155     case SHT_GNU_verdef:        return "VERDEF";
2156     case SHT_GNU_verneed:       return "VERNEED";
2157     case SHT_GNU_versym:        return "VERSYM";
2158     case 0x6ffffff0:            return "VERSYM";
2159     case 0x6ffffffc:            return "VERDEF";
2160     case 0x7ffffffd:            return "AUXILIARY";
2161     case 0x7fffffff:            return "FILTER";
2162
2163     default:
2164       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
2165         {
2166           const char * result;
2167
2168           switch (elf_header.e_machine)
2169             {
2170             case EM_MIPS:
2171             case EM_MIPS_RS3_LE:
2172               result = get_mips_section_type_name (sh_type);
2173               break;
2174             case EM_PARISC:
2175               result = get_parisc_section_type_name (sh_type);
2176               break;
2177             case EM_IA_64:
2178               result = get_ia64_section_type_name (sh_type);
2179               break;
2180             default:
2181               result = NULL;
2182               break;
2183             }
2184
2185           if (result != NULL)
2186             return result;
2187
2188           sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
2189         }
2190       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
2191         sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
2192       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
2193         sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
2194       else
2195         sprintf (buff, _("<unknown>: %x"), sh_type);
2196
2197       return buff;
2198     }
2199 }
2200
2201 struct option options [] =
2202 {
2203   {"all",              no_argument, 0, 'a'},
2204   {"file-header",      no_argument, 0, 'h'},
2205   {"program-headers",  no_argument, 0, 'l'},
2206   {"headers",          no_argument, 0, 'e'},
2207   {"histogram",        no_argument, 0, 'I'},
2208   {"segments",         no_argument, 0, 'l'},
2209   {"sections",         no_argument, 0, 'S'},
2210   {"section-headers",  no_argument, 0, 'S'},
2211   {"symbols",          no_argument, 0, 's'},
2212   {"syms",             no_argument, 0, 's'},
2213   {"relocs",           no_argument, 0, 'r'},
2214   {"notes",            no_argument, 0, 'n'},
2215   {"dynamic",          no_argument, 0, 'd'},
2216   {"arch-specific",    no_argument, 0, 'A'},
2217   {"version-info",     no_argument, 0, 'V'},
2218   {"use-dynamic",      no_argument, 0, 'D'},
2219   {"hex-dump",         required_argument, 0, 'x'},
2220   {"debug-dump",       optional_argument, 0, 'w'},
2221   {"unwind",           no_argument, 0, 'u'},
2222 #ifdef SUPPORT_DISASSEMBLY
2223   {"instruction-dump", required_argument, 0, 'i'},
2224 #endif
2225
2226   {"version",          no_argument, 0, 'v'},
2227   {"wide",             no_argument, 0, 'W'},
2228   {"help",             no_argument, 0, 'H'},
2229   {0,                  no_argument, 0, 0}
2230 };
2231
2232 static void
2233 usage ()
2234 {
2235   fprintf (stdout, _("Usage: readelf <option(s)> elf-file(s)\n"));
2236   fprintf (stdout, _(" Display information about the contents of ELF format files\n"));
2237   fprintf (stdout, _(" Options are:\n\
2238   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2239   -h --file-header       Display the ELF file header\n\
2240   -l --program-headers   Display the program headers\n\
2241      --segments          An alias for --program-headers\n\
2242   -S --section-headers   Display the sections' header\n\
2243      --sections          An alias for --section-headers\n\
2244   -e --headers           Equivalent to: -h -l -S\n\
2245   -s --syms              Display the symbol table\n\
2246       --symbols          An alias for --syms\n\
2247   -n --notes             Display the core notes (if present)\n\
2248   -r --relocs            Display the relocations (if present)\n\
2249   -u --unwind            Display the unwind info (if present)\n\
2250   -d --dynamic           Display the dynamic segment (if present)\n\
2251   -V --version-info      Display the version sections (if present)\n\
2252   -A --arch-specific     Display architecture specific information (if any).\n\
2253   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
2254   -x --hex-dump=<number> Dump the contents of section <number>\n\
2255   -w --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2256                          Display the contents of DWARF2 debug sections\n"));
2257 #ifdef SUPPORT_DISASSEMBLY
2258   fprintf (stdout, _("\
2259   -i --instruction-dump=<number>\n\
2260                          Disassemble the contents of section <number>\n"));
2261 #endif
2262   fprintf (stdout, _("\
2263   -I --histogram         Display histogram of bucket list lengths\n\
2264   -W --wide              Allow output width to exceed 80 characters\n\
2265   -H --help              Display this information\n\
2266   -v --version           Display the version number of readelf\n"));
2267   fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
2268
2269   exit (0);
2270 }
2271
2272 static void
2273 request_dump (section, type)
2274      unsigned int section;
2275      int         type;
2276 {
2277   if (section >= num_dump_sects)
2278     {
2279       char * new_dump_sects;
2280
2281       new_dump_sects = (char *) calloc (section + 1, 1);
2282
2283       if (new_dump_sects == NULL)
2284         error (_("Out of memory allocating dump request table."));
2285       else
2286         {
2287           /* Copy current flag settings.  */
2288           memcpy (new_dump_sects, dump_sects, num_dump_sects);
2289
2290           free (dump_sects);
2291
2292           dump_sects = new_dump_sects;
2293           num_dump_sects = section + 1;
2294         }
2295     }
2296
2297   if (dump_sects)
2298     dump_sects [section] |= type;
2299
2300   return;
2301 }
2302
2303 static void
2304 parse_args (argc, argv)
2305      int argc;
2306      char ** argv;
2307 {
2308   int c;
2309
2310   if (argc < 2)
2311     usage ();
2312
2313   while ((c = getopt_long
2314           (argc, argv, "ersuahnldSDAIw::x:i:vVW", options, NULL)) != EOF)
2315     {
2316       char *    cp;
2317       int       section;
2318
2319       switch (c)
2320         {
2321         case 0:
2322           /* Long options.  */
2323           break;
2324         case 'H':
2325           usage ();
2326           break;
2327
2328         case 'a':
2329           do_syms ++;
2330           do_reloc ++;
2331           do_unwind ++;
2332           do_dynamic ++;
2333           do_header ++;
2334           do_sections ++;
2335           do_segments ++;
2336           do_version ++;
2337           do_histogram ++;
2338           do_arch ++;
2339           do_notes ++;
2340           break;
2341         case 'e':
2342           do_header ++;
2343           do_sections ++;
2344           do_segments ++;
2345           break;
2346         case 'A':
2347           do_arch ++;
2348           break;
2349         case 'D':
2350           do_using_dynamic ++;
2351           break;
2352         case 'r':
2353           do_reloc ++;
2354           break;
2355         case 'u':
2356           do_unwind ++;
2357           break;
2358         case 'h':
2359           do_header ++;
2360           break;
2361         case 'l':
2362           do_segments ++;
2363           break;
2364         case 's':
2365           do_syms ++;
2366           break;
2367         case 'S':
2368           do_sections ++;
2369           break;
2370         case 'd':
2371           do_dynamic ++;
2372           break;
2373         case 'I':
2374           do_histogram ++;
2375           break;
2376         case 'n':
2377           do_notes ++;
2378           break;
2379         case 'x':
2380           do_dump ++;
2381           section = strtoul (optarg, & cp, 0);
2382           if (! * cp && section >= 0)
2383             {
2384               request_dump (section, HEX_DUMP);
2385               break;
2386             }
2387           goto oops;
2388         case 'w':
2389           do_dump ++;
2390           if (optarg == 0)
2391             do_debugging = 1;
2392           else
2393             {
2394               unsigned int index = 0;
2395
2396               do_debugging = 0;
2397
2398               while (optarg[index])
2399                 switch (optarg[index++])
2400                   {
2401                   case 'i':
2402                   case 'I':
2403                     do_debug_info = 1;
2404                     break;
2405
2406                   case 'a':
2407                   case 'A':
2408                     do_debug_abbrevs = 1;
2409                     break;
2410
2411                   case 'l':
2412                   case 'L':
2413                     do_debug_lines = 1;
2414                     break;
2415
2416                   case 'p':
2417                   case 'P':
2418                     do_debug_pubnames = 1;
2419                     break;
2420
2421                   case 'r':
2422                   case 'R':
2423                     do_debug_aranges = 1;
2424                     break;
2425
2426                   case 'F':
2427                     do_debug_frames_interp = 1;
2428                   case 'f':
2429                     do_debug_frames = 1;
2430                     break;
2431
2432                   case 'm':
2433                   case 'M':
2434                     do_debug_macinfo = 1;
2435                     break;
2436
2437                   case 's':
2438                   case 'S':
2439                     do_debug_str = 1;
2440                     break;
2441
2442                   case 'o':
2443                   case 'O':
2444                     do_debug_loc = 1;
2445                     break;
2446
2447                   default:
2448                     warn (_("Unrecognized debug option '%s'\n"), optarg);
2449                     break;
2450                   }
2451             }
2452           break;
2453 #ifdef SUPPORT_DISASSEMBLY
2454         case 'i':
2455           do_dump ++;
2456           section = strtoul (optarg, & cp, 0);
2457           if (! * cp && section >= 0)
2458             {
2459               request_dump (section, DISASS_DUMP);
2460               break;
2461             }
2462           goto oops;
2463 #endif
2464         case 'v':
2465           print_version (program_name);
2466           break;
2467         case 'V':
2468           do_version ++;
2469           break;
2470         case 'W':
2471           do_wide ++;
2472           break;
2473         default:
2474         oops:
2475           /* xgettext:c-format */
2476           error (_("Invalid option '-%c'\n"), c);
2477           /* Drop through.  */
2478         case '?':
2479           usage ();
2480         }
2481     }
2482
2483   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
2484       && !do_segments && !do_header && !do_dump && !do_version
2485       && !do_histogram && !do_debugging && !do_arch && !do_notes)
2486     usage ();
2487   else if (argc < 3)
2488     {
2489       warn (_("Nothing to do.\n"));
2490       usage();
2491     }
2492 }
2493
2494 static const char *
2495 get_elf_class (elf_class)
2496      unsigned int elf_class;
2497 {
2498   static char buff [32];
2499
2500   switch (elf_class)
2501     {
2502     case ELFCLASSNONE: return _("none");
2503     case ELFCLASS32:   return "ELF32";
2504     case ELFCLASS64:   return "ELF64";
2505     default:
2506       sprintf (buff, _("<unknown: %x>"), elf_class);
2507       return buff;
2508     }
2509 }
2510
2511 static const char *
2512 get_data_encoding (encoding)
2513      unsigned int encoding;
2514 {
2515   static char buff [32];
2516
2517   switch (encoding)
2518     {
2519     case ELFDATANONE: return _("none");
2520     case ELFDATA2LSB: return _("2's complement, little endian");
2521     case ELFDATA2MSB: return _("2's complement, big endian");
2522     default:
2523       sprintf (buff, _("<unknown: %x>"), encoding);
2524       return buff;
2525     }
2526 }
2527
2528 static const char *
2529 get_osabi_name (osabi)
2530      unsigned int osabi;
2531 {
2532   static char buff [32];
2533
2534   switch (osabi)
2535     {
2536     case ELFOSABI_NONE:       return "UNIX - System V";
2537     case ELFOSABI_HPUX:       return "UNIX - HP-UX";
2538     case ELFOSABI_NETBSD:     return "UNIX - NetBSD";
2539     case ELFOSABI_LINUX:      return "UNIX - Linux";
2540     case ELFOSABI_HURD:       return "GNU/Hurd";
2541     case ELFOSABI_SOLARIS:    return "UNIX - Solaris";
2542     case ELFOSABI_AIX:        return "UNIX - AIX";
2543     case ELFOSABI_IRIX:       return "UNIX - IRIX";
2544     case ELFOSABI_FREEBSD:    return "UNIX - FreeBSD";
2545     case ELFOSABI_TRU64:      return "UNIX - TRU64";
2546     case ELFOSABI_MODESTO:    return "Novell - Modesto";
2547     case ELFOSABI_OPENBSD:    return "UNIX - OpenBSD";
2548     case ELFOSABI_STANDALONE: return _("Standalone App");
2549     case ELFOSABI_ARM:        return "ARM";
2550     default:
2551       sprintf (buff, _("<unknown: %x>"), osabi);
2552       return buff;
2553     }
2554 }
2555
2556 /* Decode the data held in 'elf_header'.  */
2557 static int
2558 process_file_header ()
2559 {
2560   if (   elf_header.e_ident [EI_MAG0] != ELFMAG0
2561       || elf_header.e_ident [EI_MAG1] != ELFMAG1
2562       || elf_header.e_ident [EI_MAG2] != ELFMAG2
2563       || elf_header.e_ident [EI_MAG3] != ELFMAG3)
2564     {
2565       error
2566         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2567       return 0;
2568     }
2569
2570   if (do_header)
2571     {
2572       int i;
2573
2574       printf (_("ELF Header:\n"));
2575       printf (_("  Magic:   "));
2576       for (i = 0; i < EI_NIDENT; i ++)
2577         printf ("%2.2x ", elf_header.e_ident [i]);
2578       printf ("\n");
2579       printf (_("  Class:                             %s\n"),
2580               get_elf_class (elf_header.e_ident [EI_CLASS]));
2581       printf (_("  Data:                              %s\n"),
2582               get_data_encoding (elf_header.e_ident [EI_DATA]));
2583       printf (_("  Version:                           %d %s\n"),
2584               elf_header.e_ident [EI_VERSION],
2585               (elf_header.e_ident [EI_VERSION] == EV_CURRENT
2586                ? "(current)"
2587                : (elf_header.e_ident [EI_VERSION] != EV_NONE
2588                   ? "<unknown: %lx>"
2589                   : "")));
2590       printf (_("  OS/ABI:                            %s\n"),
2591               get_osabi_name (elf_header.e_ident [EI_OSABI]));
2592       printf (_("  ABI Version:                       %d\n"),
2593               elf_header.e_ident [EI_ABIVERSION]);
2594       printf (_("  Type:                              %s\n"),
2595               get_file_type (elf_header.e_type));
2596       printf (_("  Machine:                           %s\n"),
2597               get_machine_name (elf_header.e_machine));
2598       printf (_("  Version:                           0x%lx\n"),
2599               (unsigned long) elf_header.e_version);
2600
2601       printf (_("  Entry point address:               "));
2602       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2603       printf (_("\n  Start of program headers:          "));
2604       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2605       printf (_(" (bytes into file)\n  Start of section headers:          "));
2606       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
2607       printf (_(" (bytes into file)\n"));
2608
2609       printf (_("  Flags:                             0x%lx%s\n"),
2610               (unsigned long) elf_header.e_flags,
2611               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2612       printf (_("  Size of this header:               %ld (bytes)\n"),
2613               (long) elf_header.e_ehsize);
2614       printf (_("  Size of program headers:           %ld (bytes)\n"),
2615               (long) elf_header.e_phentsize);
2616       printf (_("  Number of program headers:         %ld\n"),
2617               (long) elf_header.e_phnum);
2618       printf (_("  Size of section headers:           %ld (bytes)\n"),
2619               (long) elf_header.e_shentsize);
2620       printf (_("  Number of section headers:         %ld"),
2621               (long) elf_header.e_shnum);
2622       if (section_headers != NULL && elf_header.e_shnum == 0)
2623         printf (" (%ld)", (long) section_headers[0].sh_size);
2624       putc ('\n', stdout);
2625       printf (_("  Section header string table index: %ld"),
2626               (long) elf_header.e_shstrndx);
2627       if (section_headers != NULL && elf_header.e_shstrndx == SHN_XINDEX)
2628         printf (" (%ld)", (long) section_headers[0].sh_link);
2629       putc ('\n', stdout);
2630     }
2631
2632   if (section_headers != NULL)
2633     {
2634       if (elf_header.e_shnum == 0)
2635         elf_header.e_shnum = section_headers[0].sh_size;
2636       if (elf_header.e_shstrndx == SHN_XINDEX)
2637         elf_header.e_shstrndx = section_headers[0].sh_link;
2638       free (section_headers);
2639       section_headers = NULL;
2640     }
2641
2642   return 1;
2643 }
2644
2645
2646 static int
2647 get_32bit_program_headers (file, program_headers)
2648      FILE * file;
2649      Elf_Internal_Phdr * program_headers;
2650 {
2651   Elf32_External_Phdr * phdrs;
2652   Elf32_External_Phdr * external;
2653   Elf32_Internal_Phdr * internal;
2654   unsigned int          i;
2655
2656   phdrs = ((Elf32_External_Phdr *)
2657            get_data (NULL, file, elf_header.e_phoff,
2658                      elf_header.e_phentsize * elf_header.e_phnum,
2659                      _("program headers")));
2660   if (!phdrs)
2661     return 0;
2662
2663   for (i = 0, internal = program_headers, external = phdrs;
2664        i < elf_header.e_phnum;
2665        i ++, internal ++, external ++)
2666     {
2667       internal->p_type   = BYTE_GET (external->p_type);
2668       internal->p_offset = BYTE_GET (external->p_offset);
2669       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
2670       internal->p_paddr  = BYTE_GET (external->p_paddr);
2671       internal->p_filesz = BYTE_GET (external->p_filesz);
2672       internal->p_memsz  = BYTE_GET (external->p_memsz);
2673       internal->p_flags  = BYTE_GET (external->p_flags);
2674       internal->p_align  = BYTE_GET (external->p_align);
2675     }
2676
2677   free (phdrs);
2678
2679   return 1;
2680 }
2681
2682 static int
2683 get_64bit_program_headers (file, program_headers)
2684      FILE * file;
2685      Elf_Internal_Phdr * program_headers;
2686 {
2687   Elf64_External_Phdr * phdrs;
2688   Elf64_External_Phdr * external;
2689   Elf64_Internal_Phdr * internal;
2690   unsigned int          i;
2691
2692   phdrs = ((Elf64_External_Phdr *)
2693            get_data (NULL, file, elf_header.e_phoff,
2694                      elf_header.e_phentsize * elf_header.e_phnum,
2695                      _("program headers")));
2696   if (!phdrs)
2697     return 0;
2698
2699   for (i = 0, internal = program_headers, external = phdrs;
2700        i < elf_header.e_phnum;
2701        i ++, internal ++, external ++)
2702     {
2703       internal->p_type   = BYTE_GET (external->p_type);
2704       internal->p_flags  = BYTE_GET (external->p_flags);
2705       internal->p_offset = BYTE_GET8 (external->p_offset);
2706       internal->p_vaddr  = BYTE_GET8 (external->p_vaddr);
2707       internal->p_paddr  = BYTE_GET8 (external->p_paddr);
2708       internal->p_filesz = BYTE_GET8 (external->p_filesz);
2709       internal->p_memsz  = BYTE_GET8 (external->p_memsz);
2710       internal->p_align  = BYTE_GET8 (external->p_align);
2711     }
2712
2713   free (phdrs);
2714
2715   return 1;
2716 }
2717
2718 static int
2719 process_program_headers (file)
2720      FILE * file;
2721 {
2722   Elf_Internal_Phdr * program_headers;
2723   Elf_Internal_Phdr * segment;
2724   unsigned int        i;
2725
2726   if (elf_header.e_phnum == 0)
2727     {
2728       if (do_segments)
2729         printf (_("\nThere are no program headers in this file.\n"));
2730       return 1;
2731     }
2732
2733   if (do_segments && !do_header)
2734     {
2735       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
2736       printf (_("Entry point "));
2737       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2738       printf (_("\nThere are %d program headers, starting at offset "),
2739               elf_header.e_phnum);
2740       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2741       printf ("\n");
2742     }
2743
2744   program_headers = (Elf_Internal_Phdr *) malloc
2745     (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
2746
2747   if (program_headers == NULL)
2748     {
2749       error (_("Out of memory\n"));
2750       return 0;
2751     }
2752
2753   if (is_32bit_elf)
2754     i = get_32bit_program_headers (file, program_headers);
2755   else
2756     i = get_64bit_program_headers (file, program_headers);
2757
2758   if (i == 0)
2759     {
2760       free (program_headers);
2761       return 0;
2762     }
2763
2764   if (do_segments)
2765     {
2766       printf
2767         (_("\nProgram Header%s:\n"), elf_header.e_phnum > 1 ? "s" : "");
2768
2769       if (is_32bit_elf)
2770         printf
2771           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
2772       else if (do_wide)
2773         printf
2774           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
2775       else
2776         {
2777           printf
2778             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
2779           printf
2780             (_("                 FileSiz            MemSiz              Flags  Align\n"));
2781         }
2782     }
2783
2784   loadaddr = -1;
2785   dynamic_addr = 0;
2786   dynamic_size = 0;
2787
2788   for (i = 0, segment = program_headers;
2789        i < elf_header.e_phnum;
2790        i ++, segment ++)
2791     {
2792       if (do_segments)
2793         {
2794           printf ("  %-14.14s ", get_segment_type (segment->p_type));
2795
2796           if (is_32bit_elf)
2797             {
2798               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2799               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
2800               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
2801               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
2802               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
2803               printf ("%c%c%c ",
2804                       (segment->p_flags & PF_R ? 'R' : ' '),
2805                       (segment->p_flags & PF_W ? 'W' : ' '),
2806                       (segment->p_flags & PF_X ? 'E' : ' '));
2807               printf ("%#lx", (unsigned long) segment->p_align);
2808             }
2809           else if (do_wide)
2810             {
2811               if ((unsigned long) segment->p_offset == segment->p_offset)
2812                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2813               else
2814                 {
2815                   print_vma (segment->p_offset, FULL_HEX);
2816                   putchar (' ');
2817                 }
2818
2819               print_vma (segment->p_vaddr, FULL_HEX);
2820               putchar (' ');
2821               print_vma (segment->p_paddr, FULL_HEX);
2822               putchar (' ');
2823
2824               if ((unsigned long) segment->p_filesz == segment->p_filesz)
2825                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
2826               else
2827                 {
2828                   print_vma (segment->p_filesz, FULL_HEX);
2829                   putchar (' ');
2830                 }
2831
2832               if ((unsigned long) segment->p_memsz == segment->p_memsz)
2833                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
2834               else
2835                 {
2836                   print_vma (segment->p_offset, FULL_HEX);
2837                 }
2838
2839               printf (" %c%c%c ",
2840                       (segment->p_flags & PF_R ? 'R' : ' '),
2841                       (segment->p_flags & PF_W ? 'W' : ' '),
2842                       (segment->p_flags & PF_X ? 'E' : ' '));
2843
2844               if ((unsigned long) segment->p_align == segment->p_align)
2845                 printf ("%#lx", (unsigned long) segment->p_align);
2846               else
2847                 {
2848                   print_vma (segment->p_align, PREFIX_HEX);
2849                 }
2850             }
2851           else
2852             {
2853               print_vma (segment->p_offset, FULL_HEX);
2854               putchar (' ');
2855               print_vma (segment->p_vaddr, FULL_HEX);
2856               putchar (' ');
2857               print_vma (segment->p_paddr, FULL_HEX);
2858               printf ("\n                 ");
2859               print_vma (segment->p_filesz, FULL_HEX);
2860               putchar (' ');
2861               print_vma (segment->p_memsz, FULL_HEX);
2862               printf ("  %c%c%c    ",
2863                       (segment->p_flags & PF_R ? 'R' : ' '),
2864                       (segment->p_flags & PF_W ? 'W' : ' '),
2865                       (segment->p_flags & PF_X ? 'E' : ' '));
2866               print_vma (segment->p_align, HEX);
2867             }
2868         }
2869
2870       switch (segment->p_type)
2871         {
2872         case PT_LOAD:
2873           if (loadaddr == -1)
2874             loadaddr = (segment->p_vaddr & 0xfffff000)
2875               - (segment->p_offset & 0xfffff000);
2876           break;
2877
2878         case PT_DYNAMIC:
2879           if (dynamic_addr)
2880             error (_("more than one dynamic segment\n"));
2881
2882           dynamic_addr = segment->p_offset;
2883           dynamic_size = segment->p_filesz;
2884           break;
2885
2886         case PT_INTERP:
2887           if (fseek (file, (long) segment->p_offset, SEEK_SET))
2888             error (_("Unable to find program interpreter name\n"));
2889           else
2890             {
2891               program_interpreter[0] = 0;
2892               fscanf (file, "%63s", program_interpreter);
2893
2894               if (do_segments)
2895                 printf (_("\n      [Requesting program interpreter: %s]"),
2896                     program_interpreter);
2897             }
2898           break;
2899         }
2900
2901       if (do_segments)
2902         putc ('\n', stdout);
2903     }
2904
2905   if (loadaddr == -1)
2906     {
2907       /* Very strange.  */
2908       loadaddr = 0;
2909     }
2910
2911   if (do_segments && section_headers != NULL)
2912     {
2913       printf (_("\n Section to Segment mapping:\n"));
2914       printf (_("  Segment Sections...\n"));
2915
2916       assert (string_table != NULL);
2917
2918       for (i = 0; i < elf_header.e_phnum; i++)
2919         {
2920           unsigned int j;
2921           Elf_Internal_Shdr * section;
2922
2923           segment = program_headers + i;
2924           section = section_headers;
2925
2926           printf ("   %2.2d     ", i);
2927
2928           for (j = 1; j < elf_header.e_shnum; j++, section ++)
2929             {
2930               if (section->sh_size > 0
2931                   /* Compare allocated sections by VMA, unallocated
2932                      sections by file offset.  */
2933                   && (section->sh_flags & SHF_ALLOC
2934                       ? (section->sh_addr >= segment->p_vaddr
2935                          && section->sh_addr + section->sh_size
2936                          <= segment->p_vaddr + segment->p_memsz)
2937                       : ((bfd_vma) section->sh_offset >= segment->p_offset
2938                          && (section->sh_offset + section->sh_size
2939                              <= segment->p_offset + segment->p_filesz))))
2940                 printf ("%s ", SECTION_NAME (section));
2941             }
2942
2943           putc ('\n',stdout);
2944         }
2945     }
2946
2947   free (program_headers);
2948
2949   return 1;
2950 }
2951
2952
2953 static int
2954 get_32bit_section_headers (file, num)
2955      FILE * file;
2956      unsigned int num;
2957 {
2958   Elf32_External_Shdr * shdrs;
2959   Elf32_Internal_Shdr * internal;
2960   unsigned int          i;
2961
2962   shdrs = ((Elf32_External_Shdr *)
2963            get_data (NULL, file, elf_header.e_shoff,
2964                      elf_header.e_shentsize * num,
2965                      _("section headers")));
2966   if (!shdrs)
2967     return 0;
2968
2969   section_headers = ((Elf_Internal_Shdr *)
2970                      malloc (num * sizeof (Elf_Internal_Shdr)));
2971
2972   if (section_headers == NULL)
2973     {
2974       error (_("Out of memory\n"));
2975       return 0;
2976     }
2977
2978   for (i = 0, internal = section_headers;
2979        i < num;
2980        i ++, internal ++)
2981     {
2982       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
2983       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
2984       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
2985       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
2986       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
2987       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
2988       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
2989       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
2990       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2991       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
2992     }
2993
2994   free (shdrs);
2995
2996   return 1;
2997 }
2998
2999 static int
3000 get_64bit_section_headers (file, num)
3001      FILE * file;
3002      unsigned int num;
3003 {
3004   Elf64_External_Shdr * shdrs;
3005   Elf64_Internal_Shdr * internal;
3006   unsigned int          i;
3007
3008   shdrs = ((Elf64_External_Shdr *)
3009            get_data (NULL, file, elf_header.e_shoff,
3010                      elf_header.e_shentsize * num,
3011                      _("section headers")));
3012   if (!shdrs)
3013     return 0;
3014
3015   section_headers = ((Elf_Internal_Shdr *)
3016                      malloc (num * sizeof (Elf_Internal_Shdr)));
3017
3018   if (section_headers == NULL)
3019     {
3020       error (_("Out of memory\n"));
3021       return 0;
3022     }
3023
3024   for (i = 0, internal = section_headers;
3025        i < num;
3026        i ++, internal ++)
3027     {
3028       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
3029       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
3030       internal->sh_flags     = BYTE_GET8 (shdrs[i].sh_flags);
3031       internal->sh_addr      = BYTE_GET8 (shdrs[i].sh_addr);
3032       internal->sh_size      = BYTE_GET8 (shdrs[i].sh_size);
3033       internal->sh_entsize   = BYTE_GET8 (shdrs[i].sh_entsize);
3034       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
3035       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
3036       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
3037       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3038     }
3039
3040   free (shdrs);
3041
3042   return 1;
3043 }
3044
3045 static Elf_Internal_Sym *
3046 get_32bit_elf_symbols (file, section)
3047      FILE * file;
3048      Elf_Internal_Shdr *section;
3049 {
3050   unsigned long number;
3051   Elf32_External_Sym * esyms;
3052   Elf_External_Sym_Shndx *shndx;
3053   Elf_Internal_Sym *   isyms;
3054   Elf_Internal_Sym *   psym;
3055   unsigned int         j;
3056
3057   esyms = ((Elf32_External_Sym *)
3058            get_data (NULL, file, section->sh_offset,
3059                      section->sh_size, _("symbols")));
3060   if (!esyms)
3061     return NULL;
3062
3063   shndx = NULL;
3064   if (symtab_shndx_hdr != NULL
3065       && (symtab_shndx_hdr->sh_link
3066           == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3067     {
3068       shndx = ((Elf_External_Sym_Shndx *)
3069                get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3070                          symtab_shndx_hdr->sh_size, _("symtab shndx")));
3071       if (!shndx)
3072         {
3073           free (esyms);
3074           return NULL;
3075         }
3076     }
3077
3078   number = section->sh_size / section->sh_entsize;
3079   isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
3080
3081   if (isyms == NULL)
3082     {
3083       error (_("Out of memory\n"));
3084       if (shndx)
3085         free (shndx);
3086       free (esyms);
3087       return NULL;
3088     }
3089
3090   for (j = 0, psym = isyms;
3091        j < number;
3092        j ++, psym ++)
3093     {
3094       psym->st_name  = BYTE_GET (esyms[j].st_name);
3095       psym->st_value = BYTE_GET (esyms[j].st_value);
3096       psym->st_size  = BYTE_GET (esyms[j].st_size);
3097       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3098       if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3099         psym->st_shndx
3100           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3101       psym->st_info  = BYTE_GET (esyms[j].st_info);
3102       psym->st_other = BYTE_GET (esyms[j].st_other);
3103     }
3104
3105   if (shndx)
3106     free (shndx);
3107   free (esyms);
3108
3109   return isyms;
3110 }
3111
3112 static Elf_Internal_Sym *
3113 get_64bit_elf_symbols (file, section)
3114      FILE * file;
3115      Elf_Internal_Shdr *section;
3116 {
3117   unsigned long number;
3118   Elf64_External_Sym * esyms;
3119   Elf_External_Sym_Shndx *shndx;
3120   Elf_Internal_Sym *   isyms;
3121   Elf_Internal_Sym *   psym;
3122   unsigned int         j;
3123
3124   esyms = ((Elf64_External_Sym *)
3125            get_data (NULL, file, section->sh_offset,
3126                      section->sh_size, _("symbols")));
3127   if (!esyms)
3128     return NULL;
3129
3130   shndx = NULL;
3131   if (symtab_shndx_hdr != NULL
3132       && (symtab_shndx_hdr->sh_link
3133           == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3134     {
3135       shndx = ((Elf_External_Sym_Shndx *)
3136                get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3137                          symtab_shndx_hdr->sh_size, _("symtab shndx")));
3138       if (!shndx)
3139         {
3140           free (esyms);
3141           return NULL;
3142         }
3143     }
3144
3145   number = section->sh_size / section->sh_entsize;
3146   isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
3147
3148   if (isyms == NULL)
3149     {
3150       error (_("Out of memory\n"));
3151       if (shndx)
3152         free (shndx);
3153       free (esyms);
3154       return NULL;
3155     }
3156
3157   for (j = 0, psym = isyms;
3158        j < number;
3159        j ++, psym ++)
3160     {
3161       psym->st_name  = BYTE_GET (esyms[j].st_name);
3162       psym->st_info  = BYTE_GET (esyms[j].st_info);
3163       psym->st_other = BYTE_GET (esyms[j].st_other);
3164       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3165       if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3166         psym->st_shndx
3167           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3168       psym->st_value = BYTE_GET8 (esyms[j].st_value);
3169       psym->st_size  = BYTE_GET8 (esyms[j].st_size);
3170     }
3171
3172   if (shndx)
3173     free (shndx);
3174   free (esyms);
3175
3176   return isyms;
3177 }
3178
3179 static const char *
3180 get_elf_section_flags (sh_flags)
3181      bfd_vma sh_flags;
3182 {
3183   static char buff [32];
3184
3185   * buff = 0;
3186
3187   while (sh_flags)
3188     {
3189       bfd_vma flag;
3190
3191       flag = sh_flags & - sh_flags;
3192       sh_flags &= ~ flag;
3193
3194       switch (flag)
3195         {
3196         case SHF_WRITE:            strcat (buff, "W"); break;
3197         case SHF_ALLOC:            strcat (buff, "A"); break;
3198         case SHF_EXECINSTR:        strcat (buff, "X"); break;
3199         case SHF_MERGE:            strcat (buff, "M"); break;
3200         case SHF_STRINGS:          strcat (buff, "S"); break;
3201         case SHF_INFO_LINK:        strcat (buff, "I"); break;
3202         case SHF_LINK_ORDER:       strcat (buff, "L"); break;
3203         case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
3204         case SHF_GROUP:            strcat (buff, "G"); break;
3205
3206         default:
3207           if (flag & SHF_MASKOS)
3208             {
3209               strcat (buff, "o");
3210               sh_flags &= ~ SHF_MASKOS;
3211             }
3212           else if (flag & SHF_MASKPROC)
3213             {
3214               strcat (buff, "p");
3215               sh_flags &= ~ SHF_MASKPROC;
3216             }
3217           else
3218             strcat (buff, "x");
3219           break;
3220         }
3221     }
3222
3223   return buff;
3224 }
3225
3226 static int
3227 process_section_headers (file)
3228      FILE * file;
3229 {
3230   Elf_Internal_Shdr * section;
3231   unsigned int        i;
3232
3233   section_headers = NULL;
3234
3235   if (elf_header.e_shnum == 0)
3236     {
3237       if (do_sections)
3238         printf (_("\nThere are no sections in this file.\n"));
3239
3240       return 1;
3241     }
3242
3243   if (do_sections && !do_header)
3244     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3245             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
3246
3247   if (is_32bit_elf)
3248     {
3249       if (! get_32bit_section_headers (file, elf_header.e_shnum))
3250         return 0;
3251     }
3252   else if (! get_64bit_section_headers (file, elf_header.e_shnum))
3253     return 0;
3254
3255   /* Read in the string table, so that we have names to display.  */
3256   section = SECTION_HEADER (elf_header.e_shstrndx);
3257
3258   if (section->sh_size != 0)
3259     {
3260       string_table = (char *) get_data (NULL, file, section->sh_offset,
3261                                         section->sh_size, _("string table"));
3262
3263       string_table_length = section->sh_size;
3264     }
3265
3266   /* Scan the sections for the dynamic symbol table
3267      and dynamic string table and debug sections.  */
3268   dynamic_symbols = NULL;
3269   dynamic_strings = NULL;
3270   dynamic_syminfo = NULL;
3271
3272   for (i = 0, section = section_headers;
3273        i < elf_header.e_shnum;
3274        i ++, section ++)
3275     {
3276       char * name = SECTION_NAME (section);
3277
3278       if (section->sh_type == SHT_DYNSYM)
3279         {
3280           if (dynamic_symbols != NULL)
3281             {
3282               error (_("File contains multiple dynamic symbol tables\n"));
3283               continue;
3284             }
3285
3286           num_dynamic_syms = section->sh_size / section->sh_entsize;
3287           dynamic_symbols = GET_ELF_SYMBOLS (file, section);
3288         }
3289       else if (section->sh_type == SHT_STRTAB
3290                && strcmp (name, ".dynstr") == 0)
3291         {
3292           if (dynamic_strings != NULL)
3293             {
3294               error (_("File contains multiple dynamic string tables\n"));
3295               continue;
3296             }
3297
3298           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
3299                                                section->sh_size,
3300                                                _("dynamic strings"));
3301         }
3302       else if (section->sh_type == SHT_SYMTAB_SHNDX)
3303         {
3304           if (symtab_shndx_hdr != NULL)
3305             {
3306               error (_("File contains multiple symtab shndx tables\n"));
3307               continue;
3308             }
3309           symtab_shndx_hdr = section;
3310         }
3311       else if ((do_debugging || do_debug_info || do_debug_abbrevs
3312                 || do_debug_lines || do_debug_pubnames || do_debug_aranges
3313                 || do_debug_frames || do_debug_macinfo || do_debug_str
3314                 || do_debug_loc)
3315                && strncmp (name, ".debug_", 7) == 0)
3316         {
3317           name += 7;
3318
3319           if (do_debugging
3320               || (do_debug_info     && (strcmp (name, "info") == 0))
3321               || (do_debug_abbrevs  && (strcmp (name, "abbrev") == 0))
3322               || (do_debug_lines    && (strcmp (name, "line") == 0))
3323               || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
3324               || (do_debug_aranges  && (strcmp (name, "aranges") == 0))
3325               || (do_debug_frames   && (strcmp (name, "frame") == 0))
3326               || (do_debug_macinfo  && (strcmp (name, "macinfo") == 0))
3327               || (do_debug_str      && (strcmp (name, "str") == 0))
3328               || (do_debug_loc      && (strcmp (name, "loc") == 0))
3329               )
3330             request_dump (i, DEBUG_DUMP);
3331         }
3332       /* linkonce section to be combined with .debug_info at link time.  */
3333       else if ((do_debugging || do_debug_info)
3334                && strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
3335         request_dump (i, DEBUG_DUMP);
3336       else if (do_debug_frames && strcmp (name, ".eh_frame") == 0)
3337         request_dump (i, DEBUG_DUMP);
3338     }
3339
3340   if (! do_sections)
3341     return 1;
3342
3343   printf (_("\nSection Header%s:\n"), elf_header.e_shnum > 1 ? "s" : "");
3344
3345   if (is_32bit_elf)
3346     printf
3347       (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
3348   else if (do_wide)
3349     printf
3350       (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
3351   else
3352     {
3353       printf (_("  [Nr] Name              Type             Address           Offset\n"));
3354       printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
3355     }
3356
3357   for (i = 0, section = section_headers;
3358        i < elf_header.e_shnum;
3359        i ++, section ++)
3360     {
3361       printf ("  [%2u] %-17.17s %-15.15s ",
3362               SECTION_HEADER_NUM (i),
3363               SECTION_NAME (section),
3364               get_section_type_name (section->sh_type));
3365
3366       if (is_32bit_elf)
3367         {
3368           print_vma (section->sh_addr, LONG_HEX);
3369
3370           printf ( " %6.6lx %6.6lx %2.2lx",
3371                    (unsigned long) section->sh_offset,
3372                    (unsigned long) section->sh_size,
3373                    (unsigned long) section->sh_entsize);
3374
3375           printf (" %3s ", get_elf_section_flags (section->sh_flags));
3376
3377           printf ("%2ld %3lx %2ld\n",
3378                   (unsigned long) section->sh_link,
3379                   (unsigned long) section->sh_info,
3380                   (unsigned long) section->sh_addralign);
3381         }
3382       else if (do_wide)
3383         {
3384           print_vma (section->sh_addr, LONG_HEX);
3385
3386           if ((long) section->sh_offset == section->sh_offset)
3387             printf (" %6.6lx", (unsigned long) section->sh_offset);
3388           else
3389             {
3390               putchar (' ');
3391               print_vma (section->sh_offset, LONG_HEX);
3392             }
3393
3394           if ((unsigned long) section->sh_size == section->sh_size)
3395             printf (" %6.6lx", (unsigned long) section->sh_size);
3396           else
3397             {
3398               putchar (' ');
3399               print_vma (section->sh_size, LONG_HEX);
3400             }
3401
3402           if ((unsigned long) section->sh_entsize == section->sh_entsize)
3403             printf (" %2.2lx", (unsigned long) section->sh_entsize);
3404           else
3405             {
3406               putchar (' ');
3407               print_vma (section->sh_entsize, LONG_HEX);
3408             }
3409
3410           printf (" %3s ", get_elf_section_flags (section->sh_flags));
3411
3412           printf ("%2ld %3lx ",
3413                   (unsigned long) section->sh_link,
3414                   (unsigned long) section->sh_info);
3415
3416           if ((unsigned long) section->sh_addralign == section->sh_addralign)
3417             printf ("%2ld\n", (unsigned long) section->sh_addralign);
3418           else
3419             {
3420               print_vma (section->sh_addralign, DEC);
3421               putchar ('\n');
3422             }
3423         }
3424       else
3425         {
3426           putchar (' ');
3427           print_vma (section->sh_addr, LONG_HEX);
3428           if ((long) section->sh_offset == section->sh_offset)
3429             printf ("  %8.8lx", (unsigned long) section->sh_offset);
3430           else
3431             {
3432               printf ("  ");
3433               print_vma (section->sh_offset, LONG_HEX);
3434             }
3435           printf ("\n       ");
3436           print_vma (section->sh_size, LONG_HEX);
3437           printf ("  ");
3438           print_vma (section->sh_entsize, LONG_HEX);
3439
3440           printf (" %3s ", get_elf_section_flags (section->sh_flags));
3441
3442           printf ("     %2ld   %3lx     %ld\n",
3443                   (unsigned long) section->sh_link,
3444                   (unsigned long) section->sh_info,
3445                   (unsigned long) section->sh_addralign);
3446         }
3447     }
3448
3449   printf (_("Key to Flags:\n\
3450   W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3451   I (info), L (link order), G (group), x (unknown)\n\
3452   O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3453
3454   return 1;
3455 }
3456
3457 /* Process the reloc section.  */
3458 static int
3459 process_relocs (file)
3460      FILE * file;
3461 {
3462   unsigned long    rel_size;
3463   unsigned long    rel_offset;
3464
3465
3466   if (!do_reloc)
3467     return 1;
3468
3469   if (do_using_dynamic)
3470     {
3471       int is_rela = FALSE;
3472
3473       rel_size   = 0;
3474       rel_offset = 0;
3475
3476       if (dynamic_info[DT_REL])
3477         {
3478           rel_offset = dynamic_info[DT_REL];
3479           rel_size   = dynamic_info[DT_RELSZ];
3480           is_rela    = FALSE;
3481         }
3482       else if (dynamic_info [DT_RELA])
3483         {
3484           rel_offset = dynamic_info[DT_RELA];
3485           rel_size   = dynamic_info[DT_RELASZ];
3486           is_rela    = TRUE;
3487         }
3488       else if (dynamic_info[DT_JMPREL])
3489         {
3490           rel_offset = dynamic_info[DT_JMPREL];
3491           rel_size   = dynamic_info[DT_PLTRELSZ];
3492
3493           switch (dynamic_info[DT_PLTREL])
3494             {
3495             case DT_REL:
3496               is_rela = FALSE;
3497               break;
3498             case DT_RELA:
3499               is_rela = TRUE;
3500               break;
3501             default:
3502               is_rela = UNKNOWN;
3503               break;
3504             }
3505         }
3506
3507       if (rel_size)
3508         {
3509           printf
3510             (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3511              rel_offset, rel_size);
3512
3513           dump_relocations (file, rel_offset - loadaddr, rel_size,
3514                             dynamic_symbols, num_dynamic_syms, dynamic_strings, is_rela);
3515         }
3516       else
3517         printf (_("\nThere are no dynamic relocations in this file.\n"));
3518     }
3519   else
3520     {
3521       Elf32_Internal_Shdr *     section;
3522       unsigned long             i;
3523       int               found = 0;
3524
3525       for (i = 0, section = section_headers;
3526            i < elf_header.e_shnum;
3527            i++, section ++)
3528         {
3529           if (   section->sh_type != SHT_RELA
3530               && section->sh_type != SHT_REL)
3531             continue;
3532
3533           rel_offset = section->sh_offset;
3534           rel_size   = section->sh_size;
3535
3536           if (rel_size)
3537             {
3538               Elf32_Internal_Shdr * strsec;
3539               Elf_Internal_Sym *    symtab;
3540               char *                strtab;
3541               int                   is_rela;
3542               unsigned long         nsyms;
3543
3544               printf (_("\nRelocation section "));
3545
3546               if (string_table == NULL)
3547                 printf ("%d", section->sh_name);
3548               else
3549                 printf ("'%s'", SECTION_NAME (section));
3550
3551               printf (_(" at offset 0x%lx contains %lu entries:\n"),
3552                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
3553
3554               symtab = NULL;
3555               strtab = NULL;
3556               nsyms = 0;
3557               if (section->sh_link)
3558                 {
3559                   Elf32_Internal_Shdr * symsec;
3560
3561                   symsec = SECTION_HEADER (section->sh_link);
3562                   nsyms = symsec->sh_size / symsec->sh_entsize;
3563                   symtab = GET_ELF_SYMBOLS (file, symsec);
3564
3565                   if (symtab == NULL)
3566                     continue;
3567
3568                   strsec = SECTION_HEADER (symsec->sh_link);
3569
3570                   strtab = (char *) get_data (NULL, file, strsec->sh_offset,
3571                                               strsec->sh_size,
3572                                               _("string table"));
3573                 }
3574               is_rela = section->sh_type == SHT_RELA;
3575
3576               dump_relocations (file, rel_offset, rel_size,
3577                                 symtab, nsyms, strtab, is_rela);
3578
3579               if (strtab)
3580                 free (strtab);
3581               if (symtab)
3582                 free (symtab);
3583
3584               found = 1;
3585             }
3586         }
3587
3588       if (! found)
3589         printf (_("\nThere are no relocations in this file.\n"));
3590     }
3591
3592   return 1;
3593 }
3594
3595 #include "unwind-ia64.h"
3596
3597 /* An absolute address consists of a section and an offset.  If the
3598    section is NULL, the offset itself is the address, otherwise, the
3599    address equals to LOAD_ADDRESS(section) + offset.  */
3600
3601 struct absaddr
3602   {
3603     unsigned short section;
3604     bfd_vma offset;
3605   };
3606
3607 struct unw_aux_info
3608   {
3609     struct unw_table_entry
3610       {
3611         struct absaddr    start;
3612         struct absaddr    end;
3613         struct absaddr    info;
3614       }
3615     *table;                             /* Unwind table.  */
3616     unsigned long         table_len;    /* Length of unwind table.  */
3617     unsigned char *       info;         /* Unwind info.  */
3618     unsigned long         info_size;    /* Size of unwind info.  */
3619     bfd_vma               info_addr;    /* starting address of unwind info.  */
3620     bfd_vma               seg_base;     /* Starting address of segment.  */
3621     Elf_Internal_Sym *    symtab;       /* The symbol table.  */
3622     unsigned              long nsyms;   /* Number of symbols.  */
3623     char *                strtab;       /* The string table.  */
3624     unsigned long         strtab_size;  /* Size of string table.  */
3625   };
3626
3627 static void find_symbol_for_address PARAMS ((struct unw_aux_info *,
3628                                              struct absaddr, const char **,
3629                                              bfd_vma *));
3630 static void dump_ia64_unwind PARAMS ((struct unw_aux_info *));
3631 static int  slurp_ia64_unwind_table PARAMS ((FILE *, struct unw_aux_info *,
3632                                             Elf32_Internal_Shdr *));
3633
3634 static void
3635 find_symbol_for_address (aux, addr, symname, offset)
3636      struct unw_aux_info *aux;
3637      struct absaddr addr;
3638      const char **symname;
3639      bfd_vma *offset;
3640 {
3641   bfd_vma dist = (bfd_vma) 0x100000;
3642   Elf_Internal_Sym *sym, *best = NULL;
3643   unsigned long i;
3644
3645   for (i = 0, sym = aux->symtab; i < aux->nsyms; ++i, ++sym)
3646     {
3647       if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
3648           && sym->st_name != 0
3649           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
3650           && addr.offset >= sym->st_value
3651           && addr.offset - sym->st_value < dist)
3652         {
3653           best = sym;
3654           dist = addr.offset - sym->st_value;
3655           if (!dist)
3656             break;
3657         }
3658     }
3659   if (best)
3660     {
3661       *symname = (best->st_name >= aux->strtab_size
3662                   ? "<corrupt>" : aux->strtab + best->st_name);
3663       *offset = dist;
3664       return;
3665     }
3666   *symname = NULL;
3667   *offset = addr.offset;
3668 }
3669
3670 static void
3671 dump_ia64_unwind (aux)
3672      struct unw_aux_info *aux;
3673 {
3674   bfd_vma addr_size;
3675   struct unw_table_entry * tp;
3676   int in_body;
3677
3678   addr_size = is_32bit_elf ? 4 : 8;
3679
3680   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
3681     {
3682       bfd_vma stamp;
3683       bfd_vma offset;
3684       const unsigned char * dp;
3685       const unsigned char * head;
3686       const char * procname;
3687
3688       find_symbol_for_address (aux, tp->start, &procname, &offset);
3689
3690       fputs ("\n<", stdout);
3691
3692       if (procname)
3693         {
3694           fputs (procname, stdout);
3695
3696           if (offset)
3697             printf ("+%lx", (unsigned long) offset);
3698         }
3699
3700       fputs (">: [", stdout);
3701       print_vma (tp->start.offset, PREFIX_HEX);
3702       fputc ('-', stdout);
3703       print_vma (tp->end.offset, PREFIX_HEX);
3704       printf ("), info at +0x%lx\n",
3705               (unsigned long) (tp->info.offset - aux->seg_base));
3706
3707       head = aux->info + (tp->info.offset - aux->info_addr);
3708       stamp = BYTE_GET8 ((unsigned char *) head);
3709
3710       printf ("  v%u, flags=0x%lx (%s%s ), len=%lu bytes\n",
3711               (unsigned) UNW_VER (stamp),
3712               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
3713               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
3714               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
3715               (unsigned long) (addr_size * UNW_LENGTH (stamp)));
3716
3717       if (UNW_VER (stamp) != 1)
3718         {
3719           printf ("\tUnknown version.\n");
3720           continue;
3721         }
3722
3723       in_body = 0;
3724       for (dp = head + 8; dp < head + 8 + addr_size * UNW_LENGTH (stamp);)
3725         dp = unw_decode (dp, in_body, & in_body);
3726     }
3727 }
3728
3729 static int
3730 slurp_ia64_unwind_table (file, aux, sec)
3731      FILE *file;
3732      struct unw_aux_info *aux;
3733      Elf32_Internal_Shdr *sec;
3734 {
3735   unsigned long size, addr_size, nrelas, i;
3736   Elf_Internal_Phdr *prog_hdrs, *seg;
3737   struct unw_table_entry *tep;
3738   Elf32_Internal_Shdr *relsec;
3739   Elf_Internal_Rela *rela, *rp;
3740   unsigned char *table, *tp;
3741   Elf_Internal_Sym *sym;
3742   const char *relname;
3743   int result;
3744
3745   addr_size = is_32bit_elf ? 4 : 8;
3746
3747   /* First, find the starting address of the segment that includes
3748      this section: */
3749
3750   if (elf_header.e_phnum)
3751     {
3752       prog_hdrs = (Elf_Internal_Phdr *)
3753         xmalloc (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
3754
3755       if (is_32bit_elf)
3756         result = get_32bit_program_headers (file, prog_hdrs);
3757       else
3758         result = get_64bit_program_headers (file, prog_hdrs);
3759
3760       if (!result)
3761         {
3762           free (prog_hdrs);
3763           return 0;
3764         }
3765
3766       for (seg = prog_hdrs; seg < prog_hdrs + elf_header.e_phnum; ++seg)
3767         {
3768           if (seg->p_type != PT_LOAD)
3769             continue;
3770
3771           if (sec->sh_addr >= seg->p_vaddr
3772               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
3773             {
3774               aux->seg_base = seg->p_vaddr;
3775               break;
3776             }
3777         }
3778
3779       free (prog_hdrs);
3780     }
3781
3782   /* Second, build the unwind table from the contents of the unwind section:  */
3783   size = sec->sh_size;
3784   table = (char *) get_data (NULL, file, sec->sh_offset,
3785                              size, _("unwind table"));
3786   if (!table)
3787     return 0;
3788
3789   tep = aux->table = xmalloc (size / (3 * addr_size) * sizeof (aux->table[0]));
3790   for (tp = table; tp < table + size; tp += 3 * addr_size, ++ tep)
3791     {
3792       tep->start.section = SHN_UNDEF;
3793       tep->end.section   = SHN_UNDEF;
3794       tep->info.section  = SHN_UNDEF;
3795       if (is_32bit_elf)
3796         {
3797           tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
3798           tep->end.offset   = byte_get ((unsigned char *) tp + 4, 4);
3799           tep->info.offset  = byte_get ((unsigned char *) tp + 8, 4);
3800         }
3801       else
3802         {
3803           tep->start.offset = BYTE_GET8 ((unsigned char *) tp +  0);
3804           tep->end.offset   = BYTE_GET8 ((unsigned char *) tp +  8);
3805           tep->info.offset  = BYTE_GET8 ((unsigned char *) tp + 16);
3806         }
3807       tep->start.offset += aux->seg_base;
3808       tep->end.offset   += aux->seg_base;
3809       tep->info.offset  += aux->seg_base;
3810     }
3811   free (table);
3812
3813   /* Third, apply any relocations to the unwind table: */
3814
3815   for (relsec = section_headers;
3816        relsec < section_headers + elf_header.e_shnum;
3817        ++relsec)
3818     {
3819       if (relsec->sh_type != SHT_RELA
3820           || SECTION_HEADER (relsec->sh_info) != sec)
3821         continue;
3822
3823       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
3824                               & rela, & nrelas))
3825         return 0;
3826
3827       for (rp = rela; rp < rela + nrelas; ++rp)
3828         {
3829           if (is_32bit_elf)
3830             {
3831               relname = elf_ia64_reloc_type (ELF32_R_TYPE (rp->r_info));
3832               sym = aux->symtab + ELF32_R_SYM (rp->r_info);
3833
3834               if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
3835                 {
3836                   warn (_("Skipping unexpected symbol type %u\n"),
3837                         ELF32_ST_TYPE (sym->st_info));
3838                   continue;
3839                 }
3840             }
3841           else
3842             {
3843               relname = elf_ia64_reloc_type (ELF64_R_TYPE (rp->r_info));
3844               sym = aux->symtab + ELF64_R_SYM (rp->r_info);
3845
3846               if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
3847                 {
3848                   warn (_("Skipping unexpected symbol type %u\n"),
3849                         ELF64_ST_TYPE (sym->st_info));
3850                   continue;
3851                 }
3852             }
3853
3854           if (strncmp (relname, "R_IA64_SEGREL", 13) != 0)
3855             {
3856               warn (_("Skipping unexpected relocation type %s\n"), relname);
3857               continue;
3858             }
3859
3860           i = rp->r_offset / (3 * addr_size);
3861
3862           switch (rp->r_offset/addr_size % 3)
3863             {
3864             case 0:
3865               aux->table[i].start.section = sym->st_shndx;
3866               aux->table[i].start.offset += rp->r_addend;
3867               break;
3868             case 1:
3869               aux->table[i].end.section   = sym->st_shndx;
3870               aux->table[i].end.offset   += rp->r_addend;
3871               break;
3872             case 2:
3873               aux->table[i].info.section  = sym->st_shndx;
3874               aux->table[i].info.offset  += rp->r_addend;
3875               break;
3876             default:
3877               break;
3878             }
3879         }
3880
3881       free (rela);
3882     }
3883
3884   aux->table_len = size / (3 * addr_size);
3885   return 1;
3886 }
3887
3888 static int
3889 process_unwind (file)
3890      FILE * file;
3891 {
3892   Elf32_Internal_Shdr *sec, *unwsec = NULL, *strsec;
3893   unsigned long i, addr_size, unwcount = 0, unwstart = 0;
3894   struct unw_aux_info aux;
3895
3896   if (!do_unwind)
3897     return 1;
3898
3899   if (elf_header.e_machine != EM_IA_64)
3900     {
3901       printf (_("\nThere are no unwind sections in this file.\n"));
3902       return 1;
3903     }
3904
3905   memset (& aux, 0, sizeof (aux));
3906
3907   addr_size = is_32bit_elf ? 4 : 8;
3908
3909   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
3910     {
3911       if (sec->sh_type == SHT_SYMTAB)
3912         {
3913           aux.nsyms = sec->sh_size / sec->sh_entsize;
3914           aux.symtab = GET_ELF_SYMBOLS (file, sec);
3915
3916           strsec = SECTION_HEADER (sec->sh_link);
3917           aux.strtab_size = strsec->sh_size;
3918           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
3919                                           aux.strtab_size, _("string table"));
3920         }
3921       else if (sec->sh_type == SHT_IA_64_UNWIND)
3922         unwcount++;
3923     }
3924
3925   if (!unwcount)
3926     printf (_("\nThere are no unwind sections in this file.\n"));
3927
3928   while (unwcount-- > 0)
3929     {
3930       char *suffix;
3931       size_t len, len2;
3932
3933       for (i = unwstart, sec = section_headers + unwstart;
3934            i < elf_header.e_shnum; ++i, ++sec)
3935         if (sec->sh_type == SHT_IA_64_UNWIND)
3936           {
3937             unwsec = sec;
3938             break;
3939           }
3940
3941       unwstart = i + 1;
3942       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
3943
3944       if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once,
3945                    len) == 0)
3946         {
3947           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
3948           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
3949           suffix = SECTION_NAME (unwsec) + len;
3950           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
3951                ++i, ++sec)
3952             if (strncmp (SECTION_NAME (sec),
3953                          ELF_STRING_ia64_unwind_info_once, len2) == 0
3954                 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
3955               break;
3956         }
3957       else
3958         {
3959           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
3960              .IA_64.unwind or BAR -> .IA_64.unwind_info */
3961           len = sizeof (ELF_STRING_ia64_unwind) - 1;
3962           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
3963           suffix = "";
3964           if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind,
3965                        len) == 0)
3966             suffix = SECTION_NAME (unwsec) + len;
3967           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
3968                ++i, ++sec)
3969             if (strncmp (SECTION_NAME (sec),
3970                          ELF_STRING_ia64_unwind_info, len2) == 0
3971                 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
3972               break;
3973         }
3974
3975       if (i == elf_header.e_shnum)
3976         {
3977           printf (_("\nCould not find unwind info section for "));
3978
3979           if (string_table == NULL)
3980             printf ("%d", unwsec->sh_name);
3981           else
3982             printf ("'%s'", SECTION_NAME (unwsec));
3983         }
3984       else
3985         {
3986           aux.info_size = sec->sh_size;
3987           aux.info_addr = sec->sh_addr;
3988           aux.info = (char *) get_data (NULL, file, sec->sh_offset,
3989                                         aux.info_size, _("unwind info"));
3990
3991           printf (_("\nUnwind section "));
3992
3993           if (string_table == NULL)
3994             printf ("%d", unwsec->sh_name);
3995           else
3996             printf ("'%s'", SECTION_NAME (unwsec));
3997
3998           printf (_(" at offset 0x%lx contains %lu entries:\n"),
3999                   (unsigned long) unwsec->sh_offset,
4000                   (unsigned long) (unwsec->sh_size / (3 * addr_size)));
4001
4002           (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4003
4004           if (aux.table_len > 0)
4005             dump_ia64_unwind (& aux);
4006
4007           if (aux.table)
4008             free ((char *) aux.table);
4009           if (aux.info)
4010             free ((char *) aux.info);
4011           aux.table = NULL;
4012           aux.info = NULL;
4013         }
4014     }
4015
4016   if (aux.symtab)
4017     free (aux.symtab);
4018   if (aux.strtab)
4019     free ((char *) aux.strtab);
4020
4021   return 1;
4022 }
4023
4024 static void
4025 dynamic_segment_mips_val (entry)
4026      Elf_Internal_Dyn * entry;
4027 {
4028   switch (entry->d_tag)
4029     {
4030     case DT_MIPS_FLAGS:
4031       if (entry->d_un.d_val == 0)
4032         printf ("NONE\n");
4033       else
4034         {
4035           static const char * opts[] =
4036           {
4037             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4038             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4039             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4040             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4041             "RLD_ORDER_SAFE"
4042           };
4043           unsigned int cnt;
4044           int first = 1;
4045           for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
4046             if (entry->d_un.d_val & (1 << cnt))
4047               {
4048                 printf ("%s%s", first ? "" : " ", opts[cnt]);
4049                 first = 0;
4050               }
4051           puts ("");
4052         }
4053       break;
4054
4055     case DT_MIPS_IVERSION:
4056       if (dynamic_strings != NULL)
4057         printf ("Interface Version: %s\n",
4058                 dynamic_strings + entry->d_un.d_val);
4059       else
4060         printf ("%ld\n", (long) entry->d_un.d_ptr);
4061       break;
4062
4063     case DT_MIPS_TIME_STAMP:
4064       {
4065         char timebuf[20];
4066         struct tm * tmp;
4067
4068         time_t time = entry->d_un.d_val;
4069         tmp = gmtime (&time);
4070         sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
4071                  tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
4072                  tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4073         printf ("Time Stamp: %s\n", timebuf);
4074       }
4075       break;
4076
4077     case DT_MIPS_RLD_VERSION:
4078     case DT_MIPS_LOCAL_GOTNO:
4079     case DT_MIPS_CONFLICTNO:
4080     case DT_MIPS_LIBLISTNO:
4081     case DT_MIPS_SYMTABNO:
4082     case DT_MIPS_UNREFEXTNO:
4083     case DT_MIPS_HIPAGENO:
4084     case DT_MIPS_DELTA_CLASS_NO:
4085     case DT_MIPS_DELTA_INSTANCE_NO:
4086     case DT_MIPS_DELTA_RELOC_NO:
4087     case DT_MIPS_DELTA_SYM_NO:
4088     case DT_MIPS_DELTA_CLASSSYM_NO:
4089     case DT_MIPS_COMPACT_SIZE:
4090       printf ("%ld\n", (long) entry->d_un.d_ptr);
4091       break;
4092
4093     default:
4094       printf ("%#lx\n", (long) entry->d_un.d_ptr);
4095     }
4096 }
4097
4098
4099 static void
4100 dynamic_segment_parisc_val (entry)
4101      Elf_Internal_Dyn * entry;
4102 {
4103   switch (entry->d_tag)
4104     {
4105     case DT_HP_DLD_FLAGS:
4106       {
4107         static struct
4108         {
4109           long int bit;
4110           const char * str;
4111         }
4112         flags[] =
4113         {
4114           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
4115           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
4116           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
4117           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
4118           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
4119           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
4120           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
4121           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
4122           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
4123           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
4124           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
4125         };
4126         int first = 1;
4127         size_t cnt;
4128         bfd_vma val = entry->d_un.d_val;
4129
4130         for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
4131           if (val & flags[cnt].bit)
4132             {
4133               if (! first)
4134                 putchar (' ');
4135               fputs (flags[cnt].str, stdout);
4136               first = 0;
4137               val ^= flags[cnt].bit;
4138             }
4139
4140         if (val != 0 || first)
4141           {
4142             if (! first)
4143               putchar (' ');
4144             print_vma (val, HEX);
4145           }
4146       }
4147       break;
4148
4149     default:
4150       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
4151       break;
4152     }
4153 }
4154
4155 static int
4156 get_32bit_dynamic_segment (file)
4157      FILE * file;
4158 {
4159   Elf32_External_Dyn * edyn;
4160   Elf_Internal_Dyn *   entry;
4161   bfd_size_type        i;
4162
4163   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr,
4164                                           dynamic_size, _("dynamic segment"));
4165   if (!edyn)
4166     return 0;
4167
4168   /* SGI's ELF has more than one section in the DYNAMIC segment.  Determine
4169      how large this .dynamic is now.  We can do this even before the byte
4170      swapping since the DT_NULL tag is recognizable.  */
4171   dynamic_size = 0;
4172   while (*(Elf32_Word *) edyn [dynamic_size++].d_tag != DT_NULL)
4173     ;
4174
4175   dynamic_segment = (Elf_Internal_Dyn *)
4176     malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
4177
4178   if (dynamic_segment == NULL)
4179     {
4180       error (_("Out of memory\n"));
4181       free (edyn);
4182       return 0;
4183     }
4184
4185   for (i = 0, entry = dynamic_segment;
4186        i < dynamic_size;
4187        i ++, entry ++)
4188     {
4189       entry->d_tag      = BYTE_GET (edyn [i].d_tag);
4190       entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
4191     }
4192
4193   free (edyn);
4194
4195   return 1;
4196 }
4197
4198 static int
4199 get_64bit_dynamic_segment (file)
4200      FILE * file;
4201 {
4202   Elf64_External_Dyn * edyn;
4203   Elf_Internal_Dyn *   entry;
4204   bfd_size_type        i;
4205
4206   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr,
4207                                           dynamic_size, _("dynamic segment"));
4208   if (!edyn)
4209     return 0;
4210
4211   /* SGI's ELF has more than one section in the DYNAMIC segment.  Determine
4212      how large this .dynamic is now.  We can do this even before the byte
4213      swapping since the DT_NULL tag is recognizable.  */
4214   dynamic_size = 0;
4215   while (*(bfd_vma *) edyn [dynamic_size ++].d_tag != DT_NULL)
4216     ;
4217
4218   dynamic_segment = (Elf_Internal_Dyn *)
4219     malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
4220
4221   if (dynamic_segment == NULL)
4222     {
4223       error (_("Out of memory\n"));
4224       free (edyn);
4225       return 0;
4226     }
4227
4228   for (i = 0, entry = dynamic_segment;
4229        i < dynamic_size;
4230        i ++, entry ++)
4231     {
4232       entry->d_tag      = BYTE_GET8 (edyn [i].d_tag);
4233       entry->d_un.d_val = BYTE_GET8 (edyn [i].d_un.d_val);
4234     }
4235
4236   free (edyn);
4237
4238   return 1;
4239 }
4240
4241 static const char *
4242 get_dynamic_flags (flags)
4243      bfd_vma flags;
4244 {
4245   static char buff [64];
4246   while (flags)
4247     {
4248       bfd_vma flag;
4249
4250       flag = flags & - flags;
4251       flags &= ~ flag;
4252
4253       switch (flag)
4254         {
4255         case DF_ORIGIN:   strcat (buff, "ORIGIN "); break;
4256         case DF_SYMBOLIC: strcat (buff, "SYMBOLIC "); break;
4257         case DF_TEXTREL:  strcat (buff, "TEXTREL "); break;
4258         case DF_BIND_NOW: strcat (buff, "BIND_NOW "); break;
4259         default:          strcat (buff, "unknown "); break;
4260         }
4261     }
4262   return buff;
4263 }
4264
4265 /* Parse and display the contents of the dynamic segment.  */
4266 static int
4267 process_dynamic_segment (file)
4268      FILE * file;
4269 {
4270   Elf_Internal_Dyn * entry;
4271   bfd_size_type      i;
4272
4273   if (dynamic_size == 0)
4274     {
4275       if (do_dynamic)
4276         printf (_("\nThere is no dynamic segment in this file.\n"));
4277
4278       return 1;
4279     }
4280
4281   if (is_32bit_elf)
4282     {
4283       if (! get_32bit_dynamic_segment (file))
4284         return 0;
4285     }
4286   else if (! get_64bit_dynamic_segment (file))
4287     return 0;
4288
4289   /* Find the appropriate symbol table.  */
4290   if (dynamic_symbols == NULL)
4291     {
4292       for (i = 0, entry = dynamic_segment;
4293            i < dynamic_size;
4294            ++i, ++ entry)
4295         {
4296           Elf32_Internal_Shdr section;
4297
4298           if (entry->d_tag != DT_SYMTAB)
4299             continue;
4300
4301           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
4302
4303           /* Since we do not know how big the symbol table is,
4304              we default to reading in the entire file (!) and
4305              processing that.  This is overkill, I know, but it
4306              should work.  */
4307           section.sh_offset = entry->d_un.d_val - loadaddr;
4308
4309           if (fseek (file, 0, SEEK_END))
4310             error (_("Unable to seek to end of file!"));
4311
4312           section.sh_size = ftell (file) - section.sh_offset;
4313           if (is_32bit_elf)
4314             section.sh_entsize = sizeof (Elf32_External_Sym);
4315           else
4316             section.sh_entsize = sizeof (Elf64_External_Sym);
4317
4318           num_dynamic_syms = section.sh_size / section.sh_entsize;
4319           if (num_dynamic_syms < 1)
4320             {
4321               error (_("Unable to determine the number of symbols to load\n"));
4322               continue;
4323             }
4324
4325           dynamic_symbols = GET_ELF_SYMBOLS (file, &section);
4326         }
4327     }
4328
4329   /* Similarly find a string table.  */
4330   if (dynamic_strings == NULL)
4331     {
4332       for (i = 0, entry = dynamic_segment;
4333            i < dynamic_size;
4334            ++i, ++ entry)
4335         {
4336           unsigned long offset;
4337           long          str_tab_len;
4338
4339           if (entry->d_tag != DT_STRTAB)
4340             continue;
4341
4342           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
4343
4344           /* Since we do not know how big the string table is,
4345              we default to reading in the entire file (!) and
4346              processing that.  This is overkill, I know, but it
4347              should work.  */
4348
4349           offset = entry->d_un.d_val - loadaddr;
4350           if (fseek (file, 0, SEEK_END))
4351             error (_("Unable to seek to end of file\n"));
4352           str_tab_len = ftell (file) - offset;
4353
4354           if (str_tab_len < 1)
4355             {
4356               error
4357                 (_("Unable to determine the length of the dynamic string table\n"));
4358               continue;
4359             }
4360
4361           dynamic_strings = (char *) get_data (NULL, file, offset, str_tab_len,
4362                                                _("dynamic string table"));
4363           break;
4364         }
4365     }
4366
4367   /* And find the syminfo section if available.  */
4368   if (dynamic_syminfo == NULL)
4369     {
4370       unsigned int syminsz = 0;
4371
4372       for (i = 0, entry = dynamic_segment;
4373            i < dynamic_size;
4374            ++i, ++ entry)
4375         {
4376           if (entry->d_tag == DT_SYMINENT)
4377             {
4378               /* Note: these braces are necessary to avoid a syntax
4379                  error from the SunOS4 C compiler.  */
4380               assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
4381             }
4382           else if (entry->d_tag == DT_SYMINSZ)
4383             syminsz = entry->d_un.d_val;
4384           else if (entry->d_tag == DT_SYMINFO)
4385             dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
4386         }
4387
4388       if (dynamic_syminfo_offset != 0 && syminsz != 0)
4389         {
4390           Elf_External_Syminfo * extsyminfo;
4391           Elf_Internal_Syminfo * syminfo;
4392
4393           /* There is a syminfo section.  Read the data.  */
4394           extsyminfo = ((Elf_External_Syminfo *)
4395                         get_data (NULL, file, dynamic_syminfo_offset,
4396                                   syminsz, _("symbol information")));
4397           if (!extsyminfo)
4398             return 0;
4399
4400           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
4401           if (dynamic_syminfo == NULL)
4402             {
4403               error (_("Out of memory\n"));
4404               return 0;
4405             }
4406
4407           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
4408           for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
4409                ++i, ++syminfo)
4410             {
4411               syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
4412               syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
4413             }
4414
4415           free (extsyminfo);
4416         }
4417     }
4418
4419   if (do_dynamic && dynamic_addr)
4420     printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
4421             dynamic_addr, (long) dynamic_size);
4422   if (do_dynamic)
4423     printf (_("  Tag        Type                         Name/Value\n"));
4424
4425   for (i = 0, entry = dynamic_segment;
4426        i < dynamic_size;
4427        i++, entry ++)
4428     {
4429       if (do_dynamic)
4430         {
4431           const char * dtype;
4432
4433           putchar (' ');
4434           print_vma (entry->d_tag, FULL_HEX);
4435           dtype = get_dynamic_type (entry->d_tag);
4436           printf (" (%s)%*s", dtype,
4437                   ((is_32bit_elf ? 27 : 19)
4438                    - (int) strlen (dtype)),
4439                   " ");
4440         }
4441
4442       switch (entry->d_tag)
4443         {
4444         case DT_FLAGS:
4445           if (do_dynamic)
4446             printf ("%s", get_dynamic_flags (entry->d_un.d_val));
4447           break;
4448
4449         case DT_AUXILIARY:
4450         case DT_FILTER:
4451         case DT_CONFIG:
4452         case DT_DEPAUDIT:
4453         case DT_AUDIT:
4454           if (do_dynamic)
4455             {
4456               switch (entry->d_tag)
4457                 {
4458                 case DT_AUXILIARY:
4459                   printf (_("Auxiliary library"));
4460                   break;
4461
4462                 case DT_FILTER:
4463                   printf (_("Filter library"));
4464                   break;
4465
4466                 case DT_CONFIG:
4467                   printf (_("Configuration file"));
4468                   break;
4469
4470                 case DT_DEPAUDIT:
4471                   printf (_("Dependency audit library"));
4472                   break;
4473
4474                 case DT_AUDIT:
4475                   printf (_("Audit library"));
4476                   break;
4477                 }
4478
4479               if (dynamic_strings)
4480                 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
4481               else
4482                 {
4483                   printf (": ");
4484                   print_vma (entry->d_un.d_val, PREFIX_HEX);
4485                   putchar ('\n');
4486                 }
4487             }
4488           break;
4489
4490         case DT_FEATURE:
4491           if (do_dynamic)
4492             {
4493               printf (_("Flags:"));
4494               if (entry->d_un.d_val == 0)
4495                 printf (_(" None\n"));
4496               else
4497                 {
4498                   unsigned long int val = entry->d_un.d_val;
4499                   if (val & DTF_1_PARINIT)
4500                     {
4501                       printf (" PARINIT");
4502                       val ^= DTF_1_PARINIT;
4503                     }
4504                   if (val & DTF_1_CONFEXP)
4505                     {
4506                       printf (" CONFEXP");
4507                       val ^= DTF_1_CONFEXP;
4508                     }
4509                   if (val != 0)
4510                     printf (" %lx", val);
4511                   puts ("");
4512                 }
4513             }
4514           break;
4515
4516         case DT_POSFLAG_1:
4517           if (do_dynamic)
4518             {
4519               printf (_("Flags:"));
4520               if (entry->d_un.d_val == 0)
4521                 printf (_(" None\n"));
4522               else
4523                 {
4524                   unsigned long int val = entry->d_un.d_val;
4525                   if (val & DF_P1_LAZYLOAD)
4526                     {
4527                       printf (" LAZYLOAD");
4528                       val ^= DF_P1_LAZYLOAD;
4529                     }
4530                   if (val & DF_P1_GROUPPERM)
4531                     {
4532                       printf (" GROUPPERM");
4533                       val ^= DF_P1_GROUPPERM;
4534                     }
4535                   if (val != 0)
4536                     printf (" %lx", val);
4537                   puts ("");
4538                 }
4539             }
4540           break;
4541
4542         case DT_FLAGS_1:
4543           if (do_dynamic)
4544             {
4545               printf (_("Flags:"));
4546               if (entry->d_un.d_val == 0)
4547                 printf (_(" None\n"));
4548               else
4549                 {
4550                   unsigned long int val = entry->d_un.d_val;
4551                   if (val & DF_1_NOW)
4552                     {
4553                       printf (" NOW");
4554                       val ^= DF_1_NOW;
4555                     }
4556                   if (val & DF_1_GLOBAL)
4557                     {
4558                       printf (" GLOBAL");
4559                       val ^= DF_1_GLOBAL;
4560                     }
4561                   if (val & DF_1_GROUP)
4562                     {
4563                       printf (" GROUP");
4564                       val ^= DF_1_GROUP;
4565                     }
4566                   if (val & DF_1_NODELETE)
4567                     {
4568                       printf (" NODELETE");
4569                       val ^= DF_1_NODELETE;
4570                     }
4571                   if (val & DF_1_LOADFLTR)
4572                     {
4573                       printf (" LOADFLTR");
4574                       val ^= DF_1_LOADFLTR;
4575                     }
4576                   if (val & DF_1_INITFIRST)
4577                     {
4578                       printf (" INITFIRST");
4579                       val ^= DF_1_INITFIRST;
4580                     }
4581                   if (val & DF_1_NOOPEN)
4582                     {
4583                       printf (" NOOPEN");
4584                       val ^= DF_1_NOOPEN;
4585                     }
4586                   if (val & DF_1_ORIGIN)
4587                     {
4588                       printf (" ORIGIN");
4589                       val ^= DF_1_ORIGIN;
4590                     }
4591                   if (val & DF_1_DIRECT)
4592                     {
4593                       printf (" DIRECT");
4594                       val ^= DF_1_DIRECT;
4595                     }
4596                   if (val & DF_1_TRANS)
4597                     {
4598                       printf (" TRANS");
4599                       val ^= DF_1_TRANS;
4600                     }
4601                   if (val & DF_1_INTERPOSE)
4602                     {
4603                       printf (" INTERPOSE");
4604                       val ^= DF_1_INTERPOSE;
4605                     }
4606                   if (val & DF_1_NODEFLIB)
4607                     {
4608                       printf (" NODEFLIB");
4609                       val ^= DF_1_NODEFLIB;
4610                     }
4611                   if (val & DF_1_NODUMP)
4612                     {
4613                       printf (" NODUMP");
4614                       val ^= DF_1_NODUMP;
4615                     }
4616                   if (val & DF_1_CONLFAT)
4617                     {
4618                       printf (" CONLFAT");
4619                       val ^= DF_1_CONLFAT;
4620                     }
4621                   if (val != 0)
4622                     printf (" %lx", val);
4623                   puts ("");
4624                 }
4625             }
4626           break;
4627
4628         case DT_PLTREL:
4629           if (do_dynamic)
4630             puts (get_dynamic_type (entry->d_un.d_val));
4631           break;
4632
4633         case DT_NULL    :
4634         case DT_NEEDED  :
4635         case DT_PLTGOT  :
4636         case DT_HASH    :
4637         case DT_STRTAB  :
4638         case DT_SYMTAB  :
4639         case DT_RELA    :
4640         case DT_INIT    :
4641         case DT_FINI    :
4642         case DT_SONAME  :
4643         case DT_RPATH   :
4644         case DT_SYMBOLIC:
4645         case DT_REL     :
4646         case DT_DEBUG   :
4647         case DT_TEXTREL :
4648         case DT_JMPREL  :
4649         case DT_RUNPATH :
4650           dynamic_info[entry->d_tag] = entry->d_un.d_val;
4651
4652           if (do_dynamic)
4653             {
4654               char * name;
4655
4656               if (dynamic_strings == NULL)
4657                 name = NULL;
4658               else
4659                 name = dynamic_strings + entry->d_un.d_val;
4660
4661               if (name)
4662                 {
4663                   switch (entry->d_tag)
4664                     {
4665                     case DT_NEEDED:
4666                       printf (_("Shared library: [%s]"), name);
4667
4668                       if (strcmp (name, program_interpreter) == 0)
4669                         printf (_(" program interpreter"));
4670                       break;
4671
4672                     case DT_SONAME:
4673                       printf (_("Library soname: [%s]"), name);
4674                       break;
4675
4676                     case DT_RPATH:
4677                       printf (_("Library rpath: [%s]"), name);
4678                       break;
4679
4680                     case DT_RUNPATH:
4681                       printf (_("Library runpath: [%s]"), name);
4682                       break;
4683
4684                     default:
4685                       print_vma (entry->d_un.d_val, PREFIX_HEX);
4686                       break;
4687                     }
4688                 }
4689               else
4690                 print_vma (entry->d_un.d_val, PREFIX_HEX);
4691
4692               putchar ('\n');
4693             }
4694           break;
4695
4696         case DT_PLTRELSZ:
4697         case DT_RELASZ  :
4698         case DT_STRSZ   :
4699         case DT_RELSZ   :
4700         case DT_RELAENT :
4701         case DT_SYMENT  :
4702         case DT_RELENT  :
4703         case DT_PLTPADSZ:
4704         case DT_MOVEENT :
4705         case DT_MOVESZ  :
4706         case DT_INIT_ARRAYSZ:
4707         case DT_FINI_ARRAYSZ:
4708           if (do_dynamic)
4709             {
4710               print_vma (entry->d_un.d_val, UNSIGNED);
4711               printf (" (bytes)\n");
4712             }
4713           break;
4714
4715         case DT_VERDEFNUM:
4716         case DT_VERNEEDNUM:
4717         case DT_RELACOUNT:
4718         case DT_RELCOUNT:
4719           if (do_dynamic)
4720             {
4721               print_vma (entry->d_un.d_val, UNSIGNED);
4722               putchar ('\n');
4723             }
4724           break;
4725
4726         case DT_SYMINSZ:
4727         case DT_SYMINENT:
4728         case DT_SYMINFO:
4729         case DT_USED:
4730         case DT_INIT_ARRAY:
4731         case DT_FINI_ARRAY:
4732           if (do_dynamic)
4733             {
4734               if (dynamic_strings != NULL && entry->d_tag == DT_USED)
4735                 {
4736                   char * name;
4737
4738                   name = dynamic_strings + entry->d_un.d_val;
4739
4740                   if (* name)
4741                     {
4742                       printf (_("Not needed object: [%s]\n"), name);
4743                       break;
4744                     }
4745                 }
4746
4747               print_vma (entry->d_un.d_val, PREFIX_HEX);
4748               putchar ('\n');
4749             }
4750           break;
4751
4752         case DT_BIND_NOW:
4753           /* The value of this entry is ignored.  */
4754           break;
4755
4756         default:
4757           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
4758             version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
4759               entry->d_un.d_val;
4760
4761           if (do_dynamic)
4762             {
4763               switch (elf_header.e_machine)
4764                 {
4765                 case EM_MIPS:
4766                 case EM_MIPS_RS3_LE:
4767                   dynamic_segment_mips_val (entry);
4768                   break;
4769                 case EM_PARISC:
4770                   dynamic_segment_parisc_val (entry);
4771                   break;
4772                 default:
4773                   print_vma (entry->d_un.d_val, PREFIX_HEX);
4774                   putchar ('\n');
4775                 }
4776             }
4777           break;
4778         }
4779     }
4780
4781   return 1;
4782 }
4783
4784 static char *
4785 get_ver_flags (flags)
4786      unsigned int flags;
4787 {
4788   static char buff [32];
4789
4790   buff[0] = 0;
4791
4792   if (flags == 0)
4793     return _("none");
4794
4795   if (flags & VER_FLG_BASE)
4796     strcat (buff, "BASE ");
4797
4798   if (flags & VER_FLG_WEAK)
4799     {
4800       if (flags & VER_FLG_BASE)
4801         strcat (buff, "| ");
4802
4803       strcat (buff, "WEAK ");
4804     }
4805
4806   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
4807     strcat (buff, "| <unknown>");
4808
4809   return buff;
4810 }
4811
4812 /* Display the contents of the version sections.  */
4813 static int
4814 process_version_sections (file)
4815      FILE * file;
4816 {
4817   Elf32_Internal_Shdr * section;
4818   unsigned   i;
4819   int        found = 0;
4820
4821   if (! do_version)
4822     return 1;
4823
4824   for (i = 0, section = section_headers;
4825        i < elf_header.e_shnum;
4826        i++, section ++)
4827     {
4828       switch (section->sh_type)
4829         {
4830         case SHT_GNU_verdef:
4831           {
4832             Elf_External_Verdef * edefs;
4833             unsigned int          idx;
4834             unsigned int          cnt;
4835
4836             found = 1;
4837
4838             printf
4839               (_("\nVersion definition section '%s' contains %ld entries:\n"),
4840                SECTION_NAME (section), section->sh_info);
4841
4842             printf (_("  Addr: 0x"));
4843             printf_vma (section->sh_addr);
4844             printf (_("  Offset: %#08lx  Link: %lx (%s)\n"),
4845                     (unsigned long) section->sh_offset, section->sh_link,
4846                     SECTION_NAME (SECTION_HEADER (section->sh_link)));
4847
4848             edefs = ((Elf_External_Verdef *)
4849                      get_data (NULL, file, section->sh_offset,
4850                                section->sh_size,
4851                                _("version definition section")));
4852             if (!edefs)
4853               break;
4854
4855             for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
4856               {
4857                 char *                 vstart;
4858                 Elf_External_Verdef *  edef;
4859                 Elf_Internal_Verdef    ent;
4860                 Elf_External_Verdaux * eaux;
4861                 Elf_Internal_Verdaux   aux;
4862                 int                    j;
4863                 int                    isum;
4864
4865                 vstart = ((char *) edefs) + idx;
4866
4867                 edef = (Elf_External_Verdef *) vstart;
4868
4869                 ent.vd_version = BYTE_GET (edef->vd_version);
4870                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
4871                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
4872                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
4873                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
4874                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
4875                 ent.vd_next    = BYTE_GET (edef->vd_next);
4876
4877                 printf (_("  %#06x: Rev: %d  Flags: %s"),
4878                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
4879
4880                 printf (_("  Index: %d  Cnt: %d  "),
4881                         ent.vd_ndx, ent.vd_cnt);
4882
4883                 vstart += ent.vd_aux;
4884
4885                 eaux = (Elf_External_Verdaux *) vstart;
4886
4887                 aux.vda_name = BYTE_GET (eaux->vda_name);
4888                 aux.vda_next = BYTE_GET (eaux->vda_next);
4889
4890                 if (dynamic_strings)
4891                   printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
4892                 else
4893                   printf (_("Name index: %ld\n"), aux.vda_name);
4894
4895                 isum = idx + ent.vd_aux;
4896
4897                 for (j = 1; j < ent.vd_cnt; j ++)
4898                   {
4899                     isum   += aux.vda_next;
4900                     vstart += aux.vda_next;
4901
4902                     eaux = (Elf_External_Verdaux *) vstart;
4903
4904                     aux.vda_name = BYTE_GET (eaux->vda_name);
4905                     aux.vda_next = BYTE_GET (eaux->vda_next);
4906
4907                     if (dynamic_strings)
4908                       printf (_("  %#06x: Parent %d: %s\n"),
4909                               isum, j, dynamic_strings + aux.vda_name);
4910                     else
4911                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
4912                               isum, j, aux.vda_name);
4913                   }
4914
4915                 idx += ent.vd_next;
4916               }
4917
4918             free (edefs);
4919           }
4920           break;
4921
4922         case SHT_GNU_verneed:
4923           {
4924             Elf_External_Verneed *  eneed;
4925             unsigned int            idx;
4926             unsigned int            cnt;
4927
4928             found = 1;
4929
4930             printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
4931                     SECTION_NAME (section), section->sh_info);
4932
4933             printf (_(" Addr: 0x"));
4934             printf_vma (section->sh_addr);
4935             printf (_("  Offset: %#08lx  Link to section: %ld (%s)\n"),
4936                     (unsigned long) section->sh_offset, section->sh_link,
4937                     SECTION_NAME (SECTION_HEADER (section->sh_link)));
4938
4939             eneed = ((Elf_External_Verneed *)
4940                      get_data (NULL, file, section->sh_offset,
4941                                section->sh_size, _("version need section")));
4942             if (!eneed)
4943               break;
4944
4945             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
4946               {
4947                 Elf_External_Verneed * entry;
4948                 Elf_Internal_Verneed     ent;
4949                 int                      j;
4950                 int                      isum;
4951                 char *                   vstart;
4952
4953                 vstart = ((char *) eneed) + idx;
4954
4955                 entry = (Elf_External_Verneed *) vstart;
4956
4957                 ent.vn_version = BYTE_GET (entry->vn_version);
4958                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
4959                 ent.vn_file    = BYTE_GET (entry->vn_file);
4960                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
4961                 ent.vn_next    = BYTE_GET (entry->vn_next);
4962
4963                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
4964
4965                 if (dynamic_strings)
4966                   printf (_("  File: %s"), dynamic_strings + ent.vn_file);
4967                 else
4968                   printf (_("  File: %lx"), ent.vn_file);
4969
4970                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
4971
4972                 vstart += ent.vn_aux;
4973
4974                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
4975                   {
4976                     Elf_External_Vernaux * eaux;
4977                     Elf_Internal_Vernaux   aux;
4978
4979                     eaux = (Elf_External_Vernaux *) vstart;
4980
4981                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
4982                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
4983                     aux.vna_other = BYTE_GET (eaux->vna_other);
4984                     aux.vna_name  = BYTE_GET (eaux->vna_name);
4985                     aux.vna_next  = BYTE_GET (eaux->vna_next);
4986
4987                     if (dynamic_strings)
4988                       printf (_("  %#06x: Name: %s"),
4989                               isum, dynamic_strings + aux.vna_name);
4990                     else
4991                       printf (_("  %#06x: Name index: %lx"),
4992                               isum, aux.vna_name);
4993
4994                     printf (_("  Flags: %s  Version: %d\n"),
4995                             get_ver_flags (aux.vna_flags), aux.vna_other);
4996
4997                     isum   += aux.vna_next;
4998                     vstart += aux.vna_next;
4999                   }
5000
5001                 idx += ent.vn_next;
5002               }
5003
5004             free (eneed);
5005           }
5006           break;
5007
5008         case SHT_GNU_versym:
5009           {
5010             Elf32_Internal_Shdr *       link_section;
5011             int                         total;
5012             int                         cnt;
5013             unsigned char *             edata;
5014             unsigned short *            data;
5015             char *                      strtab;
5016             Elf_Internal_Sym *          symbols;
5017             Elf32_Internal_Shdr *       string_sec;
5018
5019             link_section = SECTION_HEADER (section->sh_link);
5020             total = section->sh_size / section->sh_entsize;
5021
5022             found = 1;
5023
5024             symbols = GET_ELF_SYMBOLS (file, link_section);
5025
5026             string_sec = SECTION_HEADER (link_section->sh_link);
5027
5028             strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
5029                                         string_sec->sh_size,
5030                                         _("version string table"));
5031             if (!strtab)
5032               break;
5033
5034             printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5035                     SECTION_NAME (section), total);
5036
5037             printf (_(" Addr: "));
5038             printf_vma (section->sh_addr);
5039             printf (_("  Offset: %#08lx  Link: %lx (%s)\n"),
5040                     (unsigned long) section->sh_offset, section->sh_link,
5041                     SECTION_NAME (link_section));
5042
5043             edata =
5044               ((unsigned char *)
5045                get_data (NULL, file,
5046                          version_info[DT_VERSIONTAGIDX (DT_VERSYM)] - loadaddr,
5047                          total * sizeof (short), _("version symbol data")));
5048             if (!edata)
5049               {
5050                 free (strtab);
5051                 break;
5052               }
5053
5054             data = (unsigned short *) malloc (total * sizeof (short));
5055
5056             for (cnt = total; cnt --;)
5057               data [cnt] = byte_get (edata + cnt * sizeof (short),
5058                                      sizeof (short));
5059
5060             free (edata);
5061
5062             for (cnt = 0; cnt < total; cnt += 4)
5063               {
5064                 int j, nn;
5065                 int check_def, check_need;
5066                 char * name;
5067
5068                 printf ("  %03x:", cnt);
5069
5070                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
5071                   switch (data [cnt + j])
5072                     {
5073                     case 0:
5074                       fputs (_("   0 (*local*)    "), stdout);
5075                       break;
5076
5077                     case 1:
5078                       fputs (_("   1 (*global*)   "), stdout);
5079                       break;
5080
5081                     default:
5082                       nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
5083                                    data [cnt + j] & 0x8000 ? 'h' : ' ');
5084
5085                       check_def = 1;
5086                       check_need = 1;
5087                       if (SECTION_HEADER (symbols [cnt + j].st_shndx)->sh_type
5088                           != SHT_NOBITS)
5089                         {
5090                           if (symbols [cnt + j].st_shndx == SHN_UNDEF)
5091                             check_def = 0;
5092                           else
5093                             check_need = 0;
5094                         }
5095
5096                       if (check_need
5097                           && version_info [DT_VERSIONTAGIDX (DT_VERNEED)])
5098                         {
5099                           Elf_Internal_Verneed     ivn;
5100                           unsigned long            offset;
5101
5102                           offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
5103                             - loadaddr;
5104
5105                           do
5106                             {
5107                               Elf_Internal_Vernaux   ivna;
5108                               Elf_External_Verneed   evn;
5109                               Elf_External_Vernaux   evna;
5110                               unsigned long          a_off;
5111
5112                               get_data (&evn, file, offset, sizeof (evn),
5113                                         _("version need"));
5114
5115                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
5116                               ivn.vn_next = BYTE_GET (evn.vn_next);
5117
5118                               a_off = offset + ivn.vn_aux;
5119
5120                               do
5121                                 {
5122                                   get_data (&evna, file, a_off, sizeof (evna),
5123                                             _("version need aux (2)"));
5124
5125                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
5126                                   ivna.vna_other = BYTE_GET (evna.vna_other);
5127
5128                                   a_off += ivna.vna_next;
5129                                 }
5130                               while (ivna.vna_other != data [cnt + j]
5131                                      && ivna.vna_next != 0);
5132
5133                               if (ivna.vna_other == data [cnt + j])
5134                                 {
5135                                   ivna.vna_name = BYTE_GET (evna.vna_name);
5136
5137                                   name = strtab + ivna.vna_name;
5138                                   nn += printf ("(%s%-*s",
5139                                                 name,
5140                                                 12 - (int) strlen (name),
5141                                                 ")");
5142                                   check_def = 0;
5143                                   break;
5144                                 }
5145
5146                               offset += ivn.vn_next;
5147                             }
5148                           while (ivn.vn_next);
5149                         }
5150
5151                       if (check_def && data [cnt + j] != 0x8001
5152                           && version_info [DT_VERSIONTAGIDX (DT_VERDEF)])
5153                         {
5154                           Elf_Internal_Verdef  ivd;
5155                           Elf_External_Verdef  evd;
5156                           unsigned long        offset;
5157
5158                           offset = version_info
5159                             [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
5160
5161                           do
5162                             {
5163                               get_data (&evd, file, offset, sizeof (evd),
5164                                         _("version def"));
5165
5166                               ivd.vd_next = BYTE_GET (evd.vd_next);
5167                               ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
5168
5169                               offset += ivd.vd_next;
5170                             }
5171                           while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
5172                                  && ivd.vd_next != 0);
5173
5174                           if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
5175                             {
5176                               Elf_External_Verdaux  evda;
5177                               Elf_Internal_Verdaux  ivda;
5178
5179                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
5180
5181                               get_data (&evda, file,
5182                                         offset - ivd.vd_next + ivd.vd_aux,
5183                                         sizeof (evda), _("version def aux"));
5184
5185                               ivda.vda_name = BYTE_GET (evda.vda_name);
5186
5187                               name = strtab + ivda.vda_name;
5188                               nn += printf ("(%s%-*s",
5189                                             name,
5190                                             12 - (int) strlen (name),
5191                                             ")");
5192                             }
5193                         }
5194
5195                       if (nn < 18)
5196                         printf ("%*c", 18 - nn, ' ');
5197                     }
5198
5199                 putchar ('\n');
5200               }
5201
5202             free (data);
5203             free (strtab);
5204             free (symbols);
5205           }
5206           break;
5207
5208         default:
5209           break;
5210         }
5211     }
5212
5213   if (! found)
5214     printf (_("\nNo version information found in this file.\n"));
5215
5216   return 1;
5217 }
5218
5219 static const char *
5220 get_symbol_binding (binding)
5221      unsigned int binding;
5222 {
5223   static char buff [32];
5224
5225   switch (binding)
5226     {
5227     case STB_LOCAL:  return "LOCAL";
5228     case STB_GLOBAL: return "GLOBAL";
5229     case STB_WEAK:   return "WEAK";
5230     default:
5231       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
5232         sprintf (buff, _("<processor specific>: %d"), binding);
5233       else if (binding >= STB_LOOS && binding <= STB_HIOS)
5234         sprintf (buff, _("<OS specific>: %d"), binding);
5235       else
5236         sprintf (buff, _("<unknown>: %d"), binding);
5237       return buff;
5238     }
5239 }
5240
5241 static const char *
5242 get_symbol_type (type)
5243      unsigned int type;
5244 {
5245   static char buff [32];
5246
5247   switch (type)
5248     {
5249     case STT_NOTYPE:   return "NOTYPE";
5250     case STT_OBJECT:   return "OBJECT";
5251     case STT_FUNC:     return "FUNC";
5252     case STT_SECTION:  return "SECTION";
5253     case STT_FILE:     return "FILE";
5254     case STT_COMMON:   return "COMMON";
5255     default:
5256       if (type >= STT_LOPROC && type <= STT_HIPROC)
5257         {
5258           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
5259             return "THUMB_FUNC";
5260
5261           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
5262             return "REGISTER";
5263
5264           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
5265             return "PARISC_MILLI";
5266
5267           sprintf (buff, _("<processor specific>: %d"), type);
5268         }
5269       else if (type >= STT_LOOS && type <= STT_HIOS)
5270         {
5271           if (elf_header.e_machine == EM_PARISC)
5272             {
5273               if (type == STT_HP_OPAQUE)
5274                 return "HP_OPAQUE";
5275               if (type == STT_HP_STUB)
5276                 return "HP_STUB";
5277             }
5278
5279           sprintf (buff, _("<OS specific>: %d"), type);
5280         }
5281       else
5282         sprintf (buff, _("<unknown>: %d"), type);
5283       return buff;
5284     }
5285 }
5286
5287 static const char *
5288 get_symbol_visibility (visibility)
5289      unsigned int visibility;
5290 {
5291   switch (visibility)
5292     {
5293     case STV_DEFAULT:   return "DEFAULT";
5294     case STV_INTERNAL:  return "INTERNAL";
5295     case STV_HIDDEN:    return "HIDDEN";
5296     case STV_PROTECTED: return "PROTECTED";
5297     default: abort ();
5298     }
5299 }
5300
5301 static const char *
5302 get_symbol_index_type (type)
5303      unsigned int type;
5304 {
5305   switch (type)
5306     {
5307     case SHN_UNDEF:  return "UND";
5308     case SHN_ABS:    return "ABS";
5309     case SHN_COMMON: return "COM";
5310     default:
5311       if (type >= SHN_LOPROC && type <= SHN_HIPROC)
5312         return "PRC";
5313       else if (type >= SHN_LOOS && type <= SHN_HIOS)
5314         return "OS ";
5315       else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
5316         return "RSV";
5317       else
5318         {
5319           static char buff [32];
5320
5321           sprintf (buff, "%3d", type);
5322           return buff;
5323         }
5324     }
5325 }
5326
5327 static int *
5328 get_dynamic_data (file, number)
5329      FILE *       file;
5330      unsigned int number;
5331 {
5332   unsigned char * e_data;
5333   int *  i_data;
5334
5335   e_data = (unsigned char *) malloc (number * 4);
5336
5337   if (e_data == NULL)
5338     {
5339       error (_("Out of memory\n"));
5340       return NULL;
5341     }
5342
5343   if (fread (e_data, 4, number, file) != number)
5344     {
5345       error (_("Unable to read in dynamic data\n"));
5346       return NULL;
5347     }
5348
5349   i_data = (int *) malloc (number * sizeof (* i_data));
5350
5351   if (i_data == NULL)
5352     {
5353       error (_("Out of memory\n"));
5354       free (e_data);
5355       return NULL;
5356     }
5357
5358   while (number--)
5359     i_data [number] = byte_get (e_data + number * 4, 4);
5360
5361   free (e_data);
5362
5363   return i_data;
5364 }
5365
5366 /* Dump the symbol table.  */
5367 static int
5368 process_symbol_table (file)
5369      FILE * file;
5370 {
5371   Elf32_Internal_Shdr *   section;
5372   unsigned char   nb [4];
5373   unsigned char   nc [4];
5374   int    nbuckets = 0;
5375   int    nchains = 0;
5376   int *  buckets = NULL;
5377   int *  chains = NULL;
5378
5379   if (! do_syms && !do_histogram)
5380     return 1;
5381
5382   if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
5383                                 || do_histogram))
5384     {
5385       if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
5386         {
5387           error (_("Unable to seek to start of dynamic information"));
5388           return 0;
5389         }
5390
5391       if (fread (nb, sizeof (nb), 1, file) != 1)
5392         {
5393           error (_("Failed to read in number of buckets\n"));
5394           return 0;
5395         }
5396
5397       if (fread (nc, sizeof (nc), 1, file) != 1)
5398         {
5399           error (_("Failed to read in number of chains\n"));
5400           return 0;
5401         }
5402
5403       nbuckets = byte_get (nb, 4);
5404       nchains  = byte_get (nc, 4);
5405
5406       buckets = get_dynamic_data (file, nbuckets);
5407       chains  = get_dynamic_data (file, nchains);
5408
5409       if (buckets == NULL || chains == NULL)
5410         return 0;
5411     }
5412
5413   if (do_syms
5414       && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
5415     {
5416       int    hn;
5417       int    si;
5418
5419       printf (_("\nSymbol table for image:\n"));
5420       if (is_32bit_elf)
5421         printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
5422       else
5423         printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
5424
5425       for (hn = 0; hn < nbuckets; hn++)
5426         {
5427           if (! buckets [hn])
5428             continue;
5429
5430           for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
5431             {
5432               Elf_Internal_Sym * psym;
5433
5434               psym = dynamic_symbols + si;
5435
5436               printf ("  %3d %3d: ", si, hn);
5437               print_vma (psym->st_value, LONG_HEX);
5438               putchar (' ' );
5439               print_vma (psym->st_size, DEC_5);
5440
5441               printf ("  %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
5442               printf (" %6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
5443               printf (" %3s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5444               printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
5445               print_symbol (25, dynamic_strings + psym->st_name);
5446               putchar ('\n');
5447             }
5448         }
5449     }
5450   else if (do_syms && !do_using_dynamic)
5451     {
5452       unsigned int     i;
5453
5454       for (i = 0, section = section_headers;
5455            i < elf_header.e_shnum;
5456            i++, section++)
5457         {
5458           unsigned int          si;
5459           char *                strtab;
5460           Elf_Internal_Sym *    symtab;
5461           Elf_Internal_Sym *    psym;
5462
5463
5464           if (   section->sh_type != SHT_SYMTAB
5465               && section->sh_type != SHT_DYNSYM)
5466             continue;
5467
5468           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5469                   SECTION_NAME (section),
5470                   (unsigned long) (section->sh_size / section->sh_entsize));
5471           if (is_32bit_elf)
5472             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
5473           else
5474             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
5475
5476           symtab = GET_ELF_SYMBOLS (file, section);
5477           if (symtab == NULL)
5478             continue;
5479
5480           if (section->sh_link == elf_header.e_shstrndx)
5481             strtab = string_table;
5482           else
5483             {
5484               Elf32_Internal_Shdr * string_sec;
5485
5486               string_sec = SECTION_HEADER (section->sh_link);
5487
5488               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
5489                                           string_sec->sh_size,
5490                                           _("string table"));
5491             }
5492
5493           for (si = 0, psym = symtab;
5494                si < section->sh_size / section->sh_entsize;
5495                si ++, psym ++)
5496             {
5497               printf ("%6d: ", si);
5498               print_vma (psym->st_value, LONG_HEX);
5499               putchar (' ');
5500               print_vma (psym->st_size, DEC_5);
5501               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
5502               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
5503               printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5504               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
5505               print_symbol (25, strtab + psym->st_name);
5506
5507               if (section->sh_type == SHT_DYNSYM &&
5508                   version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
5509                 {
5510                   unsigned char   data[2];
5511                   unsigned short  vers_data;
5512                   unsigned long   offset;
5513                   int             is_nobits;
5514                   int             check_def;
5515
5516                   offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
5517                     - loadaddr;
5518
5519                   get_data (&data, file, offset + si * sizeof (vers_data),
5520                             sizeof (data), _("version data"));
5521
5522                   vers_data = byte_get (data, 2);
5523
5524                   is_nobits = (SECTION_HEADER (psym->st_shndx)->sh_type
5525                                == SHT_NOBITS);
5526
5527                   check_def = (psym->st_shndx != SHN_UNDEF);
5528
5529                   if ((vers_data & 0x8000) || vers_data > 1)
5530                     {
5531                       if (version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
5532                           && (is_nobits || ! check_def))
5533                         {
5534                           Elf_External_Verneed  evn;
5535                           Elf_Internal_Verneed  ivn;
5536                           Elf_Internal_Vernaux  ivna;
5537
5538                           /* We must test both.  */
5539                           offset = version_info
5540                             [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
5541
5542                           do
5543                             {
5544                               unsigned long  vna_off;
5545
5546                               get_data (&evn, file, offset, sizeof (evn),
5547                                         _("version need"));
5548
5549                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
5550                               ivn.vn_next = BYTE_GET (evn.vn_next);
5551
5552                               vna_off = offset + ivn.vn_aux;
5553
5554                               do
5555                                 {
5556                                   Elf_External_Vernaux  evna;
5557
5558                                   get_data (&evna, file, vna_off,
5559                                             sizeof (evna),
5560                                             _("version need aux (3)"));
5561
5562                                   ivna.vna_other = BYTE_GET (evna.vna_other);
5563                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
5564                                   ivna.vna_name  = BYTE_GET (evna.vna_name);
5565
5566                                   vna_off += ivna.vna_next;
5567                                 }
5568                               while (ivna.vna_other != vers_data
5569                                      && ivna.vna_next != 0);
5570
5571                               if (ivna.vna_other == vers_data)
5572                                 break;
5573
5574                               offset += ivn.vn_next;
5575                             }
5576                           while (ivn.vn_next != 0);
5577
5578                           if (ivna.vna_other == vers_data)
5579                             {
5580                               printf ("@%s (%d)",
5581                                       strtab + ivna.vna_name, ivna.vna_other);
5582                               check_def = 0;
5583                             }
5584                           else if (! is_nobits)
5585                             error (_("bad dynamic symbol"));
5586                           else
5587                             check_def = 1;
5588                         }
5589
5590                       if (check_def)
5591                         {
5592                           if (vers_data != 0x8001
5593                               && version_info [DT_VERSIONTAGIDX (DT_VERDEF)])
5594                             {
5595                               Elf_Internal_Verdef     ivd;
5596                               Elf_Internal_Verdaux    ivda;
5597                               Elf_External_Verdaux  evda;
5598                               unsigned long           offset;
5599
5600                               offset =
5601                                 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
5602                                 - loadaddr;
5603
5604                               do
5605                                 {
5606                                   Elf_External_Verdef   evd;
5607
5608                                   get_data (&evd, file, offset, sizeof (evd),
5609                                             _("version def"));
5610
5611                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
5612                                   ivd.vd_aux  = BYTE_GET (evd.vd_aux);
5613                                   ivd.vd_next = BYTE_GET (evd.vd_next);
5614
5615                                   offset += ivd.vd_next;
5616                                 }
5617                               while (ivd.vd_ndx != (vers_data & 0x7fff)
5618                                      && ivd.vd_next != 0);
5619
5620                               offset -= ivd.vd_next;
5621                               offset += ivd.vd_aux;
5622
5623                               get_data (&evda, file, offset, sizeof (evda),
5624                                         _("version def aux"));
5625
5626                               ivda.vda_name = BYTE_GET (evda.vda_name);
5627
5628                               if (psym->st_name != ivda.vda_name)
5629                                 printf ((vers_data & 0x8000)
5630                                         ? "@%s" : "@@%s",
5631                                         strtab + ivda.vda_name);
5632                             }
5633                         }
5634                     }
5635                 }
5636
5637               putchar ('\n');
5638             }
5639
5640           free (symtab);
5641           if (strtab != string_table)
5642             free (strtab);
5643         }
5644     }
5645   else if (do_syms)
5646     printf
5647       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5648
5649   if (do_histogram && buckets != NULL)
5650     {
5651       int * lengths;
5652       int * counts;
5653       int   hn;
5654       int   si;
5655       int   maxlength = 0;
5656       int   nzero_counts = 0;
5657       int   nsyms = 0;
5658
5659       printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5660               nbuckets);
5661       printf (_(" Length  Number     %% of total  Coverage\n"));
5662
5663       lengths = (int *) calloc (nbuckets, sizeof (int));
5664       if (lengths == NULL)
5665         {
5666           error (_("Out of memory"));
5667           return 0;
5668         }
5669       for (hn = 0; hn < nbuckets; ++hn)
5670         {
5671           if (! buckets [hn])
5672             continue;
5673
5674           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
5675             {
5676               ++ nsyms;
5677               if (maxlength < ++lengths[hn])
5678                 ++ maxlength;
5679             }
5680         }
5681
5682       counts = (int *) calloc (maxlength + 1, sizeof (int));
5683       if (counts == NULL)
5684         {
5685           error (_("Out of memory"));
5686           return 0;
5687         }
5688
5689       for (hn = 0; hn < nbuckets; ++hn)
5690         ++ counts [lengths [hn]];
5691
5692       if (nbuckets > 0)
5693         {
5694           printf ("      0  %-10d (%5.1f%%)\n",
5695                   counts[0], (counts[0] * 100.0) / nbuckets);
5696           for (si = 1; si <= maxlength; ++si)
5697             {
5698               nzero_counts += counts[si] * si;
5699               printf ("%7d  %-10d (%5.1f%%)    %5.1f%%\n",
5700                       si, counts[si], (counts[si] * 100.0) / nbuckets,
5701                       (nzero_counts * 100.0) / nsyms);
5702             }
5703         }
5704
5705       free (counts);
5706       free (lengths);
5707     }
5708
5709   if (buckets != NULL)
5710     {
5711       free (buckets);
5712       free (chains);
5713     }
5714
5715   return 1;
5716 }
5717
5718 static int
5719 process_syminfo (file)
5720      FILE * file ATTRIBUTE_UNUSED;
5721 {
5722   unsigned int i;
5723
5724   if (dynamic_syminfo == NULL
5725       || !do_dynamic)
5726     /* No syminfo, this is ok.  */
5727     return 1;
5728
5729   /* There better should be a dynamic symbol section.  */
5730   if (dynamic_symbols == NULL || dynamic_strings == NULL)
5731     return 0;
5732
5733   if (dynamic_addr)
5734     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5735             dynamic_syminfo_offset, dynamic_syminfo_nent);
5736
5737   printf (_(" Num: Name                           BoundTo     Flags\n"));
5738   for (i = 0; i < dynamic_syminfo_nent; ++i)
5739     {
5740       unsigned short int flags = dynamic_syminfo[i].si_flags;
5741
5742       printf ("%4d: ", i);
5743       print_symbol (30, dynamic_strings + dynamic_symbols[i].st_name);
5744       putchar (' ');
5745
5746       switch (dynamic_syminfo[i].si_boundto)
5747         {
5748         case SYMINFO_BT_SELF:
5749           fputs ("SELF       ", stdout);
5750           break;
5751         case SYMINFO_BT_PARENT:
5752           fputs ("PARENT     ", stdout);
5753           break;
5754         default:
5755           if (dynamic_syminfo[i].si_boundto > 0
5756               && dynamic_syminfo[i].si_boundto < dynamic_size)
5757             {
5758               print_symbol (10, dynamic_strings
5759                             + dynamic_segment
5760                             [dynamic_syminfo[i].si_boundto].d_un.d_val);
5761               putchar (' ' );
5762             }
5763           else
5764             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
5765           break;
5766         }
5767
5768       if (flags & SYMINFO_FLG_DIRECT)
5769         printf (" DIRECT");
5770       if (flags & SYMINFO_FLG_PASSTHRU)
5771         printf (" PASSTHRU");
5772       if (flags & SYMINFO_FLG_COPY)
5773         printf (" COPY");
5774       if (flags & SYMINFO_FLG_LAZYLOAD)
5775         printf (" LAZYLOAD");
5776
5777       puts ("");
5778     }
5779
5780   return 1;
5781 }
5782
5783 #ifdef SUPPORT_DISASSEMBLY
5784 static void
5785 disassemble_section (section, file)
5786      Elf32_Internal_Shdr * section;
5787      FILE * file;
5788 {
5789   printf (_("\nAssembly dump of section %s\n"),
5790           SECTION_NAME (section));
5791
5792   /* XXX -- to be done --- XXX */
5793
5794   return 1;
5795 }
5796 #endif
5797
5798 static int
5799 dump_section (section, file)
5800      Elf32_Internal_Shdr * section;
5801      FILE * file;
5802 {
5803   bfd_size_type   bytes;
5804   bfd_vma         addr;
5805   unsigned char * data;
5806   unsigned char * start;
5807
5808   bytes = section->sh_size;
5809
5810   if (bytes == 0)
5811     {
5812       printf (_("\nSection '%s' has no data to dump.\n"),
5813               SECTION_NAME (section));
5814       return 0;
5815     }
5816   else
5817     printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
5818
5819   addr = section->sh_addr;
5820
5821   start = (unsigned char *) get_data (NULL, file, section->sh_offset, bytes,
5822                                       _("section data"));
5823   if (!start)
5824     return 0;
5825
5826   data = start;
5827
5828   while (bytes)
5829     {
5830       int j;
5831       int k;
5832       int lbytes;
5833
5834       lbytes = (bytes > 16 ? 16 : bytes);
5835
5836       printf ("  0x%8.8lx ", (unsigned long) addr);
5837
5838       switch (elf_header.e_ident [EI_DATA])
5839         {
5840         default:
5841         case ELFDATA2LSB:
5842           for (j = 15; j >= 0; j --)
5843             {
5844               if (j < lbytes)
5845                 printf ("%2.2x", data [j]);
5846               else
5847                 printf ("  ");
5848
5849               if (!(j & 0x3))
5850                 printf (" ");
5851             }
5852           break;
5853
5854         case ELFDATA2MSB:
5855           for (j = 0; j < 16; j++)
5856             {
5857               if (j < lbytes)
5858                 printf ("%2.2x", data [j]);
5859               else
5860                 printf ("  ");
5861
5862               if ((j & 3) == 3)
5863                 printf (" ");
5864             }
5865           break;
5866         }
5867
5868       for (j = 0; j < lbytes; j++)
5869         {
5870           k = data [j];
5871           if (k >= ' ' && k < 0x80)
5872             printf ("%c", k);
5873           else
5874             printf (".");
5875         }
5876
5877       putchar ('\n');
5878
5879       data  += lbytes;
5880       addr  += lbytes;
5881       bytes -= lbytes;
5882     }
5883
5884   free (start);
5885
5886   return 1;
5887 }
5888
5889
5890 static unsigned long int
5891 read_leb128 (data, length_return, sign)
5892      unsigned char * data;
5893      int *           length_return;
5894      int             sign;
5895 {
5896   unsigned long int result = 0;
5897   unsigned int      num_read = 0;
5898   int               shift = 0;
5899   unsigned char     byte;
5900
5901   do
5902     {
5903       byte = * data ++;
5904       num_read ++;
5905
5906       result |= (byte & 0x7f) << shift;
5907
5908       shift += 7;
5909
5910     }
5911   while (byte & 0x80);
5912
5913   if (length_return != NULL)
5914     * length_return = num_read;
5915
5916   if (sign && (shift < 32) && (byte & 0x40))
5917     result |= -1 << shift;
5918
5919   return result;
5920 }
5921
5922 typedef struct State_Machine_Registers
5923 {
5924   unsigned long address;
5925   unsigned int  file;
5926   unsigned int  line;
5927   unsigned int  column;
5928   int           is_stmt;
5929   int           basic_block;
5930   int           end_sequence;
5931 /* This variable hold the number of the last entry seen
5932    in the File Table.  */
5933   unsigned int  last_file_entry;
5934 } SMR;
5935
5936 static SMR state_machine_regs;
5937
5938 static void
5939 reset_state_machine (is_stmt)
5940      int is_stmt;
5941 {
5942   state_machine_regs.address = 0;
5943   state_machine_regs.file = 1;
5944   state_machine_regs.line = 1;
5945   state_machine_regs.column = 0;
5946   state_machine_regs.is_stmt = is_stmt;
5947   state_machine_regs.basic_block = 0;
5948   state_machine_regs.end_sequence = 0;
5949   state_machine_regs.last_file_entry = 0;
5950 }
5951
5952 /* Handled an extend line op.  Returns true if this is the end
5953    of sequence.  */
5954 static int
5955 process_extended_line_op (data, is_stmt, pointer_size)
5956      unsigned char * data;
5957      int is_stmt;
5958      int pointer_size;
5959 {
5960   unsigned char   op_code;
5961   int             bytes_read;
5962   unsigned int    len;
5963   unsigned char * name;
5964   unsigned long   adr;
5965
5966   len = read_leb128 (data, & bytes_read, 0);
5967   data += bytes_read;
5968
5969   if (len == 0)
5970     {
5971       warn (_("badly formed extended line op encountered!\n"));
5972       return bytes_read;
5973     }
5974
5975   len += bytes_read;
5976   op_code = * data ++;
5977
5978   printf (_("  Extended opcode %d: "), op_code);
5979
5980   switch (op_code)
5981     {
5982     case DW_LNE_end_sequence:
5983       printf (_("End of Sequence\n\n"));
5984       reset_state_machine (is_stmt);
5985       break;
5986
5987     case DW_LNE_set_address:
5988       adr = byte_get (data, pointer_size);
5989       printf (_("set Address to 0x%lx\n"), adr);
5990       state_machine_regs.address = adr;
5991       break;
5992
5993     case DW_LNE_define_file:
5994       printf (_("  define new File Table entry\n"));
5995       printf (_("  Entry\tDir\tTime\tSize\tName\n"));
5996
5997       printf (_("   %d\t"), ++ state_machine_regs.last_file_entry);
5998       name = data;
5999       data += strlen ((char *) data) + 1;
6000       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6001       data += bytes_read;
6002       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6003       data += bytes_read;
6004       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6005       printf (_("%s\n\n"), name);
6006       break;
6007
6008     default:
6009       printf (_("UNKNOWN: length %d\n"), len - bytes_read);
6010       break;
6011     }
6012
6013   return len;
6014 }
6015
6016 /* Size of pointers in the .debug_line section.  This information is not
6017    really present in that section.  It's obtained before dumping the debug
6018    sections by doing some pre-scan of the .debug_info section.  */
6019 static int debug_line_pointer_size = 4;
6020
6021 static int
6022 display_debug_lines (section, start, file)
6023      Elf32_Internal_Shdr * section;
6024      unsigned char *       start;
6025      FILE *                file ATTRIBUTE_UNUSED;
6026 {
6027   DWARF2_External_LineInfo * external;
6028   DWARF2_Internal_LineInfo   info;
6029   unsigned char *            standard_opcodes;
6030   unsigned char *            data = start;
6031   unsigned char *            end  = start + section->sh_size;
6032   unsigned char *            end_of_sequence;
6033   int                        i;
6034
6035   printf (_("\nDump of debug contents of section %s:\n\n"),
6036           SECTION_NAME (section));
6037
6038   while (data < end)
6039     {
6040       external = (DWARF2_External_LineInfo *) data;
6041
6042       /* Check the length of the block.  */
6043       info.li_length = BYTE_GET (external->li_length);
6044
6045       if (info.li_length == 0xffffffff)
6046         {
6047           warn (_("64-bit DWARF line info is not supported yet.\n"));
6048           break;
6049         }
6050
6051       if (info.li_length + sizeof (external->li_length) > section->sh_size)
6052         {
6053           warn
6054             (_("The line info appears to be corrupt - the section is too small\n"));
6055           return 0;
6056         }
6057
6058       /* Check its version number.  */
6059       info.li_version = BYTE_GET (external->li_version);
6060       if (info.li_version != 2)
6061         {
6062           warn (_("Only DWARF version 2 line info is currently supported.\n"));
6063           return 0;
6064         }
6065
6066       info.li_prologue_length = BYTE_GET (external->li_prologue_length);
6067       info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
6068       info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
6069       info.li_line_base       = BYTE_GET (external->li_line_base);
6070       info.li_line_range      = BYTE_GET (external->li_line_range);
6071       info.li_opcode_base     = BYTE_GET (external->li_opcode_base);
6072
6073       /* Sign extend the line base field.  */
6074       info.li_line_base <<= 24;
6075       info.li_line_base >>= 24;
6076
6077       printf (_("  Length:                      %ld\n"), info.li_length);
6078       printf (_("  DWARF Version:               %d\n"), info.li_version);
6079       printf (_("  Prologue Length:             %d\n"), info.li_prologue_length);
6080       printf (_("  Minimum Instruction Length:  %d\n"), info.li_min_insn_length);
6081       printf (_("  Initial value of 'is_stmt':  %d\n"), info.li_default_is_stmt);
6082       printf (_("  Line Base:                   %d\n"), info.li_line_base);
6083       printf (_("  Line Range:                  %d\n"), info.li_line_range);
6084       printf (_("  Opcode Base:                 %d\n"), info.li_opcode_base);
6085
6086       end_of_sequence = data + info.li_length + sizeof (external->li_length);
6087
6088       reset_state_machine (info.li_default_is_stmt);
6089
6090       /* Display the contents of the Opcodes table.  */
6091       standard_opcodes = data + sizeof (* external);
6092
6093       printf (_("\n Opcodes:\n"));
6094
6095       for (i = 1; i < info.li_opcode_base; i++)
6096         printf (_("  Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
6097
6098       /* Display the contents of the Directory table.  */
6099       data = standard_opcodes + info.li_opcode_base - 1;
6100
6101       if (* data == 0)
6102         printf (_("\n The Directory Table is empty.\n"));
6103       else
6104         {
6105           printf (_("\n The Directory Table:\n"));
6106
6107           while (* data != 0)
6108             {
6109               printf (_("  %s\n"), data);
6110
6111               data += strlen ((char *) data) + 1;
6112             }
6113         }
6114
6115       /* Skip the NUL at the end of the table.  */
6116       data ++;
6117
6118       /* Display the contents of the File Name table.  */
6119       if (* data == 0)
6120         printf (_("\n The File Name Table is empty.\n"));
6121       else
6122         {
6123           printf (_("\n The File Name Table:\n"));
6124           printf (_("  Entry\tDir\tTime\tSize\tName\n"));
6125
6126           while (* data != 0)
6127             {
6128               unsigned char * name;
6129               int bytes_read;
6130
6131               printf (_("  %d\t"), ++ state_machine_regs.last_file_entry);
6132               name = data;
6133
6134               data += strlen ((char *) data) + 1;
6135
6136               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6137               data += bytes_read;
6138               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6139               data += bytes_read;
6140               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6141               data += bytes_read;
6142               printf (_("%s\n"), name);
6143             }
6144         }
6145
6146       /* Skip the NUL at the end of the table.  */
6147       data ++;
6148
6149       /* Now display the statements.  */
6150       printf (_("\n Line Number Statements:\n"));
6151
6152
6153       while (data < end_of_sequence)
6154         {
6155           unsigned char op_code;
6156           int           adv;
6157           int           bytes_read;
6158
6159           op_code = * data ++;
6160
6161           if (op_code >= info.li_opcode_base)
6162             {
6163               op_code -= info.li_opcode_base;
6164               adv      = (op_code / info.li_line_range) * info.li_min_insn_length;
6165               state_machine_regs.address += adv;
6166               printf (_("  Special opcode %d: advance Address by %d to 0x%lx"),
6167                       op_code, adv, state_machine_regs.address);
6168               adv = (op_code % info.li_line_range) + info.li_line_base;
6169               state_machine_regs.line += adv;
6170               printf (_(" and Line by %d to %d\n"),
6171                       adv, state_machine_regs.line);
6172             }
6173           else switch (op_code)
6174             {
6175             case DW_LNS_extended_op:
6176               data += process_extended_line_op (data, info.li_default_is_stmt,
6177                                                 debug_line_pointer_size);
6178               break;
6179
6180             case DW_LNS_copy:
6181               printf (_("  Copy\n"));
6182               break;
6183
6184             case DW_LNS_advance_pc:
6185               adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
6186               data += bytes_read;
6187               state_machine_regs.address += adv;
6188               printf (_("  Advance PC by %d to %lx\n"), adv,
6189                       state_machine_regs.address);
6190               break;
6191
6192             case DW_LNS_advance_line:
6193               adv = read_leb128 (data, & bytes_read, 1);
6194               data += bytes_read;
6195               state_machine_regs.line += adv;
6196               printf (_("  Advance Line by %d to %d\n"), adv,
6197                       state_machine_regs.line);
6198               break;
6199
6200             case DW_LNS_set_file:
6201               adv = read_leb128 (data, & bytes_read, 0);
6202               data += bytes_read;
6203               printf (_("  Set File Name to entry %d in the File Name Table\n"),
6204                       adv);
6205               state_machine_regs.file = adv;
6206               break;
6207
6208             case DW_LNS_set_column:
6209               adv = read_leb128 (data, & bytes_read, 0);
6210               data += bytes_read;
6211               printf (_("  Set column to %d\n"), adv);
6212               state_machine_regs.column = adv;
6213               break;
6214
6215             case DW_LNS_negate_stmt:
6216               adv = state_machine_regs.is_stmt;
6217               adv = ! adv;
6218               printf (_("  Set is_stmt to %d\n"), adv);
6219               state_machine_regs.is_stmt = adv;
6220               break;
6221
6222             case DW_LNS_set_basic_block:
6223               printf (_("  Set basic block\n"));
6224               state_machine_regs.basic_block = 1;
6225               break;
6226
6227             case DW_LNS_const_add_pc:
6228               adv = (((255 - info.li_opcode_base) / info.li_line_range)
6229                      * info.li_min_insn_length);
6230               state_machine_regs.address += adv;
6231               printf (_("  Advance PC by constant %d to 0x%lx\n"), adv,
6232                       state_machine_regs.address);
6233               break;
6234
6235             case DW_LNS_fixed_advance_pc:
6236               adv = byte_get (data, 2);
6237               data += 2;
6238               state_machine_regs.address += adv;
6239               printf (_("  Advance PC by fixed size amount %d to 0x%lx\n"),
6240                       adv, state_machine_regs.address);
6241               break;
6242
6243             case DW_LNS_set_prologue_end:
6244               printf (_("  Set prologue_end to true\n"));
6245               break;
6246
6247             case DW_LNS_set_epilogue_begin:
6248               printf (_("  Set epilogue_begin to true\n"));
6249               break;
6250
6251             case DW_LNS_set_isa:
6252               adv = read_leb128 (data, & bytes_read, 0);
6253               data += bytes_read;
6254               printf (_("  Set ISA to %d\n"), adv);
6255               break;
6256
6257             default:
6258               printf (_("  Unknown opcode %d with operands: "), op_code);
6259               {
6260                 int i;
6261                 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
6262                   {
6263                     printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
6264                             i == 1 ? "" : ", ");
6265                     data += bytes_read;
6266                   }
6267                 putchar ('\n');
6268               }
6269               break;
6270             }
6271         }
6272       putchar ('\n');
6273     }
6274
6275   return 1;
6276 }
6277
6278 static int
6279 display_debug_pubnames (section, start, file)
6280      Elf32_Internal_Shdr * section;
6281      unsigned char *       start;
6282      FILE *                file ATTRIBUTE_UNUSED;
6283 {
6284   DWARF2_External_PubNames * external;
6285   DWARF2_Internal_PubNames   pubnames;
6286   unsigned char *            end;
6287
6288   end = start + section->sh_size;
6289
6290   printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6291
6292   while (start < end)
6293     {
6294       unsigned char * data;
6295       unsigned long   offset;
6296
6297       external = (DWARF2_External_PubNames *) start;
6298
6299       pubnames.pn_length  = BYTE_GET (external->pn_length);
6300       pubnames.pn_version = BYTE_GET (external->pn_version);
6301       pubnames.pn_offset  = BYTE_GET (external->pn_offset);
6302       pubnames.pn_size    = BYTE_GET (external->pn_size);
6303
6304       data   = start + sizeof (* external);
6305       start += pubnames.pn_length + sizeof (external->pn_length);
6306
6307       if (pubnames.pn_length == 0xffffffff)
6308         {
6309           warn (_("64-bit DWARF pubnames are not supported yet.\n"));
6310           break;
6311         }
6312
6313       if (pubnames.pn_version != 2)
6314         {
6315           static int warned = 0;
6316
6317           if (! warned)
6318             {
6319               warn (_("Only DWARF 2 pubnames are currently supported\n"));
6320               warned = 1;
6321             }
6322
6323           continue;
6324         }
6325
6326       printf (_("  Length:                              %ld\n"),
6327               pubnames.pn_length);
6328       printf (_("  Version:                             %d\n"),
6329               pubnames.pn_version);
6330       printf (_("  Offset into .debug_info section:     %ld\n"),
6331               pubnames.pn_offset);
6332       printf (_("  Size of area in .debug_info section: %ld\n"),
6333               pubnames.pn_size);
6334
6335       printf (_("\n    Offset\tName\n"));
6336
6337       do
6338         {
6339           offset = byte_get (data, 4);
6340
6341           if (offset != 0)
6342             {
6343               data += 4;
6344               printf ("    %ld\t\t%s\n", offset, data);
6345               data += strlen ((char *) data) + 1;
6346             }
6347         }
6348       while (offset != 0);
6349     }
6350
6351   printf ("\n");
6352   return 1;
6353 }
6354
6355 static char *
6356 get_TAG_name (tag)
6357      unsigned long tag;
6358 {
6359   switch (tag)
6360     {
6361     case DW_TAG_padding:                return "DW_TAG_padding";
6362     case DW_TAG_array_type:             return "DW_TAG_array_type";
6363     case DW_TAG_class_type:             return "DW_TAG_class_type";
6364     case DW_TAG_entry_point:            return "DW_TAG_entry_point";
6365     case DW_TAG_enumeration_type:       return "DW_TAG_enumeration_type";
6366     case DW_TAG_formal_parameter:       return "DW_TAG_formal_parameter";
6367     case DW_TAG_imported_declaration:   return "DW_TAG_imported_declaration";
6368     case DW_TAG_label:                  return "DW_TAG_label";
6369     case DW_TAG_lexical_block:          return "DW_TAG_lexical_block";
6370     case DW_TAG_member:                 return "DW_TAG_member";
6371     case DW_TAG_pointer_type:           return "DW_TAG_pointer_type";
6372     case DW_TAG_reference_type:         return "DW_TAG_reference_type";
6373     case DW_TAG_compile_unit:           return "DW_TAG_compile_unit";
6374     case DW_TAG_string_type:            return "DW_TAG_string_type";
6375     case DW_TAG_structure_type:         return "DW_TAG_structure_type";
6376     case DW_TAG_subroutine_type:        return "DW_TAG_subroutine_type";
6377     case DW_TAG_typedef:                return "DW_TAG_typedef";
6378     case DW_TAG_union_type:             return "DW_TAG_union_type";
6379     case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
6380     case DW_TAG_variant:                return "DW_TAG_variant";
6381     case DW_TAG_common_block:           return "DW_TAG_common_block";
6382     case DW_TAG_common_inclusion:       return "DW_TAG_common_inclusion";
6383     case DW_TAG_inheritance:            return "DW_TAG_inheritance";
6384     case DW_TAG_inlined_subroutine:     return "DW_TAG_inlined_subroutine";
6385     case DW_TAG_module:                 return "DW_TAG_module";
6386     case DW_TAG_ptr_to_member_type:     return "DW_TAG_ptr_to_member_type";
6387     case DW_TAG_set_type:               return "DW_TAG_set_type";
6388     case DW_TAG_subrange_type:          return "DW_TAG_subrange_type";
6389     case DW_TAG_with_stmt:              return "DW_TAG_with_stmt";
6390     case DW_TAG_access_declaration:     return "DW_TAG_access_declaration";
6391     case DW_TAG_base_type:              return "DW_TAG_base_type";
6392     case DW_TAG_catch_block:            return "DW_TAG_catch_block";
6393     case DW_TAG_const_type:             return "DW_TAG_const_type";
6394     case DW_TAG_constant:               return "DW_TAG_constant";
6395     case DW_TAG_enumerator:             return "DW_TAG_enumerator";
6396     case DW_TAG_file_type:              return "DW_TAG_file_type";
6397     case DW_TAG_friend:                 return "DW_TAG_friend";
6398     case DW_TAG_namelist:               return "DW_TAG_namelist";
6399     case DW_TAG_namelist_item:          return "DW_TAG_namelist_item";
6400     case DW_TAG_packed_type:            return "DW_TAG_packed_type";
6401     case DW_TAG_subprogram:             return "DW_TAG_subprogram";
6402     case DW_TAG_template_type_param:    return "DW_TAG_template_type_param";
6403     case DW_TAG_template_value_param:   return "DW_TAG_template_value_param";
6404     case DW_TAG_thrown_type:            return "DW_TAG_thrown_type";
6405     case DW_TAG_try_block:              return "DW_TAG_try_block";
6406     case DW_TAG_variant_part:           return "DW_TAG_variant_part";
6407     case DW_TAG_variable:               return "DW_TAG_variable";
6408     case DW_TAG_volatile_type:          return "DW_TAG_volatile_type";
6409     case DW_TAG_MIPS_loop:              return "DW_TAG_MIPS_loop";
6410     case DW_TAG_format_label:           return "DW_TAG_format_label";
6411     case DW_TAG_function_template:      return "DW_TAG_function_template";
6412     case DW_TAG_class_template:         return "DW_TAG_class_template";
6413       /* DWARF 2.1 values.  */
6414     case DW_TAG_dwarf_procedure:        return "DW_TAG_dwarf_procedure";
6415     case DW_TAG_restrict_type:          return "DW_TAG_restrict_type";
6416     case DW_TAG_interface_type:         return "DW_TAG_interface_type";
6417     case DW_TAG_namespace:              return "DW_TAG_namespace";
6418     case DW_TAG_imported_module:        return "DW_TAG_imported_module";
6419     case DW_TAG_unspecified_type:       return "DW_TAG_unspecified_type";
6420     case DW_TAG_partial_unit:           return "DW_TAG_partial_unit";
6421     case DW_TAG_imported_unit:          return "DW_TAG_imported_unit";
6422     default:
6423       {
6424         static char buffer [100];
6425
6426         sprintf (buffer, _("Unknown TAG value: %lx"), tag);
6427         return buffer;
6428       }
6429     }
6430 }
6431
6432 static char *
6433 get_AT_name (attribute)
6434      unsigned long attribute;
6435 {
6436   switch (attribute)
6437     {
6438     case DW_AT_sibling:              return "DW_AT_sibling";
6439     case DW_AT_location:             return "DW_AT_location";
6440     case DW_AT_name:                 return "DW_AT_name";
6441     case DW_AT_ordering:             return "DW_AT_ordering";
6442     case DW_AT_subscr_data:          return "DW_AT_subscr_data";
6443     case DW_AT_byte_size:            return "DW_AT_byte_size";
6444     case DW_AT_bit_offset:           return "DW_AT_bit_offset";
6445     case DW_AT_bit_size:             return "DW_AT_bit_size";
6446     case DW_AT_element_list:         return "DW_AT_element_list";
6447     case DW_AT_stmt_list:            return "DW_AT_stmt_list";
6448     case DW_AT_low_pc:               return "DW_AT_low_pc";
6449     case DW_AT_high_pc:              return "DW_AT_high_pc";
6450     case DW_AT_language:             return "DW_AT_language";
6451     case DW_AT_member:               return "DW_AT_member";
6452     case DW_AT_discr:                return "DW_AT_discr";
6453     case DW_AT_discr_value:          return "DW_AT_discr_value";
6454     case DW_AT_visibility:           return "DW_AT_visibility";
6455     case DW_AT_import:               return "DW_AT_import";
6456     case DW_AT_string_length:        return "DW_AT_string_length";
6457     case DW_AT_common_reference:     return "DW_AT_common_reference";
6458     case DW_AT_comp_dir:             return "DW_AT_comp_dir";
6459     case DW_AT_const_value:          return "DW_AT_const_value";
6460     case DW_AT_containing_type:      return "DW_AT_containing_type";
6461     case DW_AT_default_value:        return "DW_AT_default_value";
6462     case DW_AT_inline:               return "DW_AT_inline";
6463     case DW_AT_is_optional:          return "DW_AT_is_optional";
6464     case DW_AT_lower_bound:          return "DW_AT_lower_bound";
6465     case DW_AT_producer:             return "DW_AT_producer";
6466     case DW_AT_prototyped:           return "DW_AT_prototyped";
6467     case DW_AT_return_addr:          return "DW_AT_return_addr";
6468     case DW_AT_start_scope:          return "DW_AT_start_scope";
6469     case DW_AT_stride_size:          return "DW_AT_stride_size";
6470     case DW_AT_upper_bound:          return "DW_AT_upper_bound";
6471     case DW_AT_abstract_origin:      return "DW_AT_abstract_origin";
6472     case DW_AT_accessibility:        return "DW_AT_accessibility";
6473     case DW_AT_address_class:        return "DW_AT_address_class";
6474     case DW_AT_artificial:           return "DW_AT_artificial";
6475     case DW_AT_base_types:           return "DW_AT_base_types";
6476     case DW_AT_calling_convention:   return "DW_AT_calling_convention";
6477     case DW_AT_count:                return "DW_AT_count";
6478     case DW_AT_data_member_location: return "DW_AT_data_member_location";
6479     case DW_AT_decl_column:          return "DW_AT_decl_column";
6480     case DW_AT_decl_file:            return "DW_AT_decl_file";
6481     case DW_AT_decl_line:            return "DW_AT_decl_line";
6482     case DW_AT_declaration:          return "DW_AT_declaration";
6483     case DW_AT_discr_list:           return "DW_AT_discr_list";
6484     case DW_AT_encoding:             return "DW_AT_encoding";
6485     case DW_AT_external:             return "DW_AT_external";
6486     case DW_AT_frame_base:           return "DW_AT_frame_base";
6487     case DW_AT_friend:               return "DW_AT_friend";
6488     case DW_AT_identifier_case:      return "DW_AT_identifier_case";
6489     case DW_AT_macro_info:           return "DW_AT_macro_info";
6490     case DW_AT_namelist_items:       return "DW_AT_namelist_items";
6491     case DW_AT_priority:             return "DW_AT_priority";
6492     case DW_AT_segment:              return "DW_AT_segment";
6493     case DW_AT_specification:        return "DW_AT_specification";
6494     case DW_AT_static_link:          return "DW_AT_static_link";
6495     case DW_AT_type:                 return "DW_AT_type";
6496     case DW_AT_use_location:         return "DW_AT_use_location";
6497     case DW_AT_variable_parameter:   return "DW_AT_variable_parameter";
6498     case DW_AT_virtuality:           return "DW_AT_virtuality";
6499     case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
6500       /* DWARF 2.1 values.  */
6501     case DW_AT_allocated:            return "DW_AT_allocated";
6502     case DW_AT_associated:           return "DW_AT_associated";
6503     case DW_AT_data_location:        return "DW_AT_data_location";
6504     case DW_AT_stride:               return "DW_AT_stride";
6505     case DW_AT_entry_pc:             return "DW_AT_entry_pc";
6506     case DW_AT_use_UTF8:             return "DW_AT_use_UTF8";
6507     case DW_AT_extension:            return "DW_AT_extension";
6508     case DW_AT_ranges:               return "DW_AT_ranges";
6509     case DW_AT_trampoline:           return "DW_AT_trampoline";
6510     case DW_AT_call_column:          return "DW_AT_call_column";
6511     case DW_AT_call_file:            return "DW_AT_call_file";
6512     case DW_AT_call_line:            return "DW_AT_call_line";
6513       /* SGI/MIPS extensions.  */
6514     case DW_AT_MIPS_fde:             return "DW_AT_MIPS_fde";
6515     case DW_AT_MIPS_loop_begin:      return "DW_AT_MIPS_loop_begin";
6516     case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
6517     case DW_AT_MIPS_epilog_begin:    return "DW_AT_MIPS_epilog_begin";
6518     case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
6519     case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
6520     case DW_AT_MIPS_linkage_name:    return "DW_AT_MIPS_linkage_name";
6521     case DW_AT_MIPS_stride:          return "DW_AT_MIPS_stride";
6522     case DW_AT_MIPS_abstract_name:   return "DW_AT_MIPS_abstract_name";
6523     case DW_AT_MIPS_clone_origin:    return "DW_AT_MIPS_clone_origin";
6524     case DW_AT_MIPS_has_inlines:     return "DW_AT_MIPS_has_inlines";
6525       /* GNU extensions.  */
6526     case DW_AT_sf_names:             return "DW_AT_sf_names";
6527     case DW_AT_src_info:             return "DW_AT_src_info";
6528     case DW_AT_mac_info:             return "DW_AT_mac_info";
6529     case DW_AT_src_coords:           return "DW_AT_src_coords";
6530     case DW_AT_body_begin:           return "DW_AT_body_begin";
6531     case DW_AT_body_end:             return "DW_AT_body_end";
6532     default:
6533       {
6534         static char buffer [100];
6535
6536         sprintf (buffer, _("Unknown AT value: %lx"), attribute);
6537         return buffer;
6538       }
6539     }
6540 }
6541
6542 static char *
6543 get_FORM_name (form)
6544      unsigned long form;
6545 {
6546   switch (form)
6547     {
6548     case DW_FORM_addr:      return "DW_FORM_addr";
6549     case DW_FORM_block2:    return "DW_FORM_block2";
6550     case DW_FORM_block4:    return "DW_FORM_block4";
6551     case DW_FORM_data2:     return "DW_FORM_data2";
6552     case DW_FORM_data4:     return "DW_FORM_data4";
6553     case DW_FORM_data8:     return "DW_FORM_data8";
6554     case DW_FORM_string:    return "DW_FORM_string";
6555     case DW_FORM_block:     return "DW_FORM_block";
6556     case DW_FORM_block1:    return "DW_FORM_block1";
6557     case DW_FORM_data1:     return "DW_FORM_data1";
6558     case DW_FORM_flag:      return "DW_FORM_flag";
6559     case DW_FORM_sdata:     return "DW_FORM_sdata";
6560     case DW_FORM_strp:      return "DW_FORM_strp";
6561     case DW_FORM_udata:     return "DW_FORM_udata";
6562     case DW_FORM_ref_addr:  return "DW_FORM_ref_addr";
6563     case DW_FORM_ref1:      return "DW_FORM_ref1";
6564     case DW_FORM_ref2:      return "DW_FORM_ref2";
6565     case DW_FORM_ref4:      return "DW_FORM_ref4";
6566     case DW_FORM_ref8:      return "DW_FORM_ref8";
6567     case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
6568     case DW_FORM_indirect:  return "DW_FORM_indirect";
6569     default:
6570       {
6571         static char buffer [100];
6572
6573         sprintf (buffer, _("Unknown FORM value: %lx"), form);
6574         return buffer;
6575       }
6576     }
6577 }
6578
6579 /* FIXME:  There are better and more effiecint ways to handle
6580    these structures.  For now though, I just want something that
6581    is simple to implement.  */
6582 typedef struct abbrev_attr
6583 {
6584   unsigned long        attribute;
6585   unsigned long        form;
6586   struct abbrev_attr * next;
6587 }
6588 abbrev_attr;
6589
6590 typedef struct abbrev_entry
6591 {
6592   unsigned long          entry;
6593   unsigned long          tag;
6594   int                    children;
6595   struct abbrev_attr *   first_attr;
6596   struct abbrev_attr *   last_attr;
6597   struct abbrev_entry *  next;
6598 }
6599 abbrev_entry;
6600
6601 static abbrev_entry * first_abbrev = NULL;
6602 static abbrev_entry * last_abbrev = NULL;
6603
6604 static void
6605 free_abbrevs PARAMS ((void))
6606 {
6607   abbrev_entry * abbrev;
6608
6609   for (abbrev = first_abbrev; abbrev;)
6610     {
6611       abbrev_entry * next = abbrev->next;
6612       abbrev_attr  * attr;
6613
6614       for (attr = abbrev->first_attr; attr;)
6615         {
6616           abbrev_attr * next = attr->next;
6617
6618           free (attr);
6619           attr = next;
6620         }
6621
6622       free (abbrev);
6623       abbrev = next;
6624     }
6625
6626   last_abbrev = first_abbrev = NULL;
6627 }
6628
6629 static void
6630 add_abbrev (number, tag, children)
6631      unsigned long number;
6632      unsigned long tag;
6633      int           children;
6634 {
6635   abbrev_entry * entry;
6636
6637   entry = (abbrev_entry *) malloc (sizeof (* entry));
6638
6639   if (entry == NULL)
6640     /* ugg */
6641     return;
6642
6643   entry->entry      = number;
6644   entry->tag        = tag;
6645   entry->children   = children;
6646   entry->first_attr = NULL;
6647   entry->last_attr  = NULL;
6648   entry->next       = NULL;
6649
6650   if (first_abbrev == NULL)
6651     first_abbrev = entry;
6652   else
6653     last_abbrev->next = entry;
6654
6655   last_abbrev = entry;
6656 }
6657
6658 static void
6659 add_abbrev_attr (attribute, form)
6660      unsigned long attribute;
6661      unsigned long form;
6662 {
6663   abbrev_attr * attr;
6664
6665   attr = (abbrev_attr *) malloc (sizeof (* attr));
6666
6667   if (attr == NULL)
6668     /* ugg */
6669     return;
6670
6671   attr->attribute = attribute;
6672   attr->form      = form;
6673   attr->next      = NULL;
6674
6675   if (last_abbrev->first_attr == NULL)
6676     last_abbrev->first_attr = attr;
6677   else
6678     last_abbrev->last_attr->next = attr;
6679
6680   last_abbrev->last_attr = attr;
6681 }
6682
6683 /* Processes the (partial) contents of a .debug_abbrev section.
6684    Returns NULL if the end of the section was encountered.
6685    Returns the address after the last byte read if the end of
6686    an abbreviation set was found.  */
6687
6688 static unsigned char *
6689 process_abbrev_section (start, end)
6690      unsigned char * start;
6691      unsigned char * end;
6692 {
6693   if (first_abbrev != NULL)
6694     return NULL;
6695
6696   while (start < end)
6697     {
6698       int           bytes_read;
6699       unsigned long entry;
6700       unsigned long tag;
6701       unsigned long attribute;
6702       int           children;
6703
6704       entry = read_leb128 (start, & bytes_read, 0);
6705       start += bytes_read;
6706
6707       /* A single zero is supposed to end the section according
6708          to the standard.  If there's more, then signal that to
6709          the caller.  */
6710       if (entry == 0)
6711         return start == end ? NULL : start;
6712
6713       tag = read_leb128 (start, & bytes_read, 0);
6714       start += bytes_read;
6715
6716       children = * start ++;
6717
6718       add_abbrev (entry, tag, children);
6719
6720       do
6721         {
6722           unsigned long form;
6723
6724           attribute = read_leb128 (start, & bytes_read, 0);
6725           start += bytes_read;
6726
6727           form = read_leb128 (start, & bytes_read, 0);
6728           start += bytes_read;
6729
6730           if (attribute != 0)
6731             add_abbrev_attr (attribute, form);
6732         }
6733       while (attribute != 0);
6734     }
6735
6736   return NULL;
6737 }
6738
6739
6740 static int
6741 display_debug_macinfo (section, start, file)
6742      Elf32_Internal_Shdr * section;
6743      unsigned char *       start;
6744      FILE *                file ATTRIBUTE_UNUSED;
6745 {
6746   unsigned char * end = start + section->sh_size;
6747   unsigned char * curr = start;
6748   unsigned int bytes_read;
6749   enum dwarf_macinfo_record_type op;
6750
6751   printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6752
6753   while (curr < end)
6754     {
6755       unsigned int lineno;
6756       const char * string;
6757
6758       op = * curr;
6759       curr ++;
6760
6761       switch (op)
6762         {
6763         case DW_MACINFO_start_file:
6764           {
6765             unsigned int filenum;
6766
6767             lineno = read_leb128 (curr, & bytes_read, 0);
6768             curr += bytes_read;
6769             filenum = read_leb128 (curr, & bytes_read, 0);
6770             curr += bytes_read;
6771
6772             printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno, filenum);
6773           }
6774           break;
6775
6776         case DW_MACINFO_end_file:
6777           printf (_(" DW_MACINFO_end_file\n"));
6778           break;
6779
6780         case DW_MACINFO_define:
6781           lineno = read_leb128 (curr, & bytes_read, 0);
6782           curr += bytes_read;
6783           string = curr;
6784           curr += strlen (string) + 1;
6785           printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno, string);
6786           break;
6787
6788         case DW_MACINFO_undef:
6789           lineno = read_leb128 (curr, & bytes_read, 0);
6790           curr += bytes_read;
6791           string = curr;
6792           curr += strlen (string) + 1;
6793           printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno, string);
6794           break;
6795
6796         case DW_MACINFO_vendor_ext:
6797           {
6798             unsigned int constant;
6799
6800             constant = read_leb128 (curr, & bytes_read, 0);
6801             curr += bytes_read;
6802             string = curr;
6803             curr += strlen (string) + 1;
6804             printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant, string);
6805           }
6806           break;
6807         }
6808     }
6809
6810   return 1;
6811 }
6812
6813
6814 static int
6815 display_debug_abbrev (section, start, file)
6816      Elf32_Internal_Shdr * section;
6817      unsigned char *       start;
6818      FILE *                file ATTRIBUTE_UNUSED;
6819 {
6820   abbrev_entry *  entry;
6821   unsigned char * end = start + section->sh_size;
6822
6823   printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6824
6825   do
6826     {
6827       start = process_abbrev_section (start, end);
6828
6829       if (first_abbrev == NULL)
6830         continue;
6831
6832       printf (_("  Number TAG\n"));
6833
6834       for (entry = first_abbrev; entry; entry = entry->next)
6835         {
6836           abbrev_attr * attr;
6837
6838           printf (_("   %ld      %s    [%s]\n"),
6839                   entry->entry,
6840                   get_TAG_name (entry->tag),
6841                   entry->children ? _("has children") : _("no children"));
6842
6843           for (attr = entry->first_attr; attr; attr = attr->next)
6844             {
6845               printf (_("    %-18s %s\n"),
6846                       get_AT_name (attr->attribute),
6847                       get_FORM_name (attr->form));
6848             }
6849         }
6850
6851       free_abbrevs ();
6852     }
6853   while (start);
6854
6855   printf ("\n");
6856
6857   return 1;
6858 }
6859
6860
6861 static unsigned char *
6862 display_block (data, length)
6863      unsigned char * data;
6864      unsigned long   length;
6865 {
6866   printf (_(" %lu byte block: "), length);
6867
6868   while (length --)
6869     printf ("%lx ", (unsigned long) byte_get (data ++, 1));
6870
6871   return data;
6872 }
6873
6874 static void
6875 decode_location_expression (data, pointer_size, length)
6876      unsigned char * data;
6877      unsigned int    pointer_size;
6878      unsigned long   length;
6879 {
6880   unsigned        op;
6881   int             bytes_read;
6882   unsigned long   uvalue;
6883   unsigned char * end = data + length;
6884
6885   while (data < end)
6886     {
6887       op = * data ++;
6888
6889       switch (op)
6890         {
6891         case DW_OP_addr:
6892           printf ("DW_OP_addr: %lx",
6893                   (unsigned long) byte_get (data, pointer_size));
6894           data += pointer_size;
6895           break;
6896         case DW_OP_deref:
6897           printf ("DW_OP_deref");
6898           break;
6899         case DW_OP_const1u:
6900           printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
6901           break;
6902         case DW_OP_const1s:
6903           printf ("DW_OP_const1s: %ld", (long) byte_get (data++, 1));
6904           break;
6905         case DW_OP_const2u:
6906           printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
6907           data += 2;
6908           break;
6909         case DW_OP_const2s:
6910           printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
6911           data += 2;
6912           break;
6913         case DW_OP_const4u:
6914           printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
6915           data += 4;
6916           break;
6917         case DW_OP_const4s:
6918           printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
6919           data += 4;
6920           break;
6921         case DW_OP_const8u:
6922           printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
6923                   (unsigned long) byte_get (data + 4, 4));
6924           data += 8;
6925           break;
6926         case DW_OP_const8s:
6927           printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
6928                   (long) byte_get (data + 4, 4));
6929           data += 8;
6930           break;
6931         case DW_OP_constu:
6932           printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
6933           data += bytes_read;
6934           break;
6935         case DW_OP_consts:
6936           printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
6937           data += bytes_read;
6938           break;
6939         case DW_OP_dup:
6940           printf ("DW_OP_dup");
6941           break;
6942         case DW_OP_drop:
6943           printf ("DW_OP_drop");
6944           break;
6945         case DW_OP_over:
6946           printf ("DW_OP_over");
6947           break;
6948         case DW_OP_pick:
6949           printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
6950           break;
6951         case DW_OP_swap:
6952           printf ("DW_OP_swap");
6953           break;
6954         case DW_OP_rot:
6955           printf ("DW_OP_rot");
6956           break;
6957         case DW_OP_xderef:
6958           printf ("DW_OP_xderef");
6959           break;
6960         case DW_OP_abs:
6961           printf ("DW_OP_abs");
6962           break;
6963         case DW_OP_and:
6964           printf ("DW_OP_and");
6965           break;
6966         case DW_OP_div:
6967           printf ("DW_OP_div");
6968           break;
6969         case DW_OP_minus:
6970           printf ("DW_OP_minus");
6971           break;
6972         case DW_OP_mod:
6973           printf ("DW_OP_mod");
6974           break;
6975         case DW_OP_mul:
6976           printf ("DW_OP_mul");
6977           break;
6978         case DW_OP_neg:
6979           printf ("DW_OP_neg");
6980           break;
6981         case DW_OP_not:
6982           printf ("DW_OP_not");
6983           break;
6984         case DW_OP_or:
6985           printf ("DW_OP_or");
6986           break;
6987         case DW_OP_plus:
6988           printf ("DW_OP_plus");
6989           break;
6990         case DW_OP_plus_uconst:
6991           printf ("DW_OP_plus_uconst: %lu",
6992                   read_leb128 (data, &bytes_read, 0));
6993           data += bytes_read;
6994           break;
6995         case DW_OP_shl:
6996           printf ("DW_OP_shl");
6997           break;
6998         case DW_OP_shr:
6999           printf ("DW_OP_shr");
7000           break;
7001         case DW_OP_shra:
7002           printf ("DW_OP_shra");
7003           break;
7004         case DW_OP_xor:
7005           printf ("DW_OP_xor");
7006           break;
7007         case DW_OP_bra:
7008           printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
7009           data += 2;
7010           break;
7011         case DW_OP_eq:
7012           printf ("DW_OP_eq");
7013           break;
7014         case DW_OP_ge:
7015           printf ("DW_OP_ge");
7016           break;
7017         case DW_OP_gt:
7018           printf ("DW_OP_gt");
7019           break;
7020         case DW_OP_le:
7021           printf ("DW_OP_le");
7022           break;
7023         case DW_OP_lt:
7024           printf ("DW_OP_lt");
7025           break;
7026         case DW_OP_ne:
7027           printf ("DW_OP_ne");
7028           break;
7029         case DW_OP_skip:
7030           printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
7031           data += 2;
7032           break;
7033
7034         case DW_OP_lit0:
7035         case DW_OP_lit1:
7036         case DW_OP_lit2:
7037         case DW_OP_lit3:
7038         case DW_OP_lit4:
7039         case DW_OP_lit5:
7040         case DW_OP_lit6:
7041         case DW_OP_lit7:
7042         case DW_OP_lit8:
7043         case DW_OP_lit9:
7044         case DW_OP_lit10:
7045         case DW_OP_lit11:
7046         case DW_OP_lit12:
7047         case DW_OP_lit13:
7048         case DW_OP_lit14:
7049         case DW_OP_lit15:
7050         case DW_OP_lit16:
7051         case DW_OP_lit17:
7052         case DW_OP_lit18:
7053         case DW_OP_lit19:
7054         case DW_OP_lit20:
7055         case DW_OP_lit21:
7056         case DW_OP_lit22:
7057         case DW_OP_lit23:
7058         case DW_OP_lit24:
7059         case DW_OP_lit25:
7060         case DW_OP_lit26:
7061         case DW_OP_lit27:
7062         case DW_OP_lit28:
7063         case DW_OP_lit29:
7064         case DW_OP_lit30:
7065         case DW_OP_lit31:
7066           printf ("DW_OP_lit%d", op - DW_OP_lit0);
7067           break;
7068
7069         case DW_OP_reg0:
7070         case DW_OP_reg1:
7071         case DW_OP_reg2:
7072         case DW_OP_reg3:
7073         case DW_OP_reg4:
7074         case DW_OP_reg5:
7075         case DW_OP_reg6:
7076         case DW_OP_reg7:
7077         case DW_OP_reg8:
7078         case DW_OP_reg9:
7079         case DW_OP_reg10:
7080         case DW_OP_reg11:
7081         case DW_OP_reg12:
7082         case DW_OP_reg13:
7083         case DW_OP_reg14:
7084         case DW_OP_reg15:
7085         case DW_OP_reg16:
7086         case DW_OP_reg17:
7087         case DW_OP_reg18:
7088         case DW_OP_reg19:
7089         case DW_OP_reg20:
7090         case DW_OP_reg21:
7091         case DW_OP_reg22:
7092         case DW_OP_reg23:
7093         case DW_OP_reg24:
7094         case DW_OP_reg25:
7095         case DW_OP_reg26:
7096         case DW_OP_reg27:
7097         case DW_OP_reg28:
7098         case DW_OP_reg29:
7099         case DW_OP_reg30:
7100         case DW_OP_reg31:
7101           printf ("DW_OP_reg%d", op - DW_OP_reg0);
7102           break;
7103
7104         case DW_OP_breg0:
7105         case DW_OP_breg1:
7106         case DW_OP_breg2:
7107         case DW_OP_breg3:
7108         case DW_OP_breg4:
7109         case DW_OP_breg5:
7110         case DW_OP_breg6:
7111         case DW_OP_breg7:
7112         case DW_OP_breg8:
7113         case DW_OP_breg9:
7114         case DW_OP_breg10:
7115         case DW_OP_breg11:
7116         case DW_OP_breg12:
7117         case DW_OP_breg13:
7118         case DW_OP_breg14:
7119         case DW_OP_breg15:
7120         case DW_OP_breg16:
7121         case DW_OP_breg17:
7122         case DW_OP_breg18:
7123         case DW_OP_breg19:
7124         case DW_OP_breg20:
7125         case DW_OP_breg21:
7126         case DW_OP_breg22:
7127         case DW_OP_breg23:
7128         case DW_OP_breg24:
7129         case DW_OP_breg25:
7130         case DW_OP_breg26:
7131         case DW_OP_breg27:
7132         case DW_OP_breg28:
7133         case DW_OP_breg29:
7134         case DW_OP_breg30:
7135         case DW_OP_breg31:
7136           printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
7137                   read_leb128 (data, &bytes_read, 1));
7138           data += bytes_read;
7139           break;
7140
7141         case DW_OP_regx:
7142           printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
7143           data += bytes_read;
7144           break;
7145         case DW_OP_fbreg:
7146           printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
7147           data += bytes_read;
7148           break;
7149         case DW_OP_bregx:
7150           uvalue = read_leb128 (data, &bytes_read, 0);
7151           data += bytes_read;
7152           printf ("DW_OP_bregx: %lu %ld", uvalue,
7153                   read_leb128 (data, &bytes_read, 1));
7154           data += bytes_read;
7155           break;
7156         case DW_OP_piece:
7157           printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
7158           data += bytes_read;
7159           break;
7160         case DW_OP_deref_size:
7161           printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
7162           break;
7163         case DW_OP_xderef_size:
7164           printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
7165           break;
7166         case DW_OP_nop:
7167           printf ("DW_OP_nop");
7168           break;
7169
7170           /* DWARF 2.1 extensions.  */
7171         case DW_OP_push_object_address:
7172           printf ("DW_OP_push_object_address");
7173           break;
7174         case DW_OP_call2:
7175           printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2));
7176           data += 2;
7177           break;
7178         case DW_OP_call4:
7179           printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4));
7180           data += 4;
7181           break;
7182         case DW_OP_calli:
7183           printf ("DW_OP_calli");
7184           break;
7185
7186         default:
7187           if (op >= DW_OP_lo_user
7188               && op <= DW_OP_hi_user)
7189             printf (_("(User defined location op)"));
7190           else
7191             printf (_("(Unknown location op)"));
7192           /* No way to tell where the next op is, so just bail.  */
7193           return;
7194         }
7195
7196       /* Separate the ops.  */
7197       printf ("; ");
7198     }
7199 }
7200
7201 static const char * debug_loc_contents;
7202 static bfd_vma      debug_loc_size;
7203
7204 static void
7205 load_debug_loc (file)
7206      FILE * file;
7207 {
7208   Elf32_Internal_Shdr * sec;
7209   unsigned int          i;
7210
7211   /* If it is already loaded, do nothing.  */
7212   if (debug_loc_contents != NULL)
7213     return;
7214
7215   /* Locate the .debug_loc section.  */
7216   for (i = 0, sec = section_headers;
7217        i < elf_header.e_shnum;
7218        i ++, sec ++)
7219     if (strcmp (SECTION_NAME (sec), ".debug_loc") == 0)
7220       break;
7221
7222   if (i == elf_header.e_shnum || sec->sh_size == 0)
7223     return;
7224
7225   debug_loc_size = sec->sh_size;
7226
7227   debug_loc_contents = ((char *)
7228                         get_data (NULL, file, sec->sh_offset, sec->sh_size,
7229                                   _("debug_loc section data")));
7230 }
7231
7232 static void
7233 free_debug_loc ()
7234 {
7235   if (debug_loc_contents == NULL)
7236     return;
7237
7238   free ((char *) debug_loc_contents);
7239   debug_loc_contents = NULL;
7240   debug_loc_size = 0;
7241 }
7242
7243
7244 static int
7245 display_debug_loc (section, start, file)
7246      Elf32_Internal_Shdr * section;
7247      unsigned char * start;
7248      FILE * file ATTRIBUTE_UNUSED;
7249 {
7250   unsigned char *section_end;
7251   unsigned long bytes;
7252   unsigned char *section_begin = start;
7253   bfd_vma addr;
7254
7255   addr = section->sh_addr;
7256   bytes = section->sh_size;
7257   section_end = start + bytes;
7258   if (bytes == 0)
7259     {
7260       printf (_("\nThe .debug_loc section is empty.\n"));
7261       return 0;
7262     }
7263   printf (_("Contents of the .debug_loc section:\n\n"));
7264   printf (_("\n    Offset   Begin    End      Expression\n"));
7265   while (start < section_end)
7266     {
7267       unsigned long begin;
7268       unsigned long end;
7269       unsigned short length;
7270       unsigned long offset;
7271
7272       offset = start - section_begin;
7273
7274       while (1)
7275         {
7276           /* Normally, the lists in  the debug_loc section are related to a
7277              given compilation unit, and thus, we would use the
7278              pointer size of that compilation unit.  However, since we are
7279              displaying it seperately here, we either have to store
7280              pointer sizes of all compilation units, or assume they don't
7281              change.   We assume, like the debug_line display, that
7282              it doesn't change.  */
7283           begin = byte_get (start, debug_line_pointer_size);
7284           start += debug_line_pointer_size;
7285           end = byte_get (start, debug_line_pointer_size);
7286           start += debug_line_pointer_size;
7287
7288           if (begin == 0 && end == 0)
7289             break;
7290
7291           begin += addr;
7292           end += addr;
7293
7294           length = byte_get (start, 2);
7295           start += 2;
7296
7297           printf ("    %8.8lx %8.8lx %8.8lx (", offset, begin, end);
7298           decode_location_expression (start, debug_line_pointer_size, length);
7299           printf (")\n");
7300
7301           start += length;
7302         }
7303       printf ("\n");
7304     }
7305   return 1;
7306 }
7307
7308 static const char * debug_str_contents;
7309 static bfd_vma      debug_str_size;
7310
7311 static void
7312 load_debug_str (file)
7313      FILE * file;
7314 {
7315   Elf32_Internal_Shdr * sec;
7316   unsigned int          i;
7317
7318   /* If it is already loaded, do nothing.  */
7319   if (debug_str_contents != NULL)
7320     return;
7321
7322   /* Locate the .debug_str section.  */
7323   for (i = 0, sec = section_headers;
7324        i < elf_header.e_shnum;
7325        i ++, sec ++)
7326     if (strcmp (SECTION_NAME (sec), ".debug_str") == 0)
7327       break;
7328
7329   if (i == elf_header.e_shnum || sec->sh_size == 0)
7330     return;
7331
7332   debug_str_size = sec->sh_size;
7333
7334   debug_str_contents = ((char *)
7335                         get_data (NULL, file, sec->sh_offset, sec->sh_size,
7336                                   _("debug_str section data")));
7337 }
7338
7339 static void
7340 free_debug_str ()
7341 {
7342   if (debug_str_contents == NULL)
7343     return;
7344
7345   free ((char *) debug_str_contents);
7346   debug_str_contents = NULL;
7347   debug_str_size = 0;
7348 }
7349
7350 static const char *
7351 fetch_indirect_string (offset)
7352      unsigned long offset;
7353 {
7354   if (debug_str_contents == NULL)
7355     return _("<no .debug_str section>");
7356
7357   if (offset > debug_str_size)
7358     return _("<offset is too big>");
7359
7360   return debug_str_contents + offset;
7361 }
7362
7363
7364 static int
7365 display_debug_str (section, start, file)
7366      Elf32_Internal_Shdr * section;
7367      unsigned char *       start;
7368      FILE *                file ATTRIBUTE_UNUSED;
7369 {
7370   unsigned long   bytes;
7371   bfd_vma         addr;
7372
7373   addr  = section->sh_addr;
7374   bytes = section->sh_size;
7375
7376   if (bytes == 0)
7377     {
7378       printf (_("\nThe .debug_str section is empty.\n"));
7379       return 0;
7380     }
7381
7382   printf (_("Contents of the .debug_str section:\n\n"));
7383
7384   while (bytes)
7385     {
7386       int j;
7387       int k;
7388       int lbytes;
7389
7390       lbytes = (bytes > 16 ? 16 : bytes);
7391
7392       printf ("  0x%8.8lx ", (unsigned long) addr);
7393
7394       for (j = 0; j < 16; j++)
7395         {
7396           if (j < lbytes)
7397             printf ("%2.2x", start [j]);
7398           else
7399             printf ("  ");
7400
7401           if ((j & 3) == 3)
7402             printf (" ");
7403         }
7404
7405       for (j = 0; j < lbytes; j++)
7406         {
7407           k = start [j];
7408           if (k >= ' ' && k < 0x80)
7409             printf ("%c", k);
7410           else
7411             printf (".");
7412         }
7413
7414       putchar ('\n');
7415
7416       start += lbytes;
7417       addr  += lbytes;
7418       bytes -= lbytes;
7419     }
7420
7421   return 1;
7422 }
7423
7424
7425 static unsigned char *
7426 read_and_display_attr_value (attribute, form, data, cu_offset, pointer_size)
7427      unsigned long   attribute;
7428      unsigned long   form;
7429      unsigned char * data;
7430      unsigned long   cu_offset;
7431      unsigned long   pointer_size;
7432 {
7433   unsigned long   uvalue = 0;
7434   unsigned char * block_start = NULL;
7435   int             bytes_read;
7436
7437   switch (form)
7438     {
7439     default:
7440       break;
7441
7442     case DW_FORM_ref_addr:
7443     case DW_FORM_addr:
7444       uvalue = byte_get (data, pointer_size);
7445       data += pointer_size;
7446       break;
7447
7448     case DW_FORM_strp:
7449       uvalue = byte_get (data, /* offset_size */ 4);
7450       data += /* offset_size */ 4;
7451       break;
7452
7453     case DW_FORM_ref1:
7454     case DW_FORM_flag:
7455     case DW_FORM_data1:
7456       uvalue = byte_get (data ++, 1);
7457       break;
7458
7459     case DW_FORM_ref2:
7460     case DW_FORM_data2:
7461       uvalue = byte_get (data, 2);
7462       data += 2;
7463       break;
7464
7465     case DW_FORM_ref4:
7466     case DW_FORM_data4:
7467       uvalue = byte_get (data, 4);
7468       data += 4;
7469       break;
7470
7471     case DW_FORM_sdata:
7472       uvalue = read_leb128 (data, & bytes_read, 1);
7473       data += bytes_read;
7474       break;
7475
7476     case DW_FORM_ref_udata:
7477     case DW_FORM_udata:
7478       uvalue = read_leb128 (data, & bytes_read, 0);
7479       data += bytes_read;
7480       break;
7481
7482     case DW_FORM_indirect:
7483       form = read_leb128 (data, & bytes_read, 0);
7484       data += bytes_read;
7485       printf (" %s", get_FORM_name (form));
7486       return read_and_display_attr_value (attribute, form, data, cu_offset,
7487                                           pointer_size);
7488     }
7489
7490   switch (form)
7491     {
7492     case DW_FORM_ref_addr:
7493       printf (" <#%lx>", uvalue);
7494       break;
7495
7496     case DW_FORM_ref1:
7497     case DW_FORM_ref2:
7498     case DW_FORM_ref4:
7499     case DW_FORM_ref_udata:
7500       printf (" <%lx>", uvalue + cu_offset);
7501       break;
7502
7503     case DW_FORM_addr:
7504       printf (" %#lx", uvalue);
7505
7506     case DW_FORM_flag:
7507     case DW_FORM_data1:
7508     case DW_FORM_data2:
7509     case DW_FORM_data4:
7510     case DW_FORM_sdata:
7511     case DW_FORM_udata:
7512       printf (" %ld", uvalue);
7513       break;
7514
7515     case DW_FORM_ref8:
7516     case DW_FORM_data8:
7517       uvalue = byte_get (data, 4);
7518       printf (" %lx", uvalue);
7519       printf (" %lx", (unsigned long) byte_get (data + 4, 4));
7520       data += 8;
7521       break;
7522
7523     case DW_FORM_string:
7524       printf (" %s", data);
7525       data += strlen ((char *) data) + 1;
7526       break;
7527
7528     case DW_FORM_block:
7529       uvalue = read_leb128 (data, & bytes_read, 0);
7530       block_start = data + bytes_read;
7531       data = display_block (block_start, uvalue);
7532       break;
7533
7534     case DW_FORM_block1:
7535       uvalue = byte_get (data, 1);
7536       block_start = data + 1;
7537       data = display_block (block_start, uvalue);
7538       break;
7539
7540     case DW_FORM_block2:
7541       uvalue = byte_get (data, 2);
7542       block_start = data + 2;
7543       data = display_block (block_start, uvalue);
7544       break;
7545
7546     case DW_FORM_block4:
7547       uvalue = byte_get (data, 4);
7548       block_start = data + 4;
7549       data = display_block (block_start, uvalue);
7550       break;
7551
7552     case DW_FORM_strp:
7553       printf (_(" (indirect string, offset: 0x%lx): "), uvalue);
7554       printf (fetch_indirect_string (uvalue));
7555       break;
7556
7557     case DW_FORM_indirect:
7558       /* Handled above.  */
7559       break;
7560
7561     default:
7562       warn (_("Unrecognized form: %d\n"), form);
7563       break;
7564     }
7565
7566   /* For some attributes we can display futher information.  */
7567
7568   printf ("\t");
7569
7570   switch (attribute)
7571     {
7572     case DW_AT_inline:
7573       switch (uvalue)
7574         {
7575         case DW_INL_not_inlined:          printf (_("(not inlined)")); break;
7576         case DW_INL_inlined:              printf (_("(inlined)")); break;
7577         case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
7578         case DW_INL_declared_inlined:     printf (_("(declared as inline and inlined)")); break;
7579         default: printf (_("  (Unknown inline attribute value: %lx)"), uvalue); break;
7580         }
7581       break;
7582
7583     case DW_AT_language:
7584       switch (uvalue)
7585         {
7586         case DW_LANG_C:              printf ("(non-ANSI C)"); break;
7587         case DW_LANG_C89:            printf ("(ANSI C)"); break;
7588         case DW_LANG_C_plus_plus:    printf ("(C++)"); break;
7589         case DW_LANG_Fortran77:      printf ("(FORTRAN 77)"); break;
7590         case DW_LANG_Fortran90:      printf ("(Fortran 90)"); break;
7591         case DW_LANG_Modula2:        printf ("(Modula 2)"); break;
7592         case DW_LANG_Pascal83:       printf ("(ANSI Pascal)"); break;
7593         case DW_LANG_Ada83:          printf ("(Ada)"); break;
7594         case DW_LANG_Cobol74:        printf ("(Cobol 74)"); break;
7595         case DW_LANG_Cobol85:        printf ("(Cobol 85)"); break;
7596           /* DWARF 2.1 values.  */
7597         case DW_LANG_C99:            printf ("(ANSI C99)"); break;
7598         case DW_LANG_Ada95:          printf ("(ADA 95)"); break;
7599         case DW_LANG_Fortran95:      printf ("(Fortran 95)"); break;
7600           /* MIPS extension.  */
7601         case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
7602         default:                     printf ("(Unknown: %lx)", uvalue); break;
7603         }
7604       break;
7605
7606     case DW_AT_encoding:
7607       switch (uvalue)
7608         {
7609         case DW_ATE_void:            printf ("(void)"); break;
7610         case DW_ATE_address:         printf ("(machine address)"); break;
7611         case DW_ATE_boolean:         printf ("(boolean)"); break;
7612         case DW_ATE_complex_float:   printf ("(complex float)"); break;
7613         case DW_ATE_float:           printf ("(float)"); break;
7614         case DW_ATE_signed:          printf ("(signed)"); break;
7615         case DW_ATE_signed_char:     printf ("(signed char)"); break;
7616         case DW_ATE_unsigned:        printf ("(unsigned)"); break;
7617         case DW_ATE_unsigned_char:   printf ("(unsigned char)"); break;
7618           /* DWARF 2.1 value.  */
7619         case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
7620         default:
7621           if (uvalue >= DW_ATE_lo_user
7622               && uvalue <= DW_ATE_hi_user)
7623             printf ("(user defined type)");
7624           else
7625             printf ("(unknown type)");
7626           break;
7627         }
7628       break;
7629
7630     case DW_AT_accessibility:
7631       switch (uvalue)
7632         {
7633         case DW_ACCESS_public:          printf ("(public)"); break;
7634         case DW_ACCESS_protected:       printf ("(protected)"); break;
7635         case DW_ACCESS_private:         printf ("(private)"); break;
7636         default:                        printf ("(unknown accessibility)"); break;
7637         }
7638       break;
7639
7640     case DW_AT_visibility:
7641       switch (uvalue)
7642         {
7643         case DW_VIS_local:      printf ("(local)"); break;
7644         case DW_VIS_exported:   printf ("(exported)"); break;
7645         case DW_VIS_qualified:  printf ("(qualified)"); break;
7646         default:                printf ("(unknown visibility)"); break;
7647         }
7648       break;
7649
7650     case DW_AT_virtuality:
7651       switch (uvalue)
7652         {
7653         case DW_VIRTUALITY_none:        printf ("(none)"); break;
7654         case DW_VIRTUALITY_virtual:     printf ("(virtual)"); break;
7655         case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
7656         default:                        printf ("(unknown virtuality)"); break;
7657         }
7658       break;
7659
7660     case DW_AT_identifier_case:
7661       switch (uvalue)
7662         {
7663         case DW_ID_case_sensitive:      printf ("(case_sensitive)"); break;
7664         case DW_ID_up_case:             printf ("(up_case)"); break;
7665         case DW_ID_down_case:           printf ("(down_case)"); break;
7666         case DW_ID_case_insensitive:    printf ("(case_insensitive)"); break;
7667         default:                        printf ("(unknown case)"); break;
7668         }
7669       break;
7670
7671     case DW_AT_calling_convention:
7672       switch (uvalue)
7673         {
7674         case DW_CC_normal:      printf ("(normal)"); break;
7675         case DW_CC_program:     printf ("(program)"); break;
7676         case DW_CC_nocall:      printf ("(nocall)"); break;
7677         default:
7678           if (uvalue >= DW_CC_lo_user
7679               && uvalue <= DW_CC_hi_user)
7680             printf ("(user defined)");
7681           else
7682             printf ("(unknown convention)");
7683         }
7684       break;
7685
7686     case DW_AT_ordering:
7687       switch (uvalue)
7688         {
7689         case -1: printf ("(undefined)"); break;
7690         case 0:  printf ("(row major)"); break;
7691         case 1:  printf ("(column major)"); break;
7692         }
7693       break;
7694
7695     case DW_AT_frame_base:
7696     case DW_AT_location:
7697     case DW_AT_data_member_location:
7698     case DW_AT_vtable_elem_location:
7699     case DW_AT_allocated:
7700     case DW_AT_associated:
7701     case DW_AT_data_location:
7702     case DW_AT_stride:
7703     case DW_AT_upper_bound:
7704     case DW_AT_lower_bound:
7705       if (block_start)
7706         {
7707           printf ("(");
7708           decode_location_expression (block_start, pointer_size, uvalue);
7709           printf (")");
7710         }
7711       else if (form == DW_FORM_data4)
7712         {
7713           printf ("(");
7714           printf ("location list");
7715           printf (")");
7716         }
7717       break;
7718
7719     default:
7720       break;
7721     }
7722
7723   return data;
7724 }
7725
7726 static unsigned char *
7727 read_and_display_attr (attribute, form, data, cu_offset, pointer_size)
7728      unsigned long   attribute;
7729      unsigned long   form;
7730      unsigned char * data;
7731      unsigned long   cu_offset;
7732      unsigned long   pointer_size;
7733 {
7734   printf ("     %-18s:", get_AT_name (attribute));
7735   data = read_and_display_attr_value (attribute, form, data, cu_offset,
7736                                       pointer_size);
7737   printf ("\n");
7738   return data;
7739 }
7740
7741 static int
7742 display_debug_info (section, start, file)
7743      Elf32_Internal_Shdr * section;
7744      unsigned char *       start;
7745      FILE *                file;
7746 {
7747   unsigned char * end = start + section->sh_size;
7748   unsigned char * section_begin = start;
7749
7750   printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
7751
7752   load_debug_str (file);
7753   load_debug_loc (file);
7754
7755   while (start < end)
7756     {
7757       DWARF2_External_CompUnit * external;
7758       DWARF2_Internal_CompUnit   compunit;
7759       Elf32_Internal_Shdr *      relsec;
7760       unsigned char *            tags;
7761       unsigned int               i;
7762       int                        level;
7763       unsigned long              cu_offset;
7764
7765       external = (DWARF2_External_CompUnit *) start;
7766
7767       compunit.cu_length        = BYTE_GET (external->cu_length);
7768       compunit.cu_version       = BYTE_GET (external->cu_version);
7769       compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
7770       compunit.cu_pointer_size  = BYTE_GET (external->cu_pointer_size);
7771
7772       if (compunit.cu_length == 0xffffffff)
7773         {
7774           warn (_("64-bit DWARF debug info is not supported yet.\n"));
7775           break;
7776         }
7777
7778       /* Check for RELA relocations in the abbrev_offset address, and
7779          apply them.  */
7780       for (relsec = section_headers;
7781            relsec < section_headers + elf_header.e_shnum;
7782            ++relsec)
7783         {
7784           unsigned long nrelas;
7785           Elf_Internal_Rela *rela, *rp;
7786           Elf32_Internal_Shdr *symsec;
7787           Elf_Internal_Sym *symtab;
7788           Elf_Internal_Sym *sym;
7789
7790           if (relsec->sh_type != SHT_RELA
7791               || SECTION_HEADER (relsec->sh_info) != section)
7792             continue;
7793
7794           if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7795                                   & rela, & nrelas))
7796             return 0;
7797
7798           symsec = SECTION_HEADER (relsec->sh_link);
7799           symtab = GET_ELF_SYMBOLS (file, symsec);
7800
7801           for (rp = rela; rp < rela + nrelas; ++rp)
7802             {
7803               if (rp->r_offset
7804                   != (bfd_vma) ((unsigned char *) &external->cu_abbrev_offset
7805                                 - section_begin))
7806                 continue;
7807
7808               if (is_32bit_elf)
7809                 {
7810                   sym = symtab + ELF32_R_SYM (rp->r_info);
7811
7812                   if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
7813                     {
7814                       warn (_("Skipping unexpected symbol type %u\n"),
7815                             ELF32_ST_TYPE (sym->st_info));
7816                       continue;
7817                     }
7818                 }
7819               else
7820                 {
7821                   sym = symtab + ELF64_R_SYM (rp->r_info);
7822
7823                   if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
7824                     {
7825                       warn (_("Skipping unexpected symbol type %u\n"),
7826                             ELF64_ST_TYPE (sym->st_info));
7827                       continue;
7828                     }
7829                 }
7830
7831               compunit.cu_abbrev_offset += rp->r_addend;
7832               break;
7833             }
7834
7835           free (rela);
7836           break;
7837         }
7838
7839       tags = start + sizeof (* external);
7840       cu_offset = start - section_begin;
7841       start += compunit.cu_length + sizeof (external->cu_length);
7842
7843       printf (_("  Compilation Unit @ %lx:\n"), cu_offset);
7844       printf (_("   Length:        %ld\n"), compunit.cu_length);
7845       printf (_("   Version:       %d\n"), compunit.cu_version);
7846       printf (_("   Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
7847       printf (_("   Pointer Size:  %d\n"), compunit.cu_pointer_size);
7848
7849       if (compunit.cu_version != 2)
7850         {
7851           warn (_("Only version 2 DWARF debug information is currently supported.\n"));
7852           continue;
7853         }
7854
7855       free_abbrevs ();
7856
7857       /* Read in the abbrevs used by this compilation unit.  */
7858
7859       {
7860         Elf32_Internal_Shdr * sec;
7861         unsigned char *       begin;
7862
7863         /* Locate the .debug_abbrev section and process it.  */
7864         for (i = 0, sec = section_headers;
7865              i < elf_header.e_shnum;
7866              i ++, sec ++)
7867           if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
7868             break;
7869
7870         if (i == elf_header.e_shnum || sec->sh_size == 0)
7871           {
7872             warn (_("Unable to locate .debug_abbrev section!\n"));
7873             return 0;
7874           }
7875
7876         begin = ((unsigned char *)
7877                  get_data (NULL, file, sec->sh_offset, sec->sh_size,
7878                            _("debug_abbrev section data")));
7879         if (!begin)
7880           return 0;
7881
7882         process_abbrev_section (begin + compunit.cu_abbrev_offset,
7883                                 begin + sec->sh_size);
7884
7885         free (begin);
7886       }
7887
7888       level = 0;
7889       while (tags < start)
7890         {
7891           int            bytes_read;
7892           unsigned long  abbrev_number;
7893           abbrev_entry * entry;
7894           abbrev_attr  * attr;
7895
7896           abbrev_number = read_leb128 (tags, & bytes_read, 0);
7897           tags += bytes_read;
7898
7899           /* A null DIE marks the end of a list of children.  */
7900           if (abbrev_number == 0)
7901             {
7902               --level;
7903               continue;
7904             }
7905
7906           /* Scan through the abbreviation list until we reach the
7907              correct entry.  */
7908           for (entry = first_abbrev;
7909                entry && entry->entry != abbrev_number;
7910                entry = entry->next)
7911             continue;
7912
7913           if (entry == NULL)
7914             {
7915               warn (_("Unable to locate entry %lu in the abbreviation table\n"),
7916                     abbrev_number);
7917               return 0;
7918             }
7919
7920           printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
7921                   level,
7922                   (unsigned long) (tags - section_begin - bytes_read),
7923                   abbrev_number,
7924                   get_TAG_name (entry->tag));
7925
7926           for (attr = entry->first_attr; attr; attr = attr->next)
7927             tags = read_and_display_attr (attr->attribute,
7928                                           attr->form,
7929                                           tags, cu_offset,
7930                                           compunit.cu_pointer_size);
7931
7932           if (entry->children)
7933             ++level;
7934         }
7935     }
7936
7937   free_debug_str ();
7938   free_debug_loc ();
7939
7940   printf ("\n");
7941
7942   return 1;
7943 }
7944
7945 static int
7946 display_debug_aranges (section, start, file)
7947      Elf32_Internal_Shdr * section;
7948      unsigned char *       start;
7949      FILE *                file ATTRIBUTE_UNUSED;
7950 {
7951   unsigned char * end = start + section->sh_size;
7952
7953   printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
7954
7955   while (start < end)
7956     {
7957       DWARF2_External_ARange * external;
7958       DWARF2_Internal_ARange   arange;
7959       unsigned char *          ranges;
7960       unsigned long            length;
7961       unsigned long            address;
7962       int                      excess;
7963
7964       external = (DWARF2_External_ARange *) start;
7965
7966       arange.ar_length       = BYTE_GET (external->ar_length);
7967       arange.ar_version      = BYTE_GET (external->ar_version);
7968       arange.ar_info_offset  = BYTE_GET (external->ar_info_offset);
7969       arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
7970       arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
7971
7972       if (arange.ar_length == 0xffffffff)
7973         {
7974           warn (_("64-bit DWARF aranges are not supported yet.\n"));
7975           break;
7976         }
7977
7978       if (arange.ar_version != 2)
7979         {
7980           warn (_("Only DWARF 2 aranges are currently supported.\n"));
7981           break;
7982         }
7983
7984       printf (_("  Length:                   %ld\n"), arange.ar_length);
7985       printf (_("  Version:                  %d\n"), arange.ar_version);
7986       printf (_("  Offset into .debug_info:  %lx\n"), arange.ar_info_offset);
7987       printf (_("  Pointer Size:             %d\n"), arange.ar_pointer_size);
7988       printf (_("  Segment Size:             %d\n"), arange.ar_segment_size);
7989
7990       printf (_("\n    Address  Length\n"));
7991
7992       ranges = start + sizeof (* external);
7993
7994       /* Must pad to an alignment boundary that is twice the pointer size.  */
7995       excess = sizeof (* external) % (2 * arange.ar_pointer_size);
7996       if (excess)
7997         ranges += (2 * arange.ar_pointer_size) - excess;
7998
7999       for (;;)
8000         {
8001           address = byte_get (ranges, arange.ar_pointer_size);
8002
8003           ranges += arange.ar_pointer_size;
8004
8005           length  = byte_get (ranges, arange.ar_pointer_size);
8006
8007           ranges += arange.ar_pointer_size;
8008
8009           /* A pair of zeros marks the end of the list.  */
8010           if (address == 0 && length == 0)
8011             break;
8012
8013           printf ("    %8.8lx %lu\n", address, length);
8014         }
8015
8016       start += arange.ar_length + sizeof (external->ar_length);
8017     }
8018
8019   printf ("\n");
8020
8021   return 1;
8022 }
8023
8024 typedef struct Frame_Chunk
8025 {
8026   struct Frame_Chunk * next;
8027   unsigned char *      chunk_start;
8028   int                  ncols;
8029   /* DW_CFA_{undefined,same_value,offset,register,unreferenced}  */
8030   short int *          col_type;
8031   int *                col_offset;
8032   char *               augmentation;
8033   unsigned int         code_factor;
8034   int                  data_factor;
8035   unsigned long        pc_begin;
8036   unsigned long        pc_range;
8037   int                  cfa_reg;
8038   int                  cfa_offset;
8039   int                  ra;
8040   unsigned char        fde_encoding;
8041 }
8042 Frame_Chunk;
8043
8044 /* A marker for a col_type that means this column was never referenced
8045    in the frame info.  */
8046 #define DW_CFA_unreferenced (-1)
8047
8048 static void frame_need_space PARAMS ((Frame_Chunk *, int));
8049 static void frame_display_row PARAMS ((Frame_Chunk *, int *, int *));
8050 static int size_of_encoded_value PARAMS ((int));
8051
8052 static void
8053 frame_need_space (fc, reg)
8054      Frame_Chunk * fc;
8055      int reg;
8056 {
8057   int prev = fc->ncols;
8058
8059   if (reg < fc->ncols)
8060     return;
8061
8062   fc->ncols = reg + 1;
8063   fc->col_type = (short int *) xrealloc (fc->col_type,
8064                                          fc->ncols * sizeof (short int));
8065   fc->col_offset = (int *) xrealloc (fc->col_offset,
8066                                      fc->ncols * sizeof (int));
8067
8068   while (prev < fc->ncols)
8069     {
8070       fc->col_type[prev] = DW_CFA_unreferenced;
8071       fc->col_offset[prev] = 0;
8072       prev++;
8073     }
8074 }
8075
8076 static void
8077 frame_display_row (fc, need_col_headers, max_regs)
8078      Frame_Chunk * fc;
8079      int *         need_col_headers;
8080      int *         max_regs;
8081 {
8082   int r;
8083   char tmp[100];
8084
8085   if (* max_regs < fc->ncols)
8086     * max_regs = fc->ncols;
8087
8088   if (* need_col_headers)
8089     {
8090       * need_col_headers = 0;
8091
8092       printf ("   LOC   CFA      ");
8093
8094       for (r = 0; r < * max_regs; r++)
8095         if (fc->col_type[r] != DW_CFA_unreferenced)
8096           {
8097             if (r == fc->ra)
8098               printf ("ra   ");
8099             else
8100               printf ("r%-4d", r);
8101           }
8102
8103       printf ("\n");
8104     }
8105
8106   printf ("%08lx ", fc->pc_begin);
8107   sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
8108   printf ("%-8s ", tmp);
8109
8110   for (r = 0; r < fc->ncols; r++)
8111     {
8112       if (fc->col_type[r] != DW_CFA_unreferenced)
8113         {
8114           switch (fc->col_type[r])
8115             {
8116             case DW_CFA_undefined:
8117               strcpy (tmp, "u");
8118               break;
8119             case DW_CFA_same_value:
8120               strcpy (tmp, "s");
8121               break;
8122             case DW_CFA_offset:
8123               sprintf (tmp, "c%+d", fc->col_offset[r]);
8124               break;
8125             case DW_CFA_register:
8126               sprintf (tmp, "r%d", fc->col_offset[r]);
8127               break;
8128             default:
8129               strcpy (tmp, "n/a");
8130               break;
8131             }
8132           printf ("%-5s", tmp);
8133         }
8134     }
8135   printf ("\n");
8136 }
8137
8138 static int
8139 size_of_encoded_value (encoding)
8140      int encoding;
8141 {
8142   switch (encoding & 0x7)
8143     {
8144     default:    /* ??? */
8145     case 0:     return is_32bit_elf ? 4 : 8;
8146     case 2:     return 2;
8147     case 3:     return 4;
8148     case 4:     return 8;
8149     }
8150 }
8151
8152 #define GET(N)  byte_get (start, N); start += N
8153 #define LEB()   read_leb128 (start, & length_return, 0); start += length_return
8154 #define SLEB()  read_leb128 (start, & length_return, 1); start += length_return
8155
8156 static int
8157 display_debug_frames (section, start, file)
8158      Elf32_Internal_Shdr * section;
8159      unsigned char *       start;
8160      FILE *                file ATTRIBUTE_UNUSED;
8161 {
8162   unsigned char * end = start + section->sh_size;
8163   unsigned char * section_start = start;
8164   Frame_Chunk *   chunks = 0;
8165   Frame_Chunk *   remembered_state = 0;
8166   Frame_Chunk *   rs;
8167   int             is_eh = (strcmp (SECTION_NAME (section), ".eh_frame") == 0);
8168   int             length_return;
8169   int             max_regs = 0;
8170   int             addr_size = is_32bit_elf ? 4 : 8;
8171
8172   printf (_("The section %s contains:\n"), SECTION_NAME (section));
8173
8174   while (start < end)
8175     {
8176       unsigned char * saved_start;
8177       unsigned char * block_end;
8178       unsigned long   length;
8179       unsigned long   cie_id;
8180       Frame_Chunk *   fc;
8181       Frame_Chunk *   cie;
8182       int             need_col_headers = 1;
8183       unsigned char * augmentation_data = NULL;
8184       unsigned long   augmentation_data_len = 0;
8185       int             encoded_ptr_size = addr_size;
8186
8187       saved_start = start;
8188       length = byte_get (start, 4); start += 4;
8189
8190       if (length == 0)
8191         return 1;
8192
8193       if (length == 0xffffffff)
8194         {
8195           warn (_("64-bit DWARF format frames are not supported yet.\n"));
8196           break;
8197         }
8198
8199       block_end = saved_start + length + 4;
8200       cie_id = byte_get (start, 4); start += 4;
8201
8202       if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
8203         {
8204           int version;
8205
8206           fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
8207           memset (fc, 0, sizeof (Frame_Chunk));
8208
8209           fc->next = chunks;
8210           chunks = fc;
8211           fc->chunk_start = saved_start;
8212           fc->ncols = 0;
8213           fc->col_type = (short int *) xmalloc (sizeof (short int));
8214           fc->col_offset = (int *) xmalloc (sizeof (int));
8215           frame_need_space (fc, max_regs-1);
8216
8217           version = *start++;
8218
8219           fc->augmentation = start;
8220           start = strchr (start, '\0') + 1;
8221
8222           if (fc->augmentation[0] == 'z')
8223             {
8224               fc->code_factor = LEB ();
8225               fc->data_factor = SLEB ();
8226               fc->ra = byte_get (start, 1); start += 1;
8227               augmentation_data_len = LEB ();
8228               augmentation_data = start;
8229               start += augmentation_data_len;
8230             }
8231           else if (strcmp (fc->augmentation, "eh") == 0)
8232             {
8233               start += addr_size;
8234               fc->code_factor = LEB ();
8235               fc->data_factor = SLEB ();
8236               fc->ra = byte_get (start, 1); start += 1;
8237             }
8238           else
8239             {
8240               fc->code_factor = LEB ();
8241               fc->data_factor = SLEB ();
8242               fc->ra = byte_get (start, 1); start += 1;
8243             }
8244           cie = fc;
8245
8246           if (do_debug_frames_interp)
8247             printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8248                     (unsigned long)(saved_start - section_start), length, cie_id,
8249                     fc->augmentation, fc->code_factor, fc->data_factor,
8250                     fc->ra);
8251           else
8252             {
8253               printf ("\n%08lx %08lx %08lx CIE\n",
8254                       (unsigned long)(saved_start - section_start), length, cie_id);
8255               printf ("  Version:               %d\n", version);
8256               printf ("  Augmentation:          \"%s\"\n", fc->augmentation);
8257               printf ("  Code alignment factor: %u\n", fc->code_factor);
8258               printf ("  Data alignment factor: %d\n", fc->data_factor);
8259               printf ("  Return address column: %d\n", fc->ra);
8260
8261               if (augmentation_data_len)
8262                 {
8263                   unsigned long i;
8264                   printf ("  Augmentation data:    ");
8265                   for (i = 0; i < augmentation_data_len; ++i)
8266                     printf (" %02x", augmentation_data[i]);
8267                   putchar ('\n');
8268                 }
8269               putchar ('\n');
8270             }
8271
8272           if (augmentation_data_len)
8273             {
8274               unsigned char *p, *q;
8275               p = fc->augmentation + 1;
8276               q = augmentation_data;
8277
8278               while (1)
8279                 {
8280                   if (*p == 'L')
8281                     q++;
8282                   else if (*p == 'P')
8283                     q += 1 + size_of_encoded_value (*q);
8284                   else if (*p == 'R')
8285                     fc->fde_encoding = *q++;
8286                   else
8287                     break;
8288                   p++;
8289                 }
8290
8291               if (fc->fde_encoding)
8292                 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
8293             }
8294
8295           frame_need_space (fc, fc->ra);
8296         }
8297       else
8298         {
8299           unsigned char *    look_for;
8300           static Frame_Chunk fde_fc;
8301
8302           fc = & fde_fc;
8303           memset (fc, 0, sizeof (Frame_Chunk));
8304
8305           look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
8306
8307           for (cie = chunks; cie ; cie = cie->next)
8308             if (cie->chunk_start == look_for)
8309               break;
8310
8311           if (!cie)
8312             {
8313               warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
8314                     cie_id, saved_start);
8315               start = block_end;
8316               fc->ncols = 0;
8317               fc->col_type = (short int *) xmalloc (sizeof (short int));
8318               fc->col_offset = (int *) xmalloc (sizeof (int));
8319               frame_need_space (fc, max_regs - 1);
8320               cie = fc;
8321               fc->augmentation = "";
8322               fc->fde_encoding = 0;
8323             }
8324           else
8325             {
8326               fc->ncols = cie->ncols;
8327               fc->col_type = (short int *) xmalloc (fc->ncols * sizeof (short int));
8328               fc->col_offset = (int *) xmalloc (fc->ncols * sizeof (int));
8329               memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
8330               memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
8331               fc->augmentation = cie->augmentation;
8332               fc->code_factor = cie->code_factor;
8333               fc->data_factor = cie->data_factor;
8334               fc->cfa_reg = cie->cfa_reg;
8335               fc->cfa_offset = cie->cfa_offset;
8336               fc->ra = cie->ra;
8337               frame_need_space (fc, max_regs-1);
8338               fc->fde_encoding = cie->fde_encoding;
8339             }
8340
8341           if (fc->fde_encoding)
8342             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
8343
8344           fc->pc_begin = byte_get (start, encoded_ptr_size);
8345           start += encoded_ptr_size;
8346           fc->pc_range = byte_get (start, encoded_ptr_size);
8347           start += encoded_ptr_size;
8348
8349           if (cie->augmentation[0] == 'z')
8350             {
8351               augmentation_data_len = LEB ();
8352               augmentation_data = start;
8353               start += augmentation_data_len;
8354             }
8355
8356           printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
8357                   (unsigned long)(saved_start - section_start), length, cie_id,
8358                   (unsigned long)(cie->chunk_start - section_start),
8359                   fc->pc_begin, fc->pc_begin + fc->pc_range);
8360           if (! do_debug_frames_interp && augmentation_data_len)
8361             {
8362               unsigned long i;
8363               printf ("  Augmentation data:    ");
8364               for (i = 0; i < augmentation_data_len; ++i)
8365                 printf (" %02x", augmentation_data[i]);
8366               putchar ('\n');
8367               putchar ('\n');
8368             }
8369         }
8370
8371       /* At this point, fc is the current chunk, cie (if any) is set, and we're
8372          about to interpret instructions for the chunk.  */
8373
8374       if (do_debug_frames_interp)
8375       {
8376         /* Start by making a pass over the chunk, allocating storage
8377            and taking note of what registers are used.  */
8378         unsigned char * tmp = start;
8379
8380         while (start < block_end)
8381           {
8382             unsigned op, opa;
8383             unsigned long reg;
8384
8385             op = * start ++;
8386             opa = op & 0x3f;
8387             if (op & 0xc0)
8388               op &= 0xc0;
8389
8390             /* Warning: if you add any more cases to this switch, be
8391                sure to add them to the corresponding switch below.  */
8392             switch (op)
8393               {
8394               case DW_CFA_advance_loc:
8395                 break;
8396               case DW_CFA_offset:
8397                 LEB ();
8398                 frame_need_space (fc, opa);
8399                 fc->col_type[opa] = DW_CFA_undefined;
8400                 break;
8401               case DW_CFA_restore:
8402                 frame_need_space (fc, opa);
8403                 fc->col_type[opa] = DW_CFA_undefined;
8404                 break;
8405               case DW_CFA_set_loc:
8406                 start += encoded_ptr_size;
8407                 break;
8408               case DW_CFA_advance_loc1:
8409                 start += 1;
8410                 break;
8411               case DW_CFA_advance_loc2:
8412                 start += 2;
8413                 break;
8414               case DW_CFA_advance_loc4:
8415                 start += 4;
8416                 break;
8417               case DW_CFA_offset_extended:
8418                 reg = LEB (); LEB ();
8419                 frame_need_space (fc, reg);
8420                 fc->col_type[reg] = DW_CFA_undefined;
8421                 break;
8422               case DW_CFA_restore_extended:
8423                 reg = LEB ();
8424                 frame_need_space (fc, reg);
8425                 fc->col_type[reg] = DW_CFA_undefined;
8426                 break;
8427               case DW_CFA_undefined:
8428                 reg = LEB ();
8429                 frame_need_space (fc, reg);
8430                 fc->col_type[reg] = DW_CFA_undefined;
8431                 break;
8432               case DW_CFA_same_value:
8433                 reg = LEB ();
8434                 frame_need_space (fc, reg);
8435                 fc->col_type[reg] = DW_CFA_undefined;
8436                 break;
8437               case DW_CFA_register:
8438                 reg = LEB (); LEB ();
8439                 frame_need_space (fc, reg);
8440                 fc->col_type[reg] = DW_CFA_undefined;
8441                 break;
8442               case DW_CFA_def_cfa:
8443                 LEB (); LEB ();
8444                 break;
8445               case DW_CFA_def_cfa_register:
8446                 LEB ();
8447                 break;
8448               case DW_CFA_def_cfa_offset:
8449                 LEB ();
8450                 break;
8451 #ifndef DW_CFA_GNU_args_size
8452 #define DW_CFA_GNU_args_size 0x2e
8453 #endif
8454               case DW_CFA_GNU_args_size:
8455                 LEB ();
8456                 break;
8457 #ifndef DW_CFA_GNU_negative_offset_extended
8458 #define DW_CFA_GNU_negative_offset_extended 0x2f
8459 #endif
8460               case DW_CFA_GNU_negative_offset_extended:
8461                 reg = LEB (); LEB ();
8462                 frame_need_space (fc, reg);
8463                 fc->col_type[reg] = DW_CFA_undefined;
8464
8465               default:
8466                 break;
8467               }
8468           }
8469         start = tmp;
8470       }
8471
8472       /* Now we know what registers are used, make a second pass over
8473          the chunk, this time actually printing out the info.  */
8474
8475       while (start < block_end)
8476         {
8477           unsigned op, opa;
8478           unsigned long ul, reg, roffs;
8479           long l, ofs;
8480           bfd_vma vma;
8481
8482           op = * start ++;
8483           opa = op & 0x3f;
8484           if (op & 0xc0)
8485             op &= 0xc0;
8486
8487             /* Warning: if you add any more cases to this switch, be
8488                sure to add them to the corresponding switch above.  */
8489           switch (op)
8490             {
8491             case DW_CFA_advance_loc:
8492               if (do_debug_frames_interp)
8493                 frame_display_row (fc, &need_col_headers, &max_regs);
8494               else
8495                 printf ("  DW_CFA_advance_loc: %d to %08lx\n",
8496                         opa * fc->code_factor,
8497                         fc->pc_begin + opa * fc->code_factor);
8498               fc->pc_begin += opa * fc->code_factor;
8499               break;
8500
8501             case DW_CFA_offset:
8502               roffs = LEB ();
8503               if (! do_debug_frames_interp)
8504                 printf ("  DW_CFA_offset: r%d at cfa%+ld\n",
8505                         opa, roffs * fc->data_factor);
8506               fc->col_type[opa] = DW_CFA_offset;
8507               fc->col_offset[opa] = roffs * fc->data_factor;
8508               break;
8509
8510             case DW_CFA_restore:
8511               if (! do_debug_frames_interp)
8512                 printf ("  DW_CFA_restore: r%d\n", opa);
8513               fc->col_type[opa] = cie->col_type[opa];
8514               fc->col_offset[opa] = cie->col_offset[opa];
8515               break;
8516
8517             case DW_CFA_set_loc:
8518               vma = byte_get (start, encoded_ptr_size);
8519               start += encoded_ptr_size;
8520               if (do_debug_frames_interp)
8521                 frame_display_row (fc, &need_col_headers, &max_regs);
8522               else
8523                 printf ("  DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
8524               fc->pc_begin = vma;
8525               break;
8526
8527             case DW_CFA_advance_loc1:
8528               ofs = byte_get (start, 1); start += 1;
8529               if (do_debug_frames_interp)
8530                 frame_display_row (fc, &need_col_headers, &max_regs);
8531               else
8532                 printf ("  DW_CFA_advance_loc1: %ld to %08lx\n",
8533                         ofs * fc->code_factor,
8534                         fc->pc_begin + ofs * fc->code_factor);
8535               fc->pc_begin += ofs * fc->code_factor;
8536               break;
8537
8538             case DW_CFA_advance_loc2:
8539               ofs = byte_get (start, 2); start += 2;
8540               if (do_debug_frames_interp)
8541                 frame_display_row (fc, &need_col_headers, &max_regs);
8542               else
8543                 printf ("  DW_CFA_advance_loc2: %ld to %08lx\n",
8544                         ofs * fc->code_factor,
8545                         fc->pc_begin + ofs * fc->code_factor);
8546               fc->pc_begin += ofs * fc->code_factor;
8547               break;
8548
8549             case DW_CFA_advance_loc4:
8550               ofs = byte_get (start, 4); start += 4;
8551               if (do_debug_frames_interp)
8552                 frame_display_row (fc, &need_col_headers, &max_regs);
8553               else
8554                 printf ("  DW_CFA_advance_loc4: %ld to %08lx\n",
8555                         ofs * fc->code_factor,
8556                         fc->pc_begin + ofs * fc->code_factor);
8557               fc->pc_begin += ofs * fc->code_factor;
8558               break;
8559
8560             case DW_CFA_offset_extended:
8561               reg = LEB ();
8562               roffs = LEB ();
8563               if (! do_debug_frames_interp)
8564                 printf ("  DW_CFA_offset_extended: r%ld at cfa%+ld\n",
8565                         reg, roffs * fc->data_factor);
8566               fc->col_type[reg] = DW_CFA_offset;
8567               fc->col_offset[reg] = roffs * fc->data_factor;
8568               break;
8569
8570             case DW_CFA_restore_extended:
8571               reg = LEB ();
8572               if (! do_debug_frames_interp)
8573                 printf ("  DW_CFA_restore_extended: r%ld\n", reg);
8574               fc->col_type[reg] = cie->col_type[reg];
8575               fc->col_offset[reg] = cie->col_offset[reg];
8576               break;
8577
8578             case DW_CFA_undefined:
8579               reg = LEB ();
8580               if (! do_debug_frames_interp)
8581                 printf ("  DW_CFA_undefined: r%ld\n", reg);
8582               fc->col_type[reg] = DW_CFA_undefined;
8583               fc->col_offset[reg] = 0;
8584               break;
8585
8586             case DW_CFA_same_value:
8587               reg = LEB ();
8588               if (! do_debug_frames_interp)
8589                 printf ("  DW_CFA_same_value: r%ld\n", reg);
8590               fc->col_type[reg] = DW_CFA_same_value;
8591               fc->col_offset[reg] = 0;
8592               break;
8593
8594             case DW_CFA_register:
8595               reg = LEB ();
8596               roffs = LEB ();
8597               if (! do_debug_frames_interp)
8598                 printf ("  DW_CFA_register: r%ld\n", reg);
8599               fc->col_type[reg] = DW_CFA_register;
8600               fc->col_offset[reg] = roffs;
8601               break;
8602
8603             case DW_CFA_remember_state:
8604               if (! do_debug_frames_interp)
8605                 printf ("  DW_CFA_remember_state\n");
8606               rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
8607               rs->ncols = fc->ncols;
8608               rs->col_type = (short int *) xmalloc (rs->ncols * sizeof (short int));
8609               rs->col_offset = (int *) xmalloc (rs->ncols * sizeof (int));
8610               memcpy (rs->col_type, fc->col_type, rs->ncols);
8611               memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
8612               rs->next = remembered_state;
8613               remembered_state = rs;
8614               break;
8615
8616             case DW_CFA_restore_state:
8617               if (! do_debug_frames_interp)
8618                 printf ("  DW_CFA_restore_state\n");
8619               rs = remembered_state;
8620               remembered_state = rs->next;
8621               frame_need_space (fc, rs->ncols-1);
8622               memcpy (fc->col_type, rs->col_type, rs->ncols);
8623               memcpy (fc->col_offset, rs->col_offset, rs->ncols * sizeof (int));
8624               free (rs->col_type);
8625               free (rs->col_offset);
8626               free (rs);
8627               break;
8628
8629             case DW_CFA_def_cfa:
8630               fc->cfa_reg = LEB ();
8631               fc->cfa_offset = LEB ();
8632               if (! do_debug_frames_interp)
8633                 printf ("  DW_CFA_def_cfa: r%d ofs %d\n",
8634                         fc->cfa_reg, fc->cfa_offset);
8635               break;
8636
8637             case DW_CFA_def_cfa_register:
8638               fc->cfa_reg = LEB ();
8639               if (! do_debug_frames_interp)
8640                 printf ("  DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
8641               break;
8642
8643             case DW_CFA_def_cfa_offset:
8644               fc->cfa_offset = LEB ();
8645               if (! do_debug_frames_interp)
8646                 printf ("  DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
8647               break;
8648
8649             case DW_CFA_nop:
8650               if (! do_debug_frames_interp)
8651                 printf ("  DW_CFA_nop\n");
8652               break;
8653
8654 #ifndef DW_CFA_GNU_window_save
8655 #define DW_CFA_GNU_window_save 0x2d
8656 #endif
8657             case DW_CFA_GNU_window_save:
8658               if (! do_debug_frames_interp)
8659                 printf ("  DW_CFA_GNU_window_save\n");
8660               break;
8661
8662             case DW_CFA_GNU_args_size:
8663               ul = LEB ();
8664               if (! do_debug_frames_interp)
8665                 printf ("  DW_CFA_GNU_args_size: %ld\n", ul);
8666               break;
8667
8668             case DW_CFA_GNU_negative_offset_extended:
8669               reg = LEB ();
8670               l = - LEB ();
8671               frame_need_space (fc, reg);
8672               if (! do_debug_frames_interp)
8673                 printf ("  DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
8674                         reg, l * fc->data_factor);
8675               fc->col_type[reg] = DW_CFA_offset;
8676               fc->col_offset[reg] = l * fc->data_factor;
8677               break;
8678
8679             default:
8680               fprintf (stderr, "unsupported or unknown DW_CFA_%d\n", op);
8681               start = block_end;
8682             }
8683         }
8684
8685       if (do_debug_frames_interp)
8686         frame_display_row (fc, &need_col_headers, &max_regs);
8687
8688       start = block_end;
8689     }
8690
8691   printf ("\n");
8692
8693   return 1;
8694 }
8695
8696 #undef GET
8697 #undef LEB
8698 #undef SLEB
8699
8700 static int
8701 display_debug_not_supported (section, start, file)
8702      Elf32_Internal_Shdr * section;
8703      unsigned char *       start ATTRIBUTE_UNUSED;
8704      FILE *                file ATTRIBUTE_UNUSED;
8705 {
8706   printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
8707             SECTION_NAME (section));
8708
8709   return 1;
8710 }
8711
8712 /* Pre-scan the .debug_info section to record the size of address.
8713    When dumping the .debug_line, we use that size information, assuming
8714    that all compilation units have the same address size.  */
8715 static int
8716 prescan_debug_info (section, start, file)
8717      Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
8718      unsigned char *       start;
8719      FILE *                file ATTRIBUTE_UNUSED;
8720 {
8721   DWARF2_External_CompUnit * external;
8722
8723   external = (DWARF2_External_CompUnit *) start;
8724
8725   debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
8726   return 0;
8727 }
8728
8729   /* A structure containing the name of a debug section and a pointer
8730      to a function that can decode it.  The third field is a prescan
8731      function to be run over the section before displaying any of the
8732      sections.  */
8733 struct
8734 {
8735   const char * const name;
8736   int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
8737   int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
8738 }
8739 debug_displays[] =
8740 {
8741   { ".debug_abbrev",      display_debug_abbrev, NULL },
8742   { ".debug_aranges",     display_debug_aranges, NULL },
8743   { ".debug_frame",       display_debug_frames, NULL },
8744   { ".debug_info",        display_debug_info, prescan_debug_info },
8745   { ".debug_line",        display_debug_lines, NULL },
8746   { ".debug_pubnames",    display_debug_pubnames, NULL },
8747   { ".eh_frame",          display_debug_frames, NULL },
8748   { ".debug_macinfo",     display_debug_macinfo, NULL },
8749   { ".debug_str",         display_debug_str, NULL },
8750   { ".debug_loc",         display_debug_loc, NULL },
8751   { ".debug_pubtypes",    display_debug_not_supported, NULL },
8752   { ".debug_ranges",      display_debug_not_supported, NULL },
8753   { ".debug_static_func", display_debug_not_supported, NULL },
8754   { ".debug_static_vars", display_debug_not_supported, NULL },
8755   { ".debug_types",       display_debug_not_supported, NULL },
8756   { ".debug_weaknames",   display_debug_not_supported, NULL }
8757 };
8758
8759 static int
8760 display_debug_section (section, file)
8761      Elf32_Internal_Shdr * section;
8762      FILE * file;
8763 {
8764   char *          name = SECTION_NAME (section);
8765   bfd_size_type   length;
8766   unsigned char * start;
8767   int             i;
8768
8769   length = section->sh_size;
8770   if (length == 0)
8771     {
8772       printf (_("\nSection '%s' has no debugging data.\n"), name);
8773       return 0;
8774     }
8775
8776   start = (unsigned char *) get_data (NULL, file, section->sh_offset, length,
8777                                       _("debug section data"));
8778   if (!start)
8779     return 0;
8780
8781   /* See if we know how to display the contents of this section.  */
8782   if (strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
8783     name = ".debug_info";
8784
8785   for (i = NUM_ELEM (debug_displays); i--;)
8786     if (strcmp (debug_displays[i].name, name) == 0)
8787       {
8788         debug_displays[i].display (section, start, file);
8789         break;
8790       }
8791
8792   if (i == -1)
8793     printf (_("Unrecognized debug section: %s\n"), name);
8794
8795   free (start);
8796
8797   /* If we loaded in the abbrev section at some point,
8798      we must release it here.  */
8799   free_abbrevs ();
8800
8801   return 1;
8802 }
8803
8804 static int
8805 process_section_contents (file)
8806      FILE * file;
8807 {
8808   Elf32_Internal_Shdr * section;
8809   unsigned int  i;
8810
8811   if (! do_dump)
8812     return 1;
8813
8814   /* Pre-scan the debug sections to find some debug information not
8815      present in some of them.  For the .debug_line, we must find out the
8816      size of address (specified in .debug_info and .debug_aranges).  */
8817   for (i = 0, section = section_headers;
8818        i < elf_header.e_shnum && i < num_dump_sects;
8819        i ++, section ++)
8820     {
8821       char *    name = SECTION_NAME (section);
8822       int       j;
8823
8824       if (section->sh_size == 0)
8825         continue;
8826
8827       /* See if there is some pre-scan operation for this section.  */
8828       for (j = NUM_ELEM (debug_displays); j--;)
8829         if (strcmp (debug_displays[j].name, name) == 0)
8830           {
8831             if (debug_displays[j].prescan != NULL)
8832               {
8833                 bfd_size_type   length;
8834                 unsigned char * start;
8835
8836                 length = section->sh_size;
8837                 start = ((unsigned char *)
8838                          get_data (NULL, file, section->sh_offset, length,
8839                                    _("debug section data")));
8840                 if (!start)
8841                   return 0;
8842
8843                 debug_displays[j].prescan (section, start, file);
8844                 free (start);
8845               }
8846
8847             break;
8848           }
8849     }
8850
8851   for (i = 0, section = section_headers;
8852        i < elf_header.e_shnum && i < num_dump_sects;
8853        i ++, section ++)
8854     {
8855 #ifdef SUPPORT_DISASSEMBLY
8856       if (dump_sects[i] & DISASS_DUMP)
8857         disassemble_section (section, file);
8858 #endif
8859       if (dump_sects[i] & HEX_DUMP)
8860         dump_section (section, file);
8861
8862       if (dump_sects[i] & DEBUG_DUMP)
8863         display_debug_section (section, file);
8864     }
8865
8866   if (i < num_dump_sects)
8867     warn (_("Some sections were not dumped because they do not exist!\n"));
8868
8869   return 1;
8870 }
8871
8872 static void
8873 process_mips_fpe_exception (mask)
8874      int mask;
8875 {
8876   if (mask)
8877     {
8878       int first = 1;
8879       if (mask & OEX_FPU_INEX)
8880         fputs ("INEX", stdout), first = 0;
8881       if (mask & OEX_FPU_UFLO)
8882         printf ("%sUFLO", first ? "" : "|"), first = 0;
8883       if (mask & OEX_FPU_OFLO)
8884         printf ("%sOFLO", first ? "" : "|"), first = 0;
8885       if (mask & OEX_FPU_DIV0)
8886         printf ("%sDIV0", first ? "" : "|"), first = 0;
8887       if (mask & OEX_FPU_INVAL)
8888         printf ("%sINVAL", first ? "" : "|");
8889     }
8890   else
8891     fputs ("0", stdout);
8892 }
8893
8894 static int
8895 process_mips_specific (file)
8896      FILE * file;
8897 {
8898   Elf_Internal_Dyn * entry;
8899   size_t liblist_offset = 0;
8900   size_t liblistno = 0;
8901   size_t conflictsno = 0;
8902   size_t options_offset = 0;
8903   size_t conflicts_offset = 0;
8904
8905   /* We have a lot of special sections.  Thanks SGI!  */
8906   if (dynamic_segment == NULL)
8907     /* No information available.  */
8908     return 0;
8909
8910   for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
8911     switch (entry->d_tag)
8912       {
8913       case DT_MIPS_LIBLIST:
8914         liblist_offset = entry->d_un.d_val - loadaddr;
8915         break;
8916       case DT_MIPS_LIBLISTNO:
8917         liblistno = entry->d_un.d_val;
8918         break;
8919       case DT_MIPS_OPTIONS:
8920         options_offset = entry->d_un.d_val - loadaddr;
8921         break;
8922       case DT_MIPS_CONFLICT:
8923         conflicts_offset = entry->d_un.d_val - loadaddr;
8924         break;
8925       case DT_MIPS_CONFLICTNO:
8926         conflictsno = entry->d_un.d_val;
8927         break;
8928       default:
8929         break;
8930       }
8931
8932   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
8933     {
8934       Elf32_External_Lib * elib;
8935       size_t cnt;
8936
8937       elib = ((Elf32_External_Lib *)
8938               get_data (NULL, file, liblist_offset,
8939                         liblistno * sizeof (Elf32_External_Lib),
8940                         _("liblist")));
8941       if (elib)
8942         {
8943           printf ("\nSection '.liblist' contains %lu entries:\n",
8944                   (unsigned long) liblistno);
8945           fputs ("     Library              Time Stamp          Checksum   Version Flags\n",
8946                  stdout);
8947
8948           for (cnt = 0; cnt < liblistno; ++cnt)
8949             {
8950               Elf32_Lib liblist;
8951               time_t time;
8952               char timebuf[20];
8953               struct tm * tmp;
8954
8955               liblist.l_name = BYTE_GET (elib[cnt].l_name);
8956               time = BYTE_GET (elib[cnt].l_time_stamp);
8957               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
8958               liblist.l_version = BYTE_GET (elib[cnt].l_version);
8959               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
8960
8961               tmp = gmtime (&time);
8962               sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
8963                        tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8964                        tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8965
8966               printf ("%3lu: ", (unsigned long) cnt);
8967               print_symbol (20, dynamic_strings + liblist.l_name);
8968               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
8969                       liblist.l_version);
8970
8971               if (liblist.l_flags == 0)
8972                 puts (" NONE");
8973               else
8974                 {
8975                   static const struct
8976                   {
8977                     const char * name;
8978                     int bit;
8979                   }
8980                   l_flags_vals[] =
8981                   {
8982                     { " EXACT_MATCH", LL_EXACT_MATCH },
8983                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
8984                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
8985                     { " EXPORTS", LL_EXPORTS },
8986                     { " DELAY_LOAD", LL_DELAY_LOAD },
8987                     { " DELTA", LL_DELTA }
8988                   };
8989                   int flags = liblist.l_flags;
8990                   size_t fcnt;
8991
8992                   for (fcnt = 0;
8993                        fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
8994                        ++fcnt)
8995                     if ((flags & l_flags_vals[fcnt].bit) != 0)
8996                       {
8997                         fputs (l_flags_vals[fcnt].name, stdout);
8998                         flags ^= l_flags_vals[fcnt].bit;
8999                       }
9000                   if (flags != 0)
9001                     printf (" %#x", (unsigned int) flags);
9002
9003                   puts ("");
9004                 }
9005             }
9006
9007           free (elib);
9008         }
9009     }
9010
9011   if (options_offset != 0)
9012     {
9013       Elf_External_Options * eopt;
9014       Elf_Internal_Shdr *    sect = section_headers;
9015       Elf_Internal_Options * iopt;
9016       Elf_Internal_Options * option;
9017       size_t offset;
9018       int cnt;
9019
9020       /* Find the section header so that we get the size.  */
9021       while (sect->sh_type != SHT_MIPS_OPTIONS)
9022         ++ sect;
9023
9024       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset,
9025                                                 sect->sh_size, _("options"));
9026       if (eopt)
9027         {
9028           iopt = ((Elf_Internal_Options *)
9029                   malloc ((sect->sh_size / sizeof (eopt)) * sizeof (* iopt)));
9030           if (iopt == NULL)
9031             {
9032               error (_("Out of memory"));
9033               return 0;
9034             }
9035
9036           offset = cnt = 0;
9037           option = iopt;
9038
9039           while (offset < sect->sh_size)
9040             {
9041               Elf_External_Options * eoption;
9042
9043               eoption = (Elf_External_Options *) ((char *) eopt + offset);
9044
9045               option->kind = BYTE_GET (eoption->kind);
9046               option->size = BYTE_GET (eoption->size);
9047               option->section = BYTE_GET (eoption->section);
9048               option->info = BYTE_GET (eoption->info);
9049
9050               offset += option->size;
9051
9052               ++option;
9053               ++cnt;
9054             }
9055
9056           printf (_("\nSection '%s' contains %d entries:\n"),
9057                   SECTION_NAME (sect), cnt);
9058
9059           option = iopt;
9060
9061           while (cnt-- > 0)
9062             {
9063               size_t len;
9064
9065               switch (option->kind)
9066                 {
9067                 case ODK_NULL:
9068                   /* This shouldn't happen.  */
9069                   printf (" NULL       %d %lx", option->section, option->info);
9070                   break;
9071                 case ODK_REGINFO:
9072                   printf (" REGINFO    ");
9073                   if (elf_header.e_machine == EM_MIPS)
9074                     {
9075                       /* 32bit form.  */
9076                       Elf32_External_RegInfo * ereg;
9077                       Elf32_RegInfo            reginfo;
9078
9079                       ereg = (Elf32_External_RegInfo *) (option + 1);
9080                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9081                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9082                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9083                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9084                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9085                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
9086
9087                       printf ("GPR %08lx  GP 0x%lx\n",
9088                               reginfo.ri_gprmask,
9089                               (unsigned long) reginfo.ri_gp_value);
9090                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
9091                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9092                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9093                     }
9094                   else
9095                     {
9096                       /* 64 bit form.  */
9097                       Elf64_External_RegInfo * ereg;
9098                       Elf64_Internal_RegInfo reginfo;
9099
9100                       ereg = (Elf64_External_RegInfo *) (option + 1);
9101                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
9102                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9103                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9104                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9105                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9106                       reginfo.ri_gp_value   = BYTE_GET8 (ereg->ri_gp_value);
9107
9108                       printf ("GPR %08lx  GP 0x",
9109                               reginfo.ri_gprmask);
9110                       printf_vma (reginfo.ri_gp_value);
9111                       printf ("\n");
9112
9113                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
9114                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9115                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9116                     }
9117                   ++option;
9118                   continue;
9119                 case ODK_EXCEPTIONS:
9120                   fputs (" EXCEPTIONS fpe_min(", stdout);
9121                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
9122                   fputs (") fpe_max(", stdout);
9123                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
9124                   fputs (")", stdout);
9125
9126                   if (option->info & OEX_PAGE0)
9127                     fputs (" PAGE0", stdout);
9128                   if (option->info & OEX_SMM)
9129                     fputs (" SMM", stdout);
9130                   if (option->info & OEX_FPDBUG)
9131                     fputs (" FPDBUG", stdout);
9132                   if (option->info & OEX_DISMISS)
9133                     fputs (" DISMISS", stdout);
9134                   break;
9135                 case ODK_PAD:
9136                   fputs (" PAD       ", stdout);
9137                   if (option->info & OPAD_PREFIX)
9138                     fputs (" PREFIX", stdout);
9139                   if (option->info & OPAD_POSTFIX)
9140                     fputs (" POSTFIX", stdout);
9141                   if (option->info & OPAD_SYMBOL)
9142                     fputs (" SYMBOL", stdout);
9143                   break;
9144                 case ODK_HWPATCH:
9145                   fputs (" HWPATCH   ", stdout);
9146                   if (option->info & OHW_R4KEOP)
9147                     fputs (" R4KEOP", stdout);
9148                   if (option->info & OHW_R8KPFETCH)
9149                     fputs (" R8KPFETCH", stdout);
9150                   if (option->info & OHW_R5KEOP)
9151                     fputs (" R5KEOP", stdout);
9152                   if (option->info & OHW_R5KCVTL)
9153                     fputs (" R5KCVTL", stdout);
9154                   break;
9155                 case ODK_FILL:
9156                   fputs (" FILL       ", stdout);
9157                   /* XXX Print content of info word?  */
9158                   break;
9159                 case ODK_TAGS:
9160                   fputs (" TAGS       ", stdout);
9161                   /* XXX Print content of info word?  */
9162                   break;
9163                 case ODK_HWAND:
9164                   fputs (" HWAND     ", stdout);
9165                   if (option->info & OHWA0_R4KEOP_CHECKED)
9166                     fputs (" R4KEOP_CHECKED", stdout);
9167                   if (option->info & OHWA0_R4KEOP_CLEAN)
9168                     fputs (" R4KEOP_CLEAN", stdout);
9169                   break;
9170                 case ODK_HWOR:
9171                   fputs (" HWOR      ", stdout);
9172                   if (option->info & OHWA0_R4KEOP_CHECKED)
9173                     fputs (" R4KEOP_CHECKED", stdout);
9174                   if (option->info & OHWA0_R4KEOP_CLEAN)
9175                     fputs (" R4KEOP_CLEAN", stdout);
9176                   break;
9177                 case ODK_GP_GROUP:
9178                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
9179                           option->info & OGP_GROUP,
9180                           (option->info & OGP_SELF) >> 16);
9181                   break;
9182                 case ODK_IDENT:
9183                   printf (" IDENT     %#06lx  self-contained %#06lx",
9184                           option->info & OGP_GROUP,
9185                           (option->info & OGP_SELF) >> 16);
9186                   break;
9187                 default:
9188                   /* This shouldn't happen.  */
9189                   printf (" %3d ???     %d %lx",
9190                           option->kind, option->section, option->info);
9191                   break;
9192                 }
9193
9194               len = sizeof (* eopt);
9195               while (len < option->size)
9196                 if (((char *) option)[len] >= ' '
9197                     && ((char *) option)[len] < 0x7f)
9198                   printf ("%c", ((char *) option)[len++]);
9199                 else
9200                   printf ("\\%03o", ((char *) option)[len++]);
9201
9202               fputs ("\n", stdout);
9203               ++option;
9204             }
9205
9206           free (eopt);
9207         }
9208     }
9209
9210   if (conflicts_offset != 0 && conflictsno != 0)
9211     {
9212       Elf32_Conflict * iconf;
9213       size_t cnt;
9214
9215       if (dynamic_symbols == NULL)
9216         {
9217           error (_("conflict list with without table"));
9218           return 0;
9219         }
9220
9221       iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (* iconf));
9222       if (iconf == NULL)
9223         {
9224           error (_("Out of memory"));
9225           return 0;
9226         }
9227
9228       if (is_32bit_elf)
9229         {
9230           Elf32_External_Conflict * econf32;
9231
9232           econf32 = ((Elf32_External_Conflict *)
9233                      get_data (NULL, file, conflicts_offset,
9234                                conflictsno * sizeof (* econf32),
9235                                _("conflict")));
9236           if (!econf32)
9237             return 0;
9238
9239           for (cnt = 0; cnt < conflictsno; ++cnt)
9240             iconf[cnt] = BYTE_GET (econf32[cnt]);
9241
9242           free (econf32);
9243         }
9244       else
9245         {
9246           Elf64_External_Conflict * econf64;
9247
9248           econf64 = ((Elf64_External_Conflict *)
9249                      get_data (NULL, file, conflicts_offset,
9250                                conflictsno * sizeof (* econf64),
9251                                _("conflict")));
9252           if (!econf64)
9253             return 0;
9254
9255           for (cnt = 0; cnt < conflictsno; ++cnt)
9256             iconf[cnt] = BYTE_GET (econf64[cnt]);
9257
9258           free (econf64);
9259         }
9260
9261       printf (_("\nSection '.conflict' contains %ld entries:\n"),
9262               (long) conflictsno);
9263       puts (_("  Num:    Index       Value  Name"));
9264
9265       for (cnt = 0; cnt < conflictsno; ++cnt)
9266         {
9267           Elf_Internal_Sym * psym = & dynamic_symbols [iconf [cnt]];
9268
9269           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf [cnt]);
9270           print_vma (psym->st_value, FULL_HEX);
9271           putchar (' ');
9272           print_symbol (25, dynamic_strings + psym->st_name);
9273           putchar ('\n');
9274         }
9275
9276       free (iconf);
9277     }
9278
9279   return 1;
9280 }
9281
9282 static const char *
9283 get_note_type (e_type)
9284      unsigned e_type;
9285 {
9286   static char buff[64];
9287
9288   switch (e_type)
9289     {
9290     case NT_PRSTATUS:   return _("NT_PRSTATUS (prstatus structure)");
9291     case NT_FPREGSET:   return _("NT_FPREGSET (floating point registers)");
9292     case NT_PRPSINFO:   return _("NT_PRPSINFO (prpsinfo structure)");
9293     case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
9294     case NT_PRXFPREG:   return _("NT_PRXFPREG (user_xfpregs structure)");
9295     case NT_PSTATUS:    return _("NT_PSTATUS (pstatus structure)");
9296     case NT_FPREGS:     return _("NT_FPREGS (floating point registers)");
9297     case NT_PSINFO:     return _("NT_PSINFO (psinfo structure)");
9298     case NT_LWPSTATUS:  return _("NT_LWPSTATUS (lwpstatus_t structure)");
9299     case NT_LWPSINFO:   return _("NT_LWPSINFO (lwpsinfo_t structure)");
9300     case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
9301     default:
9302       sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
9303       return buff;
9304     }
9305 }
9306
9307 static const char *
9308 get_netbsd_elfcore_note_type (e_type)
9309      unsigned e_type;
9310 {
9311   static char buff[64];
9312
9313   if (e_type == NT_NETBSDCORE_PROCINFO)
9314     {
9315       /* NetBSD core "procinfo" structure.  */
9316       return _("NetBSD procinfo structure");
9317     }
9318
9319   /* As of Jan 2002 there are no other machine-independent notes
9320      defined for NetBSD core files.  If the note type is less
9321      than the start of the machine-dependent note types, we don't
9322      understand it.  */
9323
9324   if (e_type < NT_NETBSDCORE_FIRSTMACH)
9325     {
9326       sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
9327       return buff;
9328     }
9329
9330   switch (elf_header.e_machine)
9331     {
9332     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9333        and PT_GETFPREGS == mach+2.  */
9334
9335     case EM_OLD_ALPHA:
9336     case EM_ALPHA:
9337     case EM_SPARC:
9338     case EM_SPARC32PLUS:
9339     case EM_SPARCV9:
9340       switch (e_type)
9341         {
9342         case NT_NETBSDCORE_FIRSTMACH+0:
9343           return _("PT_GETREGS (reg structure)");
9344         case NT_NETBSDCORE_FIRSTMACH+2:
9345           return _("PT_GETFPREGS (fpreg structure)");
9346         default:
9347           break;
9348         }
9349       break;
9350
9351     /* On all other arch's, PT_GETREGS == mach+1 and
9352        PT_GETFPREGS == mach+3.  */
9353     default:
9354       switch (e_type)
9355         {
9356         case NT_NETBSDCORE_FIRSTMACH+1:
9357           return _("PT_GETREGS (reg structure)");
9358         case NT_NETBSDCORE_FIRSTMACH+3:
9359           return _("PT_GETFPREGS (fpreg structure)");
9360         default:
9361           break;
9362         }
9363     }
9364
9365   sprintf (buff, _("PT_FIRSTMACH+%d"), e_type - NT_NETBSDCORE_FIRSTMACH);
9366   return buff;
9367 }
9368
9369 /* Note that by the ELF standard, the name field is already null byte
9370    terminated, and namesz includes the terminating null byte.
9371    I.E. the value of namesz for the name "FSF" is 4.
9372
9373    If the value of namesz is zero, there is no name present.  */
9374 static int
9375 process_note (pnote)
9376   Elf32_Internal_Note * pnote;
9377 {
9378   const char *nt;
9379
9380   if (pnote->namesz == 0)
9381     {
9382       /* If there is no note name, then use the default set of
9383          note type strings.  */
9384       nt = get_note_type (pnote->type);
9385     }
9386   else if (strncmp (pnote->namedata, "NetBSD-CORE", 11) == 0)
9387     {
9388       /* NetBSD-specific core file notes.  */
9389       nt = get_netbsd_elfcore_note_type (pnote->type);
9390     }
9391   else
9392     {
9393       /* Don't recognize this note name; just use the default set of
9394          note type strings.  */
9395       nt = get_note_type (pnote->type);
9396     }
9397
9398   printf ("  %s\t\t0x%08lx\t%s\n",
9399           pnote->namesz ? pnote->namedata : "(NONE)",
9400           pnote->descsz, nt);
9401   return 1;
9402 }
9403
9404
9405 static int
9406 process_corefile_note_segment (file, offset, length)
9407      FILE * file;
9408      bfd_vma offset;
9409      bfd_vma length;
9410 {
9411   Elf_External_Note *  pnotes;
9412   Elf_External_Note *  external;
9413   int                  res = 1;
9414
9415   if (length <= 0)
9416     return 0;
9417
9418   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, length,
9419                                            _("notes"));
9420   if (!pnotes)
9421     return 0;
9422
9423   external = pnotes;
9424
9425   printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9426           (unsigned long) offset, (unsigned long) length);
9427   printf (_("  Owner\t\tData size\tDescription\n"));
9428
9429   while (external < (Elf_External_Note *)((char *) pnotes + length))
9430     {
9431       Elf_External_Note * next;
9432       Elf32_Internal_Note inote;
9433       char * temp = NULL;
9434
9435       inote.type     = BYTE_GET (external->type);
9436       inote.namesz   = BYTE_GET (external->namesz);
9437       inote.namedata = external->name;
9438       inote.descsz   = BYTE_GET (external->descsz);
9439       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
9440       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
9441
9442       next = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
9443
9444       if (((char *) next) > (((char *) pnotes) + length))
9445         {
9446           warn (_("corrupt note found at offset %x into core notes\n"),
9447                 ((char *) external) - ((char *) pnotes));
9448           warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
9449                 inote.type, inote.namesz, inote.descsz);
9450           break;
9451         }
9452
9453       external = next;
9454
9455       /* Verify that name is null terminated.  It appears that at least
9456          one version of Linux (RedHat 6.0) generates corefiles that don't
9457          comply with the ELF spec by failing to include the null byte in
9458          namesz.  */
9459       if (inote.namedata[inote.namesz] != '\0')
9460         {
9461           temp = malloc (inote.namesz + 1);
9462
9463           if (temp == NULL)
9464             {
9465               error (_("Out of memory\n"));
9466               res = 0;
9467               break;
9468             }
9469
9470           strncpy (temp, inote.namedata, inote.namesz);
9471           temp[inote.namesz] = 0;
9472
9473           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
9474           inote.namedata = temp;
9475         }
9476
9477       res &= process_note (& inote);
9478
9479       if (temp != NULL)
9480         {
9481           free (temp);
9482           temp = NULL;
9483         }
9484     }
9485
9486   free (pnotes);
9487
9488   return res;
9489 }
9490
9491 static int
9492 process_corefile_note_segments (file)
9493      FILE * file;
9494 {
9495   Elf_Internal_Phdr * program_headers;
9496   Elf_Internal_Phdr * segment;
9497   unsigned int        i;
9498   int                 res = 1;
9499
9500   program_headers = (Elf_Internal_Phdr *) malloc
9501     (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
9502
9503   if (program_headers == NULL)
9504     {
9505       error (_("Out of memory\n"));
9506       return 0;
9507     }
9508
9509   if (is_32bit_elf)
9510     i = get_32bit_program_headers (file, program_headers);
9511   else
9512     i = get_64bit_program_headers (file, program_headers);
9513
9514   if (i == 0)
9515     {
9516       free (program_headers);
9517       return 0;
9518     }
9519
9520   for (i = 0, segment = program_headers;
9521        i < elf_header.e_phnum;
9522        i ++, segment ++)
9523     {
9524       if (segment->p_type == PT_NOTE)
9525         res &= process_corefile_note_segment (file,
9526                                               (bfd_vma) segment->p_offset,
9527                                               (bfd_vma) segment->p_filesz);
9528     }
9529
9530   free (program_headers);
9531
9532   return res;
9533 }
9534
9535 static int
9536 process_corefile_contents (file)
9537      FILE * file;
9538 {
9539   /* If we have not been asked to display the notes then do nothing.  */
9540   if (! do_notes)
9541     return 1;
9542
9543   /* If file is not a core file then exit.  */
9544   if (elf_header.e_type != ET_CORE)
9545     return 1;
9546
9547   /* No program headers means no NOTE segment.  */
9548   if (elf_header.e_phnum == 0)
9549     {
9550       printf (_("No note segments present in the core file.\n"));
9551       return 1;
9552    }
9553
9554   return process_corefile_note_segments (file);
9555 }
9556
9557 static int
9558 process_arch_specific (file)
9559      FILE * file;
9560 {
9561   if (! do_arch)
9562     return 1;
9563
9564   switch (elf_header.e_machine)
9565     {
9566     case EM_MIPS:
9567     case EM_MIPS_RS3_LE:
9568       return process_mips_specific (file);
9569       break;
9570     default:
9571       break;
9572     }
9573   return 1;
9574 }
9575
9576 static int
9577 get_file_header (file)
9578      FILE * file;
9579 {
9580   /* Read in the identity array.  */
9581   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
9582     return 0;
9583
9584   /* Determine how to read the rest of the header.  */
9585   switch (elf_header.e_ident [EI_DATA])
9586     {
9587     default: /* fall through */
9588     case ELFDATANONE: /* fall through */
9589     case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
9590     case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
9591     }
9592
9593   /* For now we only support 32 bit and 64 bit ELF files.  */
9594   is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
9595
9596   /* Read in the rest of the header.  */
9597   if (is_32bit_elf)
9598     {
9599       Elf32_External_Ehdr ehdr32;
9600
9601       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
9602         return 0;
9603
9604       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
9605       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
9606       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
9607       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
9608       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
9609       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
9610       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
9611       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
9612       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
9613       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
9614       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
9615       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
9616       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
9617     }
9618   else
9619     {
9620       Elf64_External_Ehdr ehdr64;
9621
9622       /* If we have been compiled with sizeof (bfd_vma) == 4, then
9623          we will not be able to cope with the 64bit data found in
9624          64 ELF files.  Detect this now and abort before we start
9625          overwritting things.  */
9626       if (sizeof (bfd_vma) < 8)
9627         {
9628           error (_("This instance of readelf has been built without support for a\n\
9629 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9630           return 0;
9631         }
9632
9633       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
9634         return 0;
9635
9636       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
9637       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
9638       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
9639       elf_header.e_entry     = BYTE_GET8 (ehdr64.e_entry);
9640       elf_header.e_phoff     = BYTE_GET8 (ehdr64.e_phoff);
9641       elf_header.e_shoff     = BYTE_GET8 (ehdr64.e_shoff);
9642       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
9643       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
9644       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
9645       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
9646       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
9647       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
9648       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
9649     }
9650
9651   /* There may be some extensions in the first section header.  Don't
9652      bomb if we can't read it.  */
9653   if (is_32bit_elf)
9654     get_32bit_section_headers (file, 1);
9655   else
9656     get_64bit_section_headers (file, 1);
9657
9658   return 1;
9659 }
9660
9661 static int
9662 process_file (file_name)
9663      char * file_name;
9664 {
9665   FILE *       file;
9666   struct stat  statbuf;
9667   unsigned int i;
9668
9669   if (stat (file_name, & statbuf) < 0)
9670     {
9671       error (_("Cannot stat input file %s.\n"), file_name);
9672       return 1;
9673     }
9674
9675   file = fopen (file_name, "rb");
9676   if (file == NULL)
9677     {
9678       error (_("Input file %s not found.\n"), file_name);
9679       return 1;
9680     }
9681
9682   if (! get_file_header (file))
9683     {
9684       error (_("%s: Failed to read file header\n"), file_name);
9685       fclose (file);
9686       return 1;
9687     }
9688
9689   /* Initialise per file variables.  */
9690   for (i = NUM_ELEM (version_info); i--;)
9691     version_info[i] = 0;
9692
9693   for (i = NUM_ELEM (dynamic_info); i--;)
9694     dynamic_info[i] = 0;
9695
9696   /* Process the file.  */
9697   if (show_name)
9698     printf (_("\nFile: %s\n"), file_name);
9699
9700   if (! process_file_header ())
9701     {
9702       fclose (file);
9703       return 1;
9704     }
9705
9706   process_section_headers (file);
9707
9708   process_program_headers (file);
9709
9710   process_dynamic_segment (file);
9711
9712   process_relocs (file);
9713
9714   process_unwind (file);
9715
9716   process_symbol_table (file);
9717
9718   process_syminfo (file);
9719
9720   process_version_sections (file);
9721
9722   process_section_contents (file);
9723
9724   process_corefile_contents (file);
9725
9726   process_arch_specific (file);
9727
9728   fclose (file);
9729
9730   if (section_headers)
9731     {
9732       free (section_headers);
9733       section_headers = NULL;
9734     }
9735
9736   if (string_table)
9737     {
9738       free (string_table);
9739       string_table = NULL;
9740       string_table_length = 0;
9741     }
9742
9743   if (dynamic_strings)
9744     {
9745       free (dynamic_strings);
9746       dynamic_strings = NULL;
9747     }
9748
9749   if (dynamic_symbols)
9750     {
9751       free (dynamic_symbols);
9752       dynamic_symbols = NULL;
9753       num_dynamic_syms = 0;
9754     }
9755
9756   if (dynamic_syminfo)
9757     {
9758       free (dynamic_syminfo);
9759       dynamic_syminfo = NULL;
9760     }
9761
9762   return 0;
9763 }
9764
9765 #ifdef SUPPORT_DISASSEMBLY
9766 /* Needed by the i386 disassembler.  For extra credit, someone could
9767    fix this so that we insert symbolic addresses here, esp for GOT/PLT
9768    symbols.  */
9769
9770 void
9771 print_address (unsigned int addr, FILE * outfile)
9772 {
9773   fprintf (outfile,"0x%8.8x", addr);
9774 }
9775
9776 /* Needed by the i386 disassembler.  */
9777 void
9778 db_task_printsym (unsigned int addr)
9779 {
9780   print_address (addr, stderr);
9781 }
9782 #endif
9783
9784 int main PARAMS ((int, char **));
9785
9786 int
9787 main (argc, argv)
9788      int     argc;
9789      char ** argv;
9790 {
9791   int err;
9792
9793 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
9794   setlocale (LC_MESSAGES, "");
9795 #endif
9796 #if defined (HAVE_SETLOCALE)
9797   setlocale (LC_CTYPE, "");
9798 #endif
9799   bindtextdomain (PACKAGE, LOCALEDIR);
9800   textdomain (PACKAGE);
9801
9802   parse_args (argc, argv);
9803
9804   if (optind < (argc - 1))
9805     show_name = 1;
9806
9807   err = 0;
9808   while (optind < argc)
9809     err |= process_file (argv [optind ++]);
9810
9811   if (dump_sects != NULL)
9812     free (dump_sects);
9813
9814   return err;
9815 }