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