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