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