bfd/xsym.c

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