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