bfd/xsym.c

   1 /* xSYM symbol-file support for BFD.
   2    Copyright 1999, 2000, 2001, 2002, 2003, 2004
   3    Free Software Foundation, Inc.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "xsym.h"
  22 #include "bfd.h"
  23 #include "sysdep.h"
  24 #include "libbfd.h"
  25
  26 #define bfd_sym_close_and_cleanup _bfd_generic_close_and_cleanup
  27 #define bfd_sym_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
  28 #define bfd_sym_new_section_hook _bfd_generic_new_section_hook
  29 #define bfd_sym_bfd_is_local_label_name bfd_generic_is_local_label_name
  30 #define bfd_sym_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
  31 #define bfd_sym_get_lineno _bfd_nosymbols_get_lineno
  32 #define bfd_sym_find_nearest_line _bfd_nosymbols_find_nearest_line
  33 #define bfd_sym_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
  34 #define bfd_sym_read_minisymbols _bfd_generic_read_minisymbols
  35 #define bfd_sym_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
  36 #define bfd_sym_get_reloc_upper_bound _bfd_norelocs_get_reloc_upper_bound
  37 #define bfd_sym_canonicalize_reloc _bfd_norelocs_canonicalize_reloc
  38 #define bfd_sym_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
  39 #define bfd_sym_set_arch_mach _bfd_generic_set_arch_mach
  40 #define bfd_sym_get_section_contents _bfd_generic_get_section_contents
  41 #define bfd_sym_set_section_contents _bfd_generic_set_section_contents
  42 #define bfd_sym_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
  43 #define bfd_sym_bfd_relax_section bfd_generic_relax_section
  44 #define bfd_sym_bfd_gc_sections bfd_generic_gc_sections
  45 #define bfd_sym_bfd_merge_sections bfd_generic_merge_sections
  46 #define bfd_sym_bfd_is_group_section bfd_generic_is_group_section
  47 #define bfd_sym_bfd_discard_group bfd_generic_discard_group
  48 #define bfd_sym_section_already_linked \
  49   _bfd_generic_section_already_linked
  50 #define bfd_sym_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
  51 #define bfd_sym_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
  52 #define bfd_sym_bfd_link_add_symbols _bfd_generic_link_add_symbols
  53 #define bfd_sym_bfd_link_just_syms _bfd_generic_link_just_syms
  54 #define bfd_sym_bfd_final_link _bfd_generic_final_link
  55 #define bfd_sym_bfd_link_split_section _bfd_generic_link_split_section
  56 #define bfd_sym_get_section_contents_in_window  _bfd_generic_get_section_contents_in_window
  57
  58 static int pstrcmp PARAMS ((unsigned char *, unsigned char *));
  59 static unsigned long compute_offset
  60   PARAMS ((unsigned long, unsigned long, unsigned long, unsigned long));
  61
  62 extern const bfd_target sym_vec;
  63
  64 static int
  65 pstrcmp (a, b)
  66      unsigned char *a;
  67      unsigned char *b;
  68 {
  69   unsigned char clen;
  70   int ret;
  71
  72   clen = (a[0] > b[0]) ? a[0] : b[0];
  73   ret = memcmp (a + 1, b + 1, clen);
  74   if (ret != 0)
  75     return ret;
  76
  77   if (a[0] == b[0])
  78     return 0;
  79   else if (a[0] < b[0])
  80     return -1;
  81   else
  82     return 0;
  83 }
  84
  85 static unsigned long
  86 compute_offset (first_page, page_size, entry_size, index)
  87      unsigned long first_page;
  88      unsigned long page_size;
  89      unsigned long entry_size;
  90      unsigned long index;
  91 {
  92   unsigned long entries_per_page = page_size / entry_size;
  93   unsigned long page_number = first_page + (index / entries_per_page);
  94   unsigned long page_offset = (index % entries_per_page) * entry_size;
  95
  96   return (page_number * page_size) + page_offset;
  97 }
  98
  99 bfd_boolean
 100 bfd_sym_mkobject (abfd)
 101      bfd *abfd ATTRIBUTE_UNUSED;
 102 {
 103   return 1;
 104 }
 105
 106 void
 107 bfd_sym_print_symbol (abfd, afile, symbol, how)
 108      bfd *abfd ATTRIBUTE_UNUSED;
 109      PTR afile ATTRIBUTE_UNUSED;
 110      asymbol *symbol ATTRIBUTE_UNUSED;
 111      bfd_print_symbol_type how ATTRIBUTE_UNUSED;
 112 {
 113   return;
 114 }
 115
 116 bfd_boolean
 117 bfd_sym_valid (abfd)
 118      bfd *abfd;
 119 {
 120   if (abfd == NULL || abfd->xvec == NULL)
 121     return 0;
 122
 123   return abfd->xvec == &sym_vec;
 124 }
 125
 126 unsigned char *
 127 bfd_sym_read_name_table (abfd, dshb)
 128      bfd *abfd;
 129      bfd_sym_header_block *dshb;
 130 {
 131   unsigned char *rstr;
 132   long ret;
 133   size_t table_size = dshb->dshb_nte.dti_page_count * dshb->dshb_page_size;
 134   size_t table_offset = dshb->dshb_nte.dti_first_page * dshb->dshb_page_size;
 135
 136   rstr = (unsigned char *) bfd_alloc (abfd, table_size);
 137   if (rstr == NULL)
 138     return rstr;
 139
 140   bfd_seek (abfd, table_offset, SEEK_SET);
 141   ret = bfd_bread (rstr, table_size, abfd);
 142   if (ret < 0 || (unsigned long) ret != table_size)
 143     {
 144       bfd_release (abfd, rstr);
 145       return NULL;
 146     }
 147
 148   return rstr;
 149 }
 150
 151 void
 152 bfd_sym_parse_file_reference_v32 (buf, len, entry)
 153      unsigned char *buf;
 154      size_t len;
 155      bfd_sym_file_reference *entry;
 156 {
 157   BFD_ASSERT (len == 6);
 158
 159   entry->fref_frte_index = bfd_getb16 (buf);
 160   entry->fref_offset = bfd_getb32 (buf + 2);
 161 }
 162
 163 void
 164 bfd_sym_parse_disk_table_v32 (buf, len, table)
 165      unsigned char *buf;
 166      size_t len;
 167      bfd_sym_table_info *table;
 168 {
 169   BFD_ASSERT (len == 8);
 170
 171   table->dti_first_page = bfd_getb16 (buf);
 172   table->dti_page_count = bfd_getb16 (buf + 2);
 173   table->dti_object_count = bfd_getb32 (buf + 4);
 174 }
 175
 176 void
 177 bfd_sym_parse_header_v32 (buf, len, header)
 178      unsigned char *buf;
 179      size_t len;
 180      bfd_sym_header_block *header;
 181 {
 182   BFD_ASSERT (len == 154);
 183
 184   memcpy (header->dshb_id, buf, 32);
 185   header->dshb_page_size = bfd_getb16 (buf + 32);
 186   header->dshb_hash_page = bfd_getb16 (buf + 34);
 187   header->dshb_root_mte = bfd_getb16 (buf + 36);
 188   header->dshb_mod_date = bfd_getb32 (buf + 38);
 189
 190   bfd_sym_parse_disk_table_v32 (buf + 42, 8, &header->dshb_frte);
 191   bfd_sym_parse_disk_table_v32 (buf + 50, 8, &header->dshb_rte);
 192   bfd_sym_parse_disk_table_v32 (buf + 58, 8, &header->dshb_mte);
 193   bfd_sym_parse_disk_table_v32 (buf + 66, 8, &header->dshb_cmte);
 194   bfd_sym_parse_disk_table_v32 (buf + 74, 8, &header->dshb_cvte);
 195   bfd_sym_parse_disk_table_v32 (buf + 82, 8, &header->dshb_csnte);
 196   bfd_sym_parse_disk_table_v32 (buf + 90, 8, &header->dshb_clte);
 197   bfd_sym_parse_disk_table_v32 (buf + 98, 8, &header->dshb_ctte);
 198   bfd_sym_parse_disk_table_v32 (buf + 106, 8, &header->dshb_tte);
 199   bfd_sym_parse_disk_table_v32 (buf + 114, 8, &header->dshb_nte);
 200   bfd_sym_parse_disk_table_v32 (buf + 122, 8, &header->dshb_tinfo);
 201   bfd_sym_parse_disk_table_v32 (buf + 130, 8, &header->dshb_fite);
 202   bfd_sym_parse_disk_table_v32 (buf + 138, 8, &header->dshb_const);
 203
 204   memcpy (&header->dshb_file_creator, buf + 146, 4);
 205   memcpy (&header->dshb_file_type, buf + 150, 4);
 206 }
 207
 208 int
 209 bfd_sym_read_header_v32 (abfd, header)
 210      bfd *abfd;
 211      bfd_sym_header_block *header;
 212 {
 213   unsigned char buf[154];
 214   long ret;
 215
 216   ret = bfd_bread (buf, 154, abfd);
 217   if (ret != 154)
 218     return -1;
 219
 220   bfd_sym_parse_header_v32 (buf, 154, header);
 221
 222   return 0;
 223 }
 224
 225 int
 226 bfd_sym_read_header_v34 (abfd, header)
 227      bfd *abfd ATTRIBUTE_UNUSED;
 228      bfd_sym_header_block *header ATTRIBUTE_UNUSED;
 229 {
 230   abort ();
 231 }
 232
 233 int
 234 bfd_sym_read_header (abfd, header, version)
 235      bfd *abfd;
 236      bfd_sym_header_block *header;
 237      bfd_sym_version version;
 238 {
 239   switch (version)
 240     {
 241     case BFD_SYM_VERSION_3_5:
 242     case BFD_SYM_VERSION_3_4:
 243       return bfd_sym_read_header_v34 (abfd, header);
 244     case BFD_SYM_VERSION_3_3:
 245     case BFD_SYM_VERSION_3_2:
 246       return bfd_sym_read_header_v32 (abfd, header);
 247     case BFD_SYM_VERSION_3_1:
 248     default:
 249       return FALSE;
 250     }
 251 }
 252
 253 int
 254 bfd_sym_read_version (abfd, version)
 255      bfd *abfd;
 256      bfd_sym_version *version;
 257 {
 258   unsigned char version_string[32];
 259   long ret;
 260
 261   ret = bfd_bread (version_string, sizeof (version_string), abfd);
 262   if (ret != sizeof (version_string))
 263     return -1;
 264
 265   if (pstrcmp (version_string, BFD_SYM_VERSION_STR_3_1) == 0)
 266     *version = BFD_SYM_VERSION_3_1;
 267   else if (pstrcmp (version_string, BFD_SYM_VERSION_STR_3_2) == 0)
 268     *version = BFD_SYM_VERSION_3_2;
 269   else if (pstrcmp (version_string, BFD_SYM_VERSION_STR_3_3) == 0)
 270     *version = BFD_SYM_VERSION_3_3;
 271   else if (pstrcmp (version_string, BFD_SYM_VERSION_STR_3_4) == 0)
 272     *version = BFD_SYM_VERSION_3_4;
 273   else if (pstrcmp (version_string, BFD_SYM_VERSION_STR_3_5) == 0)
 274     *version = BFD_SYM_VERSION_3_5;
 275   else
 276     return -1;
 277
 278   return 0;
 279 }
 280
 281 void
 282 bfd_sym_display_table_summary (f, dti, name)
 283      FILE *f;
 284      bfd_sym_table_info *dti;
 285      const char *name;
 286 {
 287   fprintf (f, "%-6s %13ld %13ld %13ld\n",
 288            name,
 289            dti->dti_first_page,
 290            dti->dti_page_count,
 291            dti->dti_object_count);
 292 }
 293
 294 void
 295 bfd_sym_display_header (f, dshb)
 296      FILE *f;
 297      bfd_sym_header_block *dshb;
 298 {
 299   fprintf (f, "            Version: %.*s\n", dshb->dshb_id[0], dshb->dshb_id + 1);
 300   fprintf (f, "          Page Size: 0x%x\n", dshb->dshb_page_size);
 301   fprintf (f, "          Hash Page: %lu\n", dshb->dshb_hash_page);
 302   fprintf (f, "           Root MTE: %lu\n", dshb->dshb_root_mte);
 303   fprintf (f, "  Modification Date: ");
 304   fprintf (f, "[unimplemented]");
 305   fprintf (f, " (0x%lx)\n", dshb->dshb_mod_date);
 306
 307   fprintf (f, "       File Creator:  %.4s  Type: %.4s\n\n",
 308            dshb->dshb_file_creator, dshb->dshb_file_type);
 309
 310   fprintf (f, "Table Name   First Page    Page Count   Object Count\n");
 311   fprintf (f, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
 312
 313   bfd_sym_display_table_summary (f, &dshb->dshb_nte, "NTE");
 314   bfd_sym_display_table_summary (f, &dshb->dshb_rte, "RTE");
 315   bfd_sym_display_table_summary (f, &dshb->dshb_mte, "MTE");
 316   bfd_sym_display_table_summary (f, &dshb->dshb_frte, "FRTE");
 317   bfd_sym_display_table_summary (f, &dshb->dshb_cmte, "CMTE");
 318   bfd_sym_display_table_summary (f, &dshb->dshb_cvte, "CVTE");
 319   bfd_sym_display_table_summary (f, &dshb->dshb_csnte, "CSNTE");
 320   bfd_sym_display_table_summary (f, &dshb->dshb_clte, "CLTE");
 321   bfd_sym_display_table_summary (f, &dshb->dshb_ctte, "CTTE");
 322   bfd_sym_display_table_summary (f, &dshb->dshb_tte, "TTE");
 323   bfd_sym_display_table_summary (f, &dshb->dshb_tinfo, "TINFO");
 324   bfd_sym_display_table_summary (f, &dshb->dshb_fite, "FITE");
 325   bfd_sym_display_table_summary (f, &dshb->dshb_const, "CONST");
 326
 327   fprintf (f, "\n");
 328 }
 329
 330 void
 331 bfd_sym_parse_resources_table_entry_v32 (buf, len, entry)
 332      unsigned char *buf;
 333      size_t len;
 334      bfd_sym_resources_table_entry *entry;
 335 {
 336   BFD_ASSERT (len == 18);
 337
 338   memcpy (&entry->rte_res_type, buf, 4);
 339   entry->rte_res_number = bfd_getb16 (buf + 4);
 340   entry->rte_nte_index = bfd_getb32 (buf + 6);
 341   entry->rte_mte_first = bfd_getb16 (buf + 10);
 342   entry->rte_mte_last = bfd_getb16 (buf + 12);
 343   entry->rte_res_size = bfd_getb32 (buf + 14);
 344 }
 345
 346 void
 347 bfd_sym_parse_modules_table_entry_v33 (buf, len, entry)
 348      unsigned char *buf;
 349      size_t len;
 350      bfd_sym_modules_table_entry *entry;
 351 {
 352   BFD_ASSERT (len == 46);
 353
 354   entry->mte_rte_index = bfd_getb16 (buf);
 355   entry->mte_res_offset = bfd_getb32 (buf + 2);
 356   entry->mte_size = bfd_getb32 (buf + 6);
 357   entry->mte_kind = buf[10];
 358   entry->mte_scope = buf[11];
 359   entry->mte_parent = bfd_getb16 (buf + 12);
 360   bfd_sym_parse_file_reference_v32 (buf + 14, 6, &entry->mte_imp_fref);
 361   entry->mte_imp_end = bfd_getb32 (buf + 20);
 362   entry->mte_nte_index = bfd_getb32 (buf + 24);
 363   entry->mte_cmte_index = bfd_getb16 (buf + 28);
 364   entry->mte_cvte_index = bfd_getb32 (buf + 30);
 365   entry->mte_clte_index = bfd_getb16 (buf + 34);
 366   entry->mte_ctte_index = bfd_getb16 (buf + 36);
 367   entry->mte_csnte_idx_1 = bfd_getb32 (buf + 38);
 368   entry->mte_csnte_idx_2 = bfd_getb32 (buf + 42);
 369 }
 370
 371 void
 372 bfd_sym_parse_file_references_table_entry_v32 (buf, len, entry)
 373      unsigned char *buf;
 374      size_t len;
 375      bfd_sym_file_references_table_entry *entry;
 376 {
 377   unsigned int type;
 378
 379   BFD_ASSERT (len == 10);
 380
 381   memset (entry, 0, sizeof (bfd_sym_file_references_table_entry));
 382   type = bfd_getb16 (buf);
 383
 384   switch (type)
 385     {
 386     case BFD_SYM_END_OF_LIST_3_2:
 387       entry->generic.type = BFD_SYM_END_OF_LIST;
 388       break;
 389
 390     case BFD_SYM_FILE_NAME_INDEX_3_2:
 391       entry->filename.type = BFD_SYM_FILE_NAME_INDEX;
 392       entry->filename.nte_index = bfd_getb32 (buf + 2);
 393       entry->filename.mod_date = bfd_getb32 (buf + 6);
 394       break;
 395
 396     default:
 397       entry->entry.mte_index = type;
 398       entry->entry.file_offset = bfd_getb32 (buf + 2);
 399     }
 400 }
 401
 402 void
 403 bfd_sym_parse_contained_modules_table_entry_v32 (buf, len, entry)
 404      unsigned char *buf;
 405      size_t len;
 406      bfd_sym_contained_modules_table_entry *entry;
 407 {
 408   unsigned int type;
 409
 410   BFD_ASSERT (len == 6);
 411
 412   memset (entry, 0, sizeof (bfd_sym_contained_modules_table_entry));
 413   type = bfd_getb16 (buf);
 414
 415   switch (type)
 416     {
 417     case BFD_SYM_END_OF_LIST_3_2:
 418       entry->generic.type = BFD_SYM_END_OF_LIST;
 419       break;
 420
 421     default:
 422       entry->entry.mte_index = type;
 423       entry->entry.nte_index = bfd_getb32 (buf + 2);
 424       break;
 425     }
 426 }
 427
 428 void
 429 bfd_sym_parse_contained_variables_table_entry_v32 (buf, len, entry)
 430      unsigned char *buf;
 431      size_t len;
 432      bfd_sym_contained_variables_table_entry *entry;
 433 {
 434   unsigned int type;
 435
 436   BFD_ASSERT (len == 26);
 437
 438   memset (entry, 0, sizeof (bfd_sym_contained_variables_table_entry));
 439   type = bfd_getb16 (buf);
 440
 441   switch (type)
 442     {
 443     case BFD_SYM_END_OF_LIST_3_2:
 444       entry->generic.type = BFD_SYM_END_OF_LIST;
 445       break;
 446
 447     case BFD_SYM_SOURCE_FILE_CHANGE_3_2:
 448       entry->file.type = BFD_SYM_SOURCE_FILE_CHANGE;
 449       bfd_sym_parse_file_reference_v32 (buf + 2, 6, &entry->file.fref);
 450       break;
 451
 452     default:
 453       entry->entry.tte_index = type;
 454       entry->entry.nte_index = bfd_getb32 (buf + 2);
 455       entry->entry.file_delta = bfd_getb16 (buf + 6);
 456       entry->entry.scope = buf[8];
 457       entry->entry.la_size = buf[9];
 458
 459       if (entry->entry.la_size == BFD_SYM_CVTE_SCA)
 460         {
 461           entry->entry.address.scstruct.sca_kind = buf[10];
 462           entry->entry.address.scstruct.sca_class = buf[11];
 463           entry->entry.address.scstruct.sca_offset = bfd_getb32 (buf + 12);
 464         }
 465       else if (entry->entry.la_size <= BFD_SYM_CVTE_SCA)
 466         {
 467           memcpy (&entry->entry.address.lastruct.la, buf + 10, BFD_SYM_CVTE_SCA);
 468           entry->entry.address.lastruct.la_kind = buf[23];
 469         }
 470       else if (entry->entry.la_size == BFD_SYM_CVTE_BIG_LA)
 471         {
 472           entry->entry.address.biglastruct.big_la = bfd_getb32 (buf + 10);
 473           entry->entry.address.biglastruct.big_la_kind = buf[12];
 474         }
 475     }
 476 }
 477
 478 void
 479 bfd_sym_parse_contained_statements_table_entry_v32 (buf, len, entry)
 480      unsigned char *buf;
 481      size_t len;
 482      bfd_sym_contained_statements_table_entry *entry;
 483 {
 484   unsigned int type;
 485
 486   BFD_ASSERT (len == 8);
 487
 488   memset (entry, 0, sizeof (bfd_sym_contained_statements_table_entry));
 489   type = bfd_getb16 (buf);
 490
 491   switch (type)
 492     {
 493     case BFD_SYM_END_OF_LIST_3_2:
 494       entry->generic.type = BFD_SYM_END_OF_LIST;
 495       break;
 496
 497     case BFD_SYM_SOURCE_FILE_CHANGE_3_2:
 498       entry->file.type = BFD_SYM_SOURCE_FILE_CHANGE;
 499       bfd_sym_parse_file_reference_v32 (buf + 2, 6, &entry->file.fref);
 500       break;
 501
 502     default:
 503       entry->entry.mte_index = type;
 504       entry->entry.mte_offset = bfd_getb16 (buf + 2);
 505       entry->entry.file_delta = bfd_getb32 (buf + 4);
 506       break;
 507     }
 508 }
 509
 510 void
 511 bfd_sym_parse_contained_labels_table_entry_v32 (buf, len, entry)
 512      unsigned char *buf;
 513      size_t len;
 514      bfd_sym_contained_labels_table_entry *entry;
 515 {
 516   unsigned int type;
 517
 518   BFD_ASSERT (len == 12);
 519
 520   memset (entry, 0, sizeof (bfd_sym_contained_labels_table_entry));
 521   type = bfd_getb16 (buf);
 522
 523   switch (type)
 524     {
 525     case BFD_SYM_END_OF_LIST_3_2:
 526       entry->generic.type = BFD_SYM_END_OF_LIST;
 527       break;
 528
 529     case BFD_SYM_SOURCE_FILE_CHANGE_3_2:
 530       entry->file.type = BFD_SYM_SOURCE_FILE_CHANGE;
 531       bfd_sym_parse_file_reference_v32 (buf + 2, 6, &entry->file.fref);
 532       break;
 533
 534     default:
 535       entry->entry.mte_index = type;
 536       entry->entry.mte_offset = bfd_getb16 (buf + 2);
 537       entry->entry.nte_index = bfd_getb32 (buf + 4);
 538       entry->entry.file_delta = bfd_getb16 (buf + 8);
 539       entry->entry.scope = bfd_getb16 (buf + 10);
 540       break;
 541     }
 542 }
 543
 544 void
 545 bfd_sym_parse_type_table_entry_v32 (buf, len, entry)
 546      unsigned char *buf;
 547      size_t len;
 548      bfd_sym_type_table_entry *entry;
 549 {
 550   BFD_ASSERT (len == 4);
 551
 552   *entry = bfd_getb32 (buf);
 553 }
 554
 555 int
 556 bfd_sym_fetch_resources_table_entry (abfd, entry, index)
 557      bfd *abfd;
 558      bfd_sym_resources_table_entry *entry;
 559      unsigned long index;
 560 {
 561   void (*parser) PARAMS ((unsigned char *, size_t,
 562                           bfd_sym_resources_table_entry *));
 563   unsigned long offset;
 564   unsigned long entry_size;
 565   unsigned char buf[18];
 566   bfd_sym_data_struct *sdata = NULL;
 567
 568   parser = NULL;
 569   BFD_ASSERT (bfd_sym_valid (abfd));
 570   sdata = abfd->tdata.sym_data;
 571
 572   if (index == 0)
 573     return -1;
 574
 575   switch (sdata->version)
 576     {
 577     case BFD_SYM_VERSION_3_5:
 578     case BFD_SYM_VERSION_3_4:
 579       return -1;
 580
 581     case BFD_SYM_VERSION_3_3:
 582     case BFD_SYM_VERSION_3_2:
 583       entry_size = 18;
 584       parser = bfd_sym_parse_resources_table_entry_v32;
 585       break;
 586
 587     case BFD_SYM_VERSION_3_1:
 588     default:
 589       return -1;
 590     }
 591   if (parser == NULL)
 592     return -1;
 593
 594   offset = compute_offset (sdata->header.dshb_rte.dti_first_page,
 595                            sdata->header.dshb_page_size,
 596                            entry_size, index);
 597
 598   if (bfd_seek (abfd, offset, SEEK_SET) < 0)
 599     return -1;
 600   if (bfd_bread (buf, entry_size, abfd) != entry_size)
 601     return -1;
 602
 603   (*parser) (buf, entry_size, entry);
 604
 605   return 0;
 606 }
 607
 608 int
 609 bfd_sym_fetch_modules_table_entry (abfd, entry, index)
 610      bfd *abfd;
 611      bfd_sym_modules_table_entry *entry;
 612      unsigned long index;
 613 {
 614   void (*parser) PARAMS ((unsigned char *, size_t,
 615                           bfd_sym_modules_table_entry *));
 616   unsigned long offset;
 617   unsigned long entry_size;
 618   unsigned char buf[46];
 619   bfd_sym_data_struct *sdata = NULL;
 620
 621   parser = NULL;
 622   BFD_ASSERT (bfd_sym_valid (abfd));
 623   sdata = abfd->tdata.sym_data;
 624
 625   if (index == 0)
 626     return -1;
 627
 628   switch (sdata->version)
 629     {
 630     case BFD_SYM_VERSION_3_5:
 631     case BFD_SYM_VERSION_3_4:
 632       return -1;
 633
 634     case BFD_SYM_VERSION_3_3:
 635       entry_size = 46;
 636       parser = bfd_sym_parse_modules_table_entry_v33;
 637       break;
 638
 639     case BFD_SYM_VERSION_3_2:
 640     case BFD_SYM_VERSION_3_1:
 641     default:
 642       return -1;
 643     }
 644   if (parser == NULL)
 645     return -1;
 646
 647   offset = compute_offset (sdata->header.dshb_mte.dti_first_page,
 648                            sdata->header.dshb_page_size,
 649                            entry_size, index);
 650
 651   if (bfd_seek (abfd, offset, SEEK_SET) < 0)
 652     return -1;
 653   if (bfd_bread (buf, entry_size, abfd) != entry_size)
 654     return -1;
 655
 656   (*parser) (buf, entry_size, entry);
 657
 658   return 0;
 659 }
 660
 661 int
 662 bfd_sym_fetch_file_references_table_entry (abfd, entry, index)
 663      bfd *abfd;
 664      bfd_sym_file_references_table_entry *entry;
 665      unsigned long index;
 666 {
 667   void (*parser) PARAMS ((unsigned char *, size_t,
 668                           bfd_sym_file_references_table_entry *));
 669   unsigned long offset;
 670   unsigned long entry_size = 0;
 671   unsigned char buf[8];
 672   bfd_sym_data_struct *sdata = NULL;
 673
 674   parser = NULL;
 675   BFD_ASSERT (bfd_sym_valid (abfd));
 676   sdata = abfd->tdata.sym_data;
 677
 678   if (index == 0)
 679     return -1;
 680
 681   switch (sdata->version)
 682     {
 683     case BFD_SYM_VERSION_3_3:
 684     case BFD_SYM_VERSION_3_2:
 685       entry_size = 10;
 686       parser = bfd_sym_parse_file_references_table_entry_v32;
 687       break;
 688
 689     case BFD_SYM_VERSION_3_5:
 690     case BFD_SYM_VERSION_3_4:
 691     case BFD_SYM_VERSION_3_1:
 692     default:
 693       break;
 694     }
 695
 696   if (parser == NULL)
 697     return -1;
 698
 699   offset = compute_offset (sdata->header.dshb_frte.dti_first_page,
 700                            sdata->header.dshb_page_size,
 701                            entry_size, index);
 702
 703   if (bfd_seek (abfd, offset, SEEK_SET) < 0)
 704     return -1;
 705   if (bfd_bread (buf, entry_size, abfd) != entry_size)
 706     return -1;
 707
 708   (*parser) (buf, entry_size, entry);
 709
 710   return 0;
 711 }
 712
 713 int
 714 bfd_sym_fetch_contained_modules_table_entry (abfd, entry, index)
 715      bfd *abfd;
 716      bfd_sym_contained_modules_table_entry *entry;
 717      unsigned long index;
 718 {
 719   void (*parser) PARAMS ((unsigned char *, size_t,
 720                           bfd_sym_contained_modules_table_entry *));
 721   unsigned long offset;
 722   unsigned long entry_size = 0;
 723   unsigned char buf[6];
 724   bfd_sym_data_struct *sdata = NULL;
 725
 726   parser = NULL;
 727   BFD_ASSERT (bfd_sym_valid (abfd));
 728   sdata = abfd->tdata.sym_data;
 729
 730   if (index == 0)
 731     return -1;
 732
 733   switch (sdata->version)
 734     {
 735     case BFD_SYM_VERSION_3_3:
 736     case BFD_SYM_VERSION_3_2:
 737       entry_size = 6;
 738       parser = bfd_sym_parse_contained_modules_table_entry_v32;
 739       break;
 740
 741     case BFD_SYM_VERSION_3_5:
 742     case BFD_SYM_VERSION_3_4:
 743     case BFD_SYM_VERSION_3_1:
 744     default:
 745       break;
 746     }
 747
 748   if (parser == NULL)
 749     return -1;
 750
 751   offset = compute_offset (sdata->header.dshb_cmte.dti_first_page,
 752                            sdata->header.dshb_page_size,
 753                            entry_size, index);
 754
 755   if (bfd_seek (abfd, offset, SEEK_SET) < 0)
 756     return -1;
 757   if (bfd_bread (buf, entry_size, abfd) != entry_size)
 758     return -1;
 759
 760   (*parser) (buf, entry_size, entry);
 761
 762   return 0;
 763 }
 764
 765 int
 766 bfd_sym_fetch_contained_variables_table_entry (abfd, entry, index)
 767      bfd *abfd;
 768      bfd_sym_contained_variables_table_entry *entry;
 769      unsigned long index;
 770 {
 771   void (*parser) PARAMS ((unsigned char *, size_t,
 772                           bfd_sym_contained_variables_table_entry *));
 773   unsigned long offset;
 774   unsigned long entry_size = 0;
 775   unsigned char buf[26];
 776   bfd_sym_data_struct *sdata = NULL;
 777
 778   parser = NULL;
 779   BFD_ASSERT (bfd_sym_valid (abfd));
 780   sdata = abfd->tdata.sym_data;
 781
 782   if (index == 0)
 783     return -1;
 784
 785   switch (sdata->version)
 786     {
 787     case BFD_SYM_VERSION_3_3:
 788     case BFD_SYM_VERSION_3_2:
 789       entry_size = 26;
 790       parser = bfd_sym_parse_contained_variables_table_entry_v32;
 791       break;
 792
 793     case BFD_SYM_VERSION_3_5:
 794     case BFD_SYM_VERSION_3_4:
 795     case BFD_SYM_VERSION_3_1:
 796     default:
 797       break;
 798     }
 799
 800   if (parser == NULL)
 801     return -1;
 802
 803   offset = compute_offset (sdata->header.dshb_cvte.dti_first_page,
 804                            sdata->header.dshb_page_size,
 805                            entry_size, index);
 806
 807   if (bfd_seek (abfd, offset, SEEK_SET) < 0)
 808     return -1;
 809   if (bfd_bread (buf, entry_size, abfd) != entry_size)
 810     return -1;
 811
 812   (*parser) (buf, entry_size, entry);
 813
 814   return 0;
 815 }
 816
 817 int
 818 bfd_sym_fetch_contained_statements_table_entry (abfd, entry, index)
 819      bfd *abfd;
 820      bfd_sym_contained_statements_table_entry *entry;
 821      unsigned long index;
 822 {
 823   void (*parser) PARAMS ((unsigned char *, size_t,
 824                           bfd_sym_contained_statements_table_entry *));
 825   unsigned long offset;
 826   unsigned long entry_size = 0;
 827   unsigned char buf[8];
 828   bfd_sym_data_struct *sdata = NULL;
 829
 830   parser = NULL;
 831   BFD_ASSERT (bfd_sym_valid (abfd));
 832   sdata = abfd->tdata.sym_data;
 833
 834   if (index == 0)
 835     return -1;
 836
 837   switch (sdata->version)
 838     {
 839     case BFD_SYM_VERSION_3_3:
 840     case BFD_SYM_VERSION_3_2:
 841       entry_size = 8;
 842       parser = bfd_sym_parse_contained_statements_table_entry_v32;
 843       break;
 844
 845     case BFD_SYM_VERSION_3_5:
 846     case BFD_SYM_VERSION_3_4:
 847     case BFD_SYM_VERSION_3_1:
 848     default:
 849       break;
 850     }
 851
 852   if (parser == NULL)
 853     return -1;
 854
 855   offset = compute_offset (sdata->header.dshb_csnte.dti_first_page,
 856                            sdata->header.dshb_page_size,
 857                            entry_size, index);
 858
 859   if (bfd_seek (abfd, offset, SEEK_SET) < 0)
 860     return -1;
 861   if (bfd_bread (buf, entry_size, abfd) != entry_size)
 862     return -1;
 863
 864   (*parser) (buf, entry_size, entry);
 865
 866   return 0;
 867 }
 868
 869 int
 870 bfd_sym_fetch_contained_labels_table_entry (abfd, entry, index)
 871      bfd *abfd;
 872      bfd_sym_contained_labels_table_entry *entry;
 873      unsigned long index;
 874 {
 875   void (*parser) PARAMS ((unsigned char *, size_t,
 876                           bfd_sym_contained_labels_table_entry *));
 877   unsigned long offset;
 878   unsigned long entry_size = 0;
 879   unsigned char buf[12];
 880   bfd_sym_data_struct *sdata = NULL;
 881
 882   parser = NULL;
 883   BFD_ASSERT (bfd_sym_valid (abfd));
 884   sdata = abfd->tdata.sym_data;
 885
 886   if (index == 0)
 887     return -1;
 888
 889   switch (sdata->version)
 890     {
 891     case BFD_SYM_VERSION_3_3:
 892     case BFD_SYM_VERSION_3_2:
 893       entry_size = 12;
 894       parser = bfd_sym_parse_contained_labels_table_entry_v32;
 895       break;
 896
 897     case BFD_SYM_VERSION_3_5:
 898     case BFD_SYM_VERSION_3_4:
 899     case BFD_SYM_VERSION_3_1:
 900     default:
 901       break;
 902     }
 903
 904   if (parser == NULL)
 905     return -1;
 906
 907   offset = compute_offset (sdata->header.dshb_clte.dti_first_page,
 908                            sdata->header.dshb_page_size,
 909                            entry_size, index);
 910
 911   if (bfd_seek (abfd, offset, SEEK_SET) < 0)
 912     return -1;
 913   if (bfd_bread (buf, entry_size, abfd) != entry_size)
 914     return -1;
 915
 916   (*parser) (buf, entry_size, entry);
 917
 918   return 0;
 919 }
 920
 921 int
 922 bfd_sym_fetch_contained_types_table_entry (abfd, entry, index)
 923      bfd *abfd;
 924      bfd_sym_contained_types_table_entry *entry;
 925      unsigned long index;
 926 {
 927   void (*parser) PARAMS ((unsigned char *, size_t,
 928                           bfd_sym_contained_types_table_entry *));
 929   unsigned long offset;
 930   unsigned long entry_size = 0;
 931   unsigned char buf[0];
 932   bfd_sym_data_struct *sdata = NULL;
 933
 934   parser = NULL;
 935   BFD_ASSERT (bfd_sym_valid (abfd));
 936   sdata = abfd->tdata.sym_data;
 937
 938   if (index == 0)
 939     return -1;
 940
 941   switch (sdata->version)
 942     {
 943     case BFD_SYM_VERSION_3_3:
 944     case BFD_SYM_VERSION_3_2:
 945       entry_size = 0;
 946       parser = NULL;
 947       break;
 948
 949     case BFD_SYM_VERSION_3_5:
 950     case BFD_SYM_VERSION_3_4:
 951     case BFD_SYM_VERSION_3_1:
 952     default:
 953       break;
 954     }
 955
 956   if (parser == NULL)
 957     return -1;
 958
 959   offset = compute_offset (sdata->header.dshb_ctte.dti_first_page,
 960                            sdata->header.dshb_page_size,
 961                            entry_size, index);
 962
 963   if (bfd_seek (abfd, offset, SEEK_SET) < 0)
 964     return -1;
 965   if (bfd_bread (buf, entry_size, abfd) != entry_size)
 966     return -1;
 967
 968   (*parser) (buf, entry_size, entry);
 969
 970   return 0;
 971 }
 972
 973 int
 974 bfd_sym_fetch_file_references_index_table_entry (abfd, entry, index)
 975      bfd *abfd;
 976      bfd_sym_file_references_index_table_entry *entry;
 977      unsigned long index;
 978 {
 979   void (*parser) PARAMS ((unsigned char *, size_t,
 980                           bfd_sym_file_references_index_table_entry *));
 981   unsigned long offset;
 982   unsigned long entry_size = 0;
 983   unsigned char buf[0];
 984   bfd_sym_data_struct *sdata = NULL;
 985
 986   parser = NULL;
 987   BFD_ASSERT (bfd_sym_valid (abfd));
 988   sdata = abfd->tdata.sym_data;
 989
 990   if (index == 0)
 991     return -1;
 992
 993   switch (sdata->version)
 994     {
 995     case BFD_SYM_VERSION_3_3:
 996     case BFD_SYM_VERSION_3_2:
 997       entry_size = 0;
 998       parser = NULL;
 999       break;
1000
1001     case BFD_SYM_VERSION_3_5:
1002     case BFD_SYM_VERSION_3_4:
1003     case BFD_SYM_VERSION_3_1:
1004     default:
1005       break;
1006     }
1007
1008   if (parser == NULL)
1009     return -1;
1010
1011   offset = compute_offset (sdata->header.dshb_fite.dti_first_page,
1012                            sdata->header.dshb_page_size,
1013                            entry_size, index);
1014
1015   if (bfd_seek (abfd, offset, SEEK_SET) < 0)
1016     return -1;
1017   if (bfd_bread (buf, entry_size, abfd) != entry_size)
1018     return -1;
1019
1020   (*parser) (buf, entry_size, entry);
1021
1022   return 0;
1023 }
1024
1025 int
1026 bfd_sym_fetch_constant_pool_entry (abfd, entry, index)
1027      bfd *abfd;
1028      bfd_sym_constant_pool_entry *entry;
1029      unsigned long index;
1030 {
1031   void (*parser) PARAMS ((unsigned char *, size_t,
1032                           bfd_sym_constant_pool_entry *));
1033   unsigned long offset;
1034   unsigned long entry_size = 0;
1035   unsigned char buf[0];
1036   bfd_sym_data_struct *sdata = NULL;
1037
1038   parser = NULL;
1039   BFD_ASSERT (bfd_sym_valid (abfd));
1040   sdata = abfd->tdata.sym_data;
1041
1042   if (index == 0)
1043     return -1;
1044
1045   switch (sdata->version)
1046     {
1047     case BFD_SYM_VERSION_3_3:
1048     case BFD_SYM_VERSION_3_2:
1049       entry_size = 0;
1050       parser = NULL;
1051       break;
1052
1053     case BFD_SYM_VERSION_3_5:
1054     case BFD_SYM_VERSION_3_4:
1055     case BFD_SYM_VERSION_3_1:
1056     default:
1057       break;
1058     }
1059
1060   if (parser == NULL)
1061     return -1;
1062
1063   offset = compute_offset (sdata->header.dshb_fite.dti_first_page,
1064                            sdata->header.dshb_page_size,
1065                            entry_size, index);
1066
1067   if (bfd_seek (abfd, offset, SEEK_SET) < 0)
1068     return -1;
1069   if (bfd_bread (buf, entry_size, abfd) != entry_size)
1070     return -1;
1071
1072   (*parser) (buf, entry_size, entry);
1073
1074   return 0;
1075 }
1076
1077 int
1078 bfd_sym_fetch_type_table_entry (abfd, entry, index)
1079      bfd *abfd;
1080      bfd_sym_type_table_entry *entry;
1081      unsigned long index;
1082 {
1083   void (*parser) PARAMS ((unsigned char *, size_t,
1084                           bfd_sym_type_table_entry *));
1085   unsigned long offset;
1086   unsigned long entry_size = 0;
1087   unsigned char buf[4];
1088   bfd_sym_data_struct *sdata = NULL;
1089
1090   parser = NULL;
1091   BFD_ASSERT (bfd_sym_valid (abfd));
1092   sdata = abfd->tdata.sym_data;
1093
1094   switch (sdata->version)
1095     {
1096     case BFD_SYM_VERSION_3_3:
1097     case BFD_SYM_VERSION_3_2:
1098       entry_size = 4;
1099       parser = bfd_sym_parse_type_table_entry_v32;
1100       break;
1101
1102     case BFD_SYM_VERSION_3_5:
1103     case BFD_SYM_VERSION_3_4:
1104     case BFD_SYM_VERSION_3_1:
1105     default:
1106       break;
1107     }
1108
1109   if (parser == NULL)
1110     return -1;
1111
1112   offset = compute_offset (sdata->header.dshb_tte.dti_first_page,
1113                            sdata->header.dshb_page_size,
1114                            entry_size, index);
1115
1116   if (bfd_seek (abfd, offset, SEEK_SET) < 0)
1117     return -1;
1118   if (bfd_bread (buf, entry_size, abfd) != entry_size)
1119     return -1;
1120
1121   (*parser) (buf, entry_size, entry);
1122
1123   return 0;
1124 }
1125
1126 int
1127 bfd_sym_fetch_type_information_table_entry (abfd, entry, offset)
1128      bfd *abfd;
1129      bfd_sym_type_information_table_entry *entry;
1130      unsigned long offset;
1131 {
1132   unsigned char buf[4];
1133   bfd_sym_data_struct *sdata = NULL;
1134
1135   BFD_ASSERT (bfd_sym_valid (abfd));
1136   sdata = abfd->tdata.sym_data;
1137
1138   if (offset == 0)
1139     return -1;
1140
1141   if (bfd_seek (abfd, offset, SEEK_SET) < 0)
1142     return -1;
1143
1144   if (bfd_bread (buf, 4, abfd) != 4)
1145     return -1;
1146   entry->nte_index = bfd_getb32 (buf);
1147
1148   if (bfd_bread (buf, 2, abfd) != 2)
1149     return -1;
1150   entry->physical_size = bfd_getb16 (buf);
1151
1152   if (entry->physical_size & 0x8000)
1153     {
1154       if (bfd_bread (buf, 4, abfd) != 4)
1155         return -1;
1156       entry->physical_size &= 0x7fff;
1157       entry->logical_size = bfd_getb32 (buf);
1158       entry->offset = offset + 10;
1159     }
1160   else
1161     {
1162       if (bfd_bread (buf, 2, abfd) != 2)
1163         return -1;
1164       entry->physical_size &= 0x7fff;
1165       entry->logical_size = bfd_getb16 (buf);
1166       entry->offset = offset + 8;
1167     }
1168
1169   return 0;
1170 }
1171
1172 int
1173 bfd_sym_fetch_type_table_information (abfd, entry, index)
1174      bfd *abfd;
1175      bfd_sym_type_information_table_entry *entry;
1176      unsigned long index;
1177 {
1178   bfd_sym_type_table_entry tindex;
1179   bfd_sym_data_struct *sdata = NULL;
1180
1181   BFD_ASSERT (bfd_sym_valid (abfd));
1182   sdata = abfd->tdata.sym_data;
1183
1184   if (sdata->header.dshb_tte.dti_object_count <= 99)
1185     return -1;
1186   if (index < 100)
1187     return -1;
1188
1189   if (bfd_sym_fetch_type_table_entry (abfd, &tindex, index - 100) < 0)
1190     return -1;
1191   if (bfd_sym_fetch_type_information_table_entry (abfd, entry, tindex) < 0)
1192     return -1;
1193
1194   return 0;
1195 }
1196
1197 const unsigned char *
1198 bfd_sym_symbol_name (abfd, index)
1199      bfd *abfd;
1200      unsigned long index;
1201 {
1202   bfd_sym_data_struct *sdata = NULL;
1203
1204   BFD_ASSERT (bfd_sym_valid (abfd));
1205   sdata = abfd->tdata.sym_data;
1206
1207   if (index == 0)
1208     return "";
1209
1210   index *= 2;
1211   if ((index / sdata->header.dshb_page_size)
1212       > sdata->header.dshb_nte.dti_page_count)
1213     return "\009[INVALID]";
1214
1215   return (const unsigned char *) sdata->name_table + index;
1216 }
1217
1218 const unsigned char *
1219 bfd_sym_module_name (abfd, index)
1220      bfd *abfd;
1221      unsigned long index;
1222 {
1223   bfd_sym_modules_table_entry entry;
1224
1225   if (bfd_sym_fetch_modules_table_entry (abfd, &entry, index) < 0)
1226     return "\011[INVALID]";
1227
1228   return bfd_sym_symbol_name (abfd, entry.mte_nte_index);
1229 }
1230
1231 const char *
1232 bfd_sym_unparse_storage_kind (kind)
1233      enum bfd_sym_storage_kind kind;
1234 {
1235   switch (kind)
1236     {
1237     case BFD_SYM_STORAGE_KIND_LOCAL: return "LOCAL";
1238     case BFD_SYM_STORAGE_KIND_VALUE: return "VALUE";
1239     case BFD_SYM_STORAGE_KIND_REFERENCE: return "REFERENCE";
1240     case BFD_SYM_STORAGE_KIND_WITH: return "WITH";
1241     default: return "[UNKNOWN]";
1242     }
1243 }
1244
1245 const char *
1246 bfd_sym_unparse_storage_class (kind)
1247      enum bfd_sym_storage_class kind;
1248 {
1249   switch (kind)
1250     {
1251     case BFD_SYM_STORAGE_CLASS_REGISTER: return "REGISTER";
1252     case BFD_SYM_STORAGE_CLASS_GLOBAL: return "GLOBAL";
1253     case BFD_SYM_STORAGE_CLASS_FRAME_RELATIVE: return "FRAME_RELATIVE";
1254     case BFD_SYM_STORAGE_CLASS_STACK_RELATIVE: return "STACK_RELATIVE";
1255     case BFD_SYM_STORAGE_CLASS_ABSOLUTE: return "ABSOLUTE";
1256     case BFD_SYM_STORAGE_CLASS_CONSTANT: return "CONSTANT";
1257     case BFD_SYM_STORAGE_CLASS_RESOURCE: return "RESOURCE";
1258     case BFD_SYM_STORAGE_CLASS_BIGCONSTANT: return "BIGCONSTANT";
1259     default: return "[UNKNOWN]";
1260     }
1261 }
1262
1263 const char *
1264 bfd_sym_unparse_module_kind (kind)
1265      enum bfd_sym_module_kind kind;
1266 {
1267   switch (kind)
1268     {
1269     case BFD_SYM_MODULE_KIND_NONE: return "NONE";
1270     case BFD_SYM_MODULE_KIND_PROGRAM: return "PROGRAM";
1271     case BFD_SYM_MODULE_KIND_UNIT: return "UNIT";
1272     case BFD_SYM_MODULE_KIND_PROCEDURE: return "PROCEDURE";
1273     case BFD_SYM_MODULE_KIND_FUNCTION: return "FUNCTION";
1274     case BFD_SYM_MODULE_KIND_DATA: return "DATA";
1275     case BFD_SYM_MODULE_KIND_BLOCK: return "BLOCK";
1276     default: return "[UNKNOWN]";
1277     }
1278 }
1279
1280 const char *
1281 bfd_sym_unparse_symbol_scope (scope)
1282      enum bfd_sym_symbol_scope scope;
1283 {
1284   switch (scope)
1285     {
1286     case BFD_SYM_SYMBOL_SCOPE_LOCAL: return "LOCAL";
1287     case BFD_SYM_SYMBOL_SCOPE_GLOBAL: return "GLOBAL";
1288     default:
1289       return "[UNKNOWN]";
1290     }
1291 }
1292
1293 void
1294 bfd_sym_print_file_reference (abfd, f, entry)
1295      bfd *abfd;
1296      FILE *f;
1297      bfd_sym_file_reference *entry;
1298 {
1299   bfd_sym_file_references_table_entry frtentry;
1300   int ret;
1301
1302   ret = bfd_sym_fetch_file_references_table_entry (abfd, &frtentry,
1303                                                    entry->fref_frte_index);
1304   fprintf (f, "FILE ");
1305
1306   if ((ret < 0) || (frtentry.generic.type != BFD_SYM_FILE_NAME_INDEX))
1307     fprintf (f, "[INVALID]");
1308   else
1309     fprintf (f, "\"%.*s\"",
1310              bfd_sym_symbol_name (abfd, frtentry.filename.nte_index)[0],
1311              &bfd_sym_symbol_name (abfd, frtentry.filename.nte_index)[1]);
1312
1313   fprintf (f, " (FRTE %lu)", entry->fref_frte_index);
1314 }
1315
1316 void
1317 bfd_sym_print_resources_table_entry (abfd, f, entry)
1318      bfd *abfd;
1319      FILE *f;
1320      bfd_sym_resources_table_entry *entry;
1321 {
1322   fprintf (f, " \"%.*s\" (NTE %lu), type \"%.4s\", num %u, size %lu, MTE %lu -- %lu",
1323            bfd_sym_symbol_name (abfd, entry->rte_nte_index)[0],
1324            &bfd_sym_symbol_name (abfd, entry->rte_nte_index)[1],
1325            entry->rte_nte_index, entry->rte_res_type, entry->rte_res_number,
1326            entry->rte_res_size, entry->rte_mte_first, entry->rte_mte_last);
1327 }
1328
1329 void
1330 bfd_sym_print_modules_table_entry (abfd, f, entry)
1331      bfd *abfd;
1332      FILE *f;
1333      bfd_sym_modules_table_entry *entry;
1334 {
1335   fprintf (f, "\"%.*s\" (NTE %lu)",
1336            bfd_sym_symbol_name (abfd, entry->mte_nte_index)[0],
1337            &bfd_sym_symbol_name (abfd, entry->mte_nte_index)[1],
1338            entry->mte_nte_index);
1339
1340   fprintf (f, "\n            ");
1341
1342   bfd_sym_print_file_reference (abfd, f, &entry->mte_imp_fref);
1343   fprintf (f, " range %lu -- %lu",
1344            entry->mte_imp_fref.fref_offset, entry->mte_imp_end);
1345
1346   fprintf (f, "\n            ");
1347
1348   fprintf (f, "kind %s", bfd_sym_unparse_module_kind (entry->mte_kind));
1349   fprintf (f, ", scope %s", bfd_sym_unparse_symbol_scope (entry->mte_scope));
1350
1351   fprintf (f, ", RTE %lu, offset %lu, size %lu",
1352            entry->mte_rte_index, entry->mte_res_offset, entry->mte_size);
1353
1354   fprintf (f, "\n            ");
1355
1356   fprintf (f, "CMTE %lu, CVTE %lu, CLTE %lu, CTTE %lu, CSNTE1 %lu, CSNTE2 %lu",
1357            entry->mte_cmte_index, entry->mte_cvte_index,
1358            entry->mte_clte_index, entry->mte_ctte_index,
1359            entry->mte_csnte_idx_1, entry->mte_csnte_idx_2);
1360
1361   if (entry->mte_parent != 0)
1362     fprintf (f, ", parent %lu", entry->mte_parent);
1363   else
1364     fprintf (f, ", no parent");
1365
1366   if (entry->mte_cmte_index != 0)
1367     fprintf (f, ", child %lu", entry->mte_cmte_index);
1368   else
1369     fprintf (f, ", no child");
1370
1371 #if 0
1372   {
1373     MTE bfd_sym_modules_table_entry pentry;
1374
1375     ret = bfd_sym_fetch_modules_table_entry (abfd, &pentry, entry->mte_parent);
1376     if (ret < 0)
1377       fprintf (f, " parent MTE %lu [INVALID]\n", entry->mte_parent);
1378     else
1379       fprintf (f, " parent MTE %lu \"%.*s\"\n",
1380                entry->mte_parent,
1381                bfd_sym_symbol_name (abfd, pentry.mte_nte_index)[0],
1382                &bfd_sym_symbol_name (abfd, pentry.mte_nte_index)[1]);
1383   }
1384 #endif
1385 }
1386
1387 void
1388 bfd_sym_print_file_references_table_entry (abfd, f, entry)
1389      bfd *abfd;
1390      FILE *f;
1391      bfd_sym_file_references_table_entry *entry;
1392 {
1393   switch (entry->generic.type)
1394     {
1395     case BFD_SYM_FILE_NAME_INDEX:
1396       fprintf (f, "FILE \"%.*s\" (NTE %lu), modtime ",
1397                bfd_sym_symbol_name (abfd, entry->filename.nte_index)[0],
1398                &bfd_sym_symbol_name (abfd, entry->filename.nte_index)[1],
1399                entry->filename.nte_index);
1400
1401       fprintf (f, "[UNIMPLEMENTED]");
1402       /* printModDate (entry->filename.mod_date); */
1403       fprintf (f, " (0x%lx)", entry->filename.mod_date);
1404       break;
1405
1406     case BFD_SYM_END_OF_LIST:
1407       fprintf (f, "END");
1408       break;
1409
1410     default:
1411       fprintf (f, "\"%.*s\" (MTE %lu), offset %lu",
1412                bfd_sym_module_name (abfd, entry->entry.mte_index)[0],
1413                &bfd_sym_module_name (abfd, entry->entry.mte_index)[1],
1414                entry->entry.mte_index,
1415                entry->entry.file_offset);
1416       break;
1417     }
1418 }
1419
1420 void
1421 bfd_sym_print_contained_modules_table_entry (abfd, f, entry)
1422      bfd *abfd;
1423      FILE *f;
1424      bfd_sym_contained_modules_table_entry *entry;
1425 {
1426   switch (entry->generic.type)
1427     {
1428     case BFD_SYM_END_OF_LIST:
1429       fprintf (f, "END");
1430       break;
1431
1432     default:
1433       fprintf (f, "\"%.*s\" (MTE %lu, NTE %lu)",
1434                bfd_sym_module_name (abfd, entry->entry.mte_index)[0],
1435                &bfd_sym_module_name (abfd, entry->entry.mte_index)[1],
1436                entry->entry.mte_index,
1437                entry->entry.nte_index);
1438       break;
1439     }
1440 }
1441
1442 void
1443 bfd_sym_print_contained_variables_table_entry (abfd, f, entry)
1444      bfd *abfd;
1445      FILE *f;
1446      bfd_sym_contained_variables_table_entry *entry;
1447 {
1448   if (entry->generic.type == BFD_SYM_END_OF_LIST)
1449     {
1450       fprintf (f, "END");
1451       return;
1452     }
1453
1454   if (entry->generic.type == BFD_SYM_SOURCE_FILE_CHANGE)
1455     {
1456       bfd_sym_print_file_reference (abfd, f, &entry->file.fref);
1457       fprintf (f, " offset %lu", entry->file.fref.fref_offset);
1458       return;
1459     }
1460
1461   fprintf (f, "\"%.*s\" (NTE %lu)",
1462            bfd_sym_symbol_name (abfd, entry->entry.nte_index)[0],
1463            &bfd_sym_symbol_name (abfd, entry->entry.nte_index)[1],
1464            entry->entry.nte_index);
1465
1466   fprintf (f, ", TTE %lu", entry->entry.tte_index);
1467   fprintf (f, ", offset %lu", entry->entry.file_delta);
1468   fprintf (f, ", scope %s", bfd_sym_unparse_symbol_scope (entry->entry.scope));
1469
1470   if (entry->entry.la_size == BFD_SYM_CVTE_SCA)
1471     fprintf (f, ", latype %s, laclass %s, laoffset %lu",
1472              bfd_sym_unparse_storage_kind (entry->entry.address.scstruct.sca_kind),
1473              bfd_sym_unparse_storage_class (entry->entry.address.scstruct.sca_class),
1474              entry->entry.address.scstruct.sca_offset);
1475   else if (entry->entry.la_size <= BFD_SYM_CVTE_LA_MAX_SIZE)
1476     {
1477       unsigned long i;
1478
1479       fprintf (f, ", la [");
1480       for (i = 0; i < entry->entry.la_size; i++)
1481         fprintf (f, "0x%02x ", entry->entry.address.lastruct.la[i]);
1482       fprintf (f, "]");
1483     }
1484   else if (entry->entry.la_size == BFD_SYM_CVTE_BIG_LA)
1485     fprintf (f, ", bigla %lu, biglakind %u",
1486              entry->entry.address.biglastruct.big_la,
1487              entry->entry.address.biglastruct.big_la_kind);
1488
1489   else
1490     fprintf (f, ", la [INVALID]");
1491 }
1492
1493 void
1494 bfd_sym_print_contained_statements_table_entry (abfd, f, entry)
1495      bfd *abfd;
1496      FILE *f;
1497      bfd_sym_contained_statements_table_entry *entry;
1498 {
1499   if (entry->generic.type == BFD_SYM_END_OF_LIST)
1500     {
1501       fprintf (f, "END");
1502       return;
1503     }
1504
1505   if (entry->generic.type == BFD_SYM_SOURCE_FILE_CHANGE)
1506     {
1507       bfd_sym_print_file_reference (abfd, f, &entry->file.fref);
1508       fprintf (f, " offset %lu", entry->file.fref.fref_offset);
1509       return;
1510     }
1511
1512   fprintf (f, "\"%.*s\" (MTE %lu), offset %lu, delta %lu",
1513            bfd_sym_module_name (abfd, entry->entry.mte_index)[0],
1514            &bfd_sym_module_name (abfd, entry->entry.mte_index)[1],
1515            entry->entry.mte_index,
1516            entry->entry.mte_offset,
1517            entry->entry.file_delta);
1518 }
1519
1520 void
1521 bfd_sym_print_contained_labels_table_entry (abfd, f, entry)
1522      bfd *abfd;
1523      FILE *f;
1524      bfd_sym_contained_labels_table_entry *entry;
1525 {
1526   if (entry->generic.type == BFD_SYM_END_OF_LIST)
1527     {
1528       fprintf (f, "END");
1529       return;
1530     }
1531
1532   if (entry->generic.type == BFD_SYM_SOURCE_FILE_CHANGE)
1533     {
1534       bfd_sym_print_file_reference (abfd, f, &entry->file.fref);
1535       fprintf (f, " offset %lu", entry->file.fref.fref_offset);
1536       return;
1537     }
1538
1539   fprintf (f, "\"%.*s\" (MTE %lu), offset %lu, delta %lu, scope %s",
1540            bfd_sym_module_name (abfd, entry->entry.mte_index)[0],
1541            &bfd_sym_module_name (abfd, entry->entry.mte_index)[1],
1542            entry->entry.mte_index,
1543            entry->entry.mte_offset,
1544            entry->entry.file_delta,
1545            bfd_sym_unparse_symbol_scope (entry->entry.scope));
1546 }
1547
1548 void
1549 bfd_sym_print_contained_types_table_entry (abfd, f, entry)
1550      bfd *abfd ATTRIBUTE_UNUSED;
1551      FILE *f;
1552      bfd_sym_contained_types_table_entry *entry ATTRIBUTE_UNUSED;
1553 {
1554   fprintf (f, "[UNIMPLEMENTED]");
1555 }
1556
1557 const char *
1558 bfd_sym_type_operator_name (num)
1559      unsigned char num;
1560 {
1561   switch (num)
1562     {
1563     case 1: return "TTE";
1564     case 2: return "PointerTo";
1565     case 3: return "ScalarOf";
1566     case 4: return "ConstantOf";
1567     case 5: return "EnumerationOf";
1568     case 6: return "VectorOf";
1569     case 7: return "RecordOf";
1570     case 8: return "UnionOf";
1571     case 9: return "SubRangeOf";
1572     case 10: return "SetOf";
1573     case 11: return "NamedTypeOf";
1574     case 12: return "ProcOf";
1575     case 13: return "ValueOf";
1576     case 14: return "ArrayOf";
1577     default: return "[UNKNOWN OPERATOR]";
1578     }
1579 }
1580
1581 const char *
1582 bfd_sym_type_basic_name (num)
1583      unsigned char num;
1584 {
1585   switch (num)
1586     {
1587     case 0: return "void";
1588     case 1: return "pascal string";
1589     case 2: return "unsigned long";
1590     case 3: return "signed long";
1591     case 4: return "extended (10 bytes)";
1592     case 5: return "pascal boolean (1 byte)";
1593     case 6: return "unsigned byte";
1594     case 7: return "signed byte";
1595     case 8: return "character (1 byte)";
1596     case 9: return "wide character (2 bytes)";
1597     case 10: return "unsigned short";
1598     case 11: return "signed short";
1599     case 12: return "singled";
1600     case 13: return "double";
1601     case 14: return "extended (12 bytes)";
1602     case 15: return "computational (8 bytes)";
1603     case 16: return "c string";
1604     case 17: return "as-is string";
1605     default: return "[UNKNOWN BASIC TYPE]";
1606     }
1607 }
1608
1609 int
1610 bfd_sym_fetch_long (buf, len, offset, offsetptr, value)
1611      unsigned char *buf;
1612      unsigned long len;
1613      unsigned long offset;
1614      unsigned long *offsetptr;
1615      long *value;
1616 {
1617   int ret;
1618
1619   if (offset >= len)
1620     {
1621       *value = 0;
1622       offset += 0;
1623       ret = -1;
1624     }
1625   else if (! (buf[offset] & 0x80))
1626     {
1627       *value = buf[offset];
1628       offset += 1;
1629       ret = 0;
1630     }
1631   else if (buf[offset] == 0xc0)
1632     {
1633       if ((offset + 5) > len)
1634         {
1635           *value = 0;
1636           offset = len;
1637           ret = -1;
1638         }
1639       else
1640         {
1641           *value = bfd_getb32 (buf + offset + 1);
1642           offset += 5;
1643           ret = 0;
1644         }
1645     }
1646   else if ((buf[offset] & 0xc0) == 0xc0)
1647     {
1648       *value =  -(buf[offset] & 0x3f);
1649       offset += 1;
1650       ret = 0;
1651     }
1652   else if ((buf[offset] & 0xc0) == 0x80)
1653     {
1654       if ((offset + 2) > len)
1655         {
1656           *value = 0;
1657           offset = len;
1658           ret = -1;
1659         }
1660       else
1661         {
1662           *value = bfd_getb16 (buf + offset) & 0x3fff;
1663           offset += 2;
1664           ret = 0;
1665         }
1666     }
1667   else
1668     abort ();
1669
1670   if (offsetptr != NULL)
1671     *offsetptr = offset;
1672
1673   return ret;
1674 }
1675
1676 void
1677 bfd_sym_print_type_information (abfd, f, buf, len, offset, offsetptr)
1678      bfd *abfd;
1679      FILE *f;
1680      unsigned char *buf;
1681      unsigned long len;
1682      unsigned long offset;
1683      unsigned long *offsetptr;
1684 {
1685   unsigned int type;
1686
1687   if (offset >= len)
1688     {
1689       fprintf (f, "[NULL]");
1690
1691       if (offsetptr != NULL)
1692         *offsetptr = offset;
1693       return;
1694   }
1695
1696   type = buf[offset];
1697   offset++;
1698
1699   if (! (type & 0x80))
1700     {
1701       fprintf (f, "[%s] (0x%x)", bfd_sym_type_basic_name (type & 0x7f), type);
1702
1703       if (offsetptr != NULL)
1704         *offsetptr = offset;
1705       return;
1706     }
1707
1708   if (type & 0x40)
1709     fprintf (f, "[packed ");
1710   else
1711     fprintf (f, "[");
1712
1713   switch (type & 0x3f)
1714     {
1715     case 1:
1716       {
1717         long value;
1718         bfd_sym_type_information_table_entry tinfo;
1719
1720         bfd_sym_fetch_long (buf, len, offset, &offset, &value);
1721         if (value <= 0)
1722           fprintf (f, "[INVALID]");
1723         else
1724           {
1725             if (bfd_sym_fetch_type_table_information (abfd, &tinfo, value) < 0)
1726               fprintf (f, "[INVALID]");
1727             else
1728               fprintf (f, "\"%.*s\"",
1729                        bfd_sym_symbol_name (abfd, tinfo.nte_index)[0],
1730                        &bfd_sym_symbol_name (abfd, tinfo.nte_index)[1]);
1731           }
1732         fprintf (f, " (TTE %lu)", value);
1733         break;
1734       }
1735
1736     case 2:
1737       fprintf (f, "pointer (0x%x) to ", type);
1738       bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
1739       break;
1740
1741     case 3:
1742       {
1743         unsigned long value;
1744
1745         fprintf (f, "scalar (0x%x) of ", type);
1746         bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
1747         bfd_sym_fetch_long (buf, len, offset, &offset, &value);
1748         fprintf (f, " (%lu)", value);
1749         break;
1750       }
1751
1752     case 5:
1753       {
1754         unsigned long lower, upper, nelem;
1755         unsigned long i;
1756
1757         fprintf (f, "enumeration (0x%x) of ", type);
1758         bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
1759         bfd_sym_fetch_long (buf, len, offset, &offset, &lower);
1760         bfd_sym_fetch_long (buf, len, offset, &offset, &upper);
1761         bfd_sym_fetch_long (buf, len, offset, &offset, &nelem);
1762         fprintf (f, " from %lu to %lu with %lu elements: ", lower, upper, nelem);
1763
1764         for (i = 0; i < nelem; i++)
1765           {
1766             fprintf (f, "\n                    ");
1767             bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
1768           }
1769         break;
1770       }
1771
1772     case 6:
1773       fprintf (f, "vector (0x%x)", type);
1774       fprintf (f, "\n                index ");
1775       bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
1776       fprintf (f, "\n                target ");
1777       bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
1778       break;
1779
1780     case 7:
1781     case 8:
1782       {
1783         long nrec, eloff, i;
1784
1785         if ((type & 0x3f) == 7)
1786           fprintf (f, "record (0x%x) of ", type);
1787         else
1788           fprintf (f, "union (0x%x) of ", type);
1789
1790         bfd_sym_fetch_long (buf, len, offset, &offset, &nrec);
1791         fprintf (f, "%lu elements: ", nrec);
1792
1793         for (i = 0; i < nrec; i++)
1794           {
1795             bfd_sym_fetch_long (buf, len, offset, &offset, &eloff);
1796             fprintf (f, "\n                ");
1797             fprintf (f, "offset %lu: ", eloff);
1798             bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
1799           }
1800         break;
1801       }
1802
1803     case 9:
1804       fprintf (f, "subrange (0x%x) of ", type);
1805       bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
1806       fprintf (f, " lower ");
1807       bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
1808       fprintf (f, " upper ");
1809       bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
1810       break;
1811
1812   case 11:
1813     {
1814       long value;
1815
1816       fprintf (f, "named type (0x%x) ", type);
1817       bfd_sym_fetch_long (buf, len, offset, &offset, &value);
1818       if (value <= 0)
1819         fprintf (f, "[INVALID]");
1820       else
1821         fprintf (f, "\"%.*s\"",
1822                  bfd_sym_symbol_name (abfd, value)[0],
1823                  &bfd_sym_symbol_name (abfd, value)[1]);
1824
1825       fprintf (f, " (NTE %lu) with type ", value);
1826       bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset);
1827       break;
1828     }
1829
1830   default:
1831     fprintf (f, "%s (0x%x)", bfd_sym_type_operator_name (type), type);
1832     break;
1833     }
1834
1835   if (type == (0x40 | 0x6))
1836     {
1837       /* Vector.  */
1838       long n, width, m;
1839       long l;
1840       long i;
1841
1842       bfd_sym_fetch_long (buf, len, offset, &offset, &n);
1843       bfd_sym_fetch_long (buf, len, offset, &offset, &width);
1844       bfd_sym_fetch_long (buf, len, offset, &offset, &m);
1845       /* fprintf (f, "\n                "); */
1846       fprintf (f, " N %ld, width %ld, M %ld, ", n, width, m);
1847       for (i = 0; i < m; i++)
1848         {
1849           bfd_sym_fetch_long (buf, len, offset, &offset, &l);
1850           if (i != 0)
1851             fprintf (f, " ");
1852           fprintf (f, "%ld", l);
1853         }
1854     }
1855   else  if (type & 0x40)
1856     {
1857       /* Other packed type.  */
1858       long msb, lsb;
1859
1860       bfd_sym_fetch_long (buf, len, offset, &offset, &msb);
1861       bfd_sym_fetch_long (buf, len, offset, &offset, &lsb);
1862       /* fprintf (f, "\n                "); */
1863       fprintf (f, " msb %ld, lsb %ld", msb, lsb);
1864     }
1865
1866   fprintf (f, "]");
1867
1868   if (offsetptr != NULL)
1869     *offsetptr = offset;
1870 }
1871
1872 void
1873 bfd_sym_print_type_information_table_entry (abfd, f, entry)
1874      bfd *abfd;
1875      FILE *f;
1876      bfd_sym_type_information_table_entry *entry;
1877 {
1878   unsigned char *buf;
1879   unsigned long offset;
1880   unsigned int i;
1881
1882   fprintf (f, "\"%.*s\" (NTE %lu), %lu bytes at %lu, logical size %lu",
1883            bfd_sym_symbol_name (abfd, entry->nte_index)[0],
1884            &bfd_sym_symbol_name (abfd, entry->nte_index)[1],
1885            entry->nte_index,
1886            entry->physical_size, entry->offset, entry->logical_size);
1887
1888   fprintf (f, "\n            ");
1889
1890   buf = alloca (entry->physical_size);
1891   if (buf == NULL)
1892     {
1893       fprintf (f, "[ERROR]\n");
1894       return;
1895     }
1896   if (bfd_seek (abfd, entry->offset, SEEK_SET) < 0)
1897     {
1898       fprintf (f, "[ERROR]\n");
1899       return;
1900     }
1901   if (bfd_bread (buf, entry->physical_size, abfd) != entry->physical_size)
1902     {
1903       fprintf (f, "[ERROR]\n");
1904       return;
1905     }
1906
1907   fprintf (f, "[");
1908   for (i = 0; i < entry->physical_size; i++)
1909     {
1910       if (i == 0)
1911         fprintf (f, "0x%02x", buf[i]);
1912       else
1913         fprintf (f, " 0x%02x", buf[i]);
1914     }
1915
1916   fprintf (f, "]");
1917   fprintf (f, "\n            ");
1918
1919   bfd_sym_print_type_information (abfd, f, buf, entry->physical_size, 0, &offset);
1920
1921   if (offset != entry->physical_size)
1922     fprintf (f, "\n            [parser used %lu bytes instead of %lu]", offset, entry->physical_size);        }
1923
1924 void
1925 bfd_sym_print_file_references_index_table_entry (abfd, f, entry)
1926      bfd *abfd ATTRIBUTE_UNUSED;
1927      FILE *f;
1928      bfd_sym_file_references_index_table_entry *entry ATTRIBUTE_UNUSED;
1929 {
1930   fprintf (f, "[UNIMPLEMENTED]");
1931 }
1932
1933 void
1934 bfd_sym_print_constant_pool_entry (abfd, f, entry)
1935      bfd *abfd ATTRIBUTE_UNUSED;
1936      FILE *f;
1937      bfd_sym_constant_pool_entry *entry ATTRIBUTE_UNUSED;
1938 {
1939   fprintf (f, "[UNIMPLEMENTED]");
1940 }
1941
1942 unsigned char *
1943 bfd_sym_display_name_table_entry (abfd, f, entry)
1944      bfd *abfd;
1945      FILE *f;
1946      unsigned char *entry;
1947 {
1948   unsigned long index;
1949   unsigned long offset;
1950   bfd_sym_data_struct *sdata = NULL;
1951
1952   BFD_ASSERT (bfd_sym_valid (abfd));
1953   sdata = abfd->tdata.sym_data;
1954   index = (entry - sdata->name_table) / 2;
1955
1956   if (sdata->version >= BFD_SYM_VERSION_3_4 && entry[0] == 255 && entry[1] == 0)
1957     {
1958       unsigned short length = bfd_getb16 (entry + 2);
1959       fprintf (f, "[%8lu] \"%.*s\"\n", index, length, entry + 4);
1960       offset = 2 + length + 1;
1961     }
1962   else
1963     {
1964       if (! (entry[0] == 0 || (entry[0] == 1 && entry[1] == '\0')))
1965         fprintf (f, "[%8lu] \"%.*s\"\n", index, entry[0], entry + 1);
1966
1967       if (sdata->version >= BFD_SYM_VERSION_3_4)
1968         offset = entry[0] + 2;
1969       else
1970         offset = entry[0] + 1;
1971     }
1972
1973   return (entry + offset + (offset % 2));
1974 }
1975
1976 void
1977 bfd_sym_display_name_table (abfd, f)
1978      bfd *abfd;
1979      FILE *f;
1980 {
1981   unsigned long name_table_len;
1982   unsigned char *name_table, *name_table_end, *cur;
1983   bfd_sym_data_struct *sdata = NULL;
1984
1985   BFD_ASSERT (bfd_sym_valid (abfd));
1986   sdata = abfd->tdata.sym_data;
1987
1988   name_table_len = sdata->header.dshb_nte.dti_page_count * sdata->header.dshb_page_size;
1989   name_table = sdata->name_table;
1990   name_table_end = name_table + name_table_len;
1991
1992   fprintf (f, "name table (NTE) contains %lu bytes:\n\n", name_table_len);
1993
1994   cur = name_table;
1995   for (;;)
1996     {
1997       cur = bfd_sym_display_name_table_entry (abfd, f, cur);
1998       if (cur >= name_table_end)
1999         break;
2000     }
2001 }
2002
2003 void
2004 bfd_sym_display_resources_table (abfd, f)
2005      bfd *abfd;
2006      FILE *f;
2007 {
2008   unsigned long i;
2009   bfd_sym_resources_table_entry entry;
2010   bfd_sym_data_struct *sdata = NULL;
2011
2012   BFD_ASSERT (bfd_sym_valid (abfd));
2013   sdata = abfd->tdata.sym_data;
2014
2015   fprintf (f, "resource table (RTE) contains %lu objects:\n\n",
2016            sdata->header.dshb_rte.dti_object_count);
2017
2018   for (i = 1; i <= sdata->header.dshb_rte.dti_object_count; i++)
2019     {
2020       if (bfd_sym_fetch_resources_table_entry (abfd, &entry, i) < 0)
2021         fprintf (f, " [%8lu] [INVALID]\n", i);
2022       else
2023         {
2024           fprintf (f, " [%8lu] ", i);
2025           bfd_sym_print_resources_table_entry (abfd, f, &entry);
2026           fprintf (f, "\n");
2027         }
2028     }
2029 }
2030
2031 void
2032 bfd_sym_display_modules_table (abfd, f)
2033      bfd *abfd;
2034      FILE *f;
2035 {
2036   unsigned long i;
2037   bfd_sym_modules_table_entry entry;
2038   bfd_sym_data_struct *sdata = NULL;
2039
2040   BFD_ASSERT (bfd_sym_valid (abfd));
2041   sdata = abfd->tdata.sym_data;
2042
2043   fprintf (f, "module table (MTE) contains %lu objects:\n\n",
2044            sdata->header.dshb_mte.dti_object_count);
2045
2046   for (i = 1; i <= sdata->header.dshb_mte.dti_object_count; i++)
2047     {
2048       if (bfd_sym_fetch_modules_table_entry (abfd, &entry, i) < 0)
2049         fprintf (f, " [%8lu] [INVALID]\n", i);
2050       else
2051         {
2052           fprintf (f, " [%8lu] ", i);
2053           bfd_sym_print_modules_table_entry (abfd, f, &entry);
2054           fprintf (f, "\n");
2055         }
2056     }
2057 }
2058
2059 void
2060 bfd_sym_display_file_references_table (abfd, f)
2061      bfd *abfd;
2062      FILE *f;
2063 {
2064   unsigned long i;
2065   bfd_sym_file_references_table_entry entry;
2066   bfd_sym_data_struct *sdata = NULL;
2067
2068   BFD_ASSERT (bfd_sym_valid (abfd));
2069   sdata = abfd->tdata.sym_data;
2070
2071   fprintf (f, "file reference table (FRTE) contains %lu objects:\n\n",
2072            sdata->header.dshb_frte.dti_object_count);
2073
2074   for (i = 1; i <= sdata->header.dshb_frte.dti_object_count; i++)
2075     {
2076       if (bfd_sym_fetch_file_references_table_entry (abfd, &entry, i) < 0)
2077         fprintf (f, " [%8lu] [INVALID]\n", i);
2078       else
2079         {
2080           fprintf (f, " [%8lu] ", i);
2081           bfd_sym_print_file_references_table_entry (abfd, f, &entry);
2082           fprintf (f, "\n");
2083         }
2084     }
2085 }
2086
2087 void
2088 bfd_sym_display_contained_modules_table (abfd, f)
2089      bfd *abfd;
2090      FILE *f;
2091 {
2092   unsigned long i;
2093   bfd_sym_contained_modules_table_entry entry;
2094   bfd_sym_data_struct *sdata = NULL;
2095
2096   BFD_ASSERT (bfd_sym_valid (abfd));
2097   sdata = abfd->tdata.sym_data;
2098
2099   fprintf (f, "contained modules table (CMTE) contains %lu objects:\n\n",
2100            sdata->header.dshb_cmte.dti_object_count);
2101
2102   for (i = 1; i <= sdata->header.dshb_cmte.dti_object_count; i++)
2103     {
2104       if (bfd_sym_fetch_contained_modules_table_entry (abfd, &entry, i) < 0)
2105         fprintf (f, " [%8lu] [INVALID]\n", i);
2106       else
2107         {
2108           fprintf (f, " [%8lu] ", i);
2109           bfd_sym_print_contained_modules_table_entry (abfd, f, &entry);
2110           fprintf (f, "\n");
2111         }
2112     }
2113 }
2114
2115 void
2116 bfd_sym_display_contained_variables_table (abfd, f)
2117      bfd *abfd;
2118      FILE *f;
2119 {
2120   unsigned long i;
2121   bfd_sym_contained_variables_table_entry entry;
2122   bfd_sym_data_struct *sdata = NULL;
2123
2124   BFD_ASSERT (bfd_sym_valid (abfd));
2125   sdata = abfd->tdata.sym_data;
2126
2127   fprintf (f, "contained variables table (CVTE) contains %lu objects:\n\n",
2128            sdata->header.dshb_cvte.dti_object_count);
2129
2130   for (i = 1; i <= sdata->header.dshb_cvte.dti_object_count; i++)
2131     {
2132       if (bfd_sym_fetch_contained_variables_table_entry (abfd, &entry, i) < 0)
2133         fprintf (f, " [%8lu] [INVALID]\n", i);
2134       else
2135         {
2136           fprintf (f, " [%8lu] ", i);
2137           bfd_sym_print_contained_variables_table_entry (abfd, f, &entry);
2138           fprintf (f, "\n");
2139         }
2140     }
2141
2142   fprintf (f, "\n");
2143 }
2144
2145 void
2146 bfd_sym_display_contained_statements_table (abfd, f)
2147      bfd *abfd;
2148      FILE *f;
2149 {
2150   unsigned long i;
2151   bfd_sym_contained_statements_table_entry entry;
2152   bfd_sym_data_struct *sdata = NULL;
2153
2154   BFD_ASSERT (bfd_sym_valid (abfd));
2155   sdata = abfd->tdata.sym_data;
2156
2157   fprintf (f, "contained statements table (CSNTE) contains %lu objects:\n\n",
2158            sdata->header.dshb_csnte.dti_object_count);
2159
2160   for (i = 1; i <= sdata->header.dshb_csnte.dti_object_count; i++)
2161     {
2162       if (bfd_sym_fetch_contained_statements_table_entry (abfd, &entry, i) < 0)
2163         fprintf (f, " [%8lu] [INVALID]\n", i);
2164       else
2165         {
2166           fprintf (f, " [%8lu] ", i);
2167           bfd_sym_print_contained_statements_table_entry (abfd, f, &entry);
2168           fprintf (f, "\n");
2169         }
2170     }
2171 }
2172
2173 void
2174 bfd_sym_display_contained_labels_table (abfd, f)
2175      bfd *abfd;
2176      FILE *f;
2177 {
2178   unsigned long i;
2179   bfd_sym_contained_labels_table_entry entry;
2180   bfd_sym_data_struct *sdata = NULL;
2181
2182   BFD_ASSERT (bfd_sym_valid (abfd));
2183   sdata = abfd->tdata.sym_data;
2184
2185   fprintf (f, "contained labels table (CLTE) contains %lu objects:\n\n",
2186            sdata->header.dshb_clte.dti_object_count);
2187
2188   for (i = 1; i <= sdata->header.dshb_clte.dti_object_count; i++)
2189     {
2190       if (bfd_sym_fetch_contained_labels_table_entry (abfd, &entry, i) < 0)
2191         fprintf (f, " [%8lu] [INVALID]\n", i);
2192       else
2193         {
2194           fprintf (f, " [%8lu] ", i);
2195           bfd_sym_print_contained_labels_table_entry (abfd, f, &entry);
2196           fprintf (f, "\n");
2197         }
2198     }
2199 }
2200
2201 void
2202 bfd_sym_display_contained_types_table (abfd, f)
2203      bfd *abfd;
2204      FILE *f;
2205 {
2206   unsigned long i;
2207   bfd_sym_contained_types_table_entry entry;
2208   bfd_sym_data_struct *sdata = NULL;
2209
2210   BFD_ASSERT (bfd_sym_valid (abfd));
2211   sdata = abfd->tdata.sym_data;
2212
2213   fprintf (f, "contained types table (CTTE) contains %lu objects:\n\n",
2214            sdata->header.dshb_ctte.dti_object_count);
2215
2216   for (i = 1; i <= sdata->header.dshb_ctte.dti_object_count; i++)
2217     {
2218       if (bfd_sym_fetch_contained_types_table_entry (abfd, &entry, i) < 0)
2219         fprintf (f, " [%8lu] [INVALID]\n", i);
2220       else
2221         {
2222           fprintf (f, " [%8lu] ", i);
2223           bfd_sym_print_contained_types_table_entry (abfd, f, &entry);
2224           fprintf (f, "\n");
2225         }
2226     }
2227 }
2228
2229 void
2230 bfd_sym_display_file_references_index_table (abfd, f)
2231      bfd *abfd;
2232      FILE *f;
2233 {
2234   unsigned long i;
2235   bfd_sym_file_references_index_table_entry entry;
2236   bfd_sym_data_struct *sdata = NULL;
2237
2238   BFD_ASSERT (bfd_sym_valid (abfd));
2239   sdata = abfd->tdata.sym_data;
2240
2241   fprintf (f, "file references index table (FITE) contains %lu objects:\n\n",
2242            sdata->header.dshb_fite.dti_object_count);
2243
2244   for (i = 1; i <= sdata->header.dshb_fite.dti_object_count; i++)
2245     {
2246       if (bfd_sym_fetch_file_references_index_table_entry (abfd, &entry, i) < 0)
2247         fprintf (f, " [%8lu] [INVALID]\n", i);
2248       else
2249         {
2250           fprintf (f, " [%8lu] ", i);
2251           bfd_sym_print_file_references_index_table_entry (abfd, f, &entry);
2252           fprintf (f, "\n");
2253         }
2254     }
2255 }
2256
2257 void
2258 bfd_sym_display_constant_pool (abfd, f)
2259      bfd *abfd;
2260      FILE *f;
2261 {
2262   unsigned long i;
2263   bfd_sym_constant_pool_entry entry;
2264   bfd_sym_data_struct *sdata = NULL;
2265
2266   BFD_ASSERT (bfd_sym_valid (abfd));
2267   sdata = abfd->tdata.sym_data;
2268
2269   fprintf (f, "constant pool (CONST) contains %lu objects:\n\n",
2270            sdata->header.dshb_const.dti_object_count);
2271
2272   for (i = 1; i <= sdata->header.dshb_const.dti_object_count; i++)
2273     {
2274       if (bfd_sym_fetch_constant_pool_entry (abfd, &entry, i) < 0)
2275         fprintf (f, " [%8lu] [INVALID]\n", i);
2276       else
2277         {
2278           fprintf (f, " [%8lu] ", i);
2279           bfd_sym_print_constant_pool_entry (abfd, f, &entry);
2280           fprintf (f, "\n");
2281         }
2282     }
2283 }
2284
2285 void
2286 bfd_sym_display_type_information_table (abfd, f)
2287      bfd *abfd;
2288      FILE *f;
2289 {
2290   unsigned long i;
2291   bfd_sym_type_table_entry index;
2292   bfd_sym_type_information_table_entry entry;
2293   bfd_sym_data_struct *sdata = NULL;
2294
2295   BFD_ASSERT (bfd_sym_valid (abfd));
2296   sdata = abfd->tdata.sym_data;
2297
2298   if (sdata->header.dshb_tte.dti_object_count > 99)
2299     fprintf (f, "type table (TINFO) contains %lu objects:\n\n",
2300              sdata->header.dshb_tte.dti_object_count - 99);
2301   else
2302     {
2303       fprintf (f, "type table (TINFO) contains [INVALID] objects:\n\n");
2304       return;
2305     }
2306
2307   for (i = 100; i <= sdata->header.dshb_tte.dti_object_count; i++)
2308     {
2309       if (bfd_sym_fetch_type_table_entry (abfd, &index, i - 100) < 0)
2310         fprintf (f, " [%8lu] [INVALID]\n", i);
2311       else
2312         {
2313           fprintf (f, " [%8lu] (TINFO %lu) ", i, index);
2314
2315           if (bfd_sym_fetch_type_information_table_entry (abfd, &entry, index) < 0)
2316             fprintf (f, "[INVALID]");
2317           else
2318             bfd_sym_print_type_information_table_entry (abfd, f, &entry);
2319
2320           fprintf (f, "\n");
2321         }
2322     }
2323 }
2324
2325 int
2326 bfd_sym_scan (abfd, version, mdata)
2327      bfd *abfd;
2328      bfd_sym_version version;
2329      bfd_sym_data_struct *mdata;
2330 {
2331   asection *bfdsec;
2332   const char *name = "symbols";
2333
2334   mdata->name_table = 0;
2335   mdata->sbfd = abfd;
2336   mdata->version = version;
2337
2338   bfd_seek (abfd, 0, SEEK_SET);
2339   if (bfd_sym_read_header (abfd, &mdata->header, mdata->version) != 0)
2340     return -1;
2341
2342   mdata->name_table = bfd_sym_read_name_table (abfd, &mdata->header);
2343   if (mdata->name_table == NULL)
2344     return -1;
2345
2346   bfdsec = bfd_make_section_anyway (abfd, name);
2347   if (bfdsec == NULL)
2348     return -1;
2349
2350   bfdsec->vma = 0;
2351   bfdsec->lma = 0;
2352   bfdsec->size = 0;
2353   bfdsec->filepos = 0;
2354   bfdsec->alignment_power = 0;
2355
2356   bfdsec->flags = SEC_HAS_CONTENTS;
2357
2358   abfd->tdata.sym_data = mdata;
2359
2360   return 0;
2361 }
2362
2363 const bfd_target *
2364 bfd_sym_object_p (abfd)
2365      bfd *abfd;
2366 {
2367   struct bfd_preserve preserve;
2368   bfd_sym_version version = -1;
2369
2370   preserve.marker = NULL;
2371   bfd_seek (abfd, 0, SEEK_SET);
2372   if (bfd_sym_read_version (abfd, &version) != 0)
2373     goto wrong;
2374
2375   preserve.marker = bfd_alloc (abfd, sizeof (bfd_sym_data_struct));
2376   if (preserve.marker == NULL
2377       || ! bfd_preserve_save (abfd, &preserve))
2378     goto fail;
2379
2380   if (bfd_sym_scan (abfd, version,
2381                     (bfd_sym_data_struct *) preserve.marker) != 0)
2382     goto wrong;
2383
2384   bfd_preserve_finish (abfd, &preserve);
2385   return abfd->xvec;
2386
2387  wrong:
2388   bfd_set_error (bfd_error_wrong_format);
2389
2390  fail:
2391   if (preserve.marker != NULL)
2392     bfd_preserve_restore (abfd, &preserve);
2393   return NULL;
2394 }
2395
2396 asymbol *
2397 bfd_sym_make_empty_symbol (abfd)
2398      bfd *abfd;
2399 {
2400   return (asymbol *) bfd_alloc (abfd, sizeof (asymbol));
2401 }
2402
2403 void
2404 bfd_sym_get_symbol_info (abfd, symbol, ret)
2405      bfd *abfd ATTRIBUTE_UNUSED;
2406      asymbol *symbol;
2407      symbol_info *ret;
2408 {
2409   bfd_symbol_info (symbol, ret);
2410 }
2411
2412 long
2413 bfd_sym_get_symtab_upper_bound (abfd)
2414      bfd *abfd ATTRIBUTE_UNUSED;
2415 {
2416   return 0;
2417 }
2418
2419 long
2420 bfd_sym_canonicalize_symtab (abfd, sym)
2421      bfd *abfd ATTRIBUTE_UNUSED;
2422      asymbol **sym ATTRIBUTE_UNUSED;
2423 {
2424   return 0;
2425 }
2426
2427 int
2428 bfd_sym_sizeof_headers (abfd, exec)
2429      bfd *abfd ATTRIBUTE_UNUSED;
2430      bfd_boolean exec ATTRIBUTE_UNUSED;
2431 {
2432   return 0;
2433 }
2434
2435 const bfd_target sym_vec =
2436 {
2437   "sym",                        /* name */
2438   bfd_target_sym_flavour,       /* flavour */
2439   BFD_ENDIAN_BIG,               /* byteorder */
2440   BFD_ENDIAN_BIG,               /* header_byteorder */
2441   (HAS_RELOC | EXEC_P |         /* object flags */
2442    HAS_LINENO | HAS_DEBUG |
2443    HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
2444   (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE | SEC_DATA
2445    | SEC_ROM | SEC_HAS_CONTENTS), /* section_flags */
2446   0,                            /* symbol_leading_char */
2447   ' ',                          /* ar_pad_char */
2448   16,                           /* ar_max_namelen */
2449   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2450   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2451   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* data */
2452   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2453   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2454   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* hdrs */
2455   {                             /* bfd_check_format */
2456     _bfd_dummy_target,
2457     bfd_sym_object_p,           /* bfd_check_format */
2458     _bfd_dummy_target,
2459     _bfd_dummy_target,
2460   },
2461   {                             /* bfd_set_format */
2462     bfd_false,
2463     bfd_sym_mkobject,
2464     bfd_false,
2465     bfd_false,
2466   },
2467   {                             /* bfd_write_contents */
2468     bfd_false,
2469     bfd_true,
2470     bfd_false,
2471     bfd_false,
2472   },
2473
2474   BFD_JUMP_TABLE_GENERIC (bfd_sym),
2475   BFD_JUMP_TABLE_COPY (_bfd_generic),
2476   BFD_JUMP_TABLE_CORE (_bfd_nocore),
2477   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
2478   BFD_JUMP_TABLE_SYMBOLS (bfd_sym),
2479   BFD_JUMP_TABLE_RELOCS (bfd_sym),
2480   BFD_JUMP_TABLE_WRITE (bfd_sym),
2481   BFD_JUMP_TABLE_LINK (bfd_sym),
2482   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2483
2484   NULL,
2485
2486   NULL
2487 };
2488