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 size_t table_size = dshb->dshb_nte.dti_page_count * dshb->dshb_page_size; 131 size_t table_offset = dshb->dshb_nte.dti_first_page * dshb->dshb_page_size; 132 133 if (bfd_seek (abfd, table_offset, SEEK_SET) != 0) 134 return FALSE; 135 return _bfd_alloc_and_read (abfd, table_size, table_size); 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 sym_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 (sym_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, sym_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 sym_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 (sym_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, sym_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 sym_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 (sym_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, sym_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 sym_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 (sym_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, sym_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 sym_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 (sym_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, sym_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 sym_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 (sym_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, sym_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 sym_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 (sym_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, sym_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 sym_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 (sym_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, sym_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 sym_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 (sym_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, sym_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 sym_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 (sym_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, sym_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 sym_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, sym_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 1081 BFD_ASSERT (bfd_sym_valid (abfd)); 1082 1083 if (offset == 0) 1084 return -1; 1085 1086 if (bfd_seek (abfd, offset, SEEK_SET) < 0) 1087 return -1; 1088 1089 if (bfd_bread (buf, 4, abfd) != 4) 1090 return -1; 1091 entry->nte_index = bfd_getb32 (buf); 1092 1093 if (bfd_bread (buf, 2, abfd) != 2) 1094 return -1; 1095 entry->physical_size = bfd_getb16 (buf); 1096 1097 if (entry->physical_size & 0x8000) 1098 { 1099 if (bfd_bread (buf, 4, abfd) != 4) 1100 return -1; 1101 entry->physical_size &= 0x7fff; 1102 entry->logical_size = bfd_getb32 (buf); 1103 entry->offset = offset + 10; 1104 } 1105 else 1106 { 1107 if (bfd_bread (buf, 2, abfd) != 2) 1108 return -1; 1109 entry->physical_size &= 0x7fff; 1110 entry->logical_size = bfd_getb16 (buf); 1111 entry->offset = offset + 8; 1112 } 1113 1114 return 0; 1115 } 1116 1117 int 1118 bfd_sym_fetch_type_table_information (bfd *abfd, 1119 bfd_sym_type_information_table_entry *entry, 1120 unsigned long sym_index) 1121 { 1122 bfd_sym_type_table_entry tindex; 1123 bfd_sym_data_struct *sdata = NULL; 1124 1125 BFD_ASSERT (bfd_sym_valid (abfd)); 1126 sdata = abfd->tdata.sym_data; 1127 1128 if (sdata->header.dshb_tte.dti_object_count <= 99) 1129 return -1; 1130 if (sym_index < 100) 1131 return -1; 1132 1133 if (bfd_sym_fetch_type_table_entry (abfd, &tindex, sym_index - 100) < 0) 1134 return -1; 1135 if (bfd_sym_fetch_type_information_table_entry (abfd, entry, tindex) < 0) 1136 return -1; 1137 1138 return 0; 1139 } 1140 1141 const unsigned char * 1142 bfd_sym_symbol_name (bfd *abfd, unsigned long sym_index) 1143 { 1144 bfd_sym_data_struct *sdata = NULL; 1145 1146 BFD_ASSERT (bfd_sym_valid (abfd)); 1147 sdata = abfd->tdata.sym_data; 1148 1149 if (sym_index == 0) 1150 return (const unsigned char *) ""; 1151 1152 sym_index *= 2; 1153 if ((sym_index / sdata->header.dshb_page_size) 1154 > sdata->header.dshb_nte.dti_page_count) 1155 return (const unsigned char *) "\09[INVALID]"; 1156 1157 return (const unsigned char *) sdata->name_table + sym_index; 1158 } 1159 1160 const unsigned char * 1161 bfd_sym_module_name (bfd *abfd, unsigned long sym_index) 1162 { 1163 bfd_sym_modules_table_entry entry; 1164 1165 if (bfd_sym_fetch_modules_table_entry (abfd, &entry, sym_index) < 0) 1166 return (const unsigned char *) "\09[INVALID]"; 1167 1168 return bfd_sym_symbol_name (abfd, entry.mte_nte_index); 1169 } 1170 1171 const char * 1172 bfd_sym_unparse_storage_kind (enum bfd_sym_storage_kind kind) 1173 { 1174 switch (kind) 1175 { 1176 case BFD_SYM_STORAGE_KIND_LOCAL: return "LOCAL"; 1177 case BFD_SYM_STORAGE_KIND_VALUE: return "VALUE"; 1178 case BFD_SYM_STORAGE_KIND_REFERENCE: return "REFERENCE"; 1179 case BFD_SYM_STORAGE_KIND_WITH: return "WITH"; 1180 default: return "[UNKNOWN]"; 1181 } 1182 } 1183 1184 const char * 1185 bfd_sym_unparse_storage_class (enum bfd_sym_storage_class kind) 1186 { 1187 switch (kind) 1188 { 1189 case BFD_SYM_STORAGE_CLASS_REGISTER: return "REGISTER"; 1190 case BFD_SYM_STORAGE_CLASS_GLOBAL: return "GLOBAL"; 1191 case BFD_SYM_STORAGE_CLASS_FRAME_RELATIVE: return "FRAME_RELATIVE"; 1192 case BFD_SYM_STORAGE_CLASS_STACK_RELATIVE: return "STACK_RELATIVE"; 1193 case BFD_SYM_STORAGE_CLASS_ABSOLUTE: return "ABSOLUTE"; 1194 case BFD_SYM_STORAGE_CLASS_CONSTANT: return "CONSTANT"; 1195 case BFD_SYM_STORAGE_CLASS_RESOURCE: return "RESOURCE"; 1196 case BFD_SYM_STORAGE_CLASS_BIGCONSTANT: return "BIGCONSTANT"; 1197 default: return "[UNKNOWN]"; 1198 } 1199 } 1200 1201 const char * 1202 bfd_sym_unparse_module_kind (enum bfd_sym_module_kind kind) 1203 { 1204 switch (kind) 1205 { 1206 case BFD_SYM_MODULE_KIND_NONE: return "NONE"; 1207 case BFD_SYM_MODULE_KIND_PROGRAM: return "PROGRAM"; 1208 case BFD_SYM_MODULE_KIND_UNIT: return "UNIT"; 1209 case BFD_SYM_MODULE_KIND_PROCEDURE: return "PROCEDURE"; 1210 case BFD_SYM_MODULE_KIND_FUNCTION: return "FUNCTION"; 1211 case BFD_SYM_MODULE_KIND_DATA: return "DATA"; 1212 case BFD_SYM_MODULE_KIND_BLOCK: return "BLOCK"; 1213 default: return "[UNKNOWN]"; 1214 } 1215 } 1216 1217 const char * 1218 bfd_sym_unparse_symbol_scope (enum bfd_sym_symbol_scope scope) 1219 { 1220 switch (scope) 1221 { 1222 case BFD_SYM_SYMBOL_SCOPE_LOCAL: return "LOCAL"; 1223 case BFD_SYM_SYMBOL_SCOPE_GLOBAL: return "GLOBAL"; 1224 default: 1225 return "[UNKNOWN]"; 1226 } 1227 } 1228 1229 void 1230 bfd_sym_print_file_reference (bfd *abfd, 1231 FILE *f, 1232 bfd_sym_file_reference *entry) 1233 { 1234 bfd_sym_file_references_table_entry frtentry; 1235 int ret; 1236 1237 ret = bfd_sym_fetch_file_references_table_entry (abfd, &frtentry, 1238 entry->fref_frte_index); 1239 fprintf (f, "FILE "); 1240 1241 if ((ret < 0) || (frtentry.generic.type != BFD_SYM_FILE_NAME_INDEX)) 1242 fprintf (f, "[INVALID]"); 1243 else 1244 fprintf (f, "\"%.*s\"", 1245 bfd_sym_symbol_name (abfd, frtentry.filename.nte_index)[0], 1246 &bfd_sym_symbol_name (abfd, frtentry.filename.nte_index)[1]); 1247 1248 fprintf (f, " (FRTE %lu)", entry->fref_frte_index); 1249 } 1250 1251 void 1252 bfd_sym_print_resources_table_entry (bfd *abfd, 1253 FILE *f, 1254 bfd_sym_resources_table_entry *entry) 1255 { 1256 fprintf (f, " \"%.*s\" (NTE %lu), type \"%.4s\", num %u, size %lu, MTE %lu -- %lu", 1257 bfd_sym_symbol_name (abfd, entry->rte_nte_index)[0], 1258 &bfd_sym_symbol_name (abfd, entry->rte_nte_index)[1], 1259 entry->rte_nte_index, entry->rte_res_type, entry->rte_res_number, 1260 entry->rte_res_size, entry->rte_mte_first, entry->rte_mte_last); 1261 } 1262 1263 void 1264 bfd_sym_print_modules_table_entry (bfd *abfd, 1265 FILE *f, 1266 bfd_sym_modules_table_entry *entry) 1267 { 1268 fprintf (f, "\"%.*s\" (NTE %lu)", 1269 bfd_sym_symbol_name (abfd, entry->mte_nte_index)[0], 1270 &bfd_sym_symbol_name (abfd, entry->mte_nte_index)[1], 1271 entry->mte_nte_index); 1272 1273 fprintf (f, "\n "); 1274 1275 bfd_sym_print_file_reference (abfd, f, &entry->mte_imp_fref); 1276 fprintf (f, " range %lu -- %lu", 1277 entry->mte_imp_fref.fref_offset, entry->mte_imp_end); 1278 1279 fprintf (f, "\n "); 1280 1281 fprintf (f, "kind %s", bfd_sym_unparse_module_kind (entry->mte_kind)); 1282 fprintf (f, ", scope %s", bfd_sym_unparse_symbol_scope (entry->mte_scope)); 1283 1284 fprintf (f, ", RTE %lu, offset %lu, size %lu", 1285 entry->mte_rte_index, entry->mte_res_offset, entry->mte_size); 1286 1287 fprintf (f, "\n "); 1288 1289 fprintf (f, "CMTE %lu, CVTE %lu, CLTE %lu, CTTE %lu, CSNTE1 %lu, CSNTE2 %lu", 1290 entry->mte_cmte_index, entry->mte_cvte_index, 1291 entry->mte_clte_index, entry->mte_ctte_index, 1292 entry->mte_csnte_idx_1, entry->mte_csnte_idx_2); 1293 1294 if (entry->mte_parent != 0) 1295 fprintf (f, ", parent %lu", entry->mte_parent); 1296 else 1297 fprintf (f, ", no parent"); 1298 1299 if (entry->mte_cmte_index != 0) 1300 fprintf (f, ", child %lu", entry->mte_cmte_index); 1301 else 1302 fprintf (f, ", no child"); 1303 } 1304 1305 void 1306 bfd_sym_print_file_references_table_entry (bfd *abfd, 1307 FILE *f, 1308 bfd_sym_file_references_table_entry *entry) 1309 { 1310 switch (entry->generic.type) 1311 { 1312 case BFD_SYM_FILE_NAME_INDEX: 1313 fprintf (f, "FILE \"%.*s\" (NTE %lu), modtime ", 1314 bfd_sym_symbol_name (abfd, entry->filename.nte_index)[0], 1315 &bfd_sym_symbol_name (abfd, entry->filename.nte_index)[1], 1316 entry->filename.nte_index); 1317 1318 fprintf (f, "[UNIMPLEMENTED]"); 1319 /* printModDate (entry->filename.mod_date); */ 1320 fprintf (f, " (0x%lx)", entry->filename.mod_date); 1321 break; 1322 1323 case BFD_SYM_END_OF_LIST: 1324 fprintf (f, "END"); 1325 break; 1326 1327 default: 1328 fprintf (f, "\"%.*s\" (MTE %lu), offset %lu", 1329 bfd_sym_module_name (abfd, entry->entry.mte_index)[0], 1330 &bfd_sym_module_name (abfd, entry->entry.mte_index)[1], 1331 entry->entry.mte_index, 1332 entry->entry.file_offset); 1333 break; 1334 } 1335 } 1336 1337 void 1338 bfd_sym_print_contained_modules_table_entry (bfd *abfd, 1339 FILE *f, 1340 bfd_sym_contained_modules_table_entry *entry) 1341 { 1342 switch (entry->generic.type) 1343 { 1344 case BFD_SYM_END_OF_LIST: 1345 fprintf (f, "END"); 1346 break; 1347 1348 default: 1349 fprintf (f, "\"%.*s\" (MTE %lu, NTE %lu)", 1350 bfd_sym_module_name (abfd, entry->entry.mte_index)[0], 1351 &bfd_sym_module_name (abfd, entry->entry.mte_index)[1], 1352 entry->entry.mte_index, 1353 entry->entry.nte_index); 1354 break; 1355 } 1356 } 1357 1358 void 1359 bfd_sym_print_contained_variables_table_entry (bfd *abfd, 1360 FILE *f, 1361 bfd_sym_contained_variables_table_entry *entry) 1362 { 1363 if (entry->generic.type == BFD_SYM_END_OF_LIST) 1364 { 1365 fprintf (f, "END"); 1366 return; 1367 } 1368 1369 if (entry->generic.type == BFD_SYM_SOURCE_FILE_CHANGE) 1370 { 1371 bfd_sym_print_file_reference (abfd, f, &entry->file.fref); 1372 fprintf (f, " offset %lu", entry->file.fref.fref_offset); 1373 return; 1374 } 1375 1376 fprintf (f, "\"%.*s\" (NTE %lu)", 1377 bfd_sym_symbol_name (abfd, entry->entry.nte_index)[0], 1378 &bfd_sym_symbol_name (abfd, entry->entry.nte_index)[1], 1379 entry->entry.nte_index); 1380 1381 fprintf (f, ", TTE %lu", entry->entry.tte_index); 1382 fprintf (f, ", offset %lu", entry->entry.file_delta); 1383 fprintf (f, ", scope %s", bfd_sym_unparse_symbol_scope (entry->entry.scope)); 1384 1385 if (entry->entry.la_size == BFD_SYM_CVTE_SCA) 1386 fprintf (f, ", latype %s, laclass %s, laoffset %lu", 1387 bfd_sym_unparse_storage_kind (entry->entry.address.scstruct.sca_kind), 1388 bfd_sym_unparse_storage_class (entry->entry.address.scstruct.sca_class), 1389 entry->entry.address.scstruct.sca_offset); 1390 else if (entry->entry.la_size <= BFD_SYM_CVTE_LA_MAX_SIZE) 1391 { 1392 unsigned long i; 1393 1394 fprintf (f, ", la ["); 1395 for (i = 0; i < entry->entry.la_size; i++) 1396 fprintf (f, "0x%02x ", entry->entry.address.lastruct.la[i]); 1397 fprintf (f, "]"); 1398 } 1399 else if (entry->entry.la_size == BFD_SYM_CVTE_BIG_LA) 1400 fprintf (f, ", bigla %lu, biglakind %u", 1401 entry->entry.address.biglastruct.big_la, 1402 entry->entry.address.biglastruct.big_la_kind); 1403 1404 else 1405 fprintf (f, ", la [INVALID]"); 1406 } 1407 1408 void 1409 bfd_sym_print_contained_statements_table_entry (bfd *abfd, 1410 FILE *f, 1411 bfd_sym_contained_statements_table_entry *entry) 1412 { 1413 if (entry->generic.type == BFD_SYM_END_OF_LIST) 1414 { 1415 fprintf (f, "END"); 1416 return; 1417 } 1418 1419 if (entry->generic.type == BFD_SYM_SOURCE_FILE_CHANGE) 1420 { 1421 bfd_sym_print_file_reference (abfd, f, &entry->file.fref); 1422 fprintf (f, " offset %lu", entry->file.fref.fref_offset); 1423 return; 1424 } 1425 1426 fprintf (f, "\"%.*s\" (MTE %lu), offset %lu, delta %lu", 1427 bfd_sym_module_name (abfd, entry->entry.mte_index)[0], 1428 &bfd_sym_module_name (abfd, entry->entry.mte_index)[1], 1429 entry->entry.mte_index, 1430 entry->entry.mte_offset, 1431 entry->entry.file_delta); 1432 } 1433 1434 void 1435 bfd_sym_print_contained_labels_table_entry (bfd *abfd, 1436 FILE *f, 1437 bfd_sym_contained_labels_table_entry *entry) 1438 { 1439 if (entry->generic.type == BFD_SYM_END_OF_LIST) 1440 { 1441 fprintf (f, "END"); 1442 return; 1443 } 1444 1445 if (entry->generic.type == BFD_SYM_SOURCE_FILE_CHANGE) 1446 { 1447 bfd_sym_print_file_reference (abfd, f, &entry->file.fref); 1448 fprintf (f, " offset %lu", entry->file.fref.fref_offset); 1449 return; 1450 } 1451 1452 fprintf (f, "\"%.*s\" (MTE %lu), offset %lu, delta %lu, scope %s", 1453 bfd_sym_module_name (abfd, entry->entry.mte_index)[0], 1454 &bfd_sym_module_name (abfd, entry->entry.mte_index)[1], 1455 entry->entry.mte_index, 1456 entry->entry.mte_offset, 1457 entry->entry.file_delta, 1458 bfd_sym_unparse_symbol_scope (entry->entry.scope)); 1459 } 1460 1461 void 1462 bfd_sym_print_contained_types_table_entry (bfd *abfd ATTRIBUTE_UNUSED, 1463 FILE *f, 1464 bfd_sym_contained_types_table_entry *entry ATTRIBUTE_UNUSED) 1465 { 1466 fprintf (f, "[UNIMPLEMENTED]"); 1467 } 1468 1469 const char * 1470 bfd_sym_type_operator_name (unsigned char num) 1471 { 1472 switch (num) 1473 { 1474 case 1: return "TTE"; 1475 case 2: return "PointerTo"; 1476 case 3: return "ScalarOf"; 1477 case 4: return "ConstantOf"; 1478 case 5: return "EnumerationOf"; 1479 case 6: return "VectorOf"; 1480 case 7: return "RecordOf"; 1481 case 8: return "UnionOf"; 1482 case 9: return "SubRangeOf"; 1483 case 10: return "SetOf"; 1484 case 11: return "NamedTypeOf"; 1485 case 12: return "ProcOf"; 1486 case 13: return "ValueOf"; 1487 case 14: return "ArrayOf"; 1488 default: return "[UNKNOWN OPERATOR]"; 1489 } 1490 } 1491 1492 const char * 1493 bfd_sym_type_basic_name (unsigned char num) 1494 { 1495 switch (num) 1496 { 1497 case 0: return "void"; 1498 case 1: return "pascal string"; 1499 case 2: return "unsigned long"; 1500 case 3: return "signed long"; 1501 case 4: return "extended (10 bytes)"; 1502 case 5: return "pascal boolean (1 byte)"; 1503 case 6: return "unsigned byte"; 1504 case 7: return "signed byte"; 1505 case 8: return "character (1 byte)"; 1506 case 9: return "wide character (2 bytes)"; 1507 case 10: return "unsigned short"; 1508 case 11: return "signed short"; 1509 case 12: return "singled"; 1510 case 13: return "double"; 1511 case 14: return "extended (12 bytes)"; 1512 case 15: return "computational (8 bytes)"; 1513 case 16: return "c string"; 1514 case 17: return "as-is string"; 1515 default: return "[UNKNOWN BASIC TYPE]"; 1516 } 1517 } 1518 1519 int 1520 bfd_sym_fetch_long (unsigned char *buf, 1521 unsigned long len, 1522 unsigned long offset, 1523 unsigned long *offsetptr, 1524 long *value) 1525 { 1526 int ret; 1527 1528 if (offset >= len) 1529 { 1530 *value = 0; 1531 offset += 0; 1532 ret = -1; 1533 } 1534 else if (! (buf[offset] & 0x80)) 1535 { 1536 *value = buf[offset]; 1537 offset += 1; 1538 ret = 0; 1539 } 1540 else if (buf[offset] == 0xc0) 1541 { 1542 if ((offset + 5) > len) 1543 { 1544 *value = 0; 1545 offset = len; 1546 ret = -1; 1547 } 1548 else 1549 { 1550 *value = bfd_getb32 (buf + offset + 1); 1551 offset += 5; 1552 ret = 0; 1553 } 1554 } 1555 else if ((buf[offset] & 0xc0) == 0xc0) 1556 { 1557 *value = -(buf[offset] & 0x3f); 1558 offset += 1; 1559 ret = 0; 1560 } 1561 else if ((buf[offset] & 0xc0) == 0x80) 1562 { 1563 if ((offset + 2) > len) 1564 { 1565 *value = 0; 1566 offset = len; 1567 ret = -1; 1568 } 1569 else 1570 { 1571 *value = bfd_getb16 (buf + offset) & 0x3fff; 1572 offset += 2; 1573 ret = 0; 1574 } 1575 } 1576 else 1577 abort (); 1578 1579 if (offsetptr != NULL) 1580 *offsetptr = offset; 1581 1582 return ret; 1583 } 1584 1585 void 1586 bfd_sym_print_type_information (bfd *abfd, 1587 FILE *f, 1588 unsigned char *buf, 1589 unsigned long len, 1590 unsigned long offset, 1591 unsigned long *offsetptr) 1592 { 1593 unsigned int type; 1594 1595 if (offset >= len) 1596 { 1597 fprintf (f, "[NULL]"); 1598 1599 if (offsetptr != NULL) 1600 *offsetptr = offset; 1601 return; 1602 } 1603 1604 type = buf[offset]; 1605 offset++; 1606 1607 if (! (type & 0x80)) 1608 { 1609 fprintf (f, "[%s] (0x%x)", bfd_sym_type_basic_name (type & 0x7f), type); 1610 1611 if (offsetptr != NULL) 1612 *offsetptr = offset; 1613 return; 1614 } 1615 1616 if (type & 0x40) 1617 fprintf (f, "[packed "); 1618 else 1619 fprintf (f, "["); 1620 1621 switch (type & 0x3f) 1622 { 1623 case 1: 1624 { 1625 long value; 1626 bfd_sym_type_information_table_entry tinfo; 1627 1628 bfd_sym_fetch_long (buf, len, offset, &offset, &value); 1629 if (value <= 0) 1630 fprintf (f, "[INVALID]"); 1631 else 1632 { 1633 if (bfd_sym_fetch_type_table_information (abfd, &tinfo, value) < 0) 1634 fprintf (f, "[INVALID]"); 1635 else 1636 fprintf (f, "\"%.*s\"", 1637 bfd_sym_symbol_name (abfd, tinfo.nte_index)[0], 1638 &bfd_sym_symbol_name (abfd, tinfo.nte_index)[1]); 1639 } 1640 fprintf (f, " (TTE %lu)", (unsigned long) value); 1641 break; 1642 } 1643 1644 case 2: 1645 fprintf (f, "pointer (0x%x) to ", type); 1646 bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset); 1647 break; 1648 1649 case 3: 1650 { 1651 long value; 1652 1653 fprintf (f, "scalar (0x%x) of ", type); 1654 bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset); 1655 bfd_sym_fetch_long (buf, len, offset, &offset, &value); 1656 fprintf (f, " (%lu)", (unsigned long) value); 1657 break; 1658 } 1659 1660 case 5: 1661 { 1662 long lower, upper, nelem; 1663 int i; 1664 1665 fprintf (f, "enumeration (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, &lower); 1668 bfd_sym_fetch_long (buf, len, offset, &offset, &upper); 1669 bfd_sym_fetch_long (buf, len, offset, &offset, &nelem); 1670 fprintf (f, " from %lu to %lu with %lu elements: ", 1671 (unsigned long) lower, (unsigned long) upper, 1672 (unsigned long) nelem); 1673 1674 for (i = 0; i < nelem; i++) 1675 { 1676 fprintf (f, "\n "); 1677 bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset); 1678 } 1679 break; 1680 } 1681 1682 case 6: 1683 fprintf (f, "vector (0x%x)", type); 1684 fprintf (f, "\n index "); 1685 bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset); 1686 fprintf (f, "\n target "); 1687 bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset); 1688 break; 1689 1690 case 7: 1691 case 8: 1692 { 1693 long nrec, eloff, i; 1694 1695 if ((type & 0x3f) == 7) 1696 fprintf (f, "record (0x%x) of ", type); 1697 else 1698 fprintf (f, "union (0x%x) of ", type); 1699 1700 bfd_sym_fetch_long (buf, len, offset, &offset, &nrec); 1701 fprintf (f, "%lu elements: ", (unsigned long) nrec); 1702 1703 for (i = 0; i < nrec; i++) 1704 { 1705 bfd_sym_fetch_long (buf, len, offset, &offset, &eloff); 1706 fprintf (f, "\n "); 1707 fprintf (f, "offset %lu: ", (unsigned long) eloff); 1708 bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset); 1709 } 1710 break; 1711 } 1712 1713 case 9: 1714 fprintf (f, "subrange (0x%x) of ", type); 1715 bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset); 1716 fprintf (f, " lower "); 1717 bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset); 1718 fprintf (f, " upper "); 1719 bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset); 1720 break; 1721 1722 case 11: 1723 { 1724 long value; 1725 1726 fprintf (f, "named type (0x%x) ", type); 1727 bfd_sym_fetch_long (buf, len, offset, &offset, &value); 1728 if (value <= 0) 1729 fprintf (f, "[INVALID]"); 1730 else 1731 fprintf (f, "\"%.*s\"", 1732 bfd_sym_symbol_name (abfd, value)[0], 1733 &bfd_sym_symbol_name (abfd, value)[1]); 1734 1735 fprintf (f, " (NTE %lu) with type ", (unsigned long) value); 1736 bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset); 1737 break; 1738 } 1739 1740 default: 1741 fprintf (f, "%s (0x%x)", bfd_sym_type_operator_name (type), type); 1742 break; 1743 } 1744 1745 if (type == (0x40 | 0x6)) 1746 { 1747 /* Vector. */ 1748 long n, width, m; 1749 long l; 1750 long i; 1751 1752 bfd_sym_fetch_long (buf, len, offset, &offset, &n); 1753 bfd_sym_fetch_long (buf, len, offset, &offset, &width); 1754 bfd_sym_fetch_long (buf, len, offset, &offset, &m); 1755 /* fprintf (f, "\n "); */ 1756 fprintf (f, " N %ld, width %ld, M %ld, ", n, width, m); 1757 for (i = 0; i < m; i++) 1758 { 1759 bfd_sym_fetch_long (buf, len, offset, &offset, &l); 1760 if (i != 0) 1761 fprintf (f, " "); 1762 fprintf (f, "%ld", l); 1763 } 1764 } 1765 else if (type & 0x40) 1766 { 1767 /* Other packed type. */ 1768 long msb, lsb; 1769 1770 bfd_sym_fetch_long (buf, len, offset, &offset, &msb); 1771 bfd_sym_fetch_long (buf, len, offset, &offset, &lsb); 1772 /* fprintf (f, "\n "); */ 1773 fprintf (f, " msb %ld, lsb %ld", msb, lsb); 1774 } 1775 1776 fprintf (f, "]"); 1777 1778 if (offsetptr != NULL) 1779 *offsetptr = offset; 1780 } 1781 1782 void 1783 bfd_sym_print_type_information_table_entry (bfd *abfd, 1784 FILE *f, 1785 bfd_sym_type_information_table_entry *entry) 1786 { 1787 unsigned char *buf; 1788 unsigned long offset; 1789 unsigned int i; 1790 1791 fprintf (f, "\"%.*s\" (NTE %lu), %lu bytes at %lu, logical size %lu", 1792 bfd_sym_symbol_name (abfd, entry->nte_index)[0], 1793 &bfd_sym_symbol_name (abfd, entry->nte_index)[1], 1794 entry->nte_index, 1795 entry->physical_size, entry->offset, entry->logical_size); 1796 1797 fprintf (f, "\n "); 1798 1799 if (bfd_seek (abfd, entry->offset, SEEK_SET) != 0 1800 || (buf = _bfd_malloc_and_read (abfd, entry->physical_size, 1801 entry->physical_size)) == NULL) 1802 { 1803 fprintf (f, "[ERROR]\n"); 1804 return; 1805 } 1806 1807 fprintf (f, "["); 1808 for (i = 0; i < entry->physical_size; i++) 1809 { 1810 if (i == 0) 1811 fprintf (f, "0x%02x", buf[i]); 1812 else 1813 fprintf (f, " 0x%02x", buf[i]); 1814 } 1815 1816 fprintf (f, "]"); 1817 fprintf (f, "\n "); 1818 1819 bfd_sym_print_type_information (abfd, f, buf, entry->physical_size, 0, &offset); 1820 1821 if (offset != entry->physical_size) 1822 fprintf (f, "\n [parser used %lu bytes instead of %lu]", offset, entry->physical_size); 1823 free (buf); 1824 } 1825 1826 void 1827 bfd_sym_print_file_references_index_table_entry (bfd *abfd ATTRIBUTE_UNUSED, 1828 FILE *f, 1829 bfd_sym_file_references_index_table_entry *entry ATTRIBUTE_UNUSED) 1830 { 1831 fprintf (f, "[UNIMPLEMENTED]"); 1832 } 1833 1834 void 1835 bfd_sym_print_constant_pool_entry (bfd *abfd ATTRIBUTE_UNUSED, 1836 FILE *f, 1837 bfd_sym_constant_pool_entry *entry ATTRIBUTE_UNUSED) 1838 { 1839 fprintf (f, "[UNIMPLEMENTED]"); 1840 } 1841 1842 unsigned char * 1843 bfd_sym_display_name_table_entry (bfd *abfd, 1844 FILE *f, 1845 unsigned char *entry) 1846 { 1847 unsigned long sym_index; 1848 unsigned long offset; 1849 bfd_sym_data_struct *sdata = NULL; 1850 1851 BFD_ASSERT (bfd_sym_valid (abfd)); 1852 sdata = abfd->tdata.sym_data; 1853 sym_index = (entry - sdata->name_table) / 2; 1854 1855 if (sdata->version >= BFD_SYM_VERSION_3_4 && entry[0] == 255 && entry[1] == 0) 1856 { 1857 unsigned short length = bfd_getb16 (entry + 2); 1858 fprintf (f, "[%8lu] \"%.*s\"\n", sym_index, length, entry + 4); 1859 offset = 2 + length + 1; 1860 } 1861 else 1862 { 1863 if (! (entry[0] == 0 || (entry[0] == 1 && entry[1] == '\0'))) 1864 fprintf (f, "[%8lu] \"%.*s\"\n", sym_index, entry[0], entry + 1); 1865 1866 if (sdata->version >= BFD_SYM_VERSION_3_4) 1867 offset = entry[0] + 2; 1868 else 1869 offset = entry[0] + 1; 1870 } 1871 1872 return (entry + offset + (offset % 2)); 1873 } 1874 1875 void 1876 bfd_sym_display_name_table (bfd *abfd, FILE *f) 1877 { 1878 unsigned long name_table_len; 1879 unsigned char *name_table, *name_table_end, *cur; 1880 bfd_sym_data_struct *sdata = NULL; 1881 1882 BFD_ASSERT (bfd_sym_valid (abfd)); 1883 sdata = abfd->tdata.sym_data; 1884 1885 name_table_len = sdata->header.dshb_nte.dti_page_count * sdata->header.dshb_page_size; 1886 name_table = sdata->name_table; 1887 name_table_end = name_table + name_table_len; 1888 1889 fprintf (f, "name table (NTE) contains %lu bytes:\n\n", name_table_len); 1890 1891 cur = name_table; 1892 for (;;) 1893 { 1894 cur = bfd_sym_display_name_table_entry (abfd, f, cur); 1895 if (cur >= name_table_end) 1896 break; 1897 } 1898 } 1899 1900 void 1901 bfd_sym_display_resources_table (bfd *abfd, FILE *f) 1902 { 1903 unsigned long i; 1904 bfd_sym_resources_table_entry entry; 1905 bfd_sym_data_struct *sdata = NULL; 1906 1907 BFD_ASSERT (bfd_sym_valid (abfd)); 1908 sdata = abfd->tdata.sym_data; 1909 1910 fprintf (f, "resource table (RTE) contains %lu objects:\n\n", 1911 sdata->header.dshb_rte.dti_object_count); 1912 1913 for (i = 1; i <= sdata->header.dshb_rte.dti_object_count; i++) 1914 { 1915 if (bfd_sym_fetch_resources_table_entry (abfd, &entry, i) < 0) 1916 fprintf (f, " [%8lu] [INVALID]\n", i); 1917 else 1918 { 1919 fprintf (f, " [%8lu] ", i); 1920 bfd_sym_print_resources_table_entry (abfd, f, &entry); 1921 fprintf (f, "\n"); 1922 } 1923 } 1924 } 1925 1926 void 1927 bfd_sym_display_modules_table (bfd *abfd, FILE *f) 1928 { 1929 unsigned long i; 1930 bfd_sym_modules_table_entry entry; 1931 bfd_sym_data_struct *sdata = NULL; 1932 1933 BFD_ASSERT (bfd_sym_valid (abfd)); 1934 sdata = abfd->tdata.sym_data; 1935 1936 fprintf (f, "module table (MTE) contains %lu objects:\n\n", 1937 sdata->header.dshb_mte.dti_object_count); 1938 1939 for (i = 1; i <= sdata->header.dshb_mte.dti_object_count; i++) 1940 { 1941 if (bfd_sym_fetch_modules_table_entry (abfd, &entry, i) < 0) 1942 fprintf (f, " [%8lu] [INVALID]\n", i); 1943 else 1944 { 1945 fprintf (f, " [%8lu] ", i); 1946 bfd_sym_print_modules_table_entry (abfd, f, &entry); 1947 fprintf (f, "\n"); 1948 } 1949 } 1950 } 1951 1952 void 1953 bfd_sym_display_file_references_table (bfd *abfd, FILE *f) 1954 { 1955 unsigned long i; 1956 bfd_sym_file_references_table_entry entry; 1957 bfd_sym_data_struct *sdata = NULL; 1958 1959 BFD_ASSERT (bfd_sym_valid (abfd)); 1960 sdata = abfd->tdata.sym_data; 1961 1962 fprintf (f, "file reference table (FRTE) contains %lu objects:\n\n", 1963 sdata->header.dshb_frte.dti_object_count); 1964 1965 for (i = 1; i <= sdata->header.dshb_frte.dti_object_count; i++) 1966 { 1967 if (bfd_sym_fetch_file_references_table_entry (abfd, &entry, i) < 0) 1968 fprintf (f, " [%8lu] [INVALID]\n", i); 1969 else 1970 { 1971 fprintf (f, " [%8lu] ", i); 1972 bfd_sym_print_file_references_table_entry (abfd, f, &entry); 1973 fprintf (f, "\n"); 1974 } 1975 } 1976 } 1977 1978 void 1979 bfd_sym_display_contained_modules_table (bfd *abfd, FILE *f) 1980 { 1981 unsigned long i; 1982 bfd_sym_contained_modules_table_entry entry; 1983 bfd_sym_data_struct *sdata = NULL; 1984 1985 BFD_ASSERT (bfd_sym_valid (abfd)); 1986 sdata = abfd->tdata.sym_data; 1987 1988 fprintf (f, "contained modules table (CMTE) contains %lu objects:\n\n", 1989 sdata->header.dshb_cmte.dti_object_count); 1990 1991 for (i = 1; i <= sdata->header.dshb_cmte.dti_object_count; i++) 1992 { 1993 if (bfd_sym_fetch_contained_modules_table_entry (abfd, &entry, i) < 0) 1994 fprintf (f, " [%8lu] [INVALID]\n", i); 1995 else 1996 { 1997 fprintf (f, " [%8lu] ", i); 1998 bfd_sym_print_contained_modules_table_entry (abfd, f, &entry); 1999 fprintf (f, "\n"); 2000 } 2001 } 2002 } 2003 2004 void 2005 bfd_sym_display_contained_variables_table (bfd *abfd, FILE *f) 2006 { 2007 unsigned long i; 2008 bfd_sym_contained_variables_table_entry entry; 2009 bfd_sym_data_struct *sdata = NULL; 2010 2011 BFD_ASSERT (bfd_sym_valid (abfd)); 2012 sdata = abfd->tdata.sym_data; 2013 2014 fprintf (f, "contained variables table (CVTE) contains %lu objects:\n\n", 2015 sdata->header.dshb_cvte.dti_object_count); 2016 2017 for (i = 1; i <= sdata->header.dshb_cvte.dti_object_count; i++) 2018 { 2019 if (bfd_sym_fetch_contained_variables_table_entry (abfd, &entry, i) < 0) 2020 fprintf (f, " [%8lu] [INVALID]\n", i); 2021 else 2022 { 2023 fprintf (f, " [%8lu] ", i); 2024 bfd_sym_print_contained_variables_table_entry (abfd, f, &entry); 2025 fprintf (f, "\n"); 2026 } 2027 } 2028 2029 fprintf (f, "\n"); 2030 } 2031 2032 void 2033 bfd_sym_display_contained_statements_table (bfd *abfd, FILE *f) 2034 { 2035 unsigned long i; 2036 bfd_sym_contained_statements_table_entry entry; 2037 bfd_sym_data_struct *sdata = NULL; 2038 2039 BFD_ASSERT (bfd_sym_valid (abfd)); 2040 sdata = abfd->tdata.sym_data; 2041 2042 fprintf (f, "contained statements table (CSNTE) contains %lu objects:\n\n", 2043 sdata->header.dshb_csnte.dti_object_count); 2044 2045 for (i = 1; i <= sdata->header.dshb_csnte.dti_object_count; i++) 2046 { 2047 if (bfd_sym_fetch_contained_statements_table_entry (abfd, &entry, i) < 0) 2048 fprintf (f, " [%8lu] [INVALID]\n", i); 2049 else 2050 { 2051 fprintf (f, " [%8lu] ", i); 2052 bfd_sym_print_contained_statements_table_entry (abfd, f, &entry); 2053 fprintf (f, "\n"); 2054 } 2055 } 2056 } 2057 2058 void 2059 bfd_sym_display_contained_labels_table (bfd *abfd, FILE *f) 2060 { 2061 unsigned long i; 2062 bfd_sym_contained_labels_table_entry entry; 2063 bfd_sym_data_struct *sdata = NULL; 2064 2065 BFD_ASSERT (bfd_sym_valid (abfd)); 2066 sdata = abfd->tdata.sym_data; 2067 2068 fprintf (f, "contained labels table (CLTE) contains %lu objects:\n\n", 2069 sdata->header.dshb_clte.dti_object_count); 2070 2071 for (i = 1; i <= sdata->header.dshb_clte.dti_object_count; i++) 2072 { 2073 if (bfd_sym_fetch_contained_labels_table_entry (abfd, &entry, i) < 0) 2074 fprintf (f, " [%8lu] [INVALID]\n", i); 2075 else 2076 { 2077 fprintf (f, " [%8lu] ", i); 2078 bfd_sym_print_contained_labels_table_entry (abfd, f, &entry); 2079 fprintf (f, "\n"); 2080 } 2081 } 2082 } 2083 2084 void 2085 bfd_sym_display_contained_types_table (bfd *abfd, FILE *f) 2086 { 2087 unsigned long i; 2088 bfd_sym_contained_types_table_entry entry; 2089 bfd_sym_data_struct *sdata = NULL; 2090 2091 BFD_ASSERT (bfd_sym_valid (abfd)); 2092 sdata = abfd->tdata.sym_data; 2093 2094 fprintf (f, "contained types table (CTTE) contains %lu objects:\n\n", 2095 sdata->header.dshb_ctte.dti_object_count); 2096 2097 for (i = 1; i <= sdata->header.dshb_ctte.dti_object_count; i++) 2098 { 2099 if (bfd_sym_fetch_contained_types_table_entry (abfd, &entry, i) < 0) 2100 fprintf (f, " [%8lu] [INVALID]\n", i); 2101 else 2102 { 2103 fprintf (f, " [%8lu] ", i); 2104 bfd_sym_print_contained_types_table_entry (abfd, f, &entry); 2105 fprintf (f, "\n"); 2106 } 2107 } 2108 } 2109 2110 void 2111 bfd_sym_display_file_references_index_table (bfd *abfd, FILE *f) 2112 { 2113 unsigned long i; 2114 bfd_sym_file_references_index_table_entry entry; 2115 bfd_sym_data_struct *sdata = NULL; 2116 2117 BFD_ASSERT (bfd_sym_valid (abfd)); 2118 sdata = abfd->tdata.sym_data; 2119 2120 fprintf (f, "file references index table (FITE) contains %lu objects:\n\n", 2121 sdata->header.dshb_fite.dti_object_count); 2122 2123 for (i = 1; i <= sdata->header.dshb_fite.dti_object_count; i++) 2124 { 2125 if (bfd_sym_fetch_file_references_index_table_entry (abfd, &entry, i) < 0) 2126 fprintf (f, " [%8lu] [INVALID]\n", i); 2127 else 2128 { 2129 fprintf (f, " [%8lu] ", i); 2130 bfd_sym_print_file_references_index_table_entry (abfd, f, &entry); 2131 fprintf (f, "\n"); 2132 } 2133 } 2134 } 2135 2136 void 2137 bfd_sym_display_constant_pool (bfd *abfd, FILE *f) 2138 { 2139 unsigned long i; 2140 bfd_sym_constant_pool_entry entry; 2141 bfd_sym_data_struct *sdata = NULL; 2142 2143 BFD_ASSERT (bfd_sym_valid (abfd)); 2144 sdata = abfd->tdata.sym_data; 2145 2146 fprintf (f, "constant pool (CONST) contains %lu objects:\n\n", 2147 sdata->header.dshb_const.dti_object_count); 2148 2149 for (i = 1; i <= sdata->header.dshb_const.dti_object_count; i++) 2150 { 2151 if (bfd_sym_fetch_constant_pool_entry (abfd, &entry, i) < 0) 2152 fprintf (f, " [%8lu] [INVALID]\n", i); 2153 else 2154 { 2155 fprintf (f, " [%8lu] ", i); 2156 bfd_sym_print_constant_pool_entry (abfd, f, &entry); 2157 fprintf (f, "\n"); 2158 } 2159 } 2160 } 2161 2162 void 2163 bfd_sym_display_type_information_table (bfd *abfd, FILE *f) 2164 { 2165 unsigned long i; 2166 bfd_sym_type_table_entry sym_index; 2167 bfd_sym_type_information_table_entry entry; 2168 bfd_sym_data_struct *sdata = NULL; 2169 2170 BFD_ASSERT (bfd_sym_valid (abfd)); 2171 sdata = abfd->tdata.sym_data; 2172 2173 if (sdata->header.dshb_tte.dti_object_count > 99) 2174 fprintf (f, "type table (TINFO) contains %lu objects:\n\n", 2175 sdata->header.dshb_tte.dti_object_count - 99); 2176 else 2177 { 2178 fprintf (f, "type table (TINFO) contains [INVALID] objects:\n\n"); 2179 return; 2180 } 2181 2182 for (i = 100; i <= sdata->header.dshb_tte.dti_object_count; i++) 2183 { 2184 if (bfd_sym_fetch_type_table_entry (abfd, &sym_index, i - 100) < 0) 2185 fprintf (f, " [%8lu] [INVALID]\n", i); 2186 else 2187 { 2188 fprintf (f, " [%8lu] (TINFO %lu) ", i, sym_index); 2189 2190 if (bfd_sym_fetch_type_information_table_entry (abfd, &entry, sym_index) < 0) 2191 fprintf (f, "[INVALID]"); 2192 else 2193 bfd_sym_print_type_information_table_entry (abfd, f, &entry); 2194 2195 fprintf (f, "\n"); 2196 } 2197 } 2198 } 2199 2200 int 2201 bfd_sym_scan (bfd *abfd, bfd_sym_version version, bfd_sym_data_struct *mdata) 2202 { 2203 asection *bfdsec; 2204 const char *name = "symbols"; 2205 2206 mdata->name_table = 0; 2207 mdata->sbfd = abfd; 2208 mdata->version = version; 2209 2210 bfd_seek (abfd, 0, SEEK_SET); 2211 if (bfd_sym_read_header (abfd, &mdata->header, mdata->version) != 0) 2212 return -1; 2213 2214 mdata->name_table = bfd_sym_read_name_table (abfd, &mdata->header); 2215 if (mdata->name_table == NULL) 2216 return -1; 2217 2218 bfdsec = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS); 2219 if (bfdsec == NULL) 2220 return -1; 2221 2222 bfdsec->vma = 0; 2223 bfdsec->lma = 0; 2224 bfdsec->size = 0; 2225 bfdsec->filepos = 0; 2226 bfdsec->alignment_power = 0; 2227 2228 abfd->tdata.sym_data = mdata; 2229 2230 return 0; 2231 } 2232 2233 bfd_cleanup 2234 bfd_sym_object_p (bfd *abfd) 2235 { 2236 bfd_sym_version version = -1; 2237 bfd_sym_data_struct *mdata; 2238 2239 bfd_seek (abfd, 0, SEEK_SET); 2240 if (bfd_sym_read_version (abfd, &version) != 0) 2241 goto wrong; 2242 2243 mdata = (bfd_sym_data_struct *) bfd_alloc (abfd, sizeof (*mdata)); 2244 if (mdata == NULL) 2245 goto fail; 2246 2247 if (bfd_sym_scan (abfd, version, mdata) != 0) 2248 goto wrong; 2249 2250 return _bfd_no_cleanup; 2251 2252 wrong: 2253 bfd_set_error (bfd_error_wrong_format); 2254 2255 fail: 2256 return NULL; 2257 } 2258 2259 #define bfd_sym_make_empty_symbol _bfd_generic_make_empty_symbol 2260 2261 void 2262 bfd_sym_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED, asymbol *symbol, symbol_info *ret) 2263 { 2264 bfd_symbol_info (symbol, ret); 2265 } 2266 2267 long 2268 bfd_sym_get_symtab_upper_bound (bfd *abfd ATTRIBUTE_UNUSED) 2269 { 2270 return 0; 2271 } 2272 2273 long 2274 bfd_sym_canonicalize_symtab (bfd *abfd ATTRIBUTE_UNUSED, asymbol **sym ATTRIBUTE_UNUSED) 2275 { 2276 return 0; 2277 } 2278 2279 int 2280 bfd_sym_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED, 2281 struct bfd_link_info *info ATTRIBUTE_UNUSED) 2282 { 2283 return 0; 2284 } 2285 2286 const bfd_target sym_vec = 2287 { 2288 "sym", /* Name. */ 2289 bfd_target_sym_flavour, /* Flavour. */ 2290 BFD_ENDIAN_BIG, /* Byteorder. */ 2291 BFD_ENDIAN_BIG, /* Header byteorder. */ 2292 (HAS_RELOC | EXEC_P | /* Object flags. */ 2293 HAS_LINENO | HAS_DEBUG | 2294 HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED), 2295 (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE | SEC_DATA 2296 | SEC_ROM | SEC_HAS_CONTENTS), /* Section_flags. */ 2297 0, /* Symbol_leading_char. */ 2298 ' ', /* AR_pad_char. */ 2299 16, /* AR_max_namelen. */ 2300 0, /* match priority. */ 2301 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 2302 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 2303 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */ 2304 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 2305 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 2306 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Hdrs. */ 2307 { /* bfd_check_format. */ 2308 _bfd_dummy_target, 2309 bfd_sym_object_p, /* bfd_check_format. */ 2310 _bfd_dummy_target, 2311 _bfd_dummy_target, 2312 }, 2313 { /* bfd_set_format. */ 2314 _bfd_bool_bfd_false_error, 2315 bfd_sym_mkobject, 2316 _bfd_bool_bfd_false_error, 2317 _bfd_bool_bfd_false_error, 2318 }, 2319 { /* bfd_write_contents. */ 2320 _bfd_bool_bfd_false_error, 2321 _bfd_bool_bfd_true, 2322 _bfd_bool_bfd_false_error, 2323 _bfd_bool_bfd_false_error, 2324 }, 2325 2326 BFD_JUMP_TABLE_GENERIC (bfd_sym), 2327 BFD_JUMP_TABLE_COPY (_bfd_generic), 2328 BFD_JUMP_TABLE_CORE (_bfd_nocore), 2329 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive), 2330 BFD_JUMP_TABLE_SYMBOLS (bfd_sym), 2331 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs), 2332 BFD_JUMP_TABLE_WRITE (bfd_sym), 2333 BFD_JUMP_TABLE_LINK (bfd_sym), 2334 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 2335 2336 NULL, 2337 2338 NULL 2339 }; 2340