binutils/readelf.c

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