bfd/xsym.c

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