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