bfd/xsym.c

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