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