binutils/readelf.c

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