bfd/xsym.c

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