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