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