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