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