binutils/readelf.c

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