binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998, 99, 2000 Free Software Foundation, Inc.
   3
   4    Originally developed by Eric Youngdale <eric@andante.jic.com>
   5    Modifications by Nick Clifton <nickc@cygnus.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/arc.h"
  68 #include "elf/fr30.h"
  69 #include "elf/mcore.h"
  70 #include "elf/i960.h"
  71 #include "elf/pj.h"
  72 #include "elf/avr.h"
  73
  74 #include "bucomm.h"
  75 #include "getopt.h"
  76
  77 #ifdef ANSI_PROTOTYPES
  78 #include <stdarg.h>
  79 #else
  80 #include <varargs.h>
  81 #endif
  82
  83 char *                  program_name = "readelf";
  84 unsigned int            dynamic_addr;
  85 bfd_size_type           dynamic_size;
  86 unsigned int            rela_addr;
  87 unsigned int            rela_size;
  88 char *                  dynamic_strings;
  89 char *                  string_table;
  90 unsigned long           num_dynamic_syms;
  91 Elf_Internal_Sym *      dynamic_symbols;
  92 Elf_Internal_Syminfo *  dynamic_syminfo;
  93 unsigned long           dynamic_syminfo_offset;
  94 unsigned int            dynamic_syminfo_nent;
  95 char                    program_interpreter [64];
  96 int                     dynamic_info[DT_JMPREL + 1];
  97 int                     version_info[16];
  98 int                     loadaddr = 0;
  99 Elf_Internal_Ehdr       elf_header;
 100 Elf_Internal_Shdr *     section_headers;
 101 Elf_Internal_Dyn *      dynamic_segment;
 102 int                     show_name;
 103 int                     do_dynamic;
 104 int                     do_syms;
 105 int                     do_reloc;
 106 int                     do_sections;
 107 int                     do_segments;
 108 int                     do_using_dynamic;
 109 int                     do_header;
 110 int                     do_dump;
 111 int                     do_version;
 112 int                     do_histogram;
 113 int                     do_debugging;
 114 int                     do_debug_info;
 115 int                     do_debug_abbrevs;
 116 int                     do_debug_lines;
 117 int                     do_debug_pubnames;
 118 int                     do_debug_aranges;
 119 int                     do_arch;
 120 int                     do_notes;
 121 int                     is_32bit_elf;
 122
 123 /* A dynamic array of flags indicating which sections require dumping.  */
 124 char *                  dump_sects = NULL;
 125 unsigned int            num_dump_sects = 0;
 126
 127 #define HEX_DUMP        (1 << 0)
 128 #define DISASS_DUMP     (1 << 1)
 129 #define DEBUG_DUMP      (1 << 2)
 130
 131 /* How to rpint a vma value.  */
 132 typedef enum print_mode
 133 {
 134   HEX,
 135   DEC,
 136   DEC_5,
 137   UNSIGNED,
 138   PREFIX_HEX,
 139   FULL_HEX,
 140   LONG_HEX
 141 }
 142 print_mode;
 143
 144 /* Forward declarations for dumb compilers.  */
 145 static void               print_vma                   PARAMS ((bfd_vma, print_mode));
 146 static bfd_vma (*         byte_get)                   PARAMS ((unsigned char *, int));
 147 static bfd_vma            byte_get_little_endian      PARAMS ((unsigned char *, int));
 148 static bfd_vma            byte_get_big_endian         PARAMS ((unsigned char *, int));
 149 static const char *       get_mips_dynamic_type       PARAMS ((unsigned long));
 150 static const char *       get_sparc64_dynamic_type    PARAMS ((unsigned long));
 151 static const char *       get_parisc_dynamic_type     PARAMS ((unsigned long));
 152 static const char *       get_dynamic_type            PARAMS ((unsigned long));
 153 static int                dump_relocations            PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym *, unsigned long, char *, int));
 154 static char *             get_file_type               PARAMS ((unsigned));
 155 static char *             get_machine_name            PARAMS ((unsigned));
 156 static void               decode_ARM_machine_flags    PARAMS ((unsigned, char []));
 157 static char *             get_machine_flags           PARAMS ((unsigned, unsigned));
 158 static const char *       get_mips_segment_type       PARAMS ((unsigned long));
 159 static const char *       get_parisc_segment_type     PARAMS ((unsigned long));
 160 static const char *       get_segment_type            PARAMS ((unsigned long));
 161 static const char *       get_mips_section_type_name  PARAMS ((unsigned int));
 162 static const char *       get_parisc_section_type_name PARAMS ((unsigned int));
 163 static const char *       get_section_type_name       PARAMS ((unsigned int));
 164 static const char *       get_symbol_binding          PARAMS ((unsigned int));
 165 static const char *       get_symbol_type             PARAMS ((unsigned int));
 166 static const char *       get_symbol_visibility       PARAMS ((unsigned int));
 167 static const char *       get_symbol_index_type       PARAMS ((unsigned int));
 168 static const char *       get_dynamic_flags           PARAMS ((bfd_vma));
 169 static void               usage                       PARAMS ((void));
 170 static void               parse_args                  PARAMS ((int, char **));
 171 static int                process_file_header         PARAMS ((void));
 172 static int                process_program_headers     PARAMS ((FILE *));
 173 static int                process_section_headers     PARAMS ((FILE *));
 174 static void               dynamic_segment_mips_val    PARAMS ((Elf_Internal_Dyn *));
 175 static void               dynamic_segment_parisc_val  PARAMS ((Elf_Internal_Dyn *));
 176 static int                process_dynamic_segment     PARAMS ((FILE *));
 177 static int                process_symbol_table        PARAMS ((FILE *));
 178 static int                process_section_contents    PARAMS ((FILE *));
 179 static void               process_file                PARAMS ((char *));
 180 static int                process_relocs              PARAMS ((FILE *));
 181 static int                process_version_sections    PARAMS ((FILE *));
 182 static char *             get_ver_flags               PARAMS ((unsigned int));
 183 static int                get_32bit_section_headers   PARAMS ((FILE *));
 184 static int                get_64bit_section_headers   PARAMS ((FILE *));
 185 static int                get_32bit_program_headers   PARAMS ((FILE *, Elf_Internal_Phdr *));
 186 static int                get_64bit_program_headers   PARAMS ((FILE *, Elf_Internal_Phdr *));
 187 static int                get_file_header             PARAMS ((FILE *));
 188 static Elf_Internal_Sym * get_32bit_elf_symbols       PARAMS ((FILE *, unsigned long, unsigned long));
 189 static Elf_Internal_Sym * get_64bit_elf_symbols       PARAMS ((FILE *, unsigned long, unsigned long));
 190 static int *              get_dynamic_data            PARAMS ((FILE *, unsigned int));
 191 static int                get_32bit_dynamic_segment   PARAMS ((FILE *));
 192 static int                get_64bit_dynamic_segment   PARAMS ((FILE *));
 193 #ifdef SUPPORT_DISASSEMBLY
 194 static int                disassemble_section         PARAMS ((Elf32_Internal_Shdr *, FILE *));
 195 #endif
 196 static int                dump_section                PARAMS ((Elf32_Internal_Shdr *, FILE *));
 197 static int                display_debug_section       PARAMS ((Elf32_Internal_Shdr *, FILE *));
 198 static int                display_debug_info          PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
 199 static int                display_debug_not_supported PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
 200 static int                display_debug_lines         PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
 201 static int                display_debug_abbrev        PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
 202 static int                display_debug_aranges       PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
 203 static unsigned char *    process_abbrev_section      PARAMS ((unsigned char *, unsigned char *));
 204 static unsigned long      read_leb128                 PARAMS ((unsigned char *, int *, int));
 205 static int                process_extended_line_op    PARAMS ((unsigned char *, int, int));
 206 static void               reset_state_machine         PARAMS ((int));
 207 static char *             get_TAG_name                PARAMS ((unsigned long));
 208 static char *             get_AT_name                 PARAMS ((unsigned long));
 209 static char *             get_FORM_name               PARAMS ((unsigned long));
 210 static void               free_abbrevs                PARAMS ((void));
 211 static void               add_abbrev                  PARAMS ((unsigned long, unsigned long, int));
 212 static void               add_abbrev_attr             PARAMS ((unsigned long, unsigned long));
 213 static unsigned char *    read_and_display_attr       PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long));
 214 static unsigned char *    display_block               PARAMS ((unsigned char *, unsigned long));
 215 static void               decode_location_expression  PARAMS ((unsigned char *, unsigned int));
 216 static void               request_dump                PARAMS ((unsigned int, char));
 217 static const char *       get_elf_class               PARAMS ((unsigned char));
 218 static const char *       get_data_encoding           PARAMS ((unsigned char));
 219 static const char *       get_osabi_name              PARAMS ((unsigned char));
 220 static int                guess_is_rela               PARAMS ((unsigned long));
 221 static char *             get_note_type                  PARAMS ((unsigned int));
 222 static int                process_note                   PARAMS ((Elf32_Internal_Note *));
 223 static int                process_corefile_note_segment  PARAMS ((FILE *, bfd_vma, bfd_vma));
 224 static int                process_corefile_note_segments PARAMS ((FILE *));
 225 static int                process_corefile_contents      PARAMS ((FILE *));
 226
 227 typedef int Elf32_Word;
 228
 229 #ifndef TRUE
 230 #define TRUE     1
 231 #define FALSE    0
 232 #endif
 233 #define UNKNOWN -1
 234
 235 #define SECTION_NAME(X)         (string_table + (X)->sh_name)
 236
 237 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order! */
 238
 239 #define BYTE_GET(field)         byte_get (field, sizeof (field))
 240
 241 /* If we can support a 64 bit data type then BFD64 should be defined
 242    and sizeof (bfd_vma) == 8.  In this case when translating from an
 243    external 8 byte field to an internal field, we can assume that the
 244    internal field is also 8 bytes wide and so we can extact all the data.
 245    If, however, BFD64 is not defined, then we must assume that the
 246    internal data structure only has 4 byte wide fields that are the
 247    equivalent of the 8 byte wide external counterparts, and so we must
 248    truncate the data.  */
 249 #ifdef  BFD64
 250 #define BYTE_GET8(field)        byte_get (field, -8)
 251 #else
 252 #define BYTE_GET8(field)        byte_get (field, 8)
 253 #endif
 254
 255 #define NUM_ELEM(array)         (sizeof (array) / sizeof ((array)[0]))
 256
 257 #define GET_DATA_ALLOC(offset, size, var, type, reason)                 \
 258   if (fseek (file, offset, SEEK_SET))                                   \
 259     {                                                                   \
 260       error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
 261       return 0;                                                         \
 262     }                                                                   \
 263                                                                         \
 264   var = (type) malloc (size);                                           \
 265                                                                         \
 266   if (var == NULL)                                                      \
 267     {                                                                   \
 268       error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
 269       return 0;                                                         \
 270     }                                                                   \
 271                                                                         \
 272   if (fread (var, size, 1, file) != 1)                                  \
 273     {                                                                   \
 274       error (_("Unable to read in %d bytes of %s\n"), size, reason);    \
 275       free (var);                                                       \
 276       var = NULL;                                                       \
 277       return 0;                                                         \
 278     }
 279
 280
 281 #define GET_DATA(offset, var, reason)                                   \
 282   if (fseek (file, offset, SEEK_SET))                                   \
 283     {                                                                   \
 284       error (_("Unable to seek to %x for %s\n"), offset, reason);       \
 285       return 0;                                                         \
 286     }                                                                   \
 287   else if (fread (& var, sizeof (var), 1, file) != 1)                   \
 288     {                                                                   \
 289       error (_("Unable to read data at %x for %s\n"), offset, reason);  \
 290       return 0;                                                         \
 291     }
 292
 293 #define GET_ELF_SYMBOLS(file, offset, size)                     \
 294   (is_32bit_elf ? get_32bit_elf_symbols (file, offset, size)    \
 295    : get_64bit_elf_symbols (file, offset, size))
 296
 297
 298 #ifdef ANSI_PROTOTYPES
 299 static void
 300 error (const char * message, ...)
 301 {
 302   va_list args;
 303
 304   fprintf (stderr, _("%s: Error: "), program_name);
 305   va_start (args, message);
 306   vfprintf (stderr, message, args);
 307   va_end (args);
 308   return;
 309 }
 310
 311 static void
 312 warn (const char * message, ...)
 313 {
 314   va_list args;
 315
 316   fprintf (stderr, _("%s: Warning: "), program_name);
 317   va_start (args, message);
 318   vfprintf (stderr, message, args);
 319   va_end (args);
 320   return;
 321 }
 322 #else
 323 static void
 324 error (va_alist)
 325      va_dcl
 326 {
 327   char * message;
 328   va_list args;
 329
 330   fprintf (stderr, _("%s: Error: "), program_name);
 331   va_start (args);
 332   message = va_arg (args, char *);
 333   vfprintf (stderr, message, args);
 334   va_end (args);
 335   return;
 336 }
 337
 338 static void
 339 warn (va_alist)
 340      va_dcl
 341 {
 342   char * message;
 343   va_list args;
 344
 345   fprintf (stderr, _("%s: Warning: "), program_name);
 346   va_start (args);
 347   message = va_arg (args, char *);
 348   vfprintf (stderr, message, args);
 349   va_end (args);
 350   return;
 351 }
 352 #endif
 353
 354 static bfd_vma
 355 byte_get_little_endian (field, size)
 356      unsigned char * field;
 357      int             size;
 358 {
 359   switch (size)
 360     {
 361     case 1:
 362       return * field;
 363
 364     case 2:
 365       return  ((unsigned int) (field [0]))
 366         |    (((unsigned int) (field [1])) << 8);
 367
 368     case 8:
 369       /* We want to extract data from an 8 byte wide field and
 370          place it into a 4 byte wide field.  Since this is a little
 371          endian source we can juts use the 4 byte extraction code.  */
 372       /* Fall through.  */
 373     case 4:
 374       return  ((unsigned long) (field [0]))
 375         |    (((unsigned long) (field [1])) << 8)
 376         |    (((unsigned long) (field [2])) << 16)
 377         |    (((unsigned long) (field [3])) << 24);
 378
 379 #ifdef BFD64
 380     case -8:
 381       /* This is a special case, generated by the BYTE_GET8 macro.
 382          It means that we are loading an 8 byte value from a field
 383          in an external structure into an 8 byte value in a field
 384          in an internal strcuture.  */
 385       return  ((bfd_vma) (field [0]))
 386         |    (((bfd_vma) (field [1])) << 8)
 387         |    (((bfd_vma) (field [2])) << 16)
 388         |    (((bfd_vma) (field [3])) << 24)
 389         |    (((bfd_vma) (field [4])) << 32)
 390         |    (((bfd_vma) (field [5])) << 40)
 391         |    (((bfd_vma) (field [6])) << 48)
 392         |    (((bfd_vma) (field [7])) << 56);
 393 #endif
 394     default:
 395       error (_("Unhandled data length: %d\n"), size);
 396       abort ();
 397     }
 398 }
 399
 400 /* Print a VMA value.  */
 401 static void
 402 print_vma (vma, mode)
 403      bfd_vma vma;
 404      print_mode mode;
 405 {
 406 #ifdef BFD64
 407   if (is_32bit_elf)
 408 #endif
 409     {
 410       switch (mode)
 411         {
 412         case FULL_HEX: printf ("0x"); /* drop through */
 413         case LONG_HEX: printf ("%8.8lx", (unsigned long) vma); break;
 414         case PREFIX_HEX: printf ("0x"); /* drop through */
 415         case HEX: printf ("%lx", (unsigned long) vma); break;
 416         case DEC: printf ("%ld", (unsigned long) vma); break;
 417         case DEC_5: printf ("%5ld", (long) vma); break;
 418         case UNSIGNED: printf ("%lu", (unsigned long) vma); break;
 419         }
 420     }
 421 #ifdef BFD64
 422   else
 423     {
 424       switch (mode)
 425         {
 426         case FULL_HEX:
 427           printf ("0x");
 428           /* drop through */
 429
 430         case LONG_HEX:
 431           printf_vma (vma);
 432           break;
 433
 434         case PREFIX_HEX:
 435           printf ("0x");
 436           /* drop through */
 437
 438         case HEX:
 439 #if BFD_HOST_64BIT_LONG
 440           printf ("%lx", vma);
 441 #else
 442           if (_bfd_int64_high (vma))
 443             printf ("%lx%lx", _bfd_int64_high (vma), _bfd_int64_low (vma));
 444           else
 445             printf ("%lx", _bfd_int64_low (vma));
 446 #endif
 447           break;
 448
 449         case DEC:
 450 #if BFD_HOST_64BIT_LONG
 451           printf ("%ld", vma);
 452 #else
 453           if (_bfd_int64_high (vma))
 454             /* ugg */
 455             printf ("++%ld", _bfd_int64_low (vma));
 456           else
 457             printf ("%ld", _bfd_int64_low (vma));
 458 #endif
 459           break;
 460
 461         case DEC_5:
 462 #if BFD_HOST_64BIT_LONG
 463           printf ("%5ld", vma);
 464 #else
 465           if (_bfd_int64_high (vma))
 466             /* ugg */
 467             printf ("++%ld", _bfd_int64_low (vma));
 468           else
 469             printf ("%5ld", _bfd_int64_low (vma));
 470 #endif
 471           break;
 472
 473         case UNSIGNED:
 474 #if BFD_HOST_64BIT_LONG
 475           printf ("%lu", vma);
 476 #else
 477           if (_bfd_int64_high (vma))
 478             /* ugg */
 479             printf ("++%lu", _bfd_int64_low (vma));
 480           else
 481             printf ("%lu", _bfd_int64_low (vma));
 482 #endif
 483           break;
 484         }
 485     }
 486 #endif
 487 }
 488
 489 static bfd_vma
 490 byte_get_big_endian (field, size)
 491      unsigned char * field;
 492      int             size;
 493 {
 494   switch (size)
 495     {
 496     case 1:
 497       return * field;
 498
 499     case 2:
 500       return ((unsigned int) (field [1])) | (((int) (field [0])) << 8);
 501
 502     case 4:
 503       return ((unsigned long) (field [3]))
 504         |   (((unsigned long) (field [2])) << 8)
 505         |   (((unsigned long) (field [1])) << 16)
 506         |   (((unsigned long) (field [0])) << 24);
 507
 508     case 8:
 509       /* Although we are extracing data from an 8 byte wide field, we
 510          are returning only 4 bytes of data.  */
 511       return ((unsigned long) (field [7]))
 512         |   (((unsigned long) (field [6])) << 8)
 513         |   (((unsigned long) (field [5])) << 16)
 514         |   (((unsigned long) (field [4])) << 24);
 515
 516 #ifdef BFD64
 517     case -8:
 518       /* This is a special case, generated by the BYTE_GET8 macro.
 519          It means that we are loading an 8 byte value from a field
 520          in an external structure into an 8 byte value in a field
 521          in an internal strcuture.  */
 522       return ((bfd_vma) (field [7]))
 523         |   (((bfd_vma) (field [6])) << 8)
 524         |   (((bfd_vma) (field [5])) << 16)
 525         |   (((bfd_vma) (field [4])) << 24)
 526         |   (((bfd_vma) (field [3])) << 32)
 527         |   (((bfd_vma) (field [2])) << 40)
 528         |   (((bfd_vma) (field [1])) << 48)
 529         |   (((bfd_vma) (field [0])) << 56);
 530 #endif
 531
 532     default:
 533       error (_("Unhandled data length: %d\n"), size);
 534       abort ();
 535     }
 536 }
 537
 538
 539 /* Guess the relocation sized based on the sized commonly used by the specific machine.  */
 540 static int
 541 guess_is_rela (e_machine)
 542      unsigned long e_machine;
 543 {
 544   switch (e_machine)
 545     {
 546       /* Targets that use REL relocations.  */
 547     case EM_ARM:
 548     case EM_386:
 549     case EM_486:
 550     case EM_960:
 551     case EM_CYGNUS_M32R:
 552     case EM_CYGNUS_D10V:
 553     case EM_MIPS:
 554     case EM_MIPS_RS4_BE:
 555       return FALSE;
 556
 557       /* Targets that use RELA relocations.  */
 558     case EM_68K:
 559     case EM_SPARC32PLUS:
 560     case EM_SPARCV9:
 561     case EM_SPARC:
 562     case EM_PPC:
 563     case EM_CYGNUS_V850:
 564     case EM_CYGNUS_D30V:
 565     case EM_CYGNUS_MN10200:
 566     case EM_CYGNUS_MN10300:
 567     case EM_CYGNUS_FR30:
 568     case EM_SH:
 569     case EM_ALPHA:
 570     case EM_MCORE:
 571       return TRUE;
 572
 573     case EM_MMA:
 574     case EM_PCP:
 575     case EM_NCPU:
 576     case EM_NDR1:
 577     case EM_STARCORE:
 578     case EM_ME16:
 579     case EM_ST100:
 580     case EM_TINYJ:
 581     case EM_FX66:
 582     case EM_ST9PLUS:
 583     case EM_ST7:
 584     case EM_68HC16:
 585     case EM_68HC11:
 586     case EM_68HC08:
 587     case EM_68HC05:
 588     case EM_SVX:
 589     case EM_ST19:
 590     case EM_VAX:
 591     default:
 592       warn (_("Don't know about relocations on this machine architecture\n"));
 593       return FALSE;
 594     }
 595 }
 596
 597 /* Display the contents of the relocation data found at the specified offset.  */
 598 static int
 599 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela)
 600      FILE *             file;
 601      unsigned long      rel_offset;
 602      unsigned long      rel_size;
 603      Elf_Internal_Sym * symtab;
 604      unsigned long      nsyms;
 605      char *             strtab;
 606      int                is_rela;
 607 {
 608   unsigned int        i;
 609   Elf_Internal_Rel *  rels;
 610   Elf_Internal_Rela * relas;
 611
 612
 613   if (is_rela == UNKNOWN)
 614     is_rela = guess_is_rela (elf_header.e_machine);
 615
 616   if (is_rela)
 617     {
 618       if (is_32bit_elf)
 619         {
 620           Elf32_External_Rela * erelas;
 621
 622           GET_DATA_ALLOC (rel_offset, rel_size, erelas,
 623                           Elf32_External_Rela *, "relocs");
 624
 625           rel_size = rel_size / sizeof (Elf32_External_Rela);
 626
 627           relas = (Elf_Internal_Rela *)
 628             malloc (rel_size * sizeof (Elf_Internal_Rela));
 629
 630           if (relas == NULL)
 631             {
 632               error(_("out of memory parsing relocs"));
 633               return 0;
 634             }
 635
 636           for (i = 0; i < rel_size; i++)
 637             {
 638               relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 639               relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 640               relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
 641             }
 642
 643           free (erelas);
 644
 645           rels = (Elf_Internal_Rel *) relas;
 646         }
 647       else
 648         {
 649           Elf64_External_Rela * erelas;
 650
 651           GET_DATA_ALLOC (rel_offset, rel_size, erelas,
 652                           Elf64_External_Rela *, "relocs");
 653
 654           rel_size = rel_size / sizeof (Elf64_External_Rela);
 655
 656           relas = (Elf_Internal_Rela *)
 657             malloc (rel_size * sizeof (Elf_Internal_Rela));
 658
 659           if (relas == NULL)
 660             {
 661               error(_("out of memory parsing relocs"));
 662               return 0;
 663             }
 664
 665           for (i = 0; i < rel_size; i++)
 666             {
 667               relas[i].r_offset = BYTE_GET8 (erelas[i].r_offset);
 668               relas[i].r_info   = BYTE_GET8 (erelas[i].r_info);
 669               relas[i].r_addend = BYTE_GET8 (erelas[i].r_addend);
 670             }
 671
 672           free (erelas);
 673
 674           rels = (Elf_Internal_Rel *) relas;
 675         }
 676     }
 677   else
 678     {
 679       if (is_32bit_elf)
 680         {
 681           Elf32_External_Rel * erels;
 682
 683           GET_DATA_ALLOC (rel_offset, rel_size, erels,
 684                           Elf32_External_Rel *, "relocs");
 685
 686           rel_size = rel_size / sizeof (Elf32_External_Rel);
 687
 688           rels = (Elf_Internal_Rel *)
 689             malloc (rel_size * sizeof (Elf_Internal_Rel));
 690
 691           if (rels == NULL)
 692             {
 693               error(_("out of memory parsing relocs"));
 694               return 0;
 695             }
 696
 697           for (i = 0; i < rel_size; i++)
 698             {
 699               rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 700               rels[i].r_info   = BYTE_GET (erels[i].r_info);
 701             }
 702
 703           free (erels);
 704
 705           relas = (Elf_Internal_Rela *) rels;
 706         }
 707       else
 708         {
 709           Elf64_External_Rel * erels;
 710
 711           GET_DATA_ALLOC (rel_offset, rel_size, erels,
 712                           Elf64_External_Rel *, "relocs");
 713
 714           rel_size = rel_size / sizeof (Elf64_External_Rel);
 715
 716           rels = (Elf_Internal_Rel *)
 717             malloc (rel_size * sizeof (Elf_Internal_Rel));
 718
 719           if (rels == NULL)
 720             {
 721               error(_("out of memory parsing relocs"));
 722               return 0;
 723             }
 724
 725           for (i = 0; i < rel_size; i++)
 726             {
 727               rels[i].r_offset = BYTE_GET8 (erels[i].r_offset);
 728               rels[i].r_info   = BYTE_GET8 (erels[i].r_info);
 729             }
 730
 731           free (erels);
 732
 733           relas = (Elf_Internal_Rela *) rels;
 734         }
 735     }
 736
 737   if (is_rela)
 738     printf
 739       (_("  Offset    Info  Type            Symbol's Value  Symbol's Name          Addend\n"));
 740   else
 741     printf
 742       (_("  Offset    Info  Type            Symbol's Value  Symbol's Name\n"));
 743
 744   for (i = 0; i < rel_size; i++)
 745     {
 746       const char * rtype;
 747       bfd_vma      offset;
 748       bfd_vma      info;
 749       bfd_vma      symtab_index;
 750       bfd_vma      type;
 751
 752       if (is_rela)
 753         {
 754           offset = relas [i].r_offset;
 755           info   = relas [i].r_info;
 756         }
 757       else
 758         {
 759           offset = rels [i].r_offset;
 760           info   = rels [i].r_info;
 761         }
 762
 763       if (is_32bit_elf)
 764         {
 765           type         = ELF32_R_TYPE (info);
 766           symtab_index = ELF32_R_SYM  (info);
 767         }
 768       else
 769         {
 770           if (elf_header.e_machine == EM_SPARCV9)
 771             type       = ELF64_R_TYPE_ID (info);
 772           else
 773             type       = ELF64_R_TYPE (info);
 774           /* The #ifdef BFD64 below is to prevent a compile time warning.
 775              We know that if we do not have a 64 bit data type that we
 776              will never execute this code anyway.  */
 777 #ifdef BFD64
 778           symtab_index = ELF64_R_SYM  (info);
 779 #endif
 780         }
 781
 782 #ifdef _bfd_int64_low
 783       printf ("  %8.8lx  %5.5lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
 784 #else
 785       printf ("  %8.8lx  %5.5lx ", offset, info);
 786 #endif
 787
 788       switch (elf_header.e_machine)
 789         {
 790         default:
 791           rtype = NULL;
 792           break;
 793
 794         case EM_CYGNUS_M32R:
 795           rtype = elf_m32r_reloc_type (type);
 796           break;
 797
 798         case EM_386:
 799         case EM_486:
 800           rtype = elf_i386_reloc_type (type);
 801           break;
 802
 803         case EM_68K:
 804           rtype = elf_m68k_reloc_type (type);
 805           break;
 806
 807         case EM_960:
 808           rtype = elf_i960_reloc_type (type);
 809           break;
 810
 811         case EM_AVR:
 812           rtype = elf_avr_reloc_type (type);
 813           break;
 814
 815         case EM_OLD_SPARCV9:
 816         case EM_SPARC32PLUS:
 817         case EM_SPARCV9:
 818         case EM_SPARC:
 819           rtype = elf_sparc_reloc_type (type);
 820           break;
 821
 822         case EM_CYGNUS_V850:
 823           rtype = v850_reloc_type (type);
 824           break;
 825
 826         case EM_CYGNUS_D10V:
 827           rtype = elf_d10v_reloc_type (type);
 828           break;
 829
 830         case EM_CYGNUS_D30V:
 831           rtype = elf_d30v_reloc_type (type);
 832           break;
 833
 834         case EM_SH:
 835           rtype = elf_sh_reloc_type (type);
 836           break;
 837
 838         case EM_CYGNUS_MN10300:
 839           rtype = elf_mn10300_reloc_type (type);
 840           break;
 841
 842         case EM_CYGNUS_MN10200:
 843           rtype = elf_mn10200_reloc_type (type);
 844           break;
 845
 846         case EM_CYGNUS_FR30:
 847           rtype = elf_fr30_reloc_type (type);
 848           break;
 849
 850         case EM_MCORE:
 851           rtype = elf_mcore_reloc_type (type);
 852           break;
 853
 854         case EM_PPC:
 855           rtype = elf_ppc_reloc_type (type);
 856           break;
 857
 858         case EM_MIPS:
 859         case EM_MIPS_RS4_BE:
 860           rtype = elf_mips_reloc_type (type);
 861           break;
 862
 863         case EM_ALPHA:
 864           rtype = elf_alpha_reloc_type (type);
 865           break;
 866
 867         case EM_ARM:
 868           rtype = elf_arm_reloc_type (type);
 869           break;
 870
 871         case EM_CYGNUS_ARC:
 872           rtype = elf_arc_reloc_type (type);
 873           break;
 874
 875         case EM_PARISC:
 876           rtype = elf_hppa_reloc_type (type);
 877           break;
 878
 879         case EM_PJ:
 880           rtype = elf_pj_reloc_type (type);
 881           break;
 882         }
 883
 884       if (rtype == NULL)
 885 #ifdef _bfd_int64_low
 886         printf (_("unrecognised: %-7lx"), _bfd_int64_low (type));
 887 #else
 888         printf (_("unrecognised: %-7lx"), type);
 889 #endif
 890       else
 891         printf ("%-21.21s", rtype);
 892
 893       if (symtab_index)
 894         {
 895           if (symtab != NULL)
 896             {
 897               if (symtab_index >= nsyms)
 898                 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
 899               else
 900                 {
 901                   Elf_Internal_Sym * psym;
 902
 903                   psym = symtab + symtab_index;
 904
 905                   printf (" ");
 906                   print_vma (psym->st_value, LONG_HEX);
 907                   printf ("  ");
 908
 909                   if (psym->st_name == 0)
 910                     printf ("%-25.25s",
 911                             SECTION_NAME (section_headers + psym->st_shndx));
 912                   else if (strtab == NULL)
 913                     printf (_("<string table index %3ld>"), psym->st_name);
 914                   else
 915                     printf ("%-25.25s", strtab + psym->st_name);
 916
 917                   if (is_rela)
 918                     printf (" + %lx", (unsigned long) relas [i].r_addend);
 919                 }
 920             }
 921         }
 922       else if (is_rela)
 923         {
 924           printf ("%*c", is_32bit_elf ? 34 : 26, ' ');
 925           print_vma (relas[i].r_addend, LONG_HEX);
 926         }
 927
 928       if (elf_header.e_machine == EM_SPARCV9
 929           && !strcmp (rtype, "R_SPARC_OLO10"))
 930         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
 931
 932       putchar ('\n');
 933     }
 934
 935   free (relas);
 936
 937   return 1;
 938 }
 939
 940 static const char *
 941 get_mips_dynamic_type (type)
 942      unsigned long type;
 943 {
 944   switch (type)
 945     {
 946     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
 947     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
 948     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
 949     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
 950     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
 951     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
 952     case DT_MIPS_MSYM: return "MIPS_MSYM";
 953     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
 954     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
 955     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
 956     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
 957     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
 958     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
 959     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
 960     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
 961     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
 962     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
 963     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
 964     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
 965     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
 966     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
 967     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
 968     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
 969     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
 970     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
 971     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
 972     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
 973     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
 974     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
 975     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
 976     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
 977     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
 978     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
 979     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
 980     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
 981     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
 982     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
 983     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
 984     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
 985     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
 986     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
 987     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
 988     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
 989     default:
 990       return NULL;
 991     }
 992 }
 993
 994 static const char *
 995 get_sparc64_dynamic_type (type)
 996      unsigned long type;
 997 {
 998   switch (type)
 999     {
1000     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1001     default:
1002       return NULL;
1003     }
1004 }
1005
1006 static const char *
1007 get_parisc_dynamic_type (type)
1008      unsigned long type;
1009 {
1010   switch (type)
1011     {
1012     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1013     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1014     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1015     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1016     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1017     case DT_HP_PREINIT:         return "HP_PREINIT";
1018     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1019     case DT_HP_NEEDED:          return "HP_NEEDED";
1020     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1021     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1022     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1023     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1024     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1025     default:
1026       return NULL;
1027     }
1028 }
1029
1030 static const char *
1031 get_dynamic_type (type)
1032      unsigned long type;
1033 {
1034   static char buff [32];
1035
1036   switch (type)
1037     {
1038     case DT_NULL:       return "NULL";
1039     case DT_NEEDED:     return "NEEDED";
1040     case DT_PLTRELSZ:   return "PLTRELSZ";
1041     case DT_PLTGOT:     return "PLTGOT";
1042     case DT_HASH:       return "HASH";
1043     case DT_STRTAB:     return "STRTAB";
1044     case DT_SYMTAB:     return "SYMTAB";
1045     case DT_RELA:       return "RELA";
1046     case DT_RELASZ:     return "RELASZ";
1047     case DT_RELAENT:    return "RELAENT";
1048     case DT_STRSZ:      return "STRSZ";
1049     case DT_SYMENT:     return "SYMENT";
1050     case DT_INIT:       return "INIT";
1051     case DT_FINI:       return "FINI";
1052     case DT_SONAME:     return "SONAME";
1053     case DT_RPATH:      return "RPATH";
1054     case DT_SYMBOLIC:   return "SYMBOLIC";
1055     case DT_REL:        return "REL";
1056     case DT_RELSZ:      return "RELSZ";
1057     case DT_RELENT:     return "RELENT";
1058     case DT_PLTREL:     return "PLTREL";
1059     case DT_DEBUG:      return "DEBUG";
1060     case DT_TEXTREL:    return "TEXTREL";
1061     case DT_JMPREL:     return "JMPREL";
1062     case DT_BIND_NOW:   return "BIND_NOW";
1063     case DT_INIT_ARRAY: return "INIT_ARRAY";
1064     case DT_FINI_ARRAY: return "FINI_ARRAY";
1065     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1066     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1067     case DT_RUNPATH:    return "RUNPATH";
1068     case DT_FLAGS:      return "FLAGS";
1069
1070     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1071     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1072
1073     case DT_PLTPADSZ:   return "PLTPADSZ";
1074     case DT_MOVEENT:    return "MOVEENT";
1075     case DT_MOVESZ:     return "MOVESZ";
1076     case DT_FEATURE_1:  return "FEATURE_1";
1077     case DT_POSFLAG_1:  return "POSFLAG_1";
1078     case DT_SYMINSZ:    return "SYMINSZ";
1079     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
1080
1081     case DT_ADDRRNGLO:  return "ADDRRNGLO";
1082     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
1083
1084     case DT_VERSYM:     return "VERSYM";
1085
1086     case DT_RELACOUNT:  return "RELACOUNT";
1087     case DT_RELCOUNT:   return "RELCOUNT";
1088     case DT_FLAGS_1:    return "FLAGS_1";
1089     case DT_VERDEF:     return "VERDEF";
1090     case DT_VERDEFNUM:  return "VERDEFNUM";
1091     case DT_VERNEED:    return "VERNEED";
1092     case DT_VERNEEDNUM: return "VERNEEDNUM";
1093
1094     case DT_AUXILIARY:  return "AUXILARY";
1095     case DT_USED:       return "USED";
1096     case DT_FILTER:     return "FILTER";
1097
1098     default:
1099       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1100         {
1101           const char * result;
1102
1103           switch (elf_header.e_machine)
1104             {
1105             case EM_MIPS:
1106             case EM_MIPS_RS4_BE:
1107               result = get_mips_dynamic_type (type);
1108               break;
1109             case EM_SPARCV9:
1110               result = get_sparc64_dynamic_type (type);
1111               break;
1112             default:
1113               result = NULL;
1114               break;
1115             }
1116
1117           if (result != NULL)
1118             return result;
1119
1120           sprintf (buff, _("Processor Specific: %lx"), type);
1121         }
1122       else if ((type >= DT_LOOS) && (type <= DT_HIOS))
1123         {
1124           const char * result;
1125
1126           switch (elf_header.e_machine)
1127             {
1128             case EM_PARISC:
1129               result = get_parisc_dynamic_type (type);
1130               break;
1131             default:
1132               result = NULL;
1133               break;
1134             }
1135
1136           if (result != NULL)
1137             return result;
1138
1139           sprintf (buff, _("Operating System specific: %lx"), type);
1140         }
1141       else
1142         sprintf (buff, _("<unknown>: %lx"), type);
1143
1144       return buff;
1145     }
1146 }
1147
1148 static char *
1149 get_file_type (e_type)
1150      unsigned e_type;
1151 {
1152   static char buff [32];
1153
1154   switch (e_type)
1155     {
1156     case ET_NONE:       return _("NONE (None)");
1157     case ET_REL:        return _("REL (Relocatable file)");
1158     case ET_EXEC:       return _("EXEC (Executable file)");
1159     case ET_DYN:        return _("DYN (Shared object file)");
1160     case ET_CORE:       return _("CORE (Core file)");
1161
1162     default:
1163       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1164         sprintf (buff, _("Processor Specific: (%x)"), e_type);
1165       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1166         sprintf (buff, _("OS Specific: (%x)"), e_type);
1167       else
1168         sprintf (buff, _("<unknown>: %x"), e_type);
1169       return buff;
1170     }
1171 }
1172
1173 static char *
1174 get_machine_name (e_machine)
1175      unsigned e_machine;
1176 {
1177   static char buff [64]; /* XXX */
1178
1179   switch (e_machine)
1180     {
1181     case EM_NONE:               return _("None");
1182     case EM_M32:                return "WE32100";
1183     case EM_SPARC:              return "Sparc";
1184     case EM_386:                return "Intel 80386";
1185     case EM_68K:                return "MC68000";
1186     case EM_88K:                return "MC88000";
1187     case EM_486:                return "Intel 80486";
1188     case EM_860:                return "Intel 80860";
1189     case EM_MIPS:               return "MIPS R3000";
1190     case EM_S370:               return "IBM System/370";
1191     case EM_MIPS_RS4_BE:        return "MIPS R4000 big-endian";
1192     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
1193     case EM_PARISC:             return "HPPA";
1194     case EM_PPC_OLD:            return "Power PC (old)";
1195     case EM_SPARC32PLUS:        return "Sparc v8+" ;
1196     case EM_960:                return "Intel 90860";
1197     case EM_PPC:                return "PowerPC";
1198     case EM_V800:               return "NEC V800";
1199     case EM_FR20:               return "Fujitsu FR20";
1200     case EM_RH32:               return "TRW RH32";
1201     case EM_MCORE:              return "MCORE";
1202     case EM_ARM:                return "ARM";
1203     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
1204     case EM_SH:                 return "Hitachi SH";
1205     case EM_SPARCV9:            return "Sparc v9";
1206     case EM_TRICORE:            return "Siemens Tricore";
1207     case EM_ARC:                return "Argonaut RISC Core";
1208     case EM_H8_300:             return "Hitachi H8/300";
1209     case EM_H8_300H:            return "Hitachi H8/300H";
1210     case EM_H8S:                return "Hitachi H8S";
1211     case EM_H8_500:             return "Hitachi H8/500";
1212     case EM_IA_64:              return "Intel IA-64";
1213     case EM_MIPS_X:             return "Stanford MIPS-X";
1214     case EM_COLDFIRE:           return "Motorola Coldfire";
1215     case EM_68HC12:             return "Motorola M68HC12";
1216     case EM_ALPHA:              return "Alpha";
1217     case EM_CYGNUS_D10V:        return "d10v";
1218     case EM_CYGNUS_D30V:        return "d30v";
1219     case EM_CYGNUS_ARC:         return "Arc";
1220     case EM_CYGNUS_M32R:        return "Mitsubishi M32r";
1221     case EM_CYGNUS_V850:        return "NEC v850";
1222     case EM_CYGNUS_MN10300:     return "mn10300";
1223     case EM_CYGNUS_MN10200:     return "mn10200";
1224     case EM_CYGNUS_FR30:        return "Fujitsu FR30";
1225     case EM_PJ:                 return "picoJava";
1226     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
1227     case EM_PCP:                return "Siemens PCP";
1228     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
1229     case EM_NDR1:               return "Denso NDR1 microprocesspr";
1230     case EM_STARCORE:           return "Motorola Star*Core processor";
1231     case EM_ME16:               return "Toyota ME16 processor";
1232     case EM_ST100:              return "STMicroelectronics ST100 processor";
1233     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
1234     case EM_FX66:               return "Siemens FX66 microcontroller";
1235     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1236     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
1237     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
1238     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
1239     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
1240     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
1241     case EM_SVX:                return "Silicon Graphics SVx";
1242     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
1243     case EM_VAX:                return "Digital VAX";
1244     case EM_AVR:                return "AVR";
1245     default:
1246       sprintf (buff, _("<unknown>: %x"), e_machine);
1247       return buff;
1248     }
1249 }
1250
1251 static void
1252 decode_ARM_machine_flags (e_flags, buf)
1253      unsigned e_flags;
1254      char buf[];
1255 {
1256   unsigned eabi;
1257   int unknown = 0;
1258
1259   eabi = EF_ARM_EABI_VERSION (e_flags);
1260   e_flags &= ~ EF_ARM_EABIMASK;
1261
1262   /* Handle "generic" ARM flags.  */
1263   if (e_flags & EF_ARM_RELEXEC)
1264     {
1265       strcat (buf, ", relocatable executable");
1266       e_flags &= ~ EF_ARM_RELEXEC;
1267     }
1268
1269   if (e_flags & EF_ARM_HASENTRY)
1270     {
1271       strcat (buf, ", has entry point");
1272       e_flags &= ~ EF_ARM_HASENTRY;
1273     }
1274
1275   /* Now handle EABI specific flags.  */
1276   switch (eabi)
1277     {
1278     default:
1279       strcat (buf, ", <unknown EABI>");
1280       if (e_flags)
1281         unknown = 1;
1282       break;
1283
1284     case EF_ARM_EABI_VER1:
1285       while (e_flags)
1286         {
1287           unsigned flag;
1288
1289           /* Process flags one bit at a time.  */
1290           flag = e_flags & - e_flags;
1291           e_flags &= ~ flag;
1292
1293           switch (flag)
1294             {
1295             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_INTERWORK.  */
1296               strcat (buf, ", sorted symbol tables");
1297               break;
1298
1299             default:
1300               unknown = 1;
1301               break;
1302             }
1303         }
1304       break;
1305
1306     case EF_ARM_EABI_UNKNOWN:
1307       while (e_flags)
1308         {
1309           unsigned flag;
1310
1311           /* Process flags one bit at a time.  */
1312           flag = e_flags & - e_flags;
1313           e_flags &= ~ flag;
1314
1315           switch (flag)
1316             {
1317             case EF_INTERWORK:
1318               strcat (buf, ", interworking enabled");
1319               break;
1320
1321             case EF_APCS_26:
1322               strcat (buf, ", uses APCS/26");
1323               break;
1324
1325             case EF_APCS_FLOAT:
1326               strcat (buf, ", uses APCS/float");
1327               break;
1328
1329             case EF_PIC:
1330               strcat (buf, ", position independent");
1331               break;
1332
1333             case EF_ALIGN8:
1334               strcat (buf, ", 8 bit structure alignment");
1335               break;
1336
1337             case EF_NEW_ABI:
1338               strcat (buf, ", uses new ABI");
1339               break;
1340
1341             case EF_OLD_ABI:
1342               strcat (buf, ", uses old ABI");
1343               break;
1344
1345             case EF_SOFT_FLOAT:
1346               strcat (buf, ", software FP");
1347               break;
1348
1349             default:
1350               unknown = 1;
1351               break;
1352             }
1353         }
1354     }
1355
1356
1357   if (unknown)
1358     strcat (buf,", <unknown>");
1359 }
1360
1361 static char *
1362 get_machine_flags (e_flags, e_machine)
1363      unsigned e_flags;
1364      unsigned e_machine;
1365 {
1366   static char buf [1024];
1367
1368   buf[0] = '\0';
1369
1370   if (e_flags)
1371     {
1372       switch (e_machine)
1373         {
1374         default:
1375           break;
1376
1377         case EM_ARM:
1378           decode_ARM_machine_flags (e_flags, buf);
1379           break;
1380
1381         case EM_68K:
1382           if (e_flags & EF_CPU32)
1383             strcat (buf, ", cpu32");
1384           break;
1385
1386         case EM_PPC:
1387           if (e_flags & EF_PPC_EMB)
1388             strcat (buf, ", emb");
1389
1390           if (e_flags & EF_PPC_RELOCATABLE)
1391             strcat (buf, ", relocatable");
1392
1393           if (e_flags & EF_PPC_RELOCATABLE_LIB)
1394             strcat (buf, ", relocatable-lib");
1395           break;
1396
1397         case EM_CYGNUS_V850:
1398           switch (e_flags & EF_V850_ARCH)
1399             {
1400             case E_V850E_ARCH:
1401               strcat (buf, ", v850e");
1402               break;
1403             case E_V850EA_ARCH:
1404               strcat (buf, ", v850ea");
1405               break;
1406             case E_V850_ARCH:
1407               strcat (buf, ", v850");
1408               break;
1409             default:
1410               strcat (buf, ", unknown v850 architecture variant");
1411               break;
1412             }
1413           break;
1414
1415         case EM_CYGNUS_M32R:
1416           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
1417             strcat (buf, ", m32r");
1418
1419           break;
1420
1421         case EM_MIPS:
1422         case EM_MIPS_RS4_BE:
1423           if (e_flags & EF_MIPS_NOREORDER)
1424             strcat (buf, ", noreorder");
1425
1426           if (e_flags & EF_MIPS_PIC)
1427             strcat (buf, ", pic");
1428
1429           if (e_flags & EF_MIPS_CPIC)
1430             strcat (buf, ", cpic");
1431
1432           if (e_flags & EF_MIPS_ABI2)
1433             strcat (buf, ", abi2");
1434
1435           if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
1436             strcat (buf, ", mips1");
1437
1438           if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
1439             strcat (buf, ", mips2");
1440
1441           if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
1442             strcat (buf, ", mips3");
1443
1444           if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
1445             strcat (buf, ", mips4");
1446           break;
1447
1448         case EM_SPARCV9:
1449           if (e_flags & EF_SPARC_32PLUS)
1450             strcat (buf, ", v8+");
1451
1452           if (e_flags & EF_SPARC_SUN_US1)
1453             strcat (buf, ", ultrasparcI");
1454
1455           if (e_flags & EF_SPARC_SUN_US3)
1456             strcat (buf, ", ultrasparcIII");
1457
1458           if (e_flags & EF_SPARC_HAL_R1)
1459             strcat (buf, ", halr1");
1460
1461           if (e_flags & EF_SPARC_LEDATA)
1462             strcat (buf, ", ledata");
1463
1464           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
1465             strcat (buf, ", tso");
1466
1467           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
1468             strcat (buf, ", pso");
1469
1470           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
1471             strcat (buf, ", rmo");
1472           break;
1473
1474         case EM_PARISC:
1475           switch (e_flags & EF_PARISC_ARCH)
1476             {
1477             case EFA_PARISC_1_0:
1478               strcpy (buf, ", PA-RISC 1.0");
1479               break;
1480             case EFA_PARISC_1_1:
1481               strcpy (buf, ", PA-RISC 1.1");
1482               break;
1483             case EFA_PARISC_2_0:
1484               strcpy (buf, ", PA-RISC 2.0");
1485               break;
1486             default:
1487               break;
1488             }
1489           if (e_flags & EF_PARISC_TRAPNIL)
1490             strcat (buf, ", trapnil");
1491           if (e_flags & EF_PARISC_EXT)
1492             strcat (buf, ", ext");
1493           if (e_flags & EF_PARISC_LSB)
1494             strcat (buf, ", lsb");
1495           if (e_flags & EF_PARISC_WIDE)
1496             strcat (buf, ", wide");
1497           if (e_flags & EF_PARISC_NO_KABP)
1498             strcat (buf, ", no kabp");
1499           if (e_flags & EF_PARISC_LAZYSWAP)
1500             strcat (buf, ", lazyswap");
1501           break;
1502
1503         case EM_PJ:
1504           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
1505             strcat (buf, ", new calling convention");
1506
1507           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
1508             strcat (buf, ", gnu calling convention");
1509           break;
1510         }
1511     }
1512
1513   return buf;
1514 }
1515
1516 static const char *
1517 get_mips_segment_type (type)
1518      unsigned long type;
1519 {
1520   switch (type)
1521     {
1522     case PT_MIPS_REGINFO:
1523       return "REGINFO";
1524     case PT_MIPS_RTPROC:
1525       return "RTPROC";
1526     case PT_MIPS_OPTIONS:
1527       return "OPTIONS";
1528     default:
1529       break;
1530     }
1531
1532   return NULL;
1533 }
1534
1535 static const char *
1536 get_parisc_segment_type (type)
1537      unsigned long type;
1538 {
1539   switch (type)
1540     {
1541     case PT_HP_TLS:             return "HP_TLS";
1542     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
1543     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
1544     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
1545     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
1546     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
1547     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
1548     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
1549     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
1550     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
1551     case PT_HP_PARALLEL:        return "HP_PARALLEL";
1552     case PT_HP_FASTBIND:        return "HP_FASTBIND";
1553     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
1554     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
1555     default:
1556       break;
1557     }
1558
1559   return NULL;
1560 }
1561
1562 static const char *
1563 get_segment_type (p_type)
1564      unsigned long p_type;
1565 {
1566   static char buff [32];
1567
1568   switch (p_type)
1569     {
1570     case PT_NULL:       return "NULL";
1571     case PT_LOAD:       return "LOAD";
1572     case PT_DYNAMIC:    return "DYNAMIC";
1573     case PT_INTERP:     return "INTERP";
1574     case PT_NOTE:       return "NOTE";
1575     case PT_SHLIB:      return "SHLIB";
1576     case PT_PHDR:       return "PHDR";
1577
1578     default:
1579       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
1580         {
1581           const char * result;
1582
1583           switch (elf_header.e_machine)
1584             {
1585             case EM_MIPS:
1586             case EM_MIPS_RS4_BE:
1587               result = get_mips_segment_type (p_type);
1588               break;
1589             case EM_PARISC:
1590               result = get_parisc_segment_type (p_type);
1591               break;
1592             default:
1593               result = NULL;
1594               break;
1595             }
1596
1597           if (result != NULL)
1598             return result;
1599
1600           sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
1601         }
1602       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
1603         {
1604           const char * result;
1605
1606           switch (elf_header.e_machine)
1607             {
1608             case EM_PARISC:
1609               result = get_parisc_segment_type (p_type);
1610               break;
1611             default:
1612               result = NULL;
1613               break;
1614             }
1615
1616           if (result != NULL)
1617             return result;
1618
1619           sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
1620         }
1621       else
1622         sprintf (buff, _("<unknown>: %lx"), p_type);
1623
1624       return buff;
1625     }
1626 }
1627
1628 static const char *
1629 get_mips_section_type_name (sh_type)
1630      unsigned int sh_type;
1631 {
1632   switch (sh_type)
1633     {
1634     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
1635     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
1636     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
1637     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
1638     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
1639     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
1640     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
1641     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
1642     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
1643     case SHT_MIPS_RELD:          return "MIPS_RELD";
1644     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
1645     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
1646     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
1647     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
1648     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
1649     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
1650     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
1651     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
1652     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
1653     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
1654     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
1655     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
1656     case SHT_MIPS_LINE:          return "MIPS_LINE";
1657     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
1658     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
1659     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
1660     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
1661     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
1662     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
1663     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
1664     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
1665     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
1666     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
1667     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
1668     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
1669     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
1670     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
1671     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
1672     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
1673     default:
1674       break;
1675     }
1676   return NULL;
1677 }
1678
1679 static const char *
1680 get_parisc_section_type_name (sh_type)
1681      unsigned int sh_type;
1682 {
1683   switch (sh_type)
1684     {
1685     case SHT_PARISC_EXT:        return "PARISC_EXT";
1686     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
1687     case SHT_PARISC_DOC:        return "PARISC_DOC";
1688     default:
1689       break;
1690     }
1691   return NULL;
1692 }
1693
1694 static const char *
1695 get_section_type_name (sh_type)
1696      unsigned int sh_type;
1697 {
1698   static char buff [32];
1699
1700   switch (sh_type)
1701     {
1702     case SHT_NULL:              return "NULL";
1703     case SHT_PROGBITS:          return "PROGBITS";
1704     case SHT_SYMTAB:            return "SYMTAB";
1705     case SHT_STRTAB:            return "STRTAB";
1706     case SHT_RELA:              return "RELA";
1707     case SHT_HASH:              return "HASH";
1708     case SHT_DYNAMIC:           return "DYNAMIC";
1709     case SHT_NOTE:              return "NOTE";
1710     case SHT_NOBITS:            return "NOBITS";
1711     case SHT_REL:               return "REL";
1712     case SHT_SHLIB:             return "SHLIB";
1713     case SHT_DYNSYM:            return "DYNSYM";
1714     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
1715     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
1716     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
1717     case SHT_GNU_verdef:        return "VERDEF";
1718     case SHT_GNU_verneed:       return "VERNEED";
1719     case SHT_GNU_versym:        return "VERSYM";
1720     case 0x6ffffff0:            return "VERSYM";
1721     case 0x6ffffffc:            return "VERDEF";
1722     case 0x7ffffffd:            return "AUXILIARY";
1723     case 0x7fffffff:            return "FILTER";
1724
1725     default:
1726       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
1727         {
1728           const char * result;
1729
1730           switch (elf_header.e_machine)
1731             {
1732             case EM_MIPS:
1733             case EM_MIPS_RS4_BE:
1734               result = get_mips_section_type_name (sh_type);
1735               break;
1736             case EM_PARISC:
1737               result = get_parisc_section_type_name (sh_type);
1738               break;
1739             default:
1740               result = NULL;
1741               break;
1742             }
1743
1744           if (result != NULL)
1745             return result;
1746
1747           sprintf (buff, "SHT_LOPROC+%x", sh_type - SHT_LOPROC);
1748         }
1749       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
1750         sprintf (buff, "SHT_LOOS+%x", sh_type - SHT_LOOS);
1751       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
1752         sprintf (buff, "SHT_LOUSER+%x", sh_type - SHT_LOUSER);
1753       else
1754         sprintf (buff, _("<unknown>: %x"), sh_type);
1755
1756       return buff;
1757     }
1758 }
1759
1760 struct option options [] =
1761 {
1762   {"all",              no_argument, 0, 'a'},
1763   {"file-header",      no_argument, 0, 'h'},
1764   {"program-headers",  no_argument, 0, 'l'},
1765   {"headers",          no_argument, 0, 'e'},
1766   {"histogram",        no_argument, 0, 'I'},
1767   {"segments",         no_argument, 0, 'l'},
1768   {"sections",         no_argument, 0, 'S'},
1769   {"section-headers",  no_argument, 0, 'S'},
1770   {"symbols",          no_argument, 0, 's'},
1771   {"syms",             no_argument, 0, 's'},
1772   {"relocs",           no_argument, 0, 'r'},
1773   {"notes",            no_argument, 0, 'n'},
1774   {"dynamic",          no_argument, 0, 'd'},
1775   {"arch-specific",    no_argument, 0, 'A'},
1776   {"version-info",     no_argument, 0, 'V'},
1777   {"use-dynamic",      no_argument, 0, 'D'},
1778   {"hex-dump",         required_argument, 0, 'x'},
1779   {"debug-dump",       optional_argument, 0, 'w'},
1780 #ifdef SUPPORT_DISASSEMBLY
1781   {"instruction-dump", required_argument, 0, 'i'},
1782 #endif
1783
1784   {"version",          no_argument, 0, 'v'},
1785   {"help",             no_argument, 0, 'H'},
1786   {0,                  no_argument, 0, 0}
1787 };
1788
1789 static void
1790 usage ()
1791 {
1792   fprintf (stdout, _("Usage: readelf {options} elf-file(s)\n"));
1793   fprintf (stdout, _("  Options are:\n"));
1794   fprintf (stdout, _("  -a or --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
1795   fprintf (stdout, _("  -h or --file-header       Display the ELF file header\n"));
1796   fprintf (stdout, _("  -l or --program-headers or --segments\n"));
1797   fprintf (stdout, _("                            Display the program headers\n"));
1798   fprintf (stdout, _("  -S or --section-headers or --sections\n"));
1799   fprintf (stdout, _("                            Display the sections' header\n"));
1800   fprintf (stdout, _("  -e or --headers           Equivalent to: -h -l -S\n"));
1801   fprintf (stdout, _("  -s or --syms or --symbols Display the symbol table\n"));
1802   fprintf (stdout, _("  -n or --notes             Display the core notes (if present)\n"));
1803   fprintf (stdout, _("  -r or --relocs            Display the relocations (if present)\n"));
1804   fprintf (stdout, _("  -d or --dynamic           Display the dynamic segment (if present)\n"));
1805   fprintf (stdout, _("  -V or --version-info      Display the version sections (if present)\n"));
1806   fprintf (stdout, _("  -A or --arch-specific     Display architecture specific information (if any).\n"));
1807   fprintf (stdout, _("  -D or --use-dynamic       Use the dynamic section info when displaying symbols\n"));
1808   fprintf (stdout, _("  -x <number> or --hex-dump=<number>\n"));
1809   fprintf (stdout, _("                            Dump the contents of section <number>\n"));
1810   fprintf (stdout, _("  -w[liapr] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges]\n"));
1811   fprintf (stdout, _("                            Display the contents of DWARF2 debug sections\n"));
1812 #ifdef SUPPORT_DISASSEMBLY
1813   fprintf (stdout, _("  -i <number> or --instruction-dump=<number>\n"));
1814   fprintf (stdout, _("                            Disassemble the contents of section <number>\n"));
1815 #endif
1816   fprintf (stdout, _("  -I or --histogram         Display histogram of bucket list lengths\n"));
1817   fprintf (stdout, _("  -v or --version           Display the version number of readelf\n"));
1818   fprintf (stdout, _("  -H or --help              Display this information\n"));
1819   fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
1820
1821   exit (0);
1822 }
1823
1824 static void
1825 request_dump (section, type)
1826      unsigned int section;
1827      char         type;
1828 {
1829   if (section >= num_dump_sects)
1830     {
1831       char * new_dump_sects;
1832
1833       new_dump_sects = (char *) calloc (section + 1, 1);
1834
1835       if (new_dump_sects == NULL)
1836         error (_("Out of memory allocating dump request table."));
1837       else
1838         {
1839           /* Copy current flag settings.  */
1840           memcpy (new_dump_sects, dump_sects, num_dump_sects);
1841
1842           free (dump_sects);
1843
1844           dump_sects = new_dump_sects;
1845           num_dump_sects = section + 1;
1846         }
1847     }
1848
1849   if (dump_sects)
1850     dump_sects [section] |= type;
1851
1852   return;
1853 }
1854
1855 static void
1856 parse_args (argc, argv)
1857      int argc;
1858      char ** argv;
1859 {
1860   int c;
1861
1862   if (argc < 2)
1863     usage ();
1864
1865   while ((c = getopt_long
1866           (argc, argv, "ersahnldSDAIw::x:i:vV", options, NULL)) != EOF)
1867     {
1868       char *    cp;
1869       int       section;
1870
1871       switch (c)
1872         {
1873         case 0:
1874           /* Long options.  */
1875           break;
1876         case 'H':
1877           usage ();
1878           break;
1879
1880         case 'a':
1881           do_syms ++;
1882           do_reloc ++;
1883           do_dynamic ++;
1884           do_header ++;
1885           do_sections ++;
1886           do_segments ++;
1887           do_version ++;
1888           do_histogram ++;
1889           do_arch ++;
1890           do_notes ++;
1891           break;
1892         case 'e':
1893           do_header ++;
1894           do_sections ++;
1895           do_segments ++;
1896           break;
1897         case 'A':
1898           do_arch ++;
1899           break;
1900         case 'D':
1901           do_using_dynamic ++;
1902           break;
1903         case 'r':
1904           do_reloc ++;
1905           break;
1906         case 'h':
1907           do_header ++;
1908           break;
1909         case 'l':
1910           do_segments ++;
1911           break;
1912         case 's':
1913           do_syms ++;
1914           break;
1915         case 'S':
1916           do_sections ++;
1917           break;
1918         case 'd':
1919           do_dynamic ++;
1920           break;
1921         case 'I':
1922           do_histogram ++;
1923           break;
1924         case 'n':
1925           do_notes ++;
1926           break;
1927         case 'x':
1928           do_dump ++;
1929           section = strtoul (optarg, & cp, 0);
1930           if (! * cp && section >= 0)
1931             {
1932               request_dump (section, HEX_DUMP);
1933               break;
1934             }
1935           goto oops;
1936         case 'w':
1937           do_dump ++;
1938           if (optarg == 0)
1939             do_debugging = 1;
1940           else
1941             {
1942               do_debugging = 0;
1943               switch (optarg[0])
1944                 {
1945                 case 'i':
1946                 case 'I':
1947                   do_debug_info = 1;
1948                   break;
1949
1950                 case 'a':
1951                 case 'A':
1952                   do_debug_abbrevs = 1;
1953                   break;
1954
1955                 case 'l':
1956                 case 'L':
1957                   do_debug_lines = 1;
1958                   break;
1959
1960                 case 'p':
1961                 case 'P':
1962                   do_debug_pubnames = 1;
1963                   break;
1964
1965                 case 'r':
1966                 case 'R':
1967                   do_debug_aranges = 1;
1968                   break;
1969
1970                 default:
1971                   warn (_("Unrecognised debug option '%s'\n"), optarg);
1972                   break;
1973                 }
1974             }
1975           break;
1976 #ifdef SUPPORT_DISASSEMBLY
1977         case 'i':
1978           do_dump ++;
1979           section = strtoul (optarg, & cp, 0);
1980           if (! * cp && section >= 0)
1981             {
1982               request_dump (section, DISASS_DUMP);
1983               break;
1984             }
1985           goto oops;
1986 #endif
1987         case 'v':
1988           print_version (program_name);
1989           break;
1990         case 'V':
1991           do_version ++;
1992           break;
1993         default:
1994         oops:
1995           /* xgettext:c-format */
1996           error (_("Invalid option '-%c'\n"), c);
1997           /* Drop through.  */
1998         case '?':
1999           usage ();
2000         }
2001     }
2002
2003   if (!do_dynamic && !do_syms && !do_reloc && !do_sections
2004       && !do_segments && !do_header && !do_dump && !do_version
2005       && !do_histogram && !do_debugging && !do_arch && !do_notes)
2006     usage ();
2007   else if (argc < 3)
2008     {
2009       warn (_("Nothing to do.\n"));
2010       usage();
2011     }
2012 }
2013
2014 static const char *
2015 get_elf_class (elf_class)
2016      unsigned char elf_class;
2017 {
2018   static char buff [32];
2019
2020   switch (elf_class)
2021     {
2022     case ELFCLASSNONE: return _("none");
2023     case ELFCLASS32:   return _("ELF32");
2024     case ELFCLASS64:   return _("ELF64");
2025     default:
2026       sprintf (buff, _("<unknown: %x>"), elf_class);
2027       return buff;
2028     }
2029 }
2030
2031 static const char *
2032 get_data_encoding (encoding)
2033      unsigned char encoding;
2034 {
2035   static char buff [32];
2036
2037   switch (encoding)
2038     {
2039     case ELFDATANONE: return _("none");
2040     case ELFDATA2LSB: return _("2's complement, little endian");
2041     case ELFDATA2MSB: return _("2's complement, big endian");
2042     default:
2043       sprintf (buff, _("<unknown: %x>"), encoding);
2044       return buff;
2045     }
2046 }
2047
2048 static const char *
2049 get_osabi_name (osabi)
2050      unsigned char osabi;
2051 {
2052   static char buff [32];
2053
2054   switch (osabi)
2055     {
2056     case ELFOSABI_SYSV:       return _("UNIX - System V");
2057     case ELFOSABI_HPUX:       return _("UNIX - HP-UX");
2058     case ELFOSABI_LINUX:      return _("UNIX - Linux");
2059     case ELFOSABI_STANDALONE: return _("Standalone App");
2060     case ELFOSABI_ARM:        return _("ARM");
2061     default:
2062       sprintf (buff, _("<unknown: %x>"), osabi);
2063       return buff;
2064     }
2065 }
2066
2067 /* Decode the data held in 'elf_header'.  */
2068 static int
2069 process_file_header ()
2070 {
2071   if (   elf_header.e_ident [EI_MAG0] != ELFMAG0
2072       || elf_header.e_ident [EI_MAG1] != ELFMAG1
2073       || elf_header.e_ident [EI_MAG2] != ELFMAG2
2074       || elf_header.e_ident [EI_MAG3] != ELFMAG3)
2075     {
2076       error
2077         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2078       return 0;
2079     }
2080
2081   if (do_header)
2082     {
2083       int i;
2084
2085       printf (_("ELF Header:\n"));
2086       printf (_("  Magic:   "));
2087       for (i = 0; i < EI_NIDENT; i ++)
2088         printf ("%2.2x ", elf_header.e_ident [i]);
2089       printf ("\n");
2090       printf (_("  Class:                             %s\n"),
2091               get_elf_class (elf_header.e_ident [EI_CLASS]));
2092       printf (_("  Data:                              %s\n"),
2093               get_data_encoding (elf_header.e_ident [EI_DATA]));
2094       printf (_("  Version:                           %d %s\n"),
2095               elf_header.e_ident [EI_VERSION],
2096               (elf_header.e_ident [EI_VERSION] == EV_CURRENT
2097                ? "(current)"
2098                : (elf_header.e_ident [EI_VERSION] != EV_NONE
2099                   ? "<unknown: %lx>"
2100                   : "")));
2101       printf (_("  OS/ABI:                            %s\n"),
2102               get_osabi_name (elf_header.e_ident [EI_OSABI]));
2103       printf (_("  ABI Version:                       %d\n"),
2104               elf_header.e_ident [EI_ABIVERSION]);
2105       printf (_("  Type:                              %s\n"),
2106               get_file_type (elf_header.e_type));
2107       printf (_("  Machine:                           %s\n"),
2108               get_machine_name (elf_header.e_machine));
2109       printf (_("  Version:                           0x%lx\n"),
2110               (unsigned long) elf_header.e_version);
2111
2112       printf (_("  Entry point address:               "));
2113       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2114       printf (_("\n  Start of program headers:          "));
2115       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2116       printf (_(" (bytes into file)\n  Start of section headers:          "));
2117       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
2118       printf (_(" (bytes into file)\n"));
2119
2120       printf (_("  Flags:                             0x%lx%s\n"),
2121               (unsigned long) elf_header.e_flags,
2122               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2123       printf (_("  Size of this header:               %ld (bytes)\n"),
2124               (long) elf_header.e_ehsize);
2125       printf (_("  Size of program headers:           %ld (bytes)\n"),
2126               (long) elf_header.e_phentsize);
2127       printf (_("  Number of program headers:         %ld\n"),
2128               (long) elf_header.e_phnum);
2129       printf (_("  Size of section headers:           %ld (bytes)\n"),
2130               (long) elf_header.e_shentsize);
2131       printf (_("  Number of section headers:         %ld\n"),
2132               (long) elf_header.e_shnum);
2133       printf (_("  Section header string table index: %ld\n"),
2134               (long) elf_header.e_shstrndx);
2135     }
2136
2137   return 1;
2138 }
2139
2140
2141 static int
2142 get_32bit_program_headers (file, program_headers)
2143      FILE * file;
2144      Elf_Internal_Phdr * program_headers;
2145 {
2146   Elf32_External_Phdr * phdrs;
2147   Elf32_External_Phdr * external;
2148   Elf32_Internal_Phdr * internal;
2149   unsigned int          i;
2150
2151   GET_DATA_ALLOC (elf_header.e_phoff,
2152                   elf_header.e_phentsize * elf_header.e_phnum,
2153                   phdrs, Elf32_External_Phdr *, "program headers");
2154
2155   for (i = 0, internal = program_headers, external = phdrs;
2156        i < elf_header.e_phnum;
2157        i ++, internal ++, external ++)
2158     {
2159       internal->p_type   = BYTE_GET (external->p_type);
2160       internal->p_offset = BYTE_GET (external->p_offset);
2161       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
2162       internal->p_paddr  = BYTE_GET (external->p_paddr);
2163       internal->p_filesz = BYTE_GET (external->p_filesz);
2164       internal->p_memsz  = BYTE_GET (external->p_memsz);
2165       internal->p_flags  = BYTE_GET (external->p_flags);
2166       internal->p_align  = BYTE_GET (external->p_align);
2167     }
2168
2169   free (phdrs);
2170
2171   return 1;
2172 }
2173
2174 static int
2175 get_64bit_program_headers (file, program_headers)
2176      FILE * file;
2177      Elf_Internal_Phdr * program_headers;
2178 {
2179   Elf64_External_Phdr * phdrs;
2180   Elf64_External_Phdr * external;
2181   Elf64_Internal_Phdr * internal;
2182   unsigned int          i;
2183
2184   GET_DATA_ALLOC (elf_header.e_phoff,
2185                   elf_header.e_phentsize * elf_header.e_phnum,
2186                   phdrs, Elf64_External_Phdr *, "program headers");
2187
2188   for (i = 0, internal = program_headers, external = phdrs;
2189        i < elf_header.e_phnum;
2190        i ++, internal ++, external ++)
2191     {
2192       internal->p_type   = BYTE_GET (external->p_type);
2193       internal->p_flags  = BYTE_GET (external->p_flags);
2194       internal->p_offset = BYTE_GET8 (external->p_offset);
2195       internal->p_vaddr  = BYTE_GET8 (external->p_vaddr);
2196       internal->p_paddr  = BYTE_GET8 (external->p_paddr);
2197       internal->p_filesz = BYTE_GET8 (external->p_filesz);
2198       internal->p_memsz  = BYTE_GET8 (external->p_memsz);
2199       internal->p_align  = BYTE_GET8 (external->p_align);
2200     }
2201
2202   free (phdrs);
2203
2204   return 1;
2205 }
2206
2207 static int
2208 process_program_headers (file)
2209      FILE * file;
2210 {
2211   Elf_Internal_Phdr * program_headers;
2212   Elf_Internal_Phdr * segment;
2213   unsigned int        i;
2214
2215   if (elf_header.e_phnum == 0)
2216     {
2217       if (do_segments)
2218         printf (_("\nThere are no program headers in this file.\n"));
2219       return 1;
2220     }
2221
2222   if (do_segments && !do_header)
2223     {
2224       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
2225       printf (_("Entry point "));
2226       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2227       printf (_("\nThere are %d program headers, starting at offset "),
2228               elf_header.e_phnum);
2229       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2230       printf ("\n");
2231     }
2232
2233   program_headers = (Elf_Internal_Phdr *) malloc
2234     (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
2235
2236   if (program_headers == NULL)
2237     {
2238       error (_("Out of memory\n"));
2239       return 0;
2240     }
2241
2242   if (is_32bit_elf)
2243     i = get_32bit_program_headers (file, program_headers);
2244   else
2245     i = get_64bit_program_headers (file, program_headers);
2246
2247   if (i == 0)
2248     {
2249       free (program_headers);
2250       return 0;
2251     }
2252
2253   if (do_segments)
2254     {
2255       printf
2256         (_("\nProgram Header%s:\n"), elf_header.e_phnum > 1 ? "s" : "");
2257
2258       if (is_32bit_elf)
2259         printf
2260           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
2261       else
2262         {
2263           printf
2264             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
2265           printf
2266             (_("                 FileSiz            MemSiz              Flags  Align\n"));
2267         }
2268     }
2269
2270   loadaddr = -1;
2271   dynamic_addr = 0;
2272   dynamic_size = 0;
2273
2274   for (i = 0, segment = program_headers;
2275        i < elf_header.e_phnum;
2276        i ++, segment ++)
2277     {
2278       if (do_segments)
2279         {
2280           printf ("  %-14.14s ", get_segment_type (segment->p_type));
2281
2282           if (is_32bit_elf)
2283             {
2284               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2285               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
2286               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
2287               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
2288               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
2289               printf ("%c%c%c ",
2290                       (segment->p_flags & PF_R ? 'R' : ' '),
2291                       (segment->p_flags & PF_W ? 'W' : ' '),
2292                       (segment->p_flags & PF_X ? 'E' : ' '));
2293               printf ("%#lx", (unsigned long) segment->p_align);
2294             }
2295           else
2296             {
2297               print_vma (segment->p_offset, FULL_HEX);
2298               putchar (' ');
2299               print_vma (segment->p_vaddr, FULL_HEX);
2300               putchar (' ');
2301               print_vma (segment->p_paddr, FULL_HEX);
2302               printf ("\n                 ");
2303               print_vma (segment->p_filesz, FULL_HEX);
2304               putchar (' ');
2305               print_vma (segment->p_memsz, FULL_HEX);
2306               printf ("  %c%c%c    ",
2307                       (segment->p_flags & PF_R ? 'R' : ' '),
2308                       (segment->p_flags & PF_W ? 'W' : ' '),
2309                       (segment->p_flags & PF_X ? 'E' : ' '));
2310               print_vma (segment->p_align, HEX);
2311             }
2312         }
2313
2314       switch (segment->p_type)
2315         {
2316         case PT_LOAD:
2317           if (loadaddr == -1)
2318             loadaddr = (segment->p_vaddr & 0xfffff000)
2319               - (segment->p_offset & 0xfffff000);
2320           break;
2321
2322         case PT_DYNAMIC:
2323           if (dynamic_addr)
2324             error (_("more than one dynamic segment\n"));
2325
2326           dynamic_addr = segment->p_offset;
2327           dynamic_size = segment->p_filesz;
2328           break;
2329
2330         case PT_INTERP:
2331           if (fseek (file, (long) segment->p_offset, SEEK_SET))
2332             error (_("Unable to find program interpreter name\n"));
2333           else
2334             {
2335               program_interpreter[0] = 0;
2336               fscanf (file, "%63s", program_interpreter);
2337
2338               if (do_segments)
2339                 printf (_("\n      [Requesting program interpreter: %s]"),
2340                     program_interpreter);
2341             }
2342           break;
2343         }
2344
2345       if (do_segments)
2346         putc ('\n', stdout);
2347     }
2348
2349   if (loadaddr == -1)
2350     {
2351       /* Very strange. */
2352       loadaddr = 0;
2353     }
2354
2355   if (do_segments && section_headers != NULL)
2356     {
2357       printf (_("\n Section to Segment mapping:\n"));
2358       printf (_("  Segment Sections...\n"));
2359
2360       assert (string_table != NULL);
2361
2362       for (i = 0; i < elf_header.e_phnum; i++)
2363         {
2364           int                 j;
2365           Elf_Internal_Shdr * section;
2366
2367           segment = program_headers + i;
2368           section = section_headers;
2369
2370           printf ("   %2.2d     ", i);
2371
2372           for (j = 0; j < elf_header.e_shnum; j++, section ++)
2373             {
2374               if (section->sh_size > 0
2375                   /* Compare allocated sections by VMA, unallocated
2376                      sections by file offset.  */
2377                   && (section->sh_flags & SHF_ALLOC
2378                       ? (section->sh_addr >= segment->p_vaddr
2379                          && section->sh_addr + section->sh_size
2380                          <= segment->p_vaddr + segment->p_memsz)
2381                       : ((bfd_vma) section->sh_offset >= segment->p_offset
2382                          && (section->sh_offset + section->sh_size
2383                              <= segment->p_offset + segment->p_filesz))))
2384                 printf ("%s ", SECTION_NAME (section));
2385             }
2386
2387           putc ('\n',stdout);
2388         }
2389     }
2390
2391   free (program_headers);
2392
2393   return 1;
2394 }
2395
2396
2397 static int
2398 get_32bit_section_headers (file)
2399      FILE * file;
2400 {
2401   Elf32_External_Shdr * shdrs;
2402   Elf32_Internal_Shdr * internal;
2403   unsigned int          i;
2404
2405   GET_DATA_ALLOC (elf_header.e_shoff,
2406                   elf_header.e_shentsize * elf_header.e_shnum,
2407                   shdrs, Elf32_External_Shdr *, "section headers");
2408
2409   section_headers = (Elf_Internal_Shdr *) malloc
2410     (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2411
2412   if (section_headers == NULL)
2413     {
2414       error (_("Out of memory\n"));
2415       return 0;
2416     }
2417
2418   for (i = 0, internal = section_headers;
2419        i < elf_header.e_shnum;
2420        i ++, internal ++)
2421     {
2422       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
2423       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
2424       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
2425       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
2426       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
2427       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
2428       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
2429       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
2430       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2431       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
2432     }
2433
2434   free (shdrs);
2435
2436   return 1;
2437 }
2438
2439 static int
2440 get_64bit_section_headers (file)
2441      FILE * file;
2442 {
2443   Elf64_External_Shdr * shdrs;
2444   Elf64_Internal_Shdr * internal;
2445   unsigned int          i;
2446
2447   GET_DATA_ALLOC (elf_header.e_shoff,
2448                   elf_header.e_shentsize * elf_header.e_shnum,
2449                   shdrs, Elf64_External_Shdr *, "section headers");
2450
2451   section_headers = (Elf_Internal_Shdr *) malloc
2452     (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2453
2454   if (section_headers == NULL)
2455     {
2456       error (_("Out of memory\n"));
2457       return 0;
2458     }
2459
2460   for (i = 0, internal = section_headers;
2461        i < elf_header.e_shnum;
2462        i ++, internal ++)
2463     {
2464       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
2465       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
2466       internal->sh_flags     = BYTE_GET8 (shdrs[i].sh_flags);
2467       internal->sh_addr      = BYTE_GET8 (shdrs[i].sh_addr);
2468       internal->sh_size      = BYTE_GET8 (shdrs[i].sh_size);
2469       internal->sh_entsize   = BYTE_GET8 (shdrs[i].sh_entsize);
2470       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
2471       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
2472       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
2473       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2474     }
2475
2476   free (shdrs);
2477
2478   return 1;
2479 }
2480
2481 static Elf_Internal_Sym *
2482 get_32bit_elf_symbols (file, offset, number)
2483      FILE * file;
2484      unsigned long offset;
2485      unsigned long number;
2486 {
2487   Elf32_External_Sym * esyms;
2488   Elf_Internal_Sym *   isyms;
2489   Elf_Internal_Sym *   psym;
2490   unsigned int         j;
2491
2492   GET_DATA_ALLOC (offset, number * sizeof (Elf32_External_Sym),
2493                   esyms, Elf32_External_Sym *, "symbols");
2494
2495   isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2496
2497   if (isyms == NULL)
2498     {
2499       error (_("Out of memory\n"));
2500       free (esyms);
2501
2502       return NULL;
2503     }
2504
2505   for (j = 0, psym = isyms;
2506        j < number;
2507        j ++, psym ++)
2508     {
2509       psym->st_name  = BYTE_GET (esyms[j].st_name);
2510       psym->st_value = BYTE_GET (esyms[j].st_value);
2511       psym->st_size  = BYTE_GET (esyms[j].st_size);
2512       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2513       psym->st_info  = BYTE_GET (esyms[j].st_info);
2514       psym->st_other = BYTE_GET (esyms[j].st_other);
2515     }
2516
2517   free (esyms);
2518
2519   return isyms;
2520 }
2521
2522 static Elf_Internal_Sym *
2523 get_64bit_elf_symbols (file, offset, number)
2524      FILE * file;
2525      unsigned long offset;
2526      unsigned long number;
2527 {
2528   Elf64_External_Sym * esyms;
2529   Elf_Internal_Sym *   isyms;
2530   Elf_Internal_Sym *   psym;
2531   unsigned int         j;
2532
2533   GET_DATA_ALLOC (offset, number * sizeof (Elf64_External_Sym),
2534                   esyms, Elf64_External_Sym *, "symbols");
2535
2536   isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2537
2538   if (isyms == NULL)
2539     {
2540       error (_("Out of memory\n"));
2541       free (esyms);
2542
2543       return NULL;
2544     }
2545
2546   for (j = 0, psym = isyms;
2547        j < number;
2548        j ++, psym ++)
2549     {
2550       psym->st_name  = BYTE_GET (esyms[j].st_name);
2551       psym->st_info  = BYTE_GET (esyms[j].st_info);
2552       psym->st_other = BYTE_GET (esyms[j].st_other);
2553       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2554       psym->st_value = BYTE_GET8 (esyms[j].st_value);
2555       psym->st_size  = BYTE_GET8 (esyms[j].st_size);
2556     }
2557
2558   free (esyms);
2559
2560   return isyms;
2561 }
2562
2563 static const char *
2564 get_elf_section_flags (sh_flags)
2565      bfd_vma sh_flags;
2566 {
2567   static char buff [32];
2568
2569   * buff = 0;
2570
2571   while (sh_flags)
2572     {
2573       bfd_vma flag;
2574
2575       flag = sh_flags & - sh_flags;
2576       sh_flags &= ~ flag;
2577
2578       switch (flag)
2579         {
2580         case SHF_WRITE:            strcat (buff, "W"); break;
2581         case SHF_ALLOC:            strcat (buff, "A"); break;
2582         case SHF_EXECINSTR:        strcat (buff, "X"); break;
2583         case SHF_MERGE:            strcat (buff, "M"); break;
2584         case SHF_STRINGS:          strcat (buff, "S"); break;
2585         case SHF_INFO_LINK:        strcat (buff, "I"); break;
2586         case SHF_LINK_ORDER:       strcat (buff, "L"); break;
2587         case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
2588
2589         default:
2590           if (flag & SHF_MASKOS)
2591             {
2592               strcat (buff, "o");
2593               sh_flags &= ~ SHF_MASKOS;
2594             }
2595           else if (flag & SHF_MASKPROC)
2596             {
2597               strcat (buff, "p");
2598               sh_flags &= ~ SHF_MASKPROC;
2599             }
2600           else
2601             strcat (buff, "x");
2602           break;
2603         }
2604     }
2605
2606   return buff;
2607 }
2608
2609 static int
2610 process_section_headers (file)
2611      FILE * file;
2612 {
2613   Elf_Internal_Shdr * section;
2614   int                 i;
2615
2616   section_headers = NULL;
2617
2618   if (elf_header.e_shnum == 0)
2619     {
2620       if (do_sections)
2621         printf (_("\nThere are no sections in this file.\n"));
2622
2623       return 1;
2624     }
2625
2626   if (do_sections && !do_header)
2627     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2628             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
2629
2630   if (is_32bit_elf)
2631     {
2632       if (! get_32bit_section_headers (file))
2633         return 0;
2634     }
2635   else if (! get_64bit_section_headers (file))
2636     return 0;
2637
2638   /* Read in the string table, so that we have names to display.  */
2639   section = section_headers + elf_header.e_shstrndx;
2640
2641   if (section->sh_size != 0)
2642     {
2643       unsigned long string_table_offset;
2644
2645       string_table_offset = section->sh_offset;
2646
2647       GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2648                       string_table, char *, "string table");
2649     }
2650
2651   /* Scan the sections for the dynamic symbol table
2652      and dynamic string table and debug sections. */
2653   dynamic_symbols = NULL;
2654   dynamic_strings = NULL;
2655   dynamic_syminfo = NULL;
2656
2657   for (i = 0, section = section_headers;
2658        i < elf_header.e_shnum;
2659        i ++, section ++)
2660     {
2661       char * name = SECTION_NAME (section);
2662
2663       if (section->sh_type == SHT_DYNSYM)
2664         {
2665           if (dynamic_symbols != NULL)
2666             {
2667               error (_("File contains multiple dynamic symbol tables\n"));
2668               continue;
2669             }
2670
2671           num_dynamic_syms = section->sh_size / section->sh_entsize;
2672           dynamic_symbols =
2673             GET_ELF_SYMBOLS (file, section->sh_offset, num_dynamic_syms);
2674         }
2675       else if (section->sh_type == SHT_STRTAB
2676                && strcmp (name, ".dynstr") == 0)
2677         {
2678           if (dynamic_strings != NULL)
2679             {
2680               error (_("File contains multiple dynamic string tables\n"));
2681               continue;
2682             }
2683
2684           GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2685                           dynamic_strings, char *, "dynamic strings");
2686         }
2687       else if ((do_debugging || do_debug_info || do_debug_abbrevs
2688                 || do_debug_lines || do_debug_pubnames || do_debug_aranges)
2689                && strncmp (name, ".debug_", 7) == 0)
2690         {
2691           name += 7;
2692
2693           if (do_debugging
2694               || (do_debug_info     && (strcmp (name, "info") == 0))
2695               || (do_debug_abbrevs  && (strcmp (name, "abbrev") == 0))
2696               || (do_debug_lines    && (strcmp (name, "line") == 0))
2697               || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
2698               || (do_debug_aranges  && (strcmp (name, "aranges") == 0))
2699               )
2700             request_dump (i, DEBUG_DUMP);
2701         }
2702     }
2703
2704   if (! do_sections)
2705     return 1;
2706
2707   printf (_("\nSection Header%s:\n"), elf_header.e_shnum > 1 ? "s" : "");
2708
2709   if (is_32bit_elf)
2710     printf
2711       (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
2712   else
2713     {
2714       printf (_("  [Nr] Name              Type             Address           Offset\n"));
2715       printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
2716     }
2717
2718   for (i = 0, section = section_headers;
2719        i < elf_header.e_shnum;
2720        i ++, section ++)
2721     {
2722       printf ("  [%2d] %-17.17s %-15.15s ",
2723               i,
2724               SECTION_NAME (section),
2725               get_section_type_name (section->sh_type));
2726
2727       if (is_32bit_elf)
2728         {
2729           print_vma (section->sh_addr, LONG_HEX);
2730
2731           printf ( " %6.6lx %6.6lx %2.2lx",
2732                    (unsigned long) section->sh_offset,
2733                    (unsigned long) section->sh_size,
2734                    (unsigned long) section->sh_entsize);
2735
2736           printf (" %3s ", get_elf_section_flags (section->sh_flags));
2737
2738           printf (" %2ld %3lx %ld\n",
2739                   (unsigned long) section->sh_link,
2740                   (unsigned long) section->sh_info,
2741                   (unsigned long) section->sh_addralign);
2742         }
2743       else
2744         {
2745           putchar (' ');
2746           print_vma (section->sh_addr, LONG_HEX);
2747           printf ("  %8.8lx", section->sh_offset);
2748           printf ("\n       ");
2749           print_vma (section->sh_size, LONG_HEX);
2750           printf ("  ");
2751           print_vma (section->sh_entsize, LONG_HEX);
2752
2753           printf (" %3s ", get_elf_section_flags (section->sh_flags));
2754
2755           printf ("     %2ld   %3lx     %ld\n",
2756                   (unsigned long) section->sh_link,
2757                   (unsigned long) section->sh_info,
2758                   (unsigned long) section->sh_addralign);
2759         }
2760     }
2761
2762   printf (_("Key to Flags: W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
2763   printf (_("              I (info), L (link order), O (extra OS processing required)\n"));
2764   printf (_("              o (os specific), p (processor specific) x (unknown)\n"));
2765
2766   return 1;
2767 }
2768
2769 /* Process the reloc section.  */
2770 static int
2771 process_relocs (file)
2772      FILE * file;
2773 {
2774   unsigned long    rel_size;
2775   unsigned long    rel_offset;
2776
2777
2778   if (!do_reloc)
2779     return 1;
2780
2781   if (do_using_dynamic)
2782     {
2783       int is_rela = FALSE;
2784
2785       rel_size   = 0;
2786       rel_offset = 0;
2787
2788       if (dynamic_info[DT_REL])
2789         {
2790           rel_offset = dynamic_info[DT_REL];
2791           rel_size   = dynamic_info[DT_RELSZ];
2792           is_rela    = FALSE;
2793         }
2794       else if (dynamic_info [DT_RELA])
2795         {
2796           rel_offset = dynamic_info[DT_RELA];
2797           rel_size   = dynamic_info[DT_RELASZ];
2798           is_rela    = TRUE;
2799         }
2800       else if (dynamic_info[DT_JMPREL])
2801         {
2802           rel_offset = dynamic_info[DT_JMPREL];
2803           rel_size   = dynamic_info[DT_PLTRELSZ];
2804
2805           switch (dynamic_info[DT_PLTREL])
2806             {
2807             case DT_REL:
2808               is_rela = FALSE;
2809               break;
2810             case DT_RELA:
2811               is_rela = TRUE;
2812               break;
2813             default:
2814               is_rela = UNKNOWN;
2815               break;
2816             }
2817         }
2818
2819       if (rel_size)
2820         {
2821           printf
2822             (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
2823              rel_offset, rel_size);
2824
2825           dump_relocations (file, rel_offset - loadaddr, rel_size,
2826                             dynamic_symbols, num_dynamic_syms, dynamic_strings, is_rela);
2827         }
2828       else
2829         printf (_("\nThere are no dynamic relocations in this file.\n"));
2830     }
2831   else
2832     {
2833       Elf32_Internal_Shdr *     section;
2834       unsigned long             i;
2835       int                       found = 0;
2836
2837       for (i = 0, section = section_headers;
2838            i < elf_header.e_shnum;
2839            i++, section ++)
2840         {
2841           if (   section->sh_type != SHT_RELA
2842               && section->sh_type != SHT_REL)
2843             continue;
2844
2845           rel_offset = section->sh_offset;
2846           rel_size   = section->sh_size;
2847
2848           if (rel_size)
2849             {
2850               Elf32_Internal_Shdr * strsec;
2851               Elf32_Internal_Shdr * symsec;
2852               Elf_Internal_Sym *    symtab;
2853               char *                strtab;
2854               int                   is_rela;
2855               unsigned long         nsyms;
2856
2857               printf (_("\nRelocation section "));
2858
2859               if (string_table == NULL)
2860                 printf ("%d", section->sh_name);
2861               else
2862                 printf ("'%s'", SECTION_NAME (section));
2863
2864               printf (_(" at offset 0x%lx contains %lu entries:\n"),
2865                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
2866
2867               symsec = section_headers + section->sh_link;
2868
2869               nsyms = symsec->sh_size / symsec->sh_entsize;
2870               symtab = GET_ELF_SYMBOLS (file, symsec->sh_offset, nsyms);
2871
2872               if (symtab == NULL)
2873                 continue;
2874
2875               strsec = section_headers + symsec->sh_link;
2876
2877               GET_DATA_ALLOC (strsec->sh_offset, strsec->sh_size, strtab,
2878                               char *, "string table");
2879
2880               is_rela = section->sh_type == SHT_RELA;
2881
2882               dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela);
2883
2884               free (strtab);
2885               free (symtab);
2886
2887               found = 1;
2888             }
2889         }
2890
2891       if (! found)
2892         printf (_("\nThere are no relocations in this file.\n"));
2893     }
2894
2895   return 1;
2896 }
2897
2898
2899 static void
2900 dynamic_segment_mips_val (entry)
2901      Elf_Internal_Dyn * entry;
2902 {
2903   switch (entry->d_tag)
2904     {
2905     case DT_MIPS_FLAGS:
2906       if (entry->d_un.d_val == 0)
2907         printf ("NONE\n");
2908       else
2909         {
2910           static const char * opts[] =
2911           {
2912             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
2913             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
2914             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
2915             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
2916             "RLD_ORDER_SAFE"
2917           };
2918           unsigned int cnt;
2919           int first = 1;
2920           for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
2921             if (entry->d_un.d_val & (1 << cnt))
2922               {
2923                 printf ("%s%s", first ? "" : " ", opts[cnt]);
2924                 first = 0;
2925               }
2926           puts ("");
2927         }
2928       break;
2929
2930     case DT_MIPS_IVERSION:
2931       if (dynamic_strings != NULL)
2932         printf ("Interface Version: %s\n",
2933                 dynamic_strings + entry->d_un.d_val);
2934       else
2935         printf ("%ld\n", (long) entry->d_un.d_ptr);
2936       break;
2937
2938     case DT_MIPS_TIME_STAMP:
2939       {
2940         char timebuf[20];
2941         time_t time = entry->d_un.d_val;
2942         strftime (timebuf, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time));
2943         printf ("Time Stamp: %s\n", timebuf);
2944       }
2945       break;
2946
2947     case DT_MIPS_RLD_VERSION:
2948     case DT_MIPS_LOCAL_GOTNO:
2949     case DT_MIPS_CONFLICTNO:
2950     case DT_MIPS_LIBLISTNO:
2951     case DT_MIPS_SYMTABNO:
2952     case DT_MIPS_UNREFEXTNO:
2953     case DT_MIPS_HIPAGENO:
2954     case DT_MIPS_DELTA_CLASS_NO:
2955     case DT_MIPS_DELTA_INSTANCE_NO:
2956     case DT_MIPS_DELTA_RELOC_NO:
2957     case DT_MIPS_DELTA_SYM_NO:
2958     case DT_MIPS_DELTA_CLASSSYM_NO:
2959     case DT_MIPS_COMPACT_SIZE:
2960       printf ("%ld\n", (long) entry->d_un.d_ptr);
2961       break;
2962
2963     default:
2964       printf ("%#lx\n", (long) entry->d_un.d_ptr);
2965     }
2966 }
2967
2968
2969 static void
2970 dynamic_segment_parisc_val (entry)
2971      Elf_Internal_Dyn * entry;
2972 {
2973   switch (entry->d_tag)
2974     {
2975     case DT_HP_DLD_FLAGS:
2976       {
2977         static struct
2978         {
2979           long int bit;
2980           const char * str;
2981         }
2982         flags[] =
2983         {
2984           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
2985           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
2986           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
2987           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
2988           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
2989           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
2990           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
2991           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
2992           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
2993           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
2994           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
2995         };
2996         int first = 1;
2997         size_t cnt;
2998         bfd_vma val = entry->d_un.d_val;
2999
3000         for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
3001           if (val & flags[cnt].bit)
3002             {
3003               if (! first)
3004                 putchar (' ');
3005               fputs (flags[cnt].str, stdout);
3006               first = 0;
3007               val ^= flags[cnt].bit;
3008             }
3009
3010         if (val != 0 || first)
3011           {
3012             if (! first)
3013               putchar (' ');
3014             print_vma (val, HEX);
3015           }
3016       }
3017       break;
3018
3019     default:
3020       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
3021       break;
3022     }
3023 }
3024
3025 static int
3026 get_32bit_dynamic_segment (file)
3027      FILE * file;
3028 {
3029   Elf32_External_Dyn * edyn;
3030   Elf_Internal_Dyn *   entry;
3031   bfd_size_type        i;
3032
3033   GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3034                   edyn, Elf32_External_Dyn *, "dynamic segment");
3035
3036   /* SGI's ELF has more than one section in the DYNAMIC segment.  Determine
3037      how large this .dynamic is now.  We can do this even before the byte
3038      swapping since the DT_NULL tag is recognizable.  */
3039   dynamic_size = 0;
3040   while (*(Elf32_Word *) edyn [dynamic_size++].d_tag != DT_NULL)
3041     ;
3042
3043   dynamic_segment = (Elf_Internal_Dyn *)
3044     malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3045
3046   if (dynamic_segment == NULL)
3047     {
3048       error (_("Out of memory\n"));
3049       free (edyn);
3050       return 0;
3051     }
3052
3053   for (i = 0, entry = dynamic_segment;
3054        i < dynamic_size;
3055        i ++, entry ++)
3056     {
3057       entry->d_tag      = BYTE_GET (edyn [i].d_tag);
3058       entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
3059     }
3060
3061   free (edyn);
3062
3063   return 1;
3064 }
3065
3066 static int
3067 get_64bit_dynamic_segment (file)
3068      FILE * file;
3069 {
3070   Elf64_External_Dyn * edyn;
3071   Elf_Internal_Dyn *   entry;
3072   bfd_size_type        i;
3073
3074   GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3075                   edyn, Elf64_External_Dyn *, "dynamic segment");
3076
3077   /* SGI's ELF has more than one section in the DYNAMIC segment.  Determine
3078      how large this .dynamic is now.  We can do this even before the byte
3079      swapping since the DT_NULL tag is recognizable.  */
3080   dynamic_size = 0;
3081   while (*(bfd_vma *) edyn [dynamic_size ++].d_tag != DT_NULL)
3082     ;
3083
3084   dynamic_segment = (Elf_Internal_Dyn *)
3085     malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3086
3087   if (dynamic_segment == NULL)
3088     {
3089       error (_("Out of memory\n"));
3090       free (edyn);
3091       return 0;
3092     }
3093
3094   for (i = 0, entry = dynamic_segment;
3095        i < dynamic_size;
3096        i ++, entry ++)
3097     {
3098       entry->d_tag      = BYTE_GET8 (edyn [i].d_tag);
3099       entry->d_un.d_val = BYTE_GET8 (edyn [i].d_un.d_val);
3100     }
3101
3102   free (edyn);
3103
3104   return 1;
3105 }
3106
3107 static const char *
3108 get_dynamic_flags (flags)
3109      bfd_vma flags;
3110 {
3111   static char buff [64];
3112   while (flags)
3113     {
3114       bfd_vma flag;
3115
3116       flag = flags & - flags;
3117       flags &= ~ flag;
3118
3119       switch (flag)
3120         {
3121         case DF_ORIGIN:   strcat (buff, "ORIGIN "); break;
3122         case DF_SYMBOLIC: strcat (buff, "SYMBOLIC "); break;
3123         case DF_TEXTREL:  strcat (buff, "TEXTREL "); break;
3124         case DF_BIND_NOW: strcat (buff, "BIND_NOW "); break;
3125         default:          strcat (buff, "unknown "); break;
3126         }
3127     }
3128   return buff;
3129 }
3130
3131 /* Parse and display the contents of the dynamic segment.  */
3132 static int
3133 process_dynamic_segment (file)
3134      FILE * file;
3135 {
3136   Elf_Internal_Dyn * entry;
3137   bfd_size_type      i;
3138
3139   if (dynamic_size == 0)
3140     {
3141       if (do_dynamic)
3142         printf (_("\nThere is no dynamic segment in this file.\n"));
3143
3144       return 1;
3145     }
3146
3147   if (is_32bit_elf)
3148     {
3149       if (! get_32bit_dynamic_segment (file))
3150         return 0;
3151     }
3152   else if (! get_64bit_dynamic_segment (file))
3153     return 0;
3154
3155   /* Find the appropriate symbol table.  */
3156   if (dynamic_symbols == NULL)
3157     {
3158       for (i = 0, entry = dynamic_segment;
3159            i < dynamic_size;
3160            ++i, ++ entry)
3161         {
3162           unsigned long        offset;
3163
3164           if (entry->d_tag != DT_SYMTAB)
3165             continue;
3166
3167           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
3168
3169           /* Since we do not know how big the symbol table is,
3170              we default to reading in the entire file (!) and
3171              processing that.  This is overkill, I know, but it
3172              should work. */
3173           offset = entry->d_un.d_val - loadaddr;
3174
3175           if (fseek (file, 0, SEEK_END))
3176             error (_("Unable to seek to end of file!"));
3177
3178           if (is_32bit_elf)
3179             num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf32_External_Sym);
3180           else
3181             num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf64_External_Sym);
3182
3183           if (num_dynamic_syms < 1)
3184             {
3185               error (_("Unable to determine the number of symbols to load\n"));
3186               continue;
3187             }
3188
3189           dynamic_symbols = GET_ELF_SYMBOLS (file, offset, num_dynamic_syms);
3190         }
3191     }
3192
3193   /* Similarly find a string table.  */
3194   if (dynamic_strings == NULL)
3195     {
3196       for (i = 0, entry = dynamic_segment;
3197            i < dynamic_size;
3198            ++i, ++ entry)
3199         {
3200           unsigned long offset;
3201           long          str_tab_len;
3202
3203           if (entry->d_tag != DT_STRTAB)
3204             continue;
3205
3206           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
3207
3208           /* Since we do not know how big the string table is,
3209              we default to reading in the entire file (!) and
3210              processing that.  This is overkill, I know, but it
3211              should work. */
3212
3213           offset = entry->d_un.d_val - loadaddr;
3214           if (fseek (file, 0, SEEK_END))
3215             error (_("Unable to seek to end of file\n"));
3216           str_tab_len = ftell (file) - offset;
3217
3218           if (str_tab_len < 1)
3219             {
3220               error
3221                 (_("Unable to determine the length of the dynamic string table\n"));
3222               continue;
3223             }
3224
3225           GET_DATA_ALLOC (offset, str_tab_len, dynamic_strings, char *,
3226                           "dynamic string table");
3227
3228           break;
3229         }
3230     }
3231
3232   /* And find the syminfo section if available.  */
3233   if (dynamic_syminfo == NULL)
3234     {
3235       unsigned int syminsz = 0;
3236
3237       for (i = 0, entry = dynamic_segment;
3238            i < dynamic_size;
3239            ++i, ++ entry)
3240         {
3241           if (entry->d_tag == DT_SYMINENT)
3242             {
3243               /* Note: these braces are necessary to avoid a syntax
3244                  error from the SunOS4 C compiler.  */
3245               assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
3246             }
3247           else if (entry->d_tag == DT_SYMINSZ)
3248             syminsz = entry->d_un.d_val;
3249           else if (entry->d_tag == DT_SYMINFO)
3250             dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
3251         }
3252
3253       if (dynamic_syminfo_offset != 0 && syminsz != 0)
3254         {
3255           Elf_External_Syminfo * extsyminfo;
3256           Elf_Internal_Syminfo * syminfo;
3257
3258           /* There is a syminfo section.  Read the data.  */
3259           GET_DATA_ALLOC (dynamic_syminfo_offset, syminsz, extsyminfo,
3260                           Elf_External_Syminfo *, "symbol information");
3261
3262           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
3263           if (dynamic_syminfo == NULL)
3264             {
3265               error (_("Out of memory\n"));
3266               return 0;
3267             }
3268
3269           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
3270           for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
3271                ++i, ++syminfo)
3272             {
3273               syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
3274               syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
3275             }
3276
3277           free (extsyminfo);
3278         }
3279     }
3280
3281   if (do_dynamic && dynamic_addr)
3282     printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3283             dynamic_addr, (long) dynamic_size);
3284   if (do_dynamic)
3285     printf (_("  Tag        Type                         Name/Value\n"));
3286
3287   for (i = 0, entry = dynamic_segment;
3288        i < dynamic_size;
3289        i++, entry ++)
3290     {
3291       if (do_dynamic)
3292         {
3293           const char * dtype;
3294
3295           putchar (' ');
3296           print_vma (entry->d_tag, FULL_HEX);
3297           dtype = get_dynamic_type (entry->d_tag);
3298           printf (" (%s)%*s", dtype,
3299                   ((is_32bit_elf ? 27 : 19)
3300                    - (int) strlen (dtype)),
3301                   " ");
3302         }
3303
3304       switch (entry->d_tag)
3305         {
3306         case DT_FLAGS:
3307           if (do_dynamic)
3308             printf ("%s", get_dynamic_flags (entry->d_un.d_val));
3309           break;
3310
3311         case DT_AUXILIARY:
3312         case DT_FILTER:
3313           if (do_dynamic)
3314             {
3315               if (entry->d_tag == DT_AUXILIARY)
3316                 printf (_("Auxiliary library"));
3317               else
3318                 printf (_("Filter library"));
3319
3320               if (dynamic_strings)
3321                 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
3322               else
3323                 {
3324                   printf (": ");
3325                   print_vma (entry->d_un.d_val, PREFIX_HEX);
3326                   putchar ('\n');
3327                 }
3328             }
3329           break;
3330
3331         case DT_FEATURE_1:
3332           if (do_dynamic)
3333             {
3334               printf (_("Flags:"));
3335               if (entry->d_un.d_val == 0)
3336                 printf (_(" None\n"));
3337               else
3338                 {
3339                   unsigned long int val = entry->d_un.d_val;
3340                   if (val & DTF_1_PARINIT)
3341                     {
3342                       printf (" PARINIT");
3343                       val ^= DTF_1_PARINIT;
3344                     }
3345                   if (val != 0)
3346                     printf (" %lx", val);
3347                   puts ("");
3348                 }
3349             }
3350           break;
3351
3352         case DT_POSFLAG_1:
3353           if (do_dynamic)
3354             {
3355               printf (_("Flags:"));
3356               if (entry->d_un.d_val == 0)
3357                 printf (_(" None\n"));
3358               else
3359                 {
3360                   unsigned long int val = entry->d_un.d_val;
3361                   if (val & DF_P1_LAZYLOAD)
3362                     {
3363                       printf (" LAZYLOAD");
3364                       val ^= DF_P1_LAZYLOAD;
3365                     }
3366                   if (val & DF_P1_GROUPPERM)
3367                     {
3368                       printf (" GROUPPERM");
3369                       val ^= DF_P1_GROUPPERM;
3370                     }
3371                   if (val != 0)
3372                     printf (" %lx", val);
3373                   puts ("");
3374                 }
3375             }
3376           break;
3377
3378         case DT_FLAGS_1:
3379           if (do_dynamic)
3380             {
3381               printf (_("Flags:"));
3382               if (entry->d_un.d_val == 0)
3383                 printf (_(" None\n"));
3384               else
3385                 {
3386                   unsigned long int val = entry->d_un.d_val;
3387                   if (val & DF_1_NOW)
3388                     {
3389                       printf (" NOW");
3390                       val ^= DF_1_NOW;
3391                     }
3392                   if (val & DF_1_GLOBAL)
3393                     {
3394                       printf (" GLOBAL");
3395                       val ^= DF_1_GLOBAL;
3396                     }
3397                   if (val & DF_1_GROUP)
3398                     {
3399                       printf (" GROUP");
3400                       val ^= DF_1_GROUP;
3401                     }
3402                   if (val & DF_1_NODELETE)
3403                     {
3404                       printf (" NODELETE");
3405                       val ^= DF_1_NODELETE;
3406                     }
3407                   if (val & DF_1_LOADFLTR)
3408                     {
3409                       printf (" LOADFLTR");
3410                       val ^= DF_1_LOADFLTR;
3411                     }
3412                   if (val & DF_1_INITFIRST)
3413                     {
3414                       printf (" INITFIRST");
3415                       val ^= DF_1_INITFIRST;
3416                     }
3417                   if (val & DF_1_NOOPEN)
3418                     {
3419                       printf (" NOOPEN");
3420                       val ^= DF_1_NOOPEN;
3421                     }
3422                   if (val & DF_1_ORIGIN)
3423                     {
3424                       printf (" ORIGIN");
3425                       val ^= DF_1_ORIGIN;
3426                     }
3427                   if (val & DF_1_DIRECT)
3428                     {
3429                       printf (" DIRECT");
3430                       val ^= DF_1_DIRECT;
3431                     }
3432                   if (val & DF_1_TRANS)
3433                     {
3434                       printf (" TRANS");
3435                       val ^= DF_1_TRANS;
3436                     }
3437                   if (val & DF_1_INTERPOSE)
3438                     {
3439                       printf (" INTERPOSE");
3440                       val ^= DF_1_INTERPOSE;
3441                     }
3442                   if (val != 0)
3443                     printf (" %lx", val);
3444                   puts ("");
3445                 }
3446             }
3447           break;
3448
3449         case DT_PLTREL:
3450           if (do_dynamic)
3451             puts (get_dynamic_type (entry->d_un.d_val));
3452           break;
3453
3454         case DT_NULL    :
3455         case DT_NEEDED  :
3456         case DT_PLTGOT  :
3457         case DT_HASH    :
3458         case DT_STRTAB  :
3459         case DT_SYMTAB  :
3460         case DT_RELA    :
3461         case DT_INIT    :
3462         case DT_FINI    :
3463         case DT_SONAME  :
3464         case DT_RPATH   :
3465         case DT_SYMBOLIC:
3466         case DT_REL     :
3467         case DT_DEBUG   :
3468         case DT_TEXTREL :
3469         case DT_JMPREL  :
3470           dynamic_info[entry->d_tag] = entry->d_un.d_val;
3471
3472           if (do_dynamic)
3473             {
3474               char * name;
3475
3476               if (dynamic_strings == NULL)
3477                 name = NULL;
3478               else
3479                 name = dynamic_strings + entry->d_un.d_val;
3480
3481               if (name)
3482                 {
3483                   switch (entry->d_tag)
3484                     {
3485                     case DT_NEEDED:
3486                       printf (_("Shared library: [%s]"), name);
3487
3488                       if (strcmp (name, program_interpreter) == 0)
3489                         printf (_(" program interpreter"));
3490                       break;
3491
3492                     case DT_SONAME:
3493                       printf (_("Library soname: [%s]"), name);
3494                       break;
3495
3496                     case DT_RPATH:
3497                       printf (_("Library rpath: [%s]"), name);
3498                       break;
3499
3500                     default:
3501                       print_vma (entry->d_un.d_val, PREFIX_HEX);
3502                       break;
3503                     }
3504                 }
3505               else
3506                 print_vma (entry->d_un.d_val, PREFIX_HEX);
3507
3508               putchar ('\n');
3509             }
3510           break;
3511
3512         case DT_PLTRELSZ:
3513         case DT_RELASZ  :
3514         case DT_STRSZ   :
3515         case DT_RELSZ   :
3516         case DT_RELAENT :
3517         case DT_SYMENT  :
3518         case DT_RELENT  :
3519         case DT_PLTPADSZ:
3520         case DT_MOVEENT :
3521         case DT_MOVESZ  :
3522         case DT_INIT_ARRAYSZ:
3523         case DT_FINI_ARRAYSZ:
3524           if (do_dynamic)
3525             {
3526               print_vma (entry->d_un.d_val, UNSIGNED);
3527               printf (" (bytes)\n");
3528             }
3529           break;
3530
3531         case DT_VERDEFNUM:
3532         case DT_VERNEEDNUM:
3533         case DT_RELACOUNT:
3534         case DT_RELCOUNT:
3535           if (do_dynamic)
3536             {
3537               print_vma (entry->d_un.d_val, UNSIGNED);
3538               putchar ('\n');
3539             }
3540           break;
3541
3542         case DT_SYMINSZ:
3543         case DT_SYMINENT:
3544         case DT_SYMINFO:
3545         case DT_USED:
3546         case DT_INIT_ARRAY:
3547         case DT_FINI_ARRAY:
3548           if (do_dynamic)
3549             {
3550               if (dynamic_strings != NULL && entry->d_tag == DT_USED)
3551                 {
3552                   char * name;
3553
3554                   name = dynamic_strings + entry->d_un.d_val;
3555
3556                   if (* name)
3557                     {
3558                       printf (_("Not needed object: [%s]\n"), name);
3559                       break;
3560                     }
3561                 }
3562
3563               print_vma (entry->d_un.d_val, PREFIX_HEX);
3564               putchar ('\n');
3565             }
3566           break;
3567
3568         case DT_BIND_NOW:
3569           /* The value of this entry is ignored.  */
3570           break;
3571
3572         default:
3573           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
3574             version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
3575               entry->d_un.d_val;
3576
3577           if (do_dynamic)
3578             {
3579               switch (elf_header.e_machine)
3580                 {
3581                 case EM_MIPS:
3582                 case EM_MIPS_RS4_BE:
3583                   dynamic_segment_mips_val (entry);
3584                   break;
3585                 case EM_PARISC:
3586                   dynamic_segment_parisc_val (entry);
3587                   break;
3588                 default:
3589                   print_vma (entry->d_un.d_val, PREFIX_HEX);
3590                   putchar ('\n');
3591                 }
3592             }
3593           break;
3594         }
3595     }
3596
3597   return 1;
3598 }
3599
3600 static char *
3601 get_ver_flags (flags)
3602      unsigned int flags;
3603 {
3604   static char buff [32];
3605
3606   buff[0] = 0;
3607
3608   if (flags == 0)
3609     return _("none");
3610
3611   if (flags & VER_FLG_BASE)
3612     strcat (buff, "BASE ");
3613
3614   if (flags & VER_FLG_WEAK)
3615     {
3616       if (flags & VER_FLG_BASE)
3617         strcat (buff, "| ");
3618
3619       strcat (buff, "WEAK ");
3620     }
3621
3622   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
3623     strcat (buff, "| <unknown>");
3624
3625   return buff;
3626 }
3627
3628 /* Display the contents of the version sections.  */
3629 static int
3630 process_version_sections (file)
3631      FILE * file;
3632 {
3633   Elf32_Internal_Shdr * section;
3634   unsigned   i;
3635   int        found = 0;
3636
3637   if (! do_version)
3638     return 1;
3639
3640   for (i = 0, section = section_headers;
3641        i < elf_header.e_shnum;
3642        i++, section ++)
3643     {
3644       switch (section->sh_type)
3645         {
3646         case SHT_GNU_verdef:
3647           {
3648             Elf_External_Verdef * edefs;
3649             unsigned int          idx;
3650             unsigned int          cnt;
3651
3652             found = 1;
3653
3654             printf
3655               (_("\nVersion definition section '%s' contains %ld entries:\n"),
3656                SECTION_NAME (section), section->sh_info);
3657
3658             printf (_("  Addr: 0x"));
3659             printf_vma (section->sh_addr);
3660             printf (_("  Offset: %#08lx  Link: %lx (%s)\n"),
3661                     (unsigned long) section->sh_offset, section->sh_link,
3662                     SECTION_NAME (section_headers + section->sh_link));
3663
3664             GET_DATA_ALLOC (section->sh_offset, section->sh_size,
3665                             edefs, Elf_External_Verdef *,
3666                             "version definition section");
3667
3668             for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
3669               {
3670                 char *                 vstart;
3671                 Elf_External_Verdef *  edef;
3672                 Elf_Internal_Verdef    ent;
3673                 Elf_External_Verdaux * eaux;
3674                 Elf_Internal_Verdaux   aux;
3675                 int                    j;
3676                 int                    isum;
3677
3678                 vstart = ((char *) edefs) + idx;
3679
3680                 edef = (Elf_External_Verdef *) vstart;
3681
3682                 ent.vd_version = BYTE_GET (edef->vd_version);
3683                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
3684                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
3685                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
3686                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
3687                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
3688                 ent.vd_next    = BYTE_GET (edef->vd_next);
3689
3690                 printf (_("  %#06x: Rev: %d  Flags: %s"),
3691                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
3692
3693                 printf (_("  Index: %d  Cnt: %d  "),
3694                         ent.vd_ndx, ent.vd_cnt);
3695
3696                 vstart += ent.vd_aux;
3697
3698                 eaux = (Elf_External_Verdaux *) vstart;
3699
3700                 aux.vda_name = BYTE_GET (eaux->vda_name);
3701                 aux.vda_next = BYTE_GET (eaux->vda_next);
3702
3703                 if (dynamic_strings)
3704                   printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
3705                 else
3706                   printf (_("Name index: %ld\n"), aux.vda_name);
3707
3708                 isum = idx + ent.vd_aux;
3709
3710                 for (j = 1; j < ent.vd_cnt; j ++)
3711                   {
3712                     isum   += aux.vda_next;
3713                     vstart += aux.vda_next;
3714
3715                     eaux = (Elf_External_Verdaux *) vstart;
3716
3717                     aux.vda_name = BYTE_GET (eaux->vda_name);
3718                     aux.vda_next = BYTE_GET (eaux->vda_next);
3719
3720                     if (dynamic_strings)
3721                       printf (_("  %#06x: Parent %d: %s\n"),
3722                               isum, j, dynamic_strings + aux.vda_name);
3723                     else
3724                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
3725                               isum, j, aux.vda_name);
3726                   }
3727
3728                 idx += ent.vd_next;
3729               }
3730
3731             free (edefs);
3732           }
3733           break;
3734
3735         case SHT_GNU_verneed:
3736           {
3737             Elf_External_Verneed *  eneed;
3738             unsigned int            idx;
3739             unsigned int            cnt;
3740
3741             found = 1;
3742
3743             printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
3744                     SECTION_NAME (section), section->sh_info);
3745
3746             printf (_(" Addr: 0x"));
3747             printf_vma (section->sh_addr);
3748             printf (_("  Offset: %#08lx  Link to section: %ld (%s)\n"),
3749                     (unsigned long) section->sh_offset, section->sh_link,
3750                     SECTION_NAME (section_headers + section->sh_link));
3751
3752             GET_DATA_ALLOC (section->sh_offset, section->sh_size,
3753                             eneed, Elf_External_Verneed *,
3754                             "version need section");
3755
3756             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
3757               {
3758                 Elf_External_Verneed * entry;
3759                 Elf_Internal_Verneed     ent;
3760                 int                      j;
3761                 int                      isum;
3762                 char *                   vstart;
3763
3764                 vstart = ((char *) eneed) + idx;
3765
3766                 entry = (Elf_External_Verneed *) vstart;
3767
3768                 ent.vn_version = BYTE_GET (entry->vn_version);
3769                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
3770                 ent.vn_file    = BYTE_GET (entry->vn_file);
3771                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
3772                 ent.vn_next    = BYTE_GET (entry->vn_next);
3773
3774                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
3775
3776                 if (dynamic_strings)
3777                   printf (_("  File: %s"), dynamic_strings + ent.vn_file);
3778                 else
3779                   printf (_("  File: %lx"), ent.vn_file);
3780
3781                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
3782
3783                 vstart += ent.vn_aux;
3784
3785                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
3786                   {
3787                     Elf_External_Vernaux * eaux;
3788                     Elf_Internal_Vernaux   aux;
3789
3790                     eaux = (Elf_External_Vernaux *) vstart;
3791
3792                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
3793                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
3794                     aux.vna_other = BYTE_GET (eaux->vna_other);
3795                     aux.vna_name  = BYTE_GET (eaux->vna_name);
3796                     aux.vna_next  = BYTE_GET (eaux->vna_next);
3797
3798                     if (dynamic_strings)
3799                       printf (_("  %#06x: Name: %s"),
3800                               isum, dynamic_strings + aux.vna_name);
3801                     else
3802                       printf (_("  %#06x: Name index: %lx"),
3803                               isum, aux.vna_name);
3804
3805                     printf (_("  Flags: %s  Version: %d\n"),
3806                             get_ver_flags (aux.vna_flags), aux.vna_other);
3807
3808                     isum   += aux.vna_next;
3809                     vstart += aux.vna_next;
3810                   }
3811
3812                 idx += ent.vn_next;
3813               }
3814
3815             free (eneed);
3816           }
3817           break;
3818
3819         case SHT_GNU_versym:
3820           {
3821             Elf32_Internal_Shdr *       link_section;
3822             int                         total;
3823             int                         cnt;
3824             unsigned char *             edata;
3825             unsigned short *            data;
3826             char *                      strtab;
3827             Elf_Internal_Sym *          symbols;
3828             Elf32_Internal_Shdr *       string_sec;
3829
3830             link_section = section_headers + section->sh_link;
3831             total = section->sh_size / section->sh_entsize;
3832
3833             found = 1;
3834
3835             symbols = GET_ELF_SYMBOLS (file, link_section->sh_offset,
3836                                        link_section->sh_size / link_section->sh_entsize);
3837
3838             string_sec = section_headers + link_section->sh_link;
3839
3840             GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
3841                             strtab, char *, "version string table");
3842
3843             printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
3844                     SECTION_NAME (section), total);
3845
3846             printf (_(" Addr: "));
3847             printf_vma (section->sh_addr);
3848             printf (_("  Offset: %#08lx  Link: %lx (%s)\n"),
3849                     (unsigned long) section->sh_offset, section->sh_link,
3850                     SECTION_NAME (link_section));
3851
3852             GET_DATA_ALLOC (version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
3853                             - loadaddr,
3854                             total * sizeof (short), edata,
3855                             unsigned char *, "version symbol data");
3856
3857             data = (unsigned short *) malloc (total * sizeof (short));
3858
3859             for (cnt = total; cnt --;)
3860               data [cnt] = byte_get (edata + cnt * sizeof (short),
3861                                      sizeof (short));
3862
3863             free (edata);
3864
3865             for (cnt = 0; cnt < total; cnt += 4)
3866               {
3867                 int j, nn;
3868                 char * name;
3869
3870                 printf ("  %03x:", cnt);
3871
3872                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
3873                   switch (data [cnt + j])
3874                     {
3875                     case 0:
3876                       fputs (_("   0 (*local*)    "), stdout);
3877                       break;
3878
3879                     case 1:
3880                       fputs (_("   1 (*global*)   "), stdout);
3881                       break;
3882
3883                     default:
3884                       nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
3885                                    data [cnt + j] & 0x8000 ? 'h' : ' ');
3886
3887                       if (symbols [cnt + j].st_shndx < SHN_LORESERVE
3888                           && section_headers[symbols [cnt + j].st_shndx].sh_type
3889                           == SHT_NOBITS)
3890                         {
3891                           /* We must test both.  */
3892                           Elf_Internal_Verneed     ivn;
3893                           unsigned long            offset;
3894
3895                           offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
3896                             - loadaddr;
3897
3898                           do
3899                             {
3900                               Elf_External_Verneed   evn;
3901                               Elf_External_Vernaux   evna;
3902                               Elf_Internal_Vernaux   ivna;
3903                               unsigned long          vna_off;
3904
3905                               GET_DATA (offset, evn, "version need");
3906
3907                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
3908                               ivn.vn_next = BYTE_GET (evn.vn_next);
3909
3910                               vna_off = offset + ivn.vn_aux;
3911
3912                               do
3913                                 {
3914                                   GET_DATA (vna_off, evna,
3915                                             "version need aux (1)");
3916
3917                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
3918                                   ivna.vna_other = BYTE_GET (evna.vna_other);
3919
3920                                   vna_off += ivna.vna_next;
3921                                 }
3922                               while (ivna.vna_other != data [cnt + j]
3923                                      && ivna.vna_next != 0);
3924
3925                               if (ivna.vna_other == data [cnt + j])
3926                                 {
3927                                   ivna.vna_name = BYTE_GET (evna.vna_name);
3928
3929                                   name = strtab + ivna.vna_name;
3930                                   nn += printf ("(%s%-*s",
3931                                                 name,
3932                                                 12 - (int) strlen (name),
3933                                                 ")");
3934                                   break;
3935                                 }
3936                               else if (ivn.vn_next == 0)
3937                                 {
3938                                   if (data [cnt + j] != 0x8001)
3939                                     {
3940                                       Elf_Internal_Verdef  ivd;
3941                                       Elf_External_Verdef  evd;
3942
3943                                       offset = version_info
3944                                         [DT_VERSIONTAGIDX (DT_VERDEF)]
3945                                         - loadaddr;
3946
3947                                       do
3948                                         {
3949                                           GET_DATA (offset, evd,
3950                                                     "version definition");
3951
3952                                           ivd.vd_next = BYTE_GET (evd.vd_next);
3953                                           ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
3954
3955                                           offset += ivd.vd_next;
3956                                         }
3957                                       while (ivd.vd_ndx
3958                                              != (data [cnt + j] & 0x7fff)
3959                                              && ivd.vd_next != 0);
3960
3961                                       if (ivd.vd_ndx
3962                                           == (data [cnt + j] & 0x7fff))
3963                                         {
3964                                           Elf_External_Verdaux  evda;
3965                                           Elf_Internal_Verdaux  ivda;
3966
3967                                           ivd.vd_aux = BYTE_GET (evd.vd_aux);
3968
3969                                           GET_DATA (offset + ivd.vd_aux, evda,
3970                                                     "version definition aux");
3971
3972                                           ivda.vda_name =
3973                                             BYTE_GET (evda.vda_name);
3974
3975                                           name = strtab + ivda.vda_name;
3976                                           nn +=
3977                                             printf ("(%s%-*s",
3978                                                     name,
3979                                                     12 - (int) strlen (name),
3980                                                     ")");
3981                                         }
3982                                     }
3983
3984                                   break;
3985                                 }
3986                               else
3987                                 offset += ivn.vn_next;
3988                             }
3989                           while (ivn.vn_next);
3990                         }
3991                       else if (symbols [cnt + j].st_shndx == SHN_UNDEF)
3992                         {
3993                           Elf_Internal_Verneed     ivn;
3994                           unsigned long            offset;
3995
3996                           offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
3997                             - loadaddr;
3998
3999                           do
4000                             {
4001                               Elf_Internal_Vernaux   ivna;
4002                               Elf_External_Verneed   evn;
4003                               Elf_External_Vernaux   evna;
4004                               unsigned long          a_off;
4005
4006                               GET_DATA (offset, evn, "version need");
4007
4008                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
4009                               ivn.vn_next = BYTE_GET (evn.vn_next);
4010
4011                               a_off = offset + ivn.vn_aux;
4012
4013                               do
4014                                 {
4015                                   GET_DATA (a_off, evna,
4016                                             "version need aux (2)");
4017
4018                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
4019                                   ivna.vna_other = BYTE_GET (evna.vna_other);
4020
4021                                   a_off += ivna.vna_next;
4022                                 }
4023                               while (ivna.vna_other != data [cnt + j]
4024                                      && ivna.vna_next != 0);
4025
4026                               if (ivna.vna_other == data [cnt + j])
4027                                 {
4028                                   ivna.vna_name = BYTE_GET (evna.vna_name);
4029
4030                                   name = strtab + ivna.vna_name;
4031                                   nn += printf ("(%s%-*s",
4032                                                 name,
4033                                                 12 - (int) strlen (name),
4034                                                 ")");
4035                                   break;
4036                                 }
4037
4038                               offset += ivn.vn_next;
4039                             }
4040                           while (ivn.vn_next);
4041                         }
4042                       else if (data [cnt + j] != 0x8001)
4043                         {
4044                           Elf_Internal_Verdef  ivd;
4045                           Elf_External_Verdef  evd;
4046                           unsigned long        offset;
4047
4048                           offset = version_info
4049                             [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
4050
4051                           do
4052                             {
4053                               GET_DATA (offset, evd, "version def");
4054
4055                               ivd.vd_next = BYTE_GET (evd.vd_next);
4056                               ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
4057
4058                               offset += ivd.vd_next;
4059                             }
4060                           while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
4061                                  && ivd.vd_next != 0);
4062
4063                           if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
4064                             {
4065                               Elf_External_Verdaux  evda;
4066                               Elf_Internal_Verdaux  ivda;
4067
4068                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
4069
4070                               GET_DATA (offset - ivd.vd_next + ivd.vd_aux,
4071                                         evda, "version def aux");
4072
4073                               ivda.vda_name = BYTE_GET (evda.vda_name);
4074
4075                               name = strtab + ivda.vda_name;
4076                               nn += printf ("(%s%-*s",
4077                                             name,
4078                                             12 - (int) strlen (name),
4079                                             ")");
4080                             }
4081                         }
4082
4083                       if (nn < 18)
4084                         printf ("%*c", 18 - nn, ' ');
4085                     }
4086
4087                 putchar ('\n');
4088               }
4089
4090             free (data);
4091             free (strtab);
4092             free (symbols);
4093           }
4094           break;
4095
4096         default:
4097           break;
4098         }
4099     }
4100
4101   if (! found)
4102     printf (_("\nNo version information found in this file.\n"));
4103
4104   return 1;
4105 }
4106
4107 static const char *
4108 get_symbol_binding (binding)
4109      unsigned int binding;
4110 {
4111   static char buff [32];
4112
4113   switch (binding)
4114     {
4115     case STB_LOCAL:  return "LOCAL";
4116     case STB_GLOBAL: return "GLOBAL";
4117     case STB_WEAK:   return "WEAK";
4118     default:
4119       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
4120         sprintf (buff, _("<processor specific>: %d"), binding);
4121       else if (binding >= STB_LOOS && binding <= STB_HIOS)
4122         sprintf (buff, _("<OS specific>: %d"), binding);
4123       else
4124         sprintf (buff, _("<unknown>: %d"), binding);
4125       return buff;
4126     }
4127 }
4128
4129 static const char *
4130 get_symbol_type (type)
4131      unsigned int type;
4132 {
4133   static char buff [32];
4134
4135   switch (type)
4136     {
4137     case STT_NOTYPE:   return "NOTYPE";
4138     case STT_OBJECT:   return "OBJECT";
4139     case STT_FUNC:     return "FUNC";
4140     case STT_SECTION:  return "SECTION";
4141     case STT_FILE:     return "FILE";
4142     case STT_COMMON:   return "COMMON";
4143     default:
4144       if (type >= STT_LOPROC && type <= STT_HIPROC)
4145         {
4146           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
4147             return "THUMB_FUNC";
4148
4149           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
4150             return "REGISTER";
4151
4152           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
4153             return "PARISC_MILLI";
4154
4155           sprintf (buff, _("<processor specific>: %d"), type);
4156         }
4157       else if (type >= STT_LOOS && type <= STT_HIOS)
4158         {
4159           if (elf_header.e_machine == EM_PARISC)
4160             {
4161               if (type == STT_HP_OPAQUE)
4162                 return "HP_OPAQUE";
4163               if (type == STT_HP_STUB)
4164                 return "HP_STUB";
4165             }
4166
4167           sprintf (buff, _("<OS specific>: %d"), type);
4168         }
4169       else
4170         sprintf (buff, _("<unknown>: %d"), type);
4171       return buff;
4172     }
4173 }
4174
4175 static const char *
4176 get_symbol_visibility (visibility)
4177      unsigned int visibility;
4178 {
4179   switch (visibility)
4180     {
4181     case STV_DEFAULT:   return "DEFAULT";
4182     case STV_INTERNAL:  return "INTERNAL";
4183     case STV_HIDDEN:    return "HIDDEN";
4184     case STV_PROTECTED: return "PROTECTED";
4185     default: abort ();
4186     }
4187 }
4188
4189 static const char *
4190 get_symbol_index_type (type)
4191      unsigned int type;
4192 {
4193   switch (type)
4194     {
4195     case SHN_UNDEF:  return "UND";
4196     case SHN_ABS:    return "ABS";
4197     case SHN_COMMON: return "COM";
4198     default:
4199       if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4200         return "PRC";
4201       else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
4202         return "RSV";
4203       else if (type >= SHN_LOOS && type <= SHN_HIOS)
4204         return "OS ";
4205       else
4206         {
4207           static char buff [32];
4208
4209           sprintf (buff, "%3d", type);
4210           return buff;
4211         }
4212     }
4213 }
4214
4215 static int *
4216 get_dynamic_data (file, number)
4217      FILE *       file;
4218      unsigned int number;
4219 {
4220   char * e_data;
4221   int *  i_data;
4222
4223   e_data = (char *) malloc (number * 4);
4224
4225   if (e_data == NULL)
4226     {
4227       error (_("Out of memory\n"));
4228       return NULL;
4229     }
4230
4231   if (fread (e_data, 4, number, file) != number)
4232     {
4233       error (_("Unable to read in dynamic data\n"));
4234       return NULL;
4235     }
4236
4237   i_data = (int *) malloc (number * sizeof (* i_data));
4238
4239   if (i_data == NULL)
4240     {
4241       error (_("Out of memory\n"));
4242       free (e_data);
4243       return NULL;
4244     }
4245
4246   while (number--)
4247     i_data [number] = byte_get (e_data + number * 4, 4);
4248
4249   free (e_data);
4250
4251   return i_data;
4252 }
4253
4254 /* Dump the symbol table */
4255 static int
4256 process_symbol_table (file)
4257      FILE * file;
4258 {
4259   Elf32_Internal_Shdr *   section;
4260   char   nb [4];
4261   char   nc [4];
4262   int    nbuckets = 0;
4263   int    nchains = 0;
4264   int *  buckets = NULL;
4265   int *  chains = NULL;
4266
4267   if (! do_syms && !do_histogram)
4268     return 1;
4269
4270   if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
4271                                 || do_histogram))
4272     {
4273       if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
4274         {
4275           error (_("Unable to seek to start of dynamic information"));
4276           return 0;
4277         }
4278
4279       if (fread (nb, sizeof (nb), 1, file) != 1)
4280         {
4281           error (_("Failed to read in number of buckets\n"));
4282           return 0;
4283         }
4284
4285       if (fread (nc, sizeof (nc), 1, file) != 1)
4286         {
4287           error (_("Failed to read in number of chains\n"));
4288           return 0;
4289         }
4290
4291       nbuckets = byte_get (nb, 4);
4292       nchains  = byte_get (nc, 4);
4293
4294       buckets = get_dynamic_data (file, nbuckets);
4295       chains  = get_dynamic_data (file, nchains);
4296
4297       if (buckets == NULL || chains == NULL)
4298         return 0;
4299     }
4300
4301   if (do_syms
4302       && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
4303     {
4304       int    hn;
4305       int    si;
4306
4307       printf (_("\nSymbol table for image:\n"));
4308       if (is_32bit_elf)
4309         printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
4310       else
4311         printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
4312
4313       for (hn = 0; hn < nbuckets; hn++)
4314         {
4315           if (! buckets [hn])
4316             continue;
4317
4318           for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
4319             {
4320               Elf_Internal_Sym * psym;
4321
4322               psym = dynamic_symbols + si;
4323
4324               printf ("  %3d %3d: ", si, hn);
4325               print_vma (psym->st_value, LONG_HEX);
4326               putchar (' ' );
4327               print_vma (psym->st_size, DEC_5);
4328
4329               printf ("  %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4330               printf (" %6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4331               printf (" %3s",  get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4332               printf (" %3.3s", get_symbol_index_type (psym->st_shndx));
4333               printf (" %s\n", dynamic_strings + psym->st_name);
4334             }
4335         }
4336     }
4337   else if (do_syms && !do_using_dynamic)
4338     {
4339       unsigned int     i;
4340
4341       for (i = 0, section = section_headers;
4342            i < elf_header.e_shnum;
4343            i++, section++)
4344         {
4345           unsigned int          si;
4346           char *                strtab;
4347           Elf_Internal_Sym *    symtab;
4348           Elf_Internal_Sym *    psym;
4349
4350
4351           if (   section->sh_type != SHT_SYMTAB
4352               && section->sh_type != SHT_DYNSYM)
4353             continue;
4354
4355           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4356                   SECTION_NAME (section),
4357                   (unsigned long) (section->sh_size / section->sh_entsize));
4358           if (is_32bit_elf)
4359             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
4360           else
4361             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
4362
4363           symtab = GET_ELF_SYMBOLS (file, section->sh_offset,
4364                                     section->sh_size / section->sh_entsize);
4365           if (symtab == NULL)
4366             continue;
4367
4368           if (section->sh_link == elf_header.e_shstrndx)
4369             strtab = string_table;
4370           else
4371             {
4372               Elf32_Internal_Shdr * string_sec;
4373
4374               string_sec = section_headers + section->sh_link;
4375
4376               GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
4377                               strtab, char *, "string table");
4378             }
4379
4380           for (si = 0, psym = symtab;
4381                si < section->sh_size / section->sh_entsize;
4382                si ++, psym ++)
4383             {
4384               printf ("%6d: ", si);
4385               print_vma (psym->st_value, LONG_HEX);
4386               putchar (' ');
4387               print_vma (psym->st_size, DEC_5);
4388               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4389               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4390               printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4391               printf (" %4s", get_symbol_index_type (psym->st_shndx));
4392               printf (" %s", strtab + psym->st_name);
4393
4394               if (section->sh_type == SHT_DYNSYM &&
4395                   version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
4396                 {
4397                   unsigned char   data[2];
4398                   unsigned short  vers_data;
4399                   unsigned long   offset;
4400                   int             is_nobits;
4401                   int             check_def;
4402
4403                   offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
4404                     - loadaddr;
4405
4406                   GET_DATA (offset + si * sizeof (vers_data), data,
4407                             "version data");
4408
4409                   vers_data = byte_get (data, 2);
4410
4411                   is_nobits = psym->st_shndx < SHN_LORESERVE ?
4412                     (section_headers [psym->st_shndx].sh_type == SHT_NOBITS)
4413                     : 0;
4414
4415                   check_def = (psym->st_shndx != SHN_UNDEF);
4416
4417                   if ((vers_data & 0x8000) || vers_data > 1)
4418                     {
4419                       if (is_nobits || ! check_def)
4420                         {
4421                           Elf_External_Verneed  evn;
4422                           Elf_Internal_Verneed  ivn;
4423                           Elf_Internal_Vernaux  ivna;
4424
4425                           /* We must test both.  */
4426                           offset = version_info
4427                             [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
4428
4429                           do
4430                             {
4431                               unsigned long  vna_off;
4432
4433                               GET_DATA (offset, evn, "version need");
4434
4435                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
4436                               ivn.vn_next = BYTE_GET (evn.vn_next);
4437
4438                               vna_off = offset + ivn.vn_aux;
4439
4440                               do
4441                                 {
4442                                   Elf_External_Vernaux  evna;
4443
4444                                   GET_DATA (vna_off, evna,
4445                                             "version need aux (3)");
4446
4447                                   ivna.vna_other = BYTE_GET (evna.vna_other);
4448                                   ivna.vna_next  = BYTE_GET (evna.vna_next);
4449                                   ivna.vna_name  = BYTE_GET (evna.vna_name);
4450
4451                                   vna_off += ivna.vna_next;
4452                                 }
4453                               while (ivna.vna_other != vers_data
4454                                      && ivna.vna_next != 0);
4455
4456                               if (ivna.vna_other == vers_data)
4457                                 break;
4458
4459                               offset += ivn.vn_next;
4460                             }
4461                           while (ivn.vn_next != 0);
4462
4463                           if (ivna.vna_other == vers_data)
4464                             {
4465                               printf ("@%s (%d)",
4466                                       strtab + ivna.vna_name, ivna.vna_other);
4467                               check_def = 0;
4468                             }
4469                           else if (! is_nobits)
4470                             error (_("bad dynamic symbol"));
4471                           else
4472                             check_def = 1;
4473                         }
4474
4475                       if (check_def)
4476                         {
4477                           if (vers_data != 0x8001)
4478                             {
4479                               Elf_Internal_Verdef     ivd;
4480                               Elf_Internal_Verdaux    ivda;
4481                               Elf_External_Verdaux  evda;
4482                               unsigned long           offset;
4483
4484                               offset =
4485                                 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
4486                                 - loadaddr;
4487
4488                               do
4489                                 {
4490                                   Elf_External_Verdef   evd;
4491
4492                                   GET_DATA (offset, evd, "version def");
4493
4494                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
4495                                   ivd.vd_aux  = BYTE_GET (evd.vd_aux);
4496                                   ivd.vd_next = BYTE_GET (evd.vd_next);
4497
4498                                   offset += ivd.vd_next;
4499                                 }
4500                               while (ivd.vd_ndx != (vers_data & 0x7fff)
4501                                      && ivd.vd_next != 0);
4502
4503                               offset -= ivd.vd_next;
4504                               offset += ivd.vd_aux;
4505
4506                               GET_DATA (offset, evda, "version def aux");
4507
4508                               ivda.vda_name = BYTE_GET (evda.vda_name);
4509
4510                               if (psym->st_name != ivda.vda_name)
4511                                 printf ((vers_data & 0x8000)
4512                                         ? "@%s" : "@@%s",
4513                                         strtab + ivda.vda_name);
4514                             }
4515                         }
4516                     }
4517                 }
4518
4519               putchar ('\n');
4520             }
4521
4522           free (symtab);
4523           if (strtab != string_table)
4524             free (strtab);
4525         }
4526     }
4527   else if (do_syms)
4528     printf
4529       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
4530
4531   if (do_histogram && buckets != NULL)
4532     {
4533       int *lengths;
4534       int *counts;
4535       int hn;
4536       int si;
4537       int maxlength = 0;
4538       int nzero_counts = 0;
4539       int nsyms = 0;
4540
4541       printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
4542               nbuckets);
4543       printf (_(" Length  Number     %% of total  Coverage\n"));
4544
4545       lengths = (int *) calloc (nbuckets, sizeof (int));
4546       if (lengths == NULL)
4547         {
4548           error (_("Out of memory"));
4549           return 0;
4550         }
4551       for (hn = 0; hn < nbuckets; ++hn)
4552         {
4553           if (! buckets [hn])
4554             continue;
4555
4556           for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
4557             {
4558               ++ nsyms;
4559               if (maxlength < ++lengths[hn])
4560                 ++ maxlength;
4561             }
4562         }
4563
4564       counts = (int *) calloc (maxlength + 1, sizeof (int));
4565       if (counts == NULL)
4566         {
4567           error (_("Out of memory"));
4568           return 0;
4569         }
4570
4571       for (hn = 0; hn < nbuckets; ++hn)
4572         ++ counts [lengths [hn]];
4573
4574       if (nbuckets > 0)
4575         {
4576           printf ("      0  %-10d (%5.1f%%)\n",
4577                   counts[0], (counts[0] * 100.0) / nbuckets);
4578           for (si = 1; si <= maxlength; ++si)
4579             {
4580               nzero_counts += counts[si] * si;
4581               printf ("%7d  %-10d (%5.1f%%)    %5.1f%%\n",
4582                       si, counts[si], (counts[si] * 100.0) / nbuckets,
4583                       (nzero_counts * 100.0) / nsyms);
4584             }
4585         }
4586
4587       free (counts);
4588       free (lengths);
4589     }
4590
4591   if (buckets != NULL)
4592     {
4593       free (buckets);
4594       free (chains);
4595     }
4596
4597   return 1;
4598 }
4599
4600 static int
4601 process_syminfo (file)
4602      FILE * file ATTRIBUTE_UNUSED;
4603 {
4604   unsigned int i;
4605
4606   if (dynamic_syminfo == NULL
4607       || !do_dynamic)
4608     /* No syminfo, this is ok.  */
4609     return 1;
4610
4611   /* There better should be a dynamic symbol section.  */
4612   if (dynamic_symbols == NULL || dynamic_strings == NULL)
4613     return 0;
4614
4615   if (dynamic_addr)
4616     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
4617             dynamic_syminfo_offset, dynamic_syminfo_nent);
4618
4619   printf (_(" Num: Name                           BoundTo     Flags\n"));
4620   for (i = 0; i < dynamic_syminfo_nent; ++i)
4621     {
4622       unsigned short int flags = dynamic_syminfo[i].si_flags;
4623
4624       printf ("%4d: %-30s ", i,
4625               dynamic_strings + dynamic_symbols[i].st_name);
4626
4627       switch (dynamic_syminfo[i].si_boundto)
4628         {
4629         case SYMINFO_BT_SELF:
4630           fputs ("SELF       ", stdout);
4631           break;
4632         case SYMINFO_BT_PARENT:
4633           fputs ("PARENT     ", stdout);
4634           break;
4635         default:
4636           if (dynamic_syminfo[i].si_boundto > 0
4637               && dynamic_syminfo[i].si_boundto < dynamic_size)
4638             printf ("%-10s ",
4639                     dynamic_strings
4640                     + dynamic_segment[dynamic_syminfo[i].si_boundto].d_un.d_val);
4641           else
4642             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
4643           break;
4644         }
4645
4646       if (flags & SYMINFO_FLG_DIRECT)
4647         printf (" DIRECT");
4648       if (flags & SYMINFO_FLG_PASSTHRU)
4649         printf (" PASSTHRU");
4650       if (flags & SYMINFO_FLG_COPY)
4651         printf (" COPY");
4652       if (flags & SYMINFO_FLG_LAZYLOAD)
4653         printf (" LAZYLOAD");
4654
4655       puts ("");
4656     }
4657
4658   return 1;
4659 }
4660
4661 #ifdef SUPPORT_DISASSEMBLY
4662 static void
4663 disassemble_section (section, file)
4664      Elf32_Internal_Shdr * section;
4665      FILE * file;
4666 {
4667   printf (_("\nAssembly dump of section %s\n"),
4668           SECTION_NAME (section));
4669
4670   /* XXX -- to be done --- XXX */
4671
4672   return 1;
4673 }
4674 #endif
4675
4676 static int
4677 dump_section (section, file)
4678      Elf32_Internal_Shdr * section;
4679      FILE * file;
4680 {
4681   bfd_size_type   bytes;
4682   bfd_vma         addr;
4683   unsigned char * data;
4684   unsigned char * start;
4685
4686   bytes = section->sh_size;
4687
4688   if (bytes == 0)
4689     {
4690       printf (_("\nSection '%s' has no data to dump.\n"),
4691               SECTION_NAME (section));
4692       return 0;
4693     }
4694   else
4695     printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
4696
4697   addr = section->sh_addr;
4698
4699   GET_DATA_ALLOC (section->sh_offset, bytes, start, unsigned char *,
4700                   "section data");
4701
4702   data = start;
4703
4704   while (bytes)
4705     {
4706       int j;
4707       int k;
4708       int lbytes;
4709
4710       lbytes = (bytes > 16 ? 16 : bytes);
4711
4712       printf ("  0x%8.8lx ", (unsigned long) addr);
4713
4714       switch (elf_header.e_ident [EI_DATA])
4715         {
4716         default:
4717         case ELFDATA2LSB:
4718           for (j = 15; j >= 0; j --)
4719             {
4720               if (j < lbytes)
4721                 printf ("%2.2x", data [j]);
4722               else
4723                 printf ("  ");
4724
4725               if (!(j & 0x3))
4726                 printf (" ");
4727             }
4728           break;
4729
4730         case ELFDATA2MSB:
4731           for (j = 0; j < 16; j++)
4732             {
4733               if (j < lbytes)
4734                 printf ("%2.2x", data [j]);
4735               else
4736                 printf ("  ");
4737
4738               if ((j & 3) == 3)
4739                 printf (" ");
4740             }
4741           break;
4742         }
4743
4744       for (j = 0; j < lbytes; j++)
4745         {
4746           k = data [j];
4747           if (k >= ' ' && k < 0x80)
4748             printf ("%c", k);
4749           else
4750             printf (".");
4751         }
4752
4753       putchar ('\n');
4754
4755       data  += lbytes;
4756       addr  += lbytes;
4757       bytes -= lbytes;
4758     }
4759
4760   free (start);
4761
4762   return 1;
4763 }
4764
4765
4766 static unsigned long int
4767 read_leb128 (data, length_return, sign)
4768      unsigned char * data;
4769      int *           length_return;
4770      int             sign;
4771 {
4772   unsigned long int result = 0;
4773   unsigned int      num_read = 0;
4774   int               shift = 0;
4775   unsigned char     byte;
4776
4777   do
4778     {
4779       byte = * data ++;
4780       num_read ++;
4781
4782       result |= (byte & 0x7f) << shift;
4783
4784       shift += 7;
4785
4786     }
4787   while (byte & 0x80);
4788
4789   if (length_return != NULL)
4790     * length_return = num_read;
4791
4792   if (sign && (shift < 32) && (byte & 0x40))
4793     result |= -1 << shift;
4794
4795   return result;
4796 }
4797
4798 typedef struct State_Machine_Registers
4799 {
4800   unsigned long address;
4801   unsigned int  file;
4802   unsigned int  line;
4803   unsigned int  column;
4804   int           is_stmt;
4805   int           basic_block;
4806   int           end_sequence;
4807 /* This variable hold the number of the last entry seen
4808    in the File Table.  */
4809   unsigned int  last_file_entry;
4810 } SMR;
4811
4812 static SMR state_machine_regs;
4813
4814 static void
4815 reset_state_machine (is_stmt)
4816      int is_stmt;
4817 {
4818   state_machine_regs.address = 0;
4819   state_machine_regs.file = 1;
4820   state_machine_regs.line = 1;
4821   state_machine_regs.column = 0;
4822   state_machine_regs.is_stmt = is_stmt;
4823   state_machine_regs.basic_block = 0;
4824   state_machine_regs.end_sequence = 0;
4825   state_machine_regs.last_file_entry = 0;
4826 }
4827
4828 /* Handled an extend line op.  Returns true if this is the end
4829    of sequence.  */
4830 static int
4831 process_extended_line_op (data, is_stmt, pointer_size)
4832      unsigned char * data;
4833      int is_stmt;
4834      int pointer_size;
4835 {
4836   unsigned char   op_code;
4837   int             bytes_read;
4838   unsigned int    len;
4839   unsigned char * name;
4840   unsigned long   adr;
4841
4842   len = read_leb128 (data, & bytes_read, 0);
4843   data += bytes_read;
4844
4845   if (len == 0)
4846     {
4847       warn (_("badly formed extended line op encountered!"));
4848       return bytes_read;
4849     }
4850
4851   len += bytes_read;
4852   op_code = * data ++;
4853
4854   printf (_("  Extended opcode %d: "), op_code);
4855
4856   switch (op_code)
4857     {
4858     case DW_LNE_end_sequence:
4859       printf (_("End of Sequence\n\n"));
4860       reset_state_machine (is_stmt);
4861       break;
4862
4863     case DW_LNE_set_address:
4864       adr = byte_get (data, pointer_size);
4865       printf (_("set Address to 0x%lx\n"), adr);
4866       state_machine_regs.address = adr;
4867       break;
4868
4869     case DW_LNE_define_file:
4870       printf (_("  define new File Table entry\n"));
4871       printf (_("  Entry\tDir\tTime\tSize\tName\n"));
4872
4873       printf (_("   %d\t"), ++ state_machine_regs.last_file_entry);
4874       name = data;
4875       data += strlen (data) + 1;
4876       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4877       data += bytes_read;
4878       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4879       data += bytes_read;
4880       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4881       printf (_("%s\n\n"), name);
4882       break;
4883
4884     default:
4885       printf (_("UNKNOWN: length %d\n"), len - bytes_read);
4886       break;
4887     }
4888
4889   return len;
4890 }
4891
4892 /* Size of pointers in the .debug_line section.  This information is not
4893    really present in that section.  It's obtained before dumping the debug
4894    sections by doing some pre-scan of the .debug_info section.  */
4895 static int debug_line_pointer_size = 4;
4896
4897 static int
4898 display_debug_lines (section, start, file)
4899      Elf32_Internal_Shdr * section;
4900      unsigned char *       start;
4901      FILE *                file ATTRIBUTE_UNUSED;
4902 {
4903   DWARF2_External_LineInfo * external;
4904   DWARF2_Internal_LineInfo   info;
4905   unsigned char *            standard_opcodes;
4906   unsigned char *            data = start;
4907   unsigned char *            end  = start + section->sh_size;
4908   unsigned char *            end_of_sequence;
4909   int                        i;
4910
4911   printf (_("\nDump of debug contents of section %s:\n\n"),
4912           SECTION_NAME (section));
4913
4914   while (data < end)
4915     {
4916       external = (DWARF2_External_LineInfo *) data;
4917
4918       /* Check the length of the block.  */
4919       info.li_length = BYTE_GET (external->li_length);
4920       if (info.li_length > section->sh_size)
4921         {
4922           warn
4923             (_("The line info appears to be corrupt - the section is too small\n"));
4924           return 0;
4925         }
4926
4927       /* Check its version number.  */
4928       info.li_version = BYTE_GET (external->li_version);
4929       if (info.li_version != 2)
4930         {
4931           warn (_("Only DWARF version 2 line info is currently supported.\n"));
4932           return 0;
4933         }
4934
4935       info.li_prologue_length = BYTE_GET (external->li_prologue_length);
4936       info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
4937       info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
4938       info.li_line_base       = BYTE_GET (external->li_line_base);
4939       info.li_line_range      = BYTE_GET (external->li_line_range);
4940       info.li_opcode_base     = BYTE_GET (external->li_opcode_base);
4941
4942       /* Sign extend the line base field.  */
4943       info.li_line_base <<= 24;
4944       info.li_line_base >>= 24;
4945
4946       printf (_("  Length:                      %ld\n"), info.li_length);
4947       printf (_("  DWARF Version:               %d\n"), info.li_version);
4948       printf (_("  Prolgue Length:              %d\n"), info.li_prologue_length);
4949       printf (_("  Minimum Instruction Length:  %d\n"), info.li_min_insn_length);
4950       printf (_("  Initial value of 'is_stmt':  %d\n"), info.li_default_is_stmt);
4951       printf (_("  Line Base:                   %d\n"), info.li_line_base);
4952       printf (_("  Line Range:                  %d\n"), info.li_line_range);
4953       printf (_("  Opcode Base:                 %d\n"), info.li_opcode_base);
4954
4955       end_of_sequence = data + info.li_length + sizeof (info.li_length);
4956
4957       reset_state_machine (info.li_default_is_stmt);
4958
4959       /* Display the contents of the Opcodes table.  */
4960       standard_opcodes = data + sizeof (* external);
4961
4962       printf (_("\n Opcodes:\n"));
4963
4964       for (i = 1; i < info.li_opcode_base; i++)
4965         printf (_("  Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
4966
4967       /* Display the contents of the Directory table.  */
4968       data = standard_opcodes + info.li_opcode_base - 1;
4969
4970       if (* data == 0)
4971         printf (_("\n The Directory Table is empty.\n"));
4972       else
4973         {
4974           printf (_("\n The Directory Table:\n"));
4975
4976           while (* data != 0)
4977             {
4978               printf (_("  %s\n"), data);
4979
4980               data += strlen (data) + 1;
4981             }
4982         }
4983
4984       /* Skip the NUL at the end of the table.  */
4985       data ++;
4986
4987       /* Display the contents of the File Name table.  */
4988       if (* data == 0)
4989         printf (_("\n The File Name Table is empty.\n"));
4990       else
4991         {
4992           printf (_("\n The File Name Table:\n"));
4993           printf (_("  Entry\tDir\tTime\tSize\tName\n"));
4994
4995           while (* data != 0)
4996             {
4997               char * name;
4998               int bytes_read;
4999
5000               printf (_("  %d\t"), ++ state_machine_regs.last_file_entry);
5001               name = data;
5002
5003               data += strlen (data) + 1;
5004
5005               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5006               data += bytes_read;
5007               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5008               data += bytes_read;
5009               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5010               data += bytes_read;
5011               printf (_("%s\n"), name);
5012             }
5013         }
5014
5015       /* Skip the NUL at the end of the table.  */
5016       data ++;
5017
5018       /* Now display the statements.  */
5019       printf (_("\n Line Number Statements:\n"));
5020
5021
5022       while (data < end_of_sequence)
5023         {
5024           unsigned char op_code;
5025           int           adv;
5026           int           bytes_read;
5027
5028           op_code = * data ++;
5029
5030           switch (op_code)
5031             {
5032             case DW_LNS_extended_op:
5033               data += process_extended_line_op (data, info.li_default_is_stmt,
5034                                                 debug_line_pointer_size);
5035               break;
5036
5037             case DW_LNS_copy:
5038               printf (_("  Copy\n"));
5039               break;
5040
5041             case DW_LNS_advance_pc:
5042               adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
5043               data += bytes_read;
5044               state_machine_regs.address += adv;
5045               printf (_("  Advance PC by %d to %lx\n"), adv,
5046                       state_machine_regs.address);
5047               break;
5048
5049             case DW_LNS_advance_line:
5050               adv = read_leb128 (data, & bytes_read, 1);
5051               data += bytes_read;
5052               state_machine_regs.line += adv;
5053               printf (_("  Advance Line by %d to %d\n"), adv,
5054                       state_machine_regs.line);
5055               break;
5056
5057             case DW_LNS_set_file:
5058               adv = read_leb128 (data, & bytes_read, 0);
5059               data += bytes_read;
5060               printf (_("  Set File Name to entry %d in the File Name Table\n"),
5061                       adv);
5062               state_machine_regs.file = adv;
5063               break;
5064
5065             case DW_LNS_set_column:
5066               adv = read_leb128 (data, & bytes_read, 0);
5067               data += bytes_read;
5068               printf (_("  Set column to %d\n"), adv);
5069               state_machine_regs.column = adv;
5070               break;
5071
5072             case DW_LNS_negate_stmt:
5073               adv = state_machine_regs.is_stmt;
5074               adv = ! adv;
5075               printf (_("  Set is_stmt to %d\n"), adv);
5076               state_machine_regs.is_stmt = adv;
5077               break;
5078
5079             case DW_LNS_set_basic_block:
5080               printf (_("  Set basic block\n"));
5081               state_machine_regs.basic_block = 1;
5082               break;
5083
5084             case DW_LNS_const_add_pc:
5085               adv = (((255 - info.li_opcode_base) / info.li_line_range)
5086                      * info.li_min_insn_length);
5087               state_machine_regs.address += adv;
5088               printf (_("  Advance PC by constant %d to 0x%lx\n"), adv,
5089                       state_machine_regs.address);
5090               break;
5091
5092             case DW_LNS_fixed_advance_pc:
5093               adv = byte_get (data, 2);
5094               data += 2;
5095               state_machine_regs.address += adv;
5096               printf (_("  Advance PC by fixed size amount %d to 0x%lx\n"),
5097                       adv, state_machine_regs.address);
5098               break;
5099
5100             default:
5101               op_code -= info.li_opcode_base;
5102               adv      = (op_code / info.li_line_range) * info.li_min_insn_length;
5103               state_machine_regs.address += adv;
5104               printf (_("  Special opcode %d: advance Address by %d to 0x%lx"),
5105                       op_code, adv, state_machine_regs.address);
5106               adv = (op_code % info.li_line_range) + info.li_line_base;
5107               state_machine_regs.line += adv;
5108               printf (_(" and Line by %d to %d\n"),
5109                       adv, state_machine_regs.line);
5110               break;
5111             }
5112         }
5113       printf ("\n");
5114     }
5115
5116   return 1;
5117 }
5118
5119 static int
5120 display_debug_pubnames (section, start, file)
5121      Elf32_Internal_Shdr * section;
5122      unsigned char *       start;
5123      FILE *                file ATTRIBUTE_UNUSED;
5124 {
5125   DWARF2_External_PubNames * external;
5126   DWARF2_Internal_PubNames   pubnames;
5127   unsigned char *            end;
5128
5129   end = start + section->sh_size;
5130
5131   printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5132
5133   while (start < end)
5134     {
5135       unsigned char * data;
5136       unsigned long   offset;
5137
5138       external = (DWARF2_External_PubNames *) start;
5139
5140       pubnames.pn_length  = BYTE_GET (external->pn_length);
5141       pubnames.pn_version = BYTE_GET (external->pn_version);
5142       pubnames.pn_offset  = BYTE_GET (external->pn_offset);
5143       pubnames.pn_size    = BYTE_GET (external->pn_size);
5144
5145       data   = start + sizeof (* external);
5146       start += pubnames.pn_length + sizeof (external->pn_length);
5147
5148       if (pubnames.pn_version != 2)
5149         {
5150           warn (_("Only DWARF 2 pubnames are currently supported"));
5151           continue;
5152         }
5153
5154       printf (_("  Length:                              %ld\n"),
5155               pubnames.pn_length);
5156       printf (_("  Version:                             %d\n"),
5157               pubnames.pn_version);
5158       printf (_("  Offset into .debug_info section:     %ld\n"),
5159               pubnames.pn_offset);
5160       printf (_("  Size of area in .debug_info section: %ld\n"),
5161               pubnames.pn_size);
5162
5163       printf (_("\n    Offset\tName\n"));
5164
5165       do
5166         {
5167           offset = byte_get (data, 4);
5168
5169           if (offset != 0)
5170             {
5171               data += 4;
5172               printf ("    %ld\t\t%s\n", offset, data);
5173               data += strlen (data) + 1;
5174             }
5175         }
5176       while (offset != 0);
5177     }
5178
5179   printf ("\n");
5180   return 1;
5181 }
5182
5183 static char *
5184 get_TAG_name (tag)
5185      unsigned long tag;
5186 {
5187   switch (tag)
5188     {
5189     case DW_TAG_padding: return "DW_TAG_padding";
5190     case DW_TAG_array_type: return "DW_TAG_array_type";
5191     case DW_TAG_class_type: return "DW_TAG_class_type";
5192     case DW_TAG_entry_point: return "DW_TAG_entry_point";
5193     case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
5194     case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
5195     case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
5196     case DW_TAG_label: return "DW_TAG_label";
5197     case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
5198     case DW_TAG_member: return "DW_TAG_member";
5199     case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
5200     case DW_TAG_reference_type: return "DW_TAG_reference_type";
5201     case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
5202     case DW_TAG_string_type: return "DW_TAG_string_type";
5203     case DW_TAG_structure_type: return "DW_TAG_structure_type";
5204     case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
5205     case DW_TAG_typedef: return "DW_TAG_typedef";
5206     case DW_TAG_union_type: return "DW_TAG_union_type";
5207     case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
5208     case DW_TAG_variant: return "DW_TAG_variant";
5209     case DW_TAG_common_block: return "DW_TAG_common_block";
5210     case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
5211     case DW_TAG_inheritance: return "DW_TAG_inheritance";
5212     case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
5213     case DW_TAG_module: return "DW_TAG_module";
5214     case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
5215     case DW_TAG_set_type: return "DW_TAG_set_type";
5216     case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
5217     case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
5218     case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
5219     case DW_TAG_base_type: return "DW_TAG_base_type";
5220     case DW_TAG_catch_block: return "DW_TAG_catch_block";
5221     case DW_TAG_const_type: return "DW_TAG_const_type";
5222     case DW_TAG_constant: return "DW_TAG_constant";
5223     case DW_TAG_enumerator: return "DW_TAG_enumerator";
5224     case DW_TAG_file_type: return "DW_TAG_file_type";
5225     case DW_TAG_friend: return "DW_TAG_friend";
5226     case DW_TAG_namelist: return "DW_TAG_namelist";
5227     case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
5228     case DW_TAG_packed_type: return "DW_TAG_packed_type";
5229     case DW_TAG_subprogram: return "DW_TAG_subprogram";
5230     case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
5231     case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
5232     case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
5233     case DW_TAG_try_block: return "DW_TAG_try_block";
5234     case DW_TAG_variant_part: return "DW_TAG_variant_part";
5235     case DW_TAG_variable: return "DW_TAG_variable";
5236     case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
5237     case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
5238     case DW_TAG_format_label: return "DW_TAG_format_label";
5239     case DW_TAG_function_template: return "DW_TAG_function_template";
5240     case DW_TAG_class_template: return "DW_TAG_class_template";
5241     default:
5242       {
5243         static char buffer [100];
5244
5245         sprintf (buffer, _("Unknown TAG value: %lx"), tag);
5246         return buffer;
5247       }
5248     }
5249 }
5250
5251 static char *
5252 get_AT_name (attribute)
5253      unsigned long attribute;
5254 {
5255   switch (attribute)
5256     {
5257     case DW_AT_sibling: return "DW_AT_sibling";
5258     case DW_AT_location: return "DW_AT_location";
5259     case DW_AT_name: return "DW_AT_name";
5260     case DW_AT_ordering: return "DW_AT_ordering";
5261     case DW_AT_subscr_data: return "DW_AT_subscr_data";
5262     case DW_AT_byte_size: return "DW_AT_byte_size";
5263     case DW_AT_bit_offset: return "DW_AT_bit_offset";
5264     case DW_AT_bit_size: return "DW_AT_bit_size";
5265     case DW_AT_element_list: return "DW_AT_element_list";
5266     case DW_AT_stmt_list: return "DW_AT_stmt_list";
5267     case DW_AT_low_pc: return "DW_AT_low_pc";
5268     case DW_AT_high_pc: return "DW_AT_high_pc";
5269     case DW_AT_language: return "DW_AT_language";
5270     case DW_AT_member: return "DW_AT_member";
5271     case DW_AT_discr: return "DW_AT_discr";
5272     case DW_AT_discr_value: return "DW_AT_discr_value";
5273     case DW_AT_visibility: return "DW_AT_visibility";
5274     case DW_AT_import: return "DW_AT_import";
5275     case DW_AT_string_length: return "DW_AT_string_length";
5276     case DW_AT_common_reference: return "DW_AT_common_reference";
5277     case DW_AT_comp_dir: return "DW_AT_comp_dir";
5278     case DW_AT_const_value: return "DW_AT_const_value";
5279     case DW_AT_containing_type: return "DW_AT_containing_type";
5280     case DW_AT_default_value: return "DW_AT_default_value";
5281     case DW_AT_inline: return "DW_AT_inline";
5282     case DW_AT_is_optional: return "DW_AT_is_optional";
5283     case DW_AT_lower_bound: return "DW_AT_lower_bound";
5284     case DW_AT_producer: return "DW_AT_producer";
5285     case DW_AT_prototyped: return "DW_AT_prototyped";
5286     case DW_AT_return_addr: return "DW_AT_return_addr";
5287     case DW_AT_start_scope: return "DW_AT_start_scope";
5288     case DW_AT_stride_size: return "DW_AT_stride_size";
5289     case DW_AT_upper_bound: return "DW_AT_upper_bound";
5290     case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
5291     case DW_AT_accessibility: return "DW_AT_accessibility";
5292     case DW_AT_address_class: return "DW_AT_address_class";
5293     case DW_AT_artificial: return "DW_AT_artificial";
5294     case DW_AT_base_types: return "DW_AT_base_types";
5295     case DW_AT_calling_convention: return "DW_AT_calling_convention";
5296     case DW_AT_count: return "DW_AT_count";
5297     case DW_AT_data_member_location: return "DW_AT_data_member_location";
5298     case DW_AT_decl_column: return "DW_AT_decl_column";
5299     case DW_AT_decl_file: return "DW_AT_decl_file";
5300     case DW_AT_decl_line: return "DW_AT_decl_line";
5301     case DW_AT_declaration: return "DW_AT_declaration";
5302     case DW_AT_discr_list: return "DW_AT_discr_list";
5303     case DW_AT_encoding: return "DW_AT_encoding";
5304     case DW_AT_external: return "DW_AT_external";
5305     case DW_AT_frame_base: return "DW_AT_frame_base";
5306     case DW_AT_friend: return "DW_AT_friend";
5307     case DW_AT_identifier_case: return "DW_AT_identifier_case";
5308     case DW_AT_macro_info: return "DW_AT_macro_info";
5309     case DW_AT_namelist_items: return "DW_AT_namelist_items";
5310     case DW_AT_priority: return "DW_AT_priority";
5311     case DW_AT_segment: return "DW_AT_segment";
5312     case DW_AT_specification: return "DW_AT_specification";
5313     case DW_AT_static_link: return "DW_AT_static_link";
5314     case DW_AT_type: return "DW_AT_type";
5315     case DW_AT_use_location: return "DW_AT_use_location";
5316     case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
5317     case DW_AT_virtuality: return "DW_AT_virtuality";
5318     case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
5319     case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
5320     case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
5321     case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
5322     case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
5323     case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
5324     case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
5325     case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
5326     case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
5327     case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
5328     case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
5329     case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
5330     case DW_AT_sf_names: return "DW_AT_sf_names";
5331     case DW_AT_src_info: return "DW_AT_src_info";
5332     case DW_AT_mac_info: return "DW_AT_mac_info";
5333     case DW_AT_src_coords: return "DW_AT_src_coords";
5334     case DW_AT_body_begin: return "DW_AT_body_begin";
5335     case DW_AT_body_end: return "DW_AT_body_end";
5336     default:
5337       {
5338         static char buffer [100];
5339
5340         sprintf (buffer, _("Unknown AT value: %lx"), attribute);
5341         return buffer;
5342       }
5343     }
5344 }
5345
5346 static char *
5347 get_FORM_name (form)
5348      unsigned long form;
5349 {
5350   switch (form)
5351     {
5352     case DW_FORM_addr: return "DW_FORM_addr";
5353     case DW_FORM_block2: return "DW_FORM_block2";
5354     case DW_FORM_block4: return "DW_FORM_block4";
5355     case DW_FORM_data2: return "DW_FORM_data2";
5356     case DW_FORM_data4: return "DW_FORM_data4";
5357     case DW_FORM_data8: return "DW_FORM_data8";
5358     case DW_FORM_string: return "DW_FORM_string";
5359     case DW_FORM_block: return "DW_FORM_block";
5360     case DW_FORM_block1: return "DW_FORM_block1";
5361     case DW_FORM_data1: return "DW_FORM_data1";
5362     case DW_FORM_flag: return "DW_FORM_flag";
5363     case DW_FORM_sdata: return "DW_FORM_sdata";
5364     case DW_FORM_strp: return "DW_FORM_strp";
5365     case DW_FORM_udata: return "DW_FORM_udata";
5366     case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
5367     case DW_FORM_ref1: return "DW_FORM_ref1";
5368     case DW_FORM_ref2: return "DW_FORM_ref2";
5369     case DW_FORM_ref4: return "DW_FORM_ref4";
5370     case DW_FORM_ref8: return "DW_FORM_ref8";
5371     case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
5372     case DW_FORM_indirect: return "DW_FORM_indirect";
5373     default:
5374       {
5375         static char buffer [100];
5376
5377         sprintf (buffer, _("Unknown FORM value: %lx"), form);
5378         return buffer;
5379       }
5380     }
5381 }
5382
5383 /* FIXME:  There are better and more effiecint ways to handle
5384    these structures.  For now though, I just want something that
5385    is simple to implement.  */
5386 typedef struct abbrev_attr
5387 {
5388   unsigned long        attribute;
5389   unsigned long        form;
5390   struct abbrev_attr * next;
5391 }
5392 abbrev_attr;
5393
5394 typedef struct abbrev_entry
5395 {
5396   unsigned long          entry;
5397   unsigned long          tag;
5398   int                    children;
5399   struct abbrev_attr *   first_attr;
5400   struct abbrev_attr *   last_attr;
5401   struct abbrev_entry *  next;
5402 }
5403 abbrev_entry;
5404
5405 static abbrev_entry * first_abbrev = NULL;
5406 static abbrev_entry * last_abbrev = NULL;
5407
5408 static void
5409 free_abbrevs PARAMS ((void))
5410 {
5411   abbrev_entry * abbrev;
5412
5413   for (abbrev = first_abbrev; abbrev;)
5414     {
5415       abbrev_entry * next = abbrev->next;
5416       abbrev_attr  * attr;
5417
5418       for (attr = abbrev->first_attr; attr;)
5419         {
5420           abbrev_attr * next = attr->next;
5421
5422           free (attr);
5423           attr = next;
5424         }
5425
5426       free (abbrev);
5427       abbrev = next;
5428     }
5429
5430   last_abbrev = first_abbrev = NULL;
5431 }
5432
5433 static void
5434 add_abbrev (number, tag, children)
5435      unsigned long number;
5436      unsigned long tag;
5437      int           children;
5438 {
5439   abbrev_entry * entry;
5440
5441   entry = (abbrev_entry *) malloc (sizeof (* entry));
5442
5443   if (entry == NULL)
5444     /* ugg */
5445     return;
5446
5447   entry->entry      = number;
5448   entry->tag        = tag;
5449   entry->children   = children;
5450   entry->first_attr = NULL;
5451   entry->last_attr  = NULL;
5452   entry->next       = NULL;
5453
5454   if (first_abbrev == NULL)
5455     first_abbrev = entry;
5456   else
5457     last_abbrev->next = entry;
5458
5459   last_abbrev = entry;
5460 }
5461
5462 static void
5463 add_abbrev_attr (attribute, form)
5464      unsigned long attribute;
5465      unsigned long form;
5466 {
5467   abbrev_attr * attr;
5468
5469   attr = (abbrev_attr *) malloc (sizeof (* attr));
5470
5471   if (attr == NULL)
5472     /* ugg */
5473     return;
5474
5475   attr->attribute = attribute;
5476   attr->form      = form;
5477   attr->next      = NULL;
5478
5479   if (last_abbrev->first_attr == NULL)
5480     last_abbrev->first_attr = attr;
5481   else
5482     last_abbrev->last_attr->next = attr;
5483
5484   last_abbrev->last_attr = attr;
5485 }
5486
5487 /* Processes the (partial) contents of a .debug_abbrev section.
5488    Returns NULL if the end of the section was encountered.
5489    Returns the address after the last byte read if the end of
5490    an abbreviation set was found.  */
5491
5492 static unsigned char *
5493 process_abbrev_section (start, end)
5494      unsigned char * start;
5495      unsigned char * end;
5496 {
5497   if (first_abbrev != NULL)
5498     return NULL;
5499
5500   while (start < end)
5501     {
5502       int           bytes_read;
5503       unsigned long entry;
5504       unsigned long tag;
5505       unsigned long attribute;
5506       int           children;
5507
5508       entry = read_leb128 (start, & bytes_read, 0);
5509       start += bytes_read;
5510
5511       /* A single zero is supposed to end the section according
5512          to the standard.  If there's more, then signal that to
5513          the caller.  */
5514       if (entry == 0)
5515         return start == end ? NULL : start;
5516
5517       tag = read_leb128 (start, & bytes_read, 0);
5518       start += bytes_read;
5519
5520       children = * start ++;
5521
5522       add_abbrev (entry, tag, children);
5523
5524       do
5525         {
5526           unsigned long form;
5527
5528           attribute = read_leb128 (start, & bytes_read, 0);
5529           start += bytes_read;
5530
5531           form = read_leb128 (start, & bytes_read, 0);
5532           start += bytes_read;
5533
5534           if (attribute != 0)
5535             add_abbrev_attr (attribute, form);
5536         }
5537       while (attribute != 0);
5538     }
5539
5540   return NULL;
5541 }
5542
5543
5544 static int
5545 display_debug_abbrev (section, start, file)
5546      Elf32_Internal_Shdr * section;
5547      unsigned char *       start;
5548      FILE *                file ATTRIBUTE_UNUSED;
5549 {
5550   abbrev_entry * entry;
5551   unsigned char * end = start + section->sh_size;
5552
5553   printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5554
5555   do
5556     {
5557       start = process_abbrev_section (start, end);
5558
5559       printf (_("  Number TAG\n"));
5560
5561       for (entry = first_abbrev; entry; entry = entry->next)
5562         {
5563           abbrev_attr * attr;
5564
5565           printf (_("   %ld      %s    [%s]\n"),
5566                   entry->entry,
5567                   get_TAG_name (entry->tag),
5568                   entry->children ? _("has children") : _("no children"));
5569
5570           for (attr = entry->first_attr; attr; attr = attr->next)
5571             {
5572               printf (_("    %-18s %s\n"),
5573                       get_AT_name (attr->attribute),
5574                       get_FORM_name (attr->form));
5575             }
5576         }
5577     }
5578   while (start);
5579
5580   printf ("\n");
5581
5582   return 1;
5583 }
5584
5585
5586 static unsigned char *
5587 display_block (data, length)
5588      unsigned char * data;
5589      unsigned long   length;
5590 {
5591   printf (_(" %lu byte block: "), length);
5592
5593   while (length --)
5594     printf ("%lx ", (unsigned long) byte_get (data ++, 1));
5595
5596   return data;
5597 }
5598
5599 static void
5600 decode_location_expression (data, pointer_size)
5601      unsigned char * data;
5602      unsigned int    pointer_size;
5603 {
5604   unsigned char op;
5605   int           bytes_read;
5606   unsigned long uvalue;
5607
5608   op = * data ++;
5609
5610   switch (op)
5611     {
5612     case DW_OP_addr:
5613       printf ("DW_OP_addr: %lx", (unsigned long) byte_get (data, pointer_size));
5614       break;
5615     case DW_OP_deref:
5616       printf ("DW_OP_deref");
5617       break;
5618     case DW_OP_const1u:
5619       printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data, 1));
5620       break;
5621     case DW_OP_const1s:
5622       printf ("DW_OP_const1s: %ld", (long) byte_get (data, 1));
5623       break;
5624     case DW_OP_const2u:
5625       printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
5626       break;
5627     case DW_OP_const2s:
5628       printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
5629       break;
5630     case DW_OP_const4u:
5631       printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
5632       break;
5633     case DW_OP_const4s:
5634       printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
5635       break;
5636     case DW_OP_const8u:
5637       printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
5638               (unsigned long) byte_get (data + 4, 4));
5639       break;
5640     case DW_OP_const8s:
5641       printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
5642               (long) byte_get (data + 4, 4));
5643       break;
5644     case DW_OP_constu:
5645       printf ("DW_OP_constu: %lu", read_leb128 (data, NULL, 0));
5646       break;
5647     case DW_OP_consts:
5648       printf ("DW_OP_consts: %ld", read_leb128 (data, NULL, 1));
5649       break;
5650     case DW_OP_dup:
5651       printf ("DW_OP_dup");
5652       break;
5653     case DW_OP_drop:
5654       printf ("DW_OP_drop");
5655       break;
5656     case DW_OP_over:
5657       printf ("DW_OP_over");
5658       break;
5659     case DW_OP_pick:
5660       printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data, 1));
5661       break;
5662     case DW_OP_swap:
5663       printf ("DW_OP_swap");
5664       break;
5665     case DW_OP_rot:
5666       printf ("DW_OP_rot");
5667       break;
5668     case DW_OP_xderef:
5669       printf ("DW_OP_xderef");
5670       break;
5671     case DW_OP_abs:
5672       printf ("DW_OP_abs");
5673       break;
5674     case DW_OP_and:
5675       printf ("DW_OP_and");
5676       break;
5677     case DW_OP_div:
5678       printf ("DW_OP_div");
5679       break;
5680     case DW_OP_minus:
5681       printf ("DW_OP_minus");
5682       break;
5683     case DW_OP_mod:
5684       printf ("DW_OP_mod");
5685       break;
5686     case DW_OP_mul:
5687       printf ("DW_OP_mul");
5688       break;
5689     case DW_OP_neg:
5690       printf ("DW_OP_neg");
5691       break;
5692     case DW_OP_not:
5693       printf ("DW_OP_not");
5694       break;
5695     case DW_OP_or:
5696       printf ("DW_OP_or");
5697       break;
5698     case DW_OP_plus:
5699       printf ("DW_OP_plus");
5700       break;
5701     case DW_OP_plus_uconst:
5702       printf ("DW_OP_plus_uconst: %lu", read_leb128 (data, NULL, 0));
5703       break;
5704     case DW_OP_shl:
5705       printf ("DW_OP_shl");
5706       break;
5707     case DW_OP_shr:
5708       printf ("DW_OP_shr");
5709       break;
5710     case DW_OP_shra:
5711       printf ("DW_OP_shra");
5712       break;
5713     case DW_OP_xor:
5714       printf ("DW_OP_xor");
5715       break;
5716     case DW_OP_bra:
5717       printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
5718       break;
5719     case DW_OP_eq:
5720       printf ("DW_OP_eq");
5721       break;
5722     case DW_OP_ge:
5723       printf ("DW_OP_ge");
5724       break;
5725     case DW_OP_gt:
5726       printf ("DW_OP_gt");
5727       break;
5728     case DW_OP_le:
5729       printf ("DW_OP_le");
5730       break;
5731     case DW_OP_lt:
5732       printf ("DW_OP_lt");
5733       break;
5734     case DW_OP_ne:
5735       printf ("DW_OP_ne");
5736       break;
5737     case DW_OP_skip:
5738       printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
5739       break;
5740     case DW_OP_lit0:
5741       printf ("DW_OP_lit0");
5742       break;
5743     case DW_OP_lit1:
5744       printf ("DW_OP_lit1");
5745       break;
5746     case DW_OP_lit2:
5747       printf ("DW_OP_lit2");
5748       break;
5749     case DW_OP_lit3:
5750       printf ("DW_OP_lit3");
5751       break;
5752     case DW_OP_lit4:
5753       printf ("DW_OP_lit4");
5754       break;
5755     case DW_OP_lit5:
5756       printf ("DW_OP_lit5");
5757       break;
5758     case DW_OP_lit6:
5759       printf ("DW_OP_lit6");
5760       break;
5761     case DW_OP_lit7:
5762       printf ("DW_OP_lit7");
5763       break;
5764     case DW_OP_lit8:
5765       printf ("DW_OP_lit8");
5766       break;
5767     case DW_OP_lit9:
5768       printf ("DW_OP_lit9");
5769       break;
5770     case DW_OP_lit10:
5771       printf ("DW_OP_lit10");
5772       break;
5773     case DW_OP_lit11:
5774       printf ("DW_OP_lit11");
5775       break;
5776     case DW_OP_lit12:
5777       printf ("DW_OP_lit12");
5778       break;
5779     case DW_OP_lit13:
5780       printf ("DW_OP_lit13");
5781       break;
5782     case DW_OP_lit14:
5783       printf ("DW_OP_lit14");
5784       break;
5785     case DW_OP_lit15:
5786       printf ("DW_OP_lit15");
5787       break;
5788     case DW_OP_lit16:
5789       printf ("DW_OP_lit16");
5790       break;
5791     case DW_OP_lit17:
5792       printf ("DW_OP_lit17");
5793       break;
5794     case DW_OP_lit18:
5795       printf ("DW_OP_lit18");
5796       break;
5797     case DW_OP_lit19:
5798       printf ("DW_OP_lit19");
5799       break;
5800     case DW_OP_lit20:
5801       printf ("DW_OP_lit20");
5802       break;
5803     case DW_OP_lit21:
5804       printf ("DW_OP_lit21");
5805       break;
5806     case DW_OP_lit22:
5807       printf ("DW_OP_lit22");
5808       break;
5809     case DW_OP_lit23:
5810       printf ("DW_OP_lit23");
5811       break;
5812     case DW_OP_lit24:
5813       printf ("DW_OP_lit24");
5814       break;
5815     case DW_OP_lit25:
5816       printf ("DW_OP_lit25");
5817       break;
5818     case DW_OP_lit26:
5819       printf ("DW_OP_lit26");
5820       break;
5821     case DW_OP_lit27:
5822       printf ("DW_OP_lit27");
5823       break;
5824     case DW_OP_lit28:
5825       printf ("DW_OP_lit28");
5826       break;
5827     case DW_OP_lit29:
5828       printf ("DW_OP_lit29");
5829       break;
5830     case DW_OP_lit30:
5831       printf ("DW_OP_lit30");
5832       break;
5833     case DW_OP_lit31:
5834       printf ("DW_OP_lit31");
5835       break;
5836     case DW_OP_reg0:
5837       printf ("DW_OP_reg0");
5838       break;
5839     case DW_OP_reg1:
5840       printf ("DW_OP_reg1");
5841       break;
5842     case DW_OP_reg2:
5843       printf ("DW_OP_reg2");
5844       break;
5845     case DW_OP_reg3:
5846       printf ("DW_OP_reg3");
5847       break;
5848     case DW_OP_reg4:
5849       printf ("DW_OP_reg4");
5850       break;
5851     case DW_OP_reg5:
5852       printf ("DW_OP_reg5");
5853       break;
5854     case DW_OP_reg6:
5855       printf ("DW_OP_reg6");
5856       break;
5857     case DW_OP_reg7:
5858       printf ("DW_OP_reg7");
5859       break;
5860     case DW_OP_reg8:
5861       printf ("DW_OP_reg8");
5862       break;
5863     case DW_OP_reg9:
5864       printf ("DW_OP_reg9");
5865       break;
5866     case DW_OP_reg10:
5867       printf ("DW_OP_reg10");
5868       break;
5869     case DW_OP_reg11:
5870       printf ("DW_OP_reg11");
5871       break;
5872     case DW_OP_reg12:
5873       printf ("DW_OP_reg12");
5874       break;
5875     case DW_OP_reg13:
5876       printf ("DW_OP_reg13");
5877       break;
5878     case DW_OP_reg14:
5879       printf ("DW_OP_reg14");
5880       break;
5881     case DW_OP_reg15:
5882       printf ("DW_OP_reg15");
5883       break;
5884     case DW_OP_reg16:
5885       printf ("DW_OP_reg16");
5886       break;
5887     case DW_OP_reg17:
5888       printf ("DW_OP_reg17");
5889       break;
5890     case DW_OP_reg18:
5891       printf ("DW_OP_reg18");
5892       break;
5893     case DW_OP_reg19:
5894       printf ("DW_OP_reg19");
5895       break;
5896     case DW_OP_reg20:
5897       printf ("DW_OP_reg20");
5898       break;
5899     case DW_OP_reg21:
5900       printf ("DW_OP_reg21");
5901       break;
5902     case DW_OP_reg22:
5903       printf ("DW_OP_reg22");
5904       break;
5905     case DW_OP_reg23:
5906       printf ("DW_OP_reg23");
5907       break;
5908     case DW_OP_reg24:
5909       printf ("DW_OP_reg24");
5910       break;
5911     case DW_OP_reg25:
5912       printf ("DW_OP_reg25");
5913       break;
5914     case DW_OP_reg26:
5915       printf ("DW_OP_reg26");
5916       break;
5917     case DW_OP_reg27:
5918       printf ("DW_OP_reg27");
5919       break;
5920     case DW_OP_reg28:
5921       printf ("DW_OP_reg28");
5922       break;
5923     case DW_OP_reg29:
5924       printf ("DW_OP_reg29");
5925       break;
5926     case DW_OP_reg30:
5927       printf ("DW_OP_reg30");
5928       break;
5929     case DW_OP_reg31:
5930       printf ("DW_OP_reg31");
5931       break;
5932     case DW_OP_breg0:
5933       printf ("DW_OP_breg0: %ld", read_leb128 (data, NULL, 1));
5934       break;
5935     case DW_OP_breg1:
5936       printf ("DW_OP_breg1: %ld", read_leb128 (data, NULL, 1));
5937       break;
5938     case DW_OP_breg2:
5939       printf ("DW_OP_breg2: %ld", read_leb128 (data, NULL, 1));
5940       break;
5941     case DW_OP_breg3:
5942       printf ("DW_OP_breg3: %ld", read_leb128 (data, NULL, 1));
5943       break;
5944     case DW_OP_breg4:
5945       printf ("DW_OP_breg4: %ld", read_leb128 (data, NULL, 1));
5946       break;
5947     case DW_OP_breg5:
5948       printf ("DW_OP_breg5: %ld", read_leb128 (data, NULL, 1));
5949       break;
5950     case DW_OP_breg6:
5951       printf ("DW_OP_breg6: %ld", read_leb128 (data, NULL, 1));
5952       break;
5953     case DW_OP_breg7:
5954       printf ("DW_OP_breg7: %ld", read_leb128 (data, NULL, 1));
5955       break;
5956     case DW_OP_breg8:
5957       printf ("DW_OP_breg8: %ld", read_leb128 (data, NULL, 1));
5958       break;
5959     case DW_OP_breg9:
5960       printf ("DW_OP_breg9: %ld", read_leb128 (data, NULL, 1));
5961       break;
5962     case DW_OP_breg10:
5963       printf ("DW_OP_breg10: %ld", read_leb128 (data, NULL, 1));
5964       break;
5965     case DW_OP_breg11:
5966       printf ("DW_OP_breg11: %ld", read_leb128 (data, NULL, 1));
5967       break;
5968     case DW_OP_breg12:
5969       printf ("DW_OP_breg12: %ld", read_leb128 (data, NULL, 1));
5970       break;
5971     case DW_OP_breg13:
5972       printf ("DW_OP_breg13: %ld", read_leb128 (data, NULL, 1));
5973       break;
5974     case DW_OP_breg14:
5975       printf ("DW_OP_breg14: %ld", read_leb128 (data, NULL, 1));
5976       break;
5977     case DW_OP_breg15:
5978       printf ("DW_OP_breg15: %ld", read_leb128 (data, NULL, 1));
5979       break;
5980     case DW_OP_breg16:
5981       printf ("DW_OP_breg16: %ld", read_leb128 (data, NULL, 1));
5982       break;
5983     case DW_OP_breg17:
5984       printf ("DW_OP_breg17: %ld", read_leb128 (data, NULL, 1));
5985       break;
5986     case DW_OP_breg18:
5987       printf ("DW_OP_breg18: %ld", read_leb128 (data, NULL, 1));
5988       break;
5989     case DW_OP_breg19:
5990       printf ("DW_OP_breg19: %ld", read_leb128 (data, NULL, 1));
5991       break;
5992     case DW_OP_breg20:
5993       printf ("DW_OP_breg20: %ld", read_leb128 (data, NULL, 1));
5994       break;
5995     case DW_OP_breg21:
5996       printf ("DW_OP_breg21: %ld", read_leb128 (data, NULL, 1));
5997       break;
5998     case DW_OP_breg22:
5999       printf ("DW_OP_breg22: %ld", read_leb128 (data, NULL, 1));
6000       break;
6001     case DW_OP_breg23:
6002       printf ("DW_OP_breg23: %ld", read_leb128 (data, NULL, 1));
6003       break;
6004     case DW_OP_breg24:
6005       printf ("DW_OP_breg24: %ld", read_leb128 (data, NULL, 1));
6006       break;
6007     case DW_OP_breg25:
6008       printf ("DW_OP_breg25: %ld", read_leb128 (data, NULL, 1));
6009       break;
6010     case DW_OP_breg26:
6011       printf ("DW_OP_breg26: %ld", read_leb128 (data, NULL, 1));
6012       break;
6013     case DW_OP_breg27:
6014       printf ("DW_OP_breg27: %ld", read_leb128 (data, NULL, 1));
6015       break;
6016     case DW_OP_breg28:
6017       printf ("DW_OP_breg28: %ld", read_leb128 (data, NULL, 1));
6018       break;
6019     case DW_OP_breg29:
6020       printf ("DW_OP_breg29: %ld", read_leb128 (data, NULL, 1));
6021       break;
6022     case DW_OP_breg30:
6023       printf ("DW_OP_breg30: %ld", read_leb128 (data, NULL, 1));
6024       break;
6025     case DW_OP_breg31:
6026       printf ("DW_OP_breg31: %ld", read_leb128 (data, NULL, 1));
6027       break;
6028     case DW_OP_regx:
6029       printf ("DW_OP_regx: %lu", read_leb128 (data, NULL, 0));
6030       break;
6031     case DW_OP_fbreg:
6032       printf ("DW_OP_fbreg: %ld", read_leb128 (data, NULL, 1));
6033       break;
6034     case DW_OP_bregx:
6035       uvalue = read_leb128 (data, &bytes_read, 0);
6036       printf ("DW_OP_bregx: %lu %ld", uvalue,
6037               read_leb128 (data + bytes_read, NULL, 1));
6038       break;
6039     case DW_OP_piece:
6040       printf ("DW_OP_piece: %lu", read_leb128 (data, NULL, 0));
6041       break;
6042     case DW_OP_deref_size:
6043       printf ("DW_OP_deref_size: %ld", (long) byte_get (data, 1));
6044       break;
6045     case DW_OP_xderef_size:
6046       printf ("DW_OP_xderef_size: %ld", (long) byte_get (data, 1));
6047       break;
6048     case DW_OP_nop:
6049       printf ("DW_OP_nop");
6050       break;
6051
6052     default:
6053       if (op >= DW_OP_lo_user
6054           && op <= DW_OP_hi_user)
6055         printf (_("(User defined location op)"));
6056       else
6057         printf (_("(Unknown location op)"));
6058       break;
6059     }
6060 }
6061
6062
6063 static unsigned char *
6064 read_and_display_attr (attribute, form, data, pointer_size)
6065      unsigned long   attribute;
6066      unsigned long   form;
6067      unsigned char * data;
6068      unsigned long   pointer_size;
6069 {
6070   unsigned long   uvalue = 0;
6071   unsigned char * block_start = NULL;
6072   int             bytes_read;
6073   int             is_ref = 0;
6074
6075   printf ("     %-18s:", get_AT_name (attribute));
6076
6077   switch (form)
6078     {
6079     case DW_FORM_ref_addr:
6080     case DW_FORM_ref1:
6081     case DW_FORM_ref2:
6082     case DW_FORM_ref4:
6083     case DW_FORM_ref8:
6084     case DW_FORM_ref_udata:
6085       is_ref = 1;
6086     }
6087
6088   switch (form)
6089     {
6090     case DW_FORM_ref_addr:
6091     case DW_FORM_addr:
6092       uvalue = byte_get (data, pointer_size);
6093       printf (is_ref ? " <%lx>" : " %#lx", uvalue);
6094       data += pointer_size;
6095       break;
6096
6097     case DW_FORM_ref1:
6098     case DW_FORM_flag:
6099     case DW_FORM_data1:
6100       uvalue = byte_get (data ++, 1);
6101       printf (is_ref ? " <%lx>" : " %ld", uvalue);
6102       break;
6103
6104     case DW_FORM_ref2:
6105     case DW_FORM_data2:
6106       uvalue = byte_get (data, 2);
6107       data += 2;
6108       printf (is_ref ? " <%lx>" : " %ld", uvalue);
6109       break;
6110
6111     case DW_FORM_ref4:
6112     case DW_FORM_data4:
6113       uvalue = byte_get (data, 4);
6114       data += 4;
6115       printf (is_ref ? " <%lx>" : " %ld", uvalue);
6116       break;
6117
6118     case DW_FORM_ref8:
6119     case DW_FORM_data8:
6120       uvalue = byte_get (data, 4);
6121       printf (" %lx", uvalue);
6122       printf (" %lx", (unsigned long) byte_get (data + 4, 4));
6123       data += 8;
6124       break;
6125
6126     case DW_FORM_string:
6127       printf (" %s", data);
6128       data += strlen (data) + 1;
6129       break;
6130
6131     case DW_FORM_sdata:
6132       uvalue = read_leb128 (data, & bytes_read, 1);
6133       data += bytes_read;
6134       printf (" %ld", (long) uvalue);
6135       break;
6136
6137     case DW_FORM_ref_udata:
6138     case DW_FORM_udata:
6139       uvalue = read_leb128 (data, & bytes_read, 0);
6140       data += bytes_read;
6141       printf (is_ref ? " <%lx>" : " %ld", uvalue);
6142       break;
6143
6144     case DW_FORM_block:
6145       uvalue = read_leb128 (data, & bytes_read, 0);
6146       block_start = data + bytes_read;
6147       data = display_block (block_start, uvalue);
6148       uvalue = * block_start;
6149       break;
6150
6151     case DW_FORM_block1:
6152       uvalue = byte_get (data, 1);
6153       block_start = data + 1;
6154       data = display_block (block_start, uvalue);
6155       uvalue = * block_start;
6156       break;
6157
6158     case DW_FORM_block2:
6159       uvalue = byte_get (data, 2);
6160       block_start = data + 2;
6161       data = display_block (block_start, uvalue);
6162       uvalue = * block_start;
6163       break;
6164
6165     case DW_FORM_block4:
6166       uvalue = byte_get (data, 4);
6167       block_start = data + 4;
6168       data = display_block (block_start, uvalue);
6169       uvalue = * block_start;
6170       break;
6171
6172     case DW_FORM_strp:
6173     case DW_FORM_indirect:
6174       warn (_("Unable to handle FORM: %d"), form);
6175       break;
6176
6177     default:
6178       warn (_("Unrecognised form: %d"), form);
6179       break;
6180     }
6181
6182   /* For some attributes we can display futher information.  */
6183
6184   printf ("\t");
6185
6186   switch (attribute)
6187     {
6188     case DW_AT_inline:
6189       switch (uvalue)
6190         {
6191         case DW_INL_not_inlined:          printf (_("(not inlined)")); break;
6192         case DW_INL_inlined:              printf (_("(inlined)")); break;
6193         case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
6194         case DW_INL_declared_inlined:     printf (_("(declared as inline and inlined)")); break;
6195         default: printf (_("  (Unknown inline attribute value: %lx)"), uvalue); break;
6196         }
6197       break;
6198
6199     case DW_AT_frame_base:
6200       if (uvalue >= DW_OP_reg0 && uvalue <= DW_OP_reg31)
6201         printf ("(reg %ld)", uvalue - DW_OP_reg0);
6202       break;
6203
6204     case DW_AT_language:
6205       switch (uvalue)
6206         {
6207         case DW_LANG_C:              printf ("(non-ANSI C)"); break;
6208         case DW_LANG_C89:            printf ("(ANSI C)"); break;
6209         case DW_LANG_C_plus_plus:    printf ("(C++)"); break;
6210         case DW_LANG_Fortran77:      printf ("(FORTRAN 77)"); break;
6211         case DW_LANG_Fortran90:      printf ("(Fortran 90)"); break;
6212         case DW_LANG_Modula2:        printf ("(Modula 2)"); break;
6213         case DW_LANG_Pascal83:       printf ("(ANSI Pascal)"); break;
6214         case DW_LANG_Ada83:          printf ("(Ada)"); break;
6215         case DW_LANG_Cobol74:        printf ("(Cobol 74)"); break;
6216         case DW_LANG_Cobol85:        printf ("(Cobol 85)"); break;
6217         case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
6218         default:                     printf ("(Unknown: %lx)", uvalue); break;
6219         }
6220       break;
6221
6222     case DW_AT_encoding:
6223       switch (uvalue)
6224         {
6225         case DW_ATE_void:            printf ("(void)"); break;
6226         case DW_ATE_address:         printf ("(machine address)"); break;
6227         case DW_ATE_boolean:         printf ("(boolean)"); break;
6228         case DW_ATE_complex_float:   printf ("(complex float)"); break;
6229         case DW_ATE_float:           printf ("(float)"); break;
6230         case DW_ATE_signed:          printf ("(signed)"); break;
6231         case DW_ATE_signed_char:     printf ("(signed char)"); break;
6232         case DW_ATE_unsigned:        printf ("(unsigned)"); break;
6233         case DW_ATE_unsigned_char:   printf ("(unsigned char)"); break;
6234         default:
6235           if (uvalue >= DW_ATE_lo_user
6236               && uvalue <= DW_ATE_hi_user)
6237             printf ("(user defined type)");
6238           else
6239             printf ("(unknown type)");
6240           break;
6241         }
6242       break;
6243
6244     case DW_AT_accessibility:
6245       switch (uvalue)
6246         {
6247         case DW_ACCESS_public:          printf ("(public)"); break;
6248         case DW_ACCESS_protected:       printf ("(protected)"); break;
6249         case DW_ACCESS_private:         printf ("(private)"); break;
6250         default:                        printf ("(unknown accessibility)"); break;
6251         }
6252       break;
6253
6254     case DW_AT_visibility:
6255       switch (uvalue)
6256         {
6257         case DW_VIS_local:      printf ("(local)"); break;
6258         case DW_VIS_exported:   printf ("(exported)"); break;
6259         case DW_VIS_qualified:  printf ("(qualified)"); break;
6260         default:                printf ("(unknown visibility)"); break;
6261         }
6262       break;
6263
6264     case DW_AT_virtuality:
6265       switch (uvalue)
6266         {
6267         case DW_VIRTUALITY_none:        printf ("(none)"); break;
6268         case DW_VIRTUALITY_virtual:     printf ("(virtual)"); break;
6269         case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
6270         default:                        printf ("(unknown virtuality)"); break;
6271         }
6272       break;
6273
6274     case DW_AT_identifier_case:
6275       switch (uvalue)
6276         {
6277         case DW_ID_case_sensitive:      printf ("(case_sensitive)"); break;
6278         case DW_ID_up_case:             printf ("(up_case)"); break;
6279         case DW_ID_down_case:           printf ("(down_case)"); break;
6280         case DW_ID_case_insensitive:    printf ("(case_insensitive)"); break;
6281         default:                        printf ("(unknown case)"); break;
6282         }
6283       break;
6284
6285     case DW_AT_calling_convention:
6286       switch (uvalue)
6287         {
6288         case DW_CC_normal:      printf ("(normal)"); break;
6289         case DW_CC_program:     printf ("(program)"); break;
6290         case DW_CC_nocall:      printf ("(nocall)"); break;
6291         default:
6292           if (uvalue >= DW_CC_lo_user
6293               && uvalue <= DW_CC_hi_user)
6294             printf ("(user defined)");
6295           else
6296             printf ("(unknown convention)");
6297         }
6298       break;
6299
6300     case DW_AT_location:
6301     case DW_AT_data_member_location:
6302     case DW_AT_vtable_elem_location:
6303       printf ("(");
6304       decode_location_expression (block_start, pointer_size);
6305       printf (")");
6306       break;
6307
6308     default:
6309       break;
6310     }
6311
6312   printf ("\n");
6313   return data;
6314 }
6315
6316 static int
6317 display_debug_info (section, start, file)
6318      Elf32_Internal_Shdr * section;
6319      unsigned char *       start;
6320      FILE *                file;
6321 {
6322   unsigned char * end = start + section->sh_size;
6323   unsigned char * section_begin = start;
6324
6325   printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6326
6327   while (start < end)
6328     {
6329       DWARF2_External_CompUnit * external;
6330       DWARF2_Internal_CompUnit   compunit;
6331       unsigned char *            tags;
6332       int                        i;
6333       int                        level;
6334
6335       external = (DWARF2_External_CompUnit *) start;
6336
6337       compunit.cu_length        = BYTE_GET (external->cu_length);
6338       compunit.cu_version       = BYTE_GET (external->cu_version);
6339       compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
6340       compunit.cu_pointer_size  = BYTE_GET (external->cu_pointer_size);
6341
6342       tags = start + sizeof (* external);
6343       start += compunit.cu_length + sizeof (external->cu_length);
6344
6345       if (compunit.cu_version != 2)
6346         {
6347           warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6348           continue;
6349         }
6350
6351       printf (_("  Compilation Unit:\n"));
6352       printf (_("   Length:        %ld\n"), compunit.cu_length);
6353       printf (_("   Version:       %d\n"), compunit.cu_version);
6354       printf (_("   Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
6355       printf (_("   Pointer Size:  %d\n"), compunit.cu_pointer_size);
6356
6357       if (first_abbrev != NULL)
6358         free_abbrevs ();
6359
6360       /* Read in the abbrevs used by this compilation unit.  */
6361
6362       {
6363         Elf32_Internal_Shdr * sec;
6364         unsigned char *       begin;
6365
6366         /* Locate the .debug_abbrev section and process it.  */
6367         for (i = 0, sec = section_headers;
6368              i < elf_header.e_shnum;
6369              i ++, sec ++)
6370           if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
6371             break;
6372
6373         if (i == -1 || sec->sh_size == 0)
6374           {
6375             warn (_("Unable to locate .debug_abbrev section!\n"));
6376             return 0;
6377           }
6378
6379         GET_DATA_ALLOC (sec->sh_offset, sec->sh_size, begin, unsigned char *,
6380                         "debug_abbrev section data");
6381
6382         process_abbrev_section (begin + compunit.cu_abbrev_offset,
6383                                 begin + sec->sh_size);
6384
6385         free (begin);
6386       }
6387
6388       level = 0;
6389       while (tags < start)
6390         {
6391           int            bytes_read;
6392           unsigned long  abbrev_number;
6393           abbrev_entry * entry;
6394           abbrev_attr  * attr;
6395
6396           abbrev_number = read_leb128 (tags, & bytes_read, 0);
6397           tags += bytes_read;
6398
6399           /* A null DIE marks the end of a list of children.  */
6400           if (abbrev_number == 0)
6401             {
6402               --level;
6403               continue;
6404             }
6405
6406           /* Scan through the abbreviation list until we reach the
6407              correct entry.  */
6408           for (entry = first_abbrev;
6409                entry && entry->entry != abbrev_number;
6410                entry = entry->next)
6411             continue;
6412
6413           if (entry == NULL)
6414             {
6415               warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6416                     abbrev_number);
6417               return 0;
6418             }
6419
6420           printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6421                   level, tags - section_begin - bytes_read,
6422                   abbrev_number,
6423                   get_TAG_name (entry->tag));
6424
6425           for (attr = entry->first_attr; attr; attr = attr->next)
6426             tags = read_and_display_attr (attr->attribute,
6427                                           attr->form,
6428                                           tags,
6429                                           compunit.cu_pointer_size);
6430
6431           if (entry->children)
6432             ++level;
6433         }
6434     }
6435
6436   printf ("\n");
6437
6438   return 1;
6439 }
6440
6441 static int
6442 display_debug_aranges (section, start, file)
6443      Elf32_Internal_Shdr * section;
6444      unsigned char *       start;
6445      FILE *                file ATTRIBUTE_UNUSED;
6446 {
6447   unsigned char * end = start + section->sh_size;
6448
6449   printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6450
6451   while (start < end)
6452     {
6453       DWARF2_External_ARange * external;
6454       DWARF2_Internal_ARange   arange;
6455       unsigned char *          ranges;
6456       unsigned long            length;
6457       unsigned long            address;
6458       int                      excess;
6459
6460       external = (DWARF2_External_ARange *) start;
6461
6462       arange.ar_length       = BYTE_GET (external->ar_length);
6463       arange.ar_version      = BYTE_GET (external->ar_version);
6464       arange.ar_info_offset  = BYTE_GET (external->ar_info_offset);
6465       arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
6466       arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
6467
6468       printf (_("  Length:                   %ld\n"), arange.ar_length);
6469       printf (_("  Version:                  %d\n"), arange.ar_version);
6470       printf (_("  Offset into .debug_info:  %lx\n"), arange.ar_info_offset);
6471       printf (_("  Pointer Size:             %d\n"), arange.ar_pointer_size);
6472       printf (_("  Segment Size:             %d\n"), arange.ar_segment_size);
6473
6474       printf (_("\n    Address  Length\n"));
6475
6476       ranges = start + sizeof (* external);
6477
6478       /* Must pad to an alignment boundary that is twice the pointer size.  */
6479       excess = sizeof (*external) % (2 * arange.ar_pointer_size);
6480       if (excess)
6481         ranges += (2 * arange.ar_pointer_size) - excess;
6482
6483       for (;;)
6484         {
6485           address = byte_get (ranges, arange.ar_pointer_size);
6486
6487           ranges += arange.ar_pointer_size;
6488
6489           length  = byte_get (ranges, arange.ar_pointer_size);
6490
6491           ranges += arange.ar_pointer_size;
6492
6493           /* A pair of zeros marks the end of the list.  */
6494           if (address == 0 && length == 0)
6495             break;
6496
6497           printf ("    %8.8lx %lu\n", address, length);
6498         }
6499
6500       start += arange.ar_length + sizeof (external->ar_length);
6501     }
6502
6503   printf ("\n");
6504
6505   return 1;
6506 }
6507
6508
6509 static int
6510 display_debug_not_supported (section, start, file)
6511      Elf32_Internal_Shdr * section;
6512      unsigned char *       start ATTRIBUTE_UNUSED;
6513      FILE *                file ATTRIBUTE_UNUSED;
6514 {
6515   printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6516             SECTION_NAME (section));
6517
6518   return 1;
6519 }
6520
6521 /* Pre-scan the .debug_info section to record the size of address.
6522    When dumping the .debug_line, we use that size information, assuming
6523    that all compilation units have the same address size.  */
6524 static int
6525 prescan_debug_info (section, start, file)
6526      Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
6527      unsigned char *       start;
6528      FILE *                file ATTRIBUTE_UNUSED;
6529 {
6530   DWARF2_External_CompUnit * external;
6531
6532   external = (DWARF2_External_CompUnit *) start;
6533
6534   debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
6535   return 0;
6536 }
6537
6538   /* A structure containing the name of a debug section and a pointer
6539      to a function that can decode it.  The third field is a prescan
6540      function to be run over the section before displaying any of the
6541      sections.  */
6542 struct
6543 {
6544   char * name;
6545   int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
6546   int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
6547 }
6548 debug_displays[] =
6549 {
6550   { ".debug_info",        display_debug_info, prescan_debug_info },
6551   { ".debug_abbrev",      display_debug_abbrev, NULL },
6552   { ".debug_line",        display_debug_lines, NULL },
6553   { ".debug_aranges",     display_debug_aranges, NULL },
6554   { ".debug_pubnames",    display_debug_pubnames, NULL },
6555   { ".debug_macinfo",     display_debug_not_supported, NULL },
6556   { ".debug_frame",       display_debug_not_supported, NULL },
6557   { ".debug_str",         display_debug_not_supported, NULL },
6558   { ".debug_static_func", display_debug_not_supported, NULL },
6559   { ".debug_static_vars", display_debug_not_supported, NULL },
6560   { ".debug_types",       display_debug_not_supported, NULL },
6561   { ".debug_weaknames",   display_debug_not_supported, NULL }
6562 };
6563
6564 static int
6565 display_debug_section (section, file)
6566      Elf32_Internal_Shdr * section;
6567      FILE * file;
6568 {
6569   char *          name = SECTION_NAME (section);
6570   bfd_size_type   length;
6571   unsigned char * start;
6572   int             i;
6573
6574   length = section->sh_size;
6575   if (length == 0)
6576     {
6577       printf (_("\nSection '%s' has no debugging data.\n"), name);
6578       return 0;
6579     }
6580
6581   GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
6582                   "debug section data");
6583
6584   /* See if we know how to display the contents of this section.  */
6585   for (i = NUM_ELEM (debug_displays); i--;)
6586     if (strcmp (debug_displays[i].name, name) == 0)
6587       {
6588         debug_displays[i].display (section, start, file);
6589         break;
6590       }
6591
6592   if (i == -1)
6593     printf (_("Unrecognised debug section: %s\n"), name);
6594
6595   free (start);
6596
6597   /* If we loaded in the abbrev section at some point,
6598      we must release it here.  */
6599   if (first_abbrev != NULL)
6600     free_abbrevs ();
6601
6602   return 1;
6603 }
6604
6605 static int
6606 process_section_contents (file)
6607      FILE * file;
6608 {
6609   Elf32_Internal_Shdr * section;
6610   unsigned int          i;
6611
6612   if (! do_dump)
6613     return 1;
6614
6615   /* Pre-scan the debug sections to find some debug information not
6616      present in some of them.  For the .debug_line, we must find out the
6617      size of address (specified in .debug_info and .debug_aranges).  */
6618   for (i = 0, section = section_headers;
6619        i < elf_header.e_shnum && i < num_dump_sects;
6620        i ++, section ++)
6621     {
6622       char *    name = SECTION_NAME (section);
6623       int       j;
6624
6625       if (section->sh_size == 0)
6626         continue;
6627
6628       /* See if there is some pre-scan operation for this section.  */
6629       for (j = NUM_ELEM (debug_displays); j--;)
6630         if (strcmp (debug_displays[j].name, name) == 0)
6631           {
6632             if (debug_displays[j].prescan != NULL)
6633               {
6634                 bfd_size_type   length;
6635                 unsigned char * start;
6636
6637                 length = section->sh_size;
6638                 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
6639                                 "debug section data");
6640
6641                 debug_displays[j].prescan (section, start, file);
6642                 free (start);
6643               }
6644
6645             break;
6646           }
6647     }
6648
6649   for (i = 0, section = section_headers;
6650        i < elf_header.e_shnum && i < num_dump_sects;
6651        i ++, section ++)
6652     {
6653 #ifdef SUPPORT_DISASSEMBLY
6654       if (dump_sects[i] & DISASS_DUMP)
6655         disassemble_section (section, file);
6656 #endif
6657       if (dump_sects[i] & HEX_DUMP)
6658         dump_section (section, file);
6659
6660       if (dump_sects[i] & DEBUG_DUMP)
6661         display_debug_section (section, file);
6662     }
6663
6664   if (i < num_dump_sects)
6665     warn (_("Some sections were not dumped because they do not exist!\n"));
6666
6667   return 1;
6668 }
6669
6670 static void
6671 process_mips_fpe_exception (mask)
6672      int mask;
6673 {
6674   if (mask)
6675     {
6676       int first = 1;
6677       if (mask & OEX_FPU_INEX)
6678         fputs ("INEX", stdout), first = 0;
6679       if (mask & OEX_FPU_UFLO)
6680         printf ("%sUFLO", first ? "" : "|"), first = 0;
6681       if (mask & OEX_FPU_OFLO)
6682         printf ("%sOFLO", first ? "" : "|"), first = 0;
6683       if (mask & OEX_FPU_DIV0)
6684         printf ("%sDIV0", first ? "" : "|"), first = 0;
6685       if (mask & OEX_FPU_INVAL)
6686         printf ("%sINVAL", first ? "" : "|");
6687     }
6688   else
6689     fputs ("0", stdout);
6690 }
6691
6692 static int
6693 process_mips_specific (file)
6694      FILE * file;
6695 {
6696   Elf_Internal_Dyn * entry;
6697   size_t liblist_offset = 0;
6698   size_t liblistno = 0;
6699   size_t conflictsno = 0;
6700   size_t options_offset = 0;
6701   size_t conflicts_offset = 0;
6702
6703   /* We have a lot of special sections.  Thanks SGI!  */
6704   if (dynamic_segment == NULL)
6705     /* No information available.  */
6706     return 0;
6707
6708   for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
6709     switch (entry->d_tag)
6710       {
6711       case DT_MIPS_LIBLIST:
6712         liblist_offset = entry->d_un.d_val - loadaddr;
6713         break;
6714       case DT_MIPS_LIBLISTNO:
6715         liblistno = entry->d_un.d_val;
6716         break;
6717       case DT_MIPS_OPTIONS:
6718         options_offset = entry->d_un.d_val - loadaddr;
6719         break;
6720       case DT_MIPS_CONFLICT:
6721         conflicts_offset = entry->d_un.d_val - loadaddr;
6722         break;
6723       case DT_MIPS_CONFLICTNO:
6724         conflictsno = entry->d_un.d_val;
6725         break;
6726       default:
6727         break;
6728       }
6729
6730   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
6731     {
6732       Elf32_External_Lib * elib;
6733       size_t cnt;
6734
6735       GET_DATA_ALLOC (liblist_offset, liblistno * sizeof (Elf32_External_Lib),
6736                       elib, Elf32_External_Lib *, "liblist");
6737
6738       printf ("\nSection '.liblist' contains %lu entries:\n",
6739               (unsigned long) liblistno);
6740       fputs ("     Library              Time Stamp          Checksum   Version Flags\n",
6741              stdout);
6742
6743       for (cnt = 0; cnt < liblistno; ++cnt)
6744         {
6745           Elf32_Lib liblist;
6746           time_t time;
6747           char timebuf[20];
6748
6749           liblist.l_name = BYTE_GET (elib[cnt].l_name);
6750           time = BYTE_GET (elib[cnt].l_time_stamp);
6751           liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
6752           liblist.l_version = BYTE_GET (elib[cnt].l_version);
6753           liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
6754
6755           strftime (timebuf, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time));
6756
6757           printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt,
6758                   dynamic_strings + liblist.l_name, timebuf,
6759                   liblist.l_checksum, liblist.l_version);
6760
6761           if (liblist.l_flags == 0)
6762             puts (" NONE");
6763           else
6764             {
6765               static const struct
6766               {
6767                 const char * name;
6768                 int bit;
6769               }
6770               l_flags_vals[] =
6771               {
6772                 { " EXACT_MATCH", LL_EXACT_MATCH },
6773                 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
6774                 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
6775                 { " EXPORTS", LL_EXPORTS },
6776                 { " DELAY_LOAD", LL_DELAY_LOAD },
6777                 { " DELTA", LL_DELTA }
6778               };
6779               int flags = liblist.l_flags;
6780               size_t fcnt;
6781
6782               for (fcnt = 0;
6783                    fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
6784                    ++fcnt)
6785                 if ((flags & l_flags_vals[fcnt].bit) != 0)
6786                   {
6787                     fputs (l_flags_vals[fcnt].name, stdout);
6788                     flags ^= l_flags_vals[fcnt].bit;
6789                   }
6790               if (flags != 0)
6791                 printf (" %#x", (unsigned int) flags);
6792
6793               puts ("");
6794             }
6795         }
6796
6797       free (elib);
6798     }
6799
6800   if (options_offset != 0)
6801     {
6802       Elf_External_Options * eopt;
6803       Elf_Internal_Shdr *    sect = section_headers;
6804       Elf_Internal_Options * iopt;
6805       Elf_Internal_Options * option;
6806       size_t offset;
6807       int cnt;
6808
6809       /* Find the section header so that we get the size.  */
6810       while (sect->sh_type != SHT_MIPS_OPTIONS)
6811         ++ sect;
6812
6813       GET_DATA_ALLOC (options_offset, sect->sh_size, eopt,
6814                       Elf_External_Options *, "options");
6815
6816       iopt = (Elf_Internal_Options *) malloc ((sect->sh_size / sizeof (eopt))
6817                                               * sizeof (*iopt));
6818       if (iopt == NULL)
6819         {
6820           error (_("Out of memory"));
6821           return 0;
6822         }
6823
6824       offset = cnt = 0;
6825       option = iopt;
6826
6827       while (offset < sect->sh_size)
6828         {
6829           Elf_External_Options * eoption;
6830
6831           eoption = (Elf_External_Options *) ((char *) eopt + offset);
6832
6833           option->kind = BYTE_GET (eoption->kind);
6834           option->size = BYTE_GET (eoption->size);
6835           option->section = BYTE_GET (eoption->section);
6836           option->info = BYTE_GET (eoption->info);
6837
6838           offset += option->size;
6839
6840           ++option;
6841           ++cnt;
6842         }
6843
6844       printf (_("\nSection '%s' contains %d entries:\n"),
6845               string_table + sect->sh_name, cnt);
6846
6847       option = iopt;
6848
6849       while (cnt-- > 0)
6850         {
6851           size_t len;
6852
6853           switch (option->kind)
6854             {
6855             case ODK_NULL:
6856               /* This shouldn't happen.  */
6857               printf (" NULL       %d %lx", option->section, option->info);
6858               break;
6859             case ODK_REGINFO:
6860               printf (" REGINFO    ");
6861               if (elf_header.e_machine == EM_MIPS)
6862                 {
6863                   /* 32bit form.  */
6864                   Elf32_External_RegInfo *ereg;
6865                   Elf32_RegInfo reginfo;
6866
6867                   ereg = (Elf32_External_RegInfo *) (option + 1);
6868                   reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
6869                   reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
6870                   reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
6871                   reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
6872                   reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
6873                   reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
6874
6875                   printf ("GPR %08lx  GP 0x%lx\n",
6876                           reginfo.ri_gprmask,
6877                           (unsigned long) reginfo.ri_gp_value);
6878                   printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
6879                           reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
6880                           reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
6881                 }
6882               else
6883                 {
6884                   /* 64 bit form.  */
6885                   Elf64_External_RegInfo * ereg;
6886                   Elf64_Internal_RegInfo reginfo;
6887
6888                   ereg = (Elf64_External_RegInfo *) (option + 1);
6889                   reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
6890                   reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
6891                   reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
6892                   reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
6893                   reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
6894                   reginfo.ri_gp_value   = BYTE_GET8 (ereg->ri_gp_value);
6895
6896                   printf ("GPR %08lx  GP 0x",
6897                           reginfo.ri_gprmask);
6898                   printf_vma (reginfo.ri_gp_value);
6899                   printf ("\n");
6900
6901                   printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
6902                           reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
6903                           reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
6904                 }
6905               ++option;
6906               continue;
6907             case ODK_EXCEPTIONS:
6908               fputs (" EXCEPTIONS fpe_min(", stdout);
6909               process_mips_fpe_exception (option->info & OEX_FPU_MIN);
6910               fputs (") fpe_max(", stdout);
6911               process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
6912               fputs (")", stdout);
6913
6914               if (option->info & OEX_PAGE0)
6915                 fputs (" PAGE0", stdout);
6916               if (option->info & OEX_SMM)
6917                 fputs (" SMM", stdout);
6918               if (option->info & OEX_FPDBUG)
6919                 fputs (" FPDBUG", stdout);
6920               if (option->info & OEX_DISMISS)
6921                 fputs (" DISMISS", stdout);
6922               break;
6923             case ODK_PAD:
6924               fputs (" PAD       ", stdout);
6925               if (option->info & OPAD_PREFIX)
6926                 fputs (" PREFIX", stdout);
6927               if (option->info & OPAD_POSTFIX)
6928                 fputs (" POSTFIX", stdout);
6929               if (option->info & OPAD_SYMBOL)
6930                 fputs (" SYMBOL", stdout);
6931               break;
6932             case ODK_HWPATCH:
6933               fputs (" HWPATCH   ", stdout);
6934               if (option->info & OHW_R4KEOP)
6935                 fputs (" R4KEOP", stdout);
6936               if (option->info & OHW_R8KPFETCH)
6937                 fputs (" R8KPFETCH", stdout);
6938               if (option->info & OHW_R5KEOP)
6939                 fputs (" R5KEOP", stdout);
6940               if (option->info & OHW_R5KCVTL)
6941                 fputs (" R5KCVTL", stdout);
6942               break;
6943             case ODK_FILL:
6944               fputs (" FILL       ", stdout);
6945               /* XXX Print content of info word?  */
6946               break;
6947             case ODK_TAGS:
6948               fputs (" TAGS       ", stdout);
6949               /* XXX Print content of info word?  */
6950               break;
6951             case ODK_HWAND:
6952               fputs (" HWAND     ", stdout);
6953               if (option->info & OHWA0_R4KEOP_CHECKED)
6954                 fputs (" R4KEOP_CHECKED", stdout);
6955               if (option->info & OHWA0_R4KEOP_CLEAN)
6956                 fputs (" R4KEOP_CLEAN", stdout);
6957               break;
6958             case ODK_HWOR:
6959               fputs (" HWOR      ", stdout);
6960               if (option->info & OHWA0_R4KEOP_CHECKED)
6961                 fputs (" R4KEOP_CHECKED", stdout);
6962               if (option->info & OHWA0_R4KEOP_CLEAN)
6963                 fputs (" R4KEOP_CLEAN", stdout);
6964               break;
6965             case ODK_GP_GROUP:
6966               printf (" GP_GROUP  %#06lx  self-contained %#06lx",
6967                       option->info & OGP_GROUP,
6968                       (option->info & OGP_SELF) >> 16);
6969               break;
6970             case ODK_IDENT:
6971               printf (" IDENT     %#06lx  self-contained %#06lx",
6972                       option->info & OGP_GROUP,
6973                       (option->info & OGP_SELF) >> 16);
6974               break;
6975             default:
6976               /* This shouldn't happen.  */
6977               printf (" %3d ???     %d %lx",
6978                       option->kind, option->section, option->info);
6979               break;
6980             }
6981
6982           len = sizeof (*eopt);
6983           while (len < option->size)
6984             if (((char *) option)[len] >= ' '
6985                 && ((char *) option)[len] < 0x7f)
6986               printf ("%c", ((char *) option)[len++]);
6987             else
6988               printf ("\\%03o", ((char *) option)[len++]);
6989
6990           fputs ("\n", stdout);
6991           ++option;
6992         }
6993
6994       free (eopt);
6995     }
6996
6997   if (conflicts_offset != 0 && conflictsno != 0)
6998     {
6999       Elf32_External_Conflict * econf32;
7000       Elf64_External_Conflict * econf64;
7001       Elf32_Conflict * iconf;
7002       size_t cnt;
7003
7004       if (dynamic_symbols == NULL)
7005         {
7006           error (_("conflict list with without table"));
7007           return 0;
7008         }
7009
7010       iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (*iconf));
7011       if (iconf == NULL)
7012         {
7013           error (_("Out of memory"));
7014           return 0;
7015         }
7016
7017       if (is_32bit_elf)
7018         {
7019           GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (*econf32),
7020                           econf32, Elf32_External_Conflict *, "conflict");
7021
7022           for (cnt = 0; cnt < conflictsno; ++cnt)
7023             iconf[cnt] = BYTE_GET (econf32[cnt]);
7024         }
7025       else
7026         {
7027           GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (*econf64),
7028                           econf64, Elf64_External_Conflict *, "conflict");
7029
7030           for (cnt = 0; cnt < conflictsno; ++cnt)
7031             iconf[cnt] = BYTE_GET (econf64[cnt]);
7032         }
7033
7034       printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno);
7035       puts (_("  Num:    Index       Value  Name"));
7036
7037       for (cnt = 0; cnt < conflictsno; ++cnt)
7038         {
7039           Elf_Internal_Sym * psym = &dynamic_symbols[iconf[cnt]];
7040
7041           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
7042           print_vma (psym->st_value, FULL_HEX);
7043           printf ("  %s\n", dynamic_strings + psym->st_name);
7044         }
7045
7046       free (iconf);
7047     }
7048
7049   return 1;
7050 }
7051
7052 static char *
7053 get_note_type (e_type)
7054      unsigned e_type;
7055 {
7056   static char buff[64];
7057
7058   switch (e_type)
7059     {
7060     case NT_PRSTATUS:   return _("NT_PRSTATUS (prstatus structure)");
7061     case NT_FPREGSET:   return _("NT_FPREGSET (floating point registers)");
7062     case NT_PRPSINFO:   return _("NT_PRPSINFO (prpsinfo structure)");
7063     case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
7064     case NT_PRXFPREG:   return _("NT_PRXFPREG (user_xfpregs structure)");
7065     case NT_PSTATUS:    return _("NT_PSTATUS (pstatus structure)");
7066     case NT_FPREGS:     return _("NT_FPREGS (floating point registers)");
7067     case NT_PSINFO:     return _("NT_PSINFO (psinfo structure)");
7068     case NT_LWPSTATUS:  return _("NT_LWPSTATUS (lwpstatus_t structure)");
7069     case NT_LWPSINFO:   return _("NT_LWPSINFO (lwpsinfo_t structure)");
7070     case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
7071     default:
7072       sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
7073       return buff;
7074     }
7075 }
7076
7077 /* Note that by the ELF standard, the name field is already null byte
7078    terminated, and namesz includes the terminating null byte.
7079    I.E. the value of namesz for the name "FSF" is 4.
7080
7081    If the value of namesz is zero, there is no name present. */
7082 static int
7083 process_note (pnote)
7084   Elf32_Internal_Note * pnote;
7085 {
7086   printf ("  %s\t\t0x%08lx\t%s\n",
7087           pnote->namesz ? pnote->namedata : "(NONE)",
7088           pnote->descsz, get_note_type (pnote->type));
7089   return 1;
7090 }
7091
7092
7093 static int
7094 process_corefile_note_segment (file, offset, length)
7095      FILE * file;
7096      bfd_vma offset;
7097      bfd_vma length;
7098 {
7099   Elf_External_Note *  pnotes;
7100   Elf_External_Note *  external;
7101   int                  res = 1;
7102
7103   if (length <= 0)
7104     return 0;
7105
7106   GET_DATA_ALLOC (offset, length, pnotes, Elf_External_Note *, "notes");
7107
7108   external = pnotes;
7109
7110   printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
7111           (unsigned long) offset, (unsigned long) length);
7112   printf (_("  Owner\t\tData size\tDescription\n"));
7113
7114   while (external < (Elf_External_Note *)((char *) pnotes + length))
7115     {
7116       Elf32_Internal_Note inote;
7117       char * temp = NULL;
7118
7119       inote.type     = BYTE_GET (external->type);
7120       inote.namesz   = BYTE_GET (external->namesz);
7121       inote.namedata = external->name;
7122       inote.descsz   = BYTE_GET (external->descsz);
7123       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
7124       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
7125
7126       external = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
7127
7128       /* Verify that name is null terminated.  It appears that at least
7129          one version of Linux (RedHat 6.0) generates corefiles that don't
7130          comply with the ELF spec by failing to include the null byte in
7131          namesz.  */
7132       if (inote.namedata[inote.namesz] != '\0')
7133         {
7134           temp = malloc (inote.namesz + 1);
7135
7136           if (temp == NULL)
7137             {
7138               error (_("Out of memory\n"));
7139               res = 0;
7140               break;
7141             }
7142
7143           strncpy (temp, inote.namedata, inote.namesz);
7144           temp[inote.namesz] = 0;
7145
7146           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
7147           inote.namedata = temp;
7148         }
7149
7150       res &= process_note (& inote);
7151
7152       if (temp != NULL)
7153         {
7154           free (temp);
7155           temp = NULL;
7156         }
7157     }
7158
7159   free (pnotes);
7160
7161   return res;
7162 }
7163
7164 static int
7165 process_corefile_note_segments (file)
7166      FILE * file;
7167 {
7168   Elf_Internal_Phdr * program_headers;
7169   Elf_Internal_Phdr * segment;
7170   unsigned int        i;
7171   int                 res = 1;
7172
7173   program_headers = (Elf_Internal_Phdr *) malloc
7174     (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
7175
7176   if (program_headers == NULL)
7177     {
7178       error (_("Out of memory\n"));
7179       return 0;
7180     }
7181
7182   if (is_32bit_elf)
7183     i = get_32bit_program_headers (file, program_headers);
7184   else
7185     i = get_64bit_program_headers (file, program_headers);
7186
7187   if (i == 0)
7188     {
7189       free (program_headers);
7190       return 0;
7191     }
7192
7193   for (i = 0, segment = program_headers;
7194        i < elf_header.e_phnum;
7195        i ++, segment ++)
7196     {
7197       if (segment->p_type == PT_NOTE)
7198         res &= process_corefile_note_segment (file,
7199                                               (bfd_vma) segment->p_offset,
7200                                               (bfd_vma) segment->p_filesz);
7201     }
7202
7203   free (program_headers);
7204
7205   return res;
7206 }
7207
7208 static int
7209 process_corefile_contents (file)
7210      FILE * file;
7211 {
7212   /* If we have not been asked to display the notes then do nothing.  */
7213   if (! do_notes)
7214     return 1;
7215
7216   /* If file is not a core file then exit.  */
7217   if (elf_header.e_type != ET_CORE)
7218     return 1;
7219
7220   /* No program headers means no NOTE segment.  */
7221   if (elf_header.e_phnum == 0)
7222     {
7223       printf (_("No note segments present in the core file.\n"));
7224       return 1;
7225    }
7226
7227   return process_corefile_note_segments (file);
7228 }
7229
7230 static int
7231 process_arch_specific (file)
7232      FILE * file;
7233 {
7234   if (! do_arch)
7235     return 1;
7236
7237   switch (elf_header.e_machine)
7238     {
7239     case EM_MIPS:
7240     case EM_MIPS_RS4_BE:
7241       return process_mips_specific (file);
7242       break;
7243     default:
7244       break;
7245     }
7246   return 1;
7247 }
7248
7249 static int
7250 get_file_header (file)
7251      FILE * file;
7252 {
7253   /* Read in the identity array.  */
7254   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
7255     return 0;
7256
7257   /* Determine how to read the rest of the header.  */
7258   switch (elf_header.e_ident [EI_DATA])
7259     {
7260     default: /* fall through */
7261     case ELFDATANONE: /* fall through */
7262     case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
7263     case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
7264     }
7265
7266   /* For now we only support 32 bit and 64 bit ELF files.  */
7267   is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
7268
7269   /* Read in the rest of the header.  */
7270   if (is_32bit_elf)
7271     {
7272       Elf32_External_Ehdr ehdr32;
7273
7274       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
7275         return 0;
7276
7277       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
7278       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
7279       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
7280       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
7281       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
7282       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
7283       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
7284       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
7285       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
7286       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
7287       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
7288       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
7289       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
7290     }
7291   else
7292     {
7293       Elf64_External_Ehdr ehdr64;
7294
7295       /* If we have been compiled with sizeof (bfd_vma) == 4, then
7296          we will not be able to cope with the 64bit data found in
7297          64 ELF files.  Detect this now and abort before we start
7298          overwritting things.  */
7299       if (sizeof (bfd_vma) < 8)
7300         {
7301           error (_("This instance of readelf has been built without support for a\n"));
7302           error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
7303           return 0;
7304         }
7305
7306       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
7307         return 0;
7308
7309       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
7310       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
7311       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
7312       elf_header.e_entry     = BYTE_GET8 (ehdr64.e_entry);
7313       elf_header.e_phoff     = BYTE_GET8 (ehdr64.e_phoff);
7314       elf_header.e_shoff     = BYTE_GET8 (ehdr64.e_shoff);
7315       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
7316       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
7317       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
7318       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
7319       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
7320       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
7321       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
7322     }
7323
7324   return 1;
7325 }
7326
7327 static void
7328 process_file (file_name)
7329      char * file_name;
7330 {
7331   FILE *       file;
7332   struct stat  statbuf;
7333   unsigned int i;
7334
7335   if (stat (file_name, & statbuf) < 0)
7336     {
7337       error (_("Cannot stat input file %s.\n"), file_name);
7338       return;
7339     }
7340
7341   file = fopen (file_name, "rb");
7342   if (file == NULL)
7343     {
7344       error (_("Input file %s not found.\n"), file_name);
7345       return;
7346     }
7347
7348   if (! get_file_header (file))
7349     {
7350       error (_("%s: Failed to read file header\n"), file_name);
7351       fclose (file);
7352       return;
7353     }
7354
7355   /* Initialise per file variables.  */
7356   for (i = NUM_ELEM (version_info); i--;)
7357     version_info[i] = 0;
7358
7359   for (i = NUM_ELEM (dynamic_info); i--;)
7360     dynamic_info[i] = 0;
7361
7362   /* Process the file.  */
7363   if (show_name)
7364     printf (_("\nFile: %s\n"), file_name);
7365
7366   if (! process_file_header ())
7367     {
7368       fclose (file);
7369       return;
7370     }
7371
7372   process_section_headers (file);
7373
7374   process_program_headers (file);
7375
7376   process_dynamic_segment (file);
7377
7378   process_relocs (file);
7379
7380   process_symbol_table (file);
7381
7382   process_syminfo (file);
7383
7384   process_version_sections (file);
7385
7386   process_section_contents (file);
7387
7388   process_corefile_contents (file);
7389
7390   process_arch_specific (file);
7391
7392   fclose (file);
7393
7394   if (section_headers)
7395     {
7396       free (section_headers);
7397       section_headers = NULL;
7398     }
7399
7400   if (string_table)
7401     {
7402       free (string_table);
7403       string_table = NULL;
7404     }
7405
7406   if (dynamic_strings)
7407     {
7408       free (dynamic_strings);
7409       dynamic_strings = NULL;
7410     }
7411
7412   if (dynamic_symbols)
7413     {
7414       free (dynamic_symbols);
7415       dynamic_symbols = NULL;
7416       num_dynamic_syms = 0;
7417     }
7418
7419   if (dynamic_syminfo)
7420     {
7421       free (dynamic_syminfo);
7422       dynamic_syminfo = NULL;
7423     }
7424 }
7425
7426 #ifdef SUPPORT_DISASSEMBLY
7427 /* Needed by the i386 disassembler.  For extra credit, someone could
7428    fix this so that we insert symbolic addresses here, esp for GOT/PLT
7429    symbols */
7430
7431 void
7432 print_address (unsigned int addr, FILE * outfile)
7433 {
7434   fprintf (outfile,"0x%8.8x", addr);
7435 }
7436
7437 /* Needed by the i386 disassembler. */
7438 void
7439 db_task_printsym (unsigned int addr)
7440 {
7441   print_address (addr, stderr);
7442 }
7443 #endif
7444
7445 int
7446 main (argc, argv)
7447      int     argc;
7448      char ** argv;
7449 {
7450 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
7451   setlocale (LC_MESSAGES, "");
7452 #endif
7453   bindtextdomain (PACKAGE, LOCALEDIR);
7454   textdomain (PACKAGE);
7455
7456   parse_args (argc, argv);
7457
7458   if (optind < (argc - 1))
7459     show_name = 1;
7460
7461   while (optind < argc)
7462     process_file (argv [optind ++]);
7463
7464   if (dump_sects != NULL)
7465     free (dump_sects);
7466
7467   return 0;
7468 }