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