bfd/xsym.c

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