1 /* PEF support for BFD. 2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 3 2009, 2011 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 3 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, 20 MA 02110-1301, USA. */ 21 22 /* PEF (Preferred Executable Format) is the binary file format for late 23 classic Mac OS versions (before Darwin). It is supported by both m68k 24 and PowerPc. It is also called CFM (Code Fragment Manager). */ 25 26 #include "sysdep.h" 27 #include "safe-ctype.h" 28 #include "pef.h" 29 #include "pef-traceback.h" 30 #include "bfd.h" 31 #include "libbfd.h" 32 #include "libiberty.h" 33 34 #ifndef BFD_IO_FUNCS 35 #define BFD_IO_FUNCS 0 36 #endif 37 38 #define bfd_pef_close_and_cleanup _bfd_generic_close_and_cleanup 39 #define bfd_pef_bfd_free_cached_info _bfd_generic_bfd_free_cached_info 40 #define bfd_pef_new_section_hook _bfd_generic_new_section_hook 41 #define bfd_pef_bfd_is_local_label_name bfd_generic_is_local_label_name 42 #define bfd_pef_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false) 43 #define bfd_pef_get_lineno _bfd_nosymbols_get_lineno 44 #define bfd_pef_find_nearest_line _bfd_nosymbols_find_nearest_line 45 #define bfd_pef_find_inliner_info _bfd_nosymbols_find_inliner_info 46 #define bfd_pef_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol 47 #define bfd_pef_read_minisymbols _bfd_generic_read_minisymbols 48 #define bfd_pef_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol 49 #define bfd_pef_set_arch_mach _bfd_generic_set_arch_mach 50 #define bfd_pef_get_section_contents _bfd_generic_get_section_contents 51 #define bfd_pef_set_section_contents _bfd_generic_set_section_contents 52 #define bfd_pef_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents 53 #define bfd_pef_bfd_relax_section bfd_generic_relax_section 54 #define bfd_pef_bfd_gc_sections bfd_generic_gc_sections 55 #define bfd_pef_bfd_lookup_section_flags bfd_generic_lookup_section_flags 56 #define bfd_pef_bfd_merge_sections bfd_generic_merge_sections 57 #define bfd_pef_bfd_is_group_section bfd_generic_is_group_section 58 #define bfd_pef_bfd_discard_group bfd_generic_discard_group 59 #define bfd_pef_section_already_linked _bfd_generic_section_already_linked 60 #define bfd_pef_bfd_define_common_symbol bfd_generic_define_common_symbol 61 #define bfd_pef_bfd_link_hash_table_create _bfd_generic_link_hash_table_create 62 #define bfd_pef_bfd_link_hash_table_free _bfd_generic_link_hash_table_free 63 #define bfd_pef_bfd_link_add_symbols _bfd_generic_link_add_symbols 64 #define bfd_pef_bfd_link_just_syms _bfd_generic_link_just_syms 65 #define bfd_pef_bfd_copy_link_hash_symbol_type \ 66 _bfd_generic_copy_link_hash_symbol_type 67 #define bfd_pef_bfd_final_link _bfd_generic_final_link 68 #define bfd_pef_bfd_link_split_section _bfd_generic_link_split_section 69 #define bfd_pef_get_section_contents_in_window _bfd_generic_get_section_contents_in_window 70 71 static int 72 bfd_pef_parse_traceback_table (bfd *abfd, 73 asection *section, 74 unsigned char *buf, 75 size_t len, 76 size_t pos, 77 asymbol *sym, 78 FILE *file) 79 { 80 struct traceback_table table; 81 size_t offset; 82 const char *s; 83 asymbol tmpsymbol; 84 85 if (sym == NULL) 86 sym = & tmpsymbol; 87 88 sym->name = NULL; 89 sym->value = 0; 90 sym->the_bfd = abfd; 91 sym->section = section; 92 sym->flags = 0; 93 sym->udata.i = 0; 94 95 /* memcpy is fine since all fields are unsigned char. */ 96 if ((pos + 8) > len) 97 return -1; 98 memcpy (&table, buf + pos, 8); 99 100 /* Calling code relies on returned symbols having a name and 101 correct offset. */ 102 if ((table.lang != TB_C) && (table.lang != TB_CPLUSPLUS)) 103 return -1; 104 105 if (! (table.flags2 & TB_NAME_PRESENT)) 106 return -1; 107 108 if (! (table.flags1 & TB_HAS_TBOFF)) 109 return -1; 110 111 offset = 8; 112 113 if ((table.flags5 & TB_FLOATPARAMS) || (table.fixedparams)) 114 offset += 4; 115 116 if (table.flags1 & TB_HAS_TBOFF) 117 { 118 struct traceback_table_tboff off; 119 120 if ((pos + offset + 4) > len) 121 return -1; 122 off.tb_offset = bfd_getb32 (buf + pos + offset); 123 offset += 4; 124 125 /* Need to subtract 4 because the offset includes the 0x0L 126 preceding the table. */ 127 if (file != NULL) 128 fprintf (file, " [offset = 0x%lx]", off.tb_offset); 129 130 if ((file == NULL) && ((off.tb_offset + 4) > (pos + offset))) 131 return -1; 132 133 sym->value = pos - off.tb_offset - 4; 134 } 135 136 if (table.flags2 & TB_INT_HNDL) 137 offset += 4; 138 139 if (table.flags1 & TB_HAS_CTL) 140 { 141 struct traceback_table_anchors anchors; 142 143 if ((pos + offset + 4) > len) 144 return -1; 145 anchors.ctl_info = bfd_getb32 (buf + pos + offset); 146 offset += 4; 147 148 if (anchors.ctl_info > 1024) 149 return -1; 150 151 offset += anchors.ctl_info * 4; 152 } 153 154 if (table.flags2 & TB_NAME_PRESENT) 155 { 156 struct traceback_table_routine name; 157 char *namebuf; 158 159 if ((pos + offset + 2) > len) 160 return -1; 161 name.name_len = bfd_getb16 (buf + pos + offset); 162 offset += 2; 163 164 if (name.name_len > 4096) 165 return -1; 166 167 if ((pos + offset + name.name_len) > len) 168 return -1; 169 170 namebuf = bfd_alloc (abfd, name.name_len + 1); 171 if (namebuf == NULL) 172 return -1; 173 174 memcpy (namebuf, buf + pos + offset, name.name_len); 175 namebuf[name.name_len] = '\0'; 176 177 /* Strip leading period inserted by compiler. */ 178 if (namebuf[0] == '.') 179 memmove (namebuf, namebuf + 1, name.name_len + 1); 180 181 sym->name = namebuf; 182 183 for (s = sym->name; (*s != '\0'); s++) 184 if (! ISPRINT (*s)) 185 return -1; 186 187 offset += name.name_len; 188 } 189 190 if (table.flags2 & TB_USES_ALLOCA) 191 offset += 4; 192 193 if (table.flags4 & TB_HAS_VEC_INFO) 194 offset += 4; 195 196 if (file != NULL) 197 fprintf (file, " [length = 0x%lx]", (unsigned long) offset); 198 199 return offset; 200 } 201 202 static void 203 bfd_pef_print_symbol (bfd *abfd, 204 void * afile, 205 asymbol *symbol, 206 bfd_print_symbol_type how) 207 { 208 FILE *file = (FILE *) afile; 209 210 switch (how) 211 { 212 case bfd_print_symbol_name: 213 fprintf (file, "%s", symbol->name); 214 break; 215 default: 216 bfd_print_symbol_vandf (abfd, (void *) file, symbol); 217 fprintf (file, " %-5s %s", symbol->section->name, symbol->name); 218 if (CONST_STRNEQ (symbol->name, "__traceback_")) 219 { 220 unsigned char *buf = alloca (symbol->udata.i); 221 size_t offset = symbol->value + 4; 222 size_t len = symbol->udata.i; 223 int ret; 224 225 bfd_get_section_contents (abfd, symbol->section, buf, offset, len); 226 ret = bfd_pef_parse_traceback_table (abfd, symbol->section, buf, 227 len, 0, NULL, file); 228 if (ret < 0) 229 fprintf (file, " [ERROR]"); 230 } 231 } 232 } 233 234 static void 235 bfd_pef_convert_architecture (unsigned long architecture, 236 enum bfd_architecture *type, 237 unsigned long *subtype) 238 { 239 const unsigned long ARCH_POWERPC = 0x70777063; /* 'pwpc'. */ 240 const unsigned long ARCH_M68K = 0x6d36386b; /* 'm68k'. */ 241 242 *subtype = bfd_arch_unknown; 243 *type = bfd_arch_unknown; 244 245 if (architecture == ARCH_POWERPC) 246 *type = bfd_arch_powerpc; 247 else if (architecture == ARCH_M68K) 248 *type = bfd_arch_m68k; 249 } 250 251 static bfd_boolean 252 bfd_pef_mkobject (bfd *abfd ATTRIBUTE_UNUSED) 253 { 254 return TRUE; 255 } 256 257 static const char *bfd_pef_section_name (bfd_pef_section *section) 258 { 259 switch (section->section_kind) 260 { 261 case BFD_PEF_SECTION_CODE: return "code"; 262 case BFD_PEF_SECTION_UNPACKED_DATA: return "unpacked-data"; 263 case BFD_PEF_SECTION_PACKED_DATA: return "packed-data"; 264 case BFD_PEF_SECTION_CONSTANT: return "constant"; 265 case BFD_PEF_SECTION_LOADER: return "loader"; 266 case BFD_PEF_SECTION_DEBUG: return "debug"; 267 case BFD_PEF_SECTION_EXEC_DATA: return "exec-data"; 268 case BFD_PEF_SECTION_EXCEPTION: return "exception"; 269 case BFD_PEF_SECTION_TRACEBACK: return "traceback"; 270 default: return "unknown"; 271 } 272 } 273 274 static unsigned long bfd_pef_section_flags (bfd_pef_section *section) 275 { 276 switch (section->section_kind) 277 { 278 case BFD_PEF_SECTION_CODE: 279 return SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC | SEC_CODE; 280 case BFD_PEF_SECTION_UNPACKED_DATA: 281 case BFD_PEF_SECTION_PACKED_DATA: 282 case BFD_PEF_SECTION_CONSTANT: 283 case BFD_PEF_SECTION_LOADER: 284 case BFD_PEF_SECTION_DEBUG: 285 case BFD_PEF_SECTION_EXEC_DATA: 286 case BFD_PEF_SECTION_EXCEPTION: 287 case BFD_PEF_SECTION_TRACEBACK: 288 default: 289 return SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC; 290 } 291 } 292 293 static asection * 294 bfd_pef_make_bfd_section (bfd *abfd, bfd_pef_section *section) 295 { 296 asection *bfdsec; 297 const char *name = bfd_pef_section_name (section); 298 299 bfdsec = bfd_make_section_anyway (abfd, name); 300 if (bfdsec == NULL) 301 return NULL; 302 303 bfdsec->vma = section->default_address + section->container_offset; 304 bfdsec->lma = section->default_address + section->container_offset; 305 bfdsec->size = section->container_length; 306 bfdsec->filepos = section->container_offset; 307 bfdsec->alignment_power = section->alignment; 308 309 bfdsec->flags = bfd_pef_section_flags (section); 310 311 return bfdsec; 312 } 313 314 int 315 bfd_pef_parse_loader_header (bfd *abfd ATTRIBUTE_UNUSED, 316 unsigned char *buf, 317 size_t len, 318 bfd_pef_loader_header *header) 319 { 320 BFD_ASSERT (len == 56); 321 322 header->main_section = bfd_getb32 (buf); 323 header->main_offset = bfd_getb32 (buf + 4); 324 header->init_section = bfd_getb32 (buf + 8); 325 header->init_offset = bfd_getb32 (buf + 12); 326 header->term_section = bfd_getb32 (buf + 16); 327 header->term_offset = bfd_getb32 (buf + 20); 328 header->imported_library_count = bfd_getb32 (buf + 24); 329 header->total_imported_symbol_count = bfd_getb32 (buf + 28); 330 header->reloc_section_count = bfd_getb32 (buf + 32); 331 header->reloc_instr_offset = bfd_getb32 (buf + 36); 332 header->loader_strings_offset = bfd_getb32 (buf + 40); 333 header->export_hash_offset = bfd_getb32 (buf + 44); 334 header->export_hash_table_power = bfd_getb32 (buf + 48); 335 header->exported_symbol_count = bfd_getb32 (buf + 52); 336 337 return 0; 338 } 339 340 int 341 bfd_pef_parse_imported_library (bfd *abfd ATTRIBUTE_UNUSED, 342 unsigned char *buf, 343 size_t len, 344 bfd_pef_imported_library *header) 345 { 346 BFD_ASSERT (len == 24); 347 348 header->name_offset = bfd_getb32 (buf); 349 header->old_implementation_version = bfd_getb32 (buf + 4); 350 header->current_version = bfd_getb32 (buf + 8); 351 header->imported_symbol_count = bfd_getb32 (buf + 12); 352 header->first_imported_symbol = bfd_getb32 (buf + 16); 353 header->options = buf[20]; 354 header->reserved_a = buf[21]; 355 header->reserved_b = bfd_getb16 (buf + 22); 356 357 return 0; 358 } 359 360 int 361 bfd_pef_parse_imported_symbol (bfd *abfd ATTRIBUTE_UNUSED, 362 unsigned char *buf, 363 size_t len, 364 bfd_pef_imported_symbol *symbol) 365 { 366 unsigned long value; 367 368 BFD_ASSERT (len == 4); 369 370 value = bfd_getb32 (buf); 371 symbol->symbol_class = value >> 24; 372 symbol->name = value & 0x00ffffff; 373 374 return 0; 375 } 376 377 int 378 bfd_pef_scan_section (bfd *abfd, bfd_pef_section *section) 379 { 380 unsigned char buf[28]; 381 382 bfd_seek (abfd, section->header_offset, SEEK_SET); 383 if (bfd_bread ((void *) buf, 28, abfd) != 28) 384 return -1; 385 386 section->name_offset = bfd_h_get_32 (abfd, buf); 387 section->default_address = bfd_h_get_32 (abfd, buf + 4); 388 section->total_length = bfd_h_get_32 (abfd, buf + 8); 389 section->unpacked_length = bfd_h_get_32 (abfd, buf + 12); 390 section->container_length = bfd_h_get_32 (abfd, buf + 16); 391 section->container_offset = bfd_h_get_32 (abfd, buf + 20); 392 section->section_kind = buf[24]; 393 section->share_kind = buf[25]; 394 section->alignment = buf[26]; 395 section->reserved = buf[27]; 396 397 section->bfd_section = bfd_pef_make_bfd_section (abfd, section); 398 if (section->bfd_section == NULL) 399 return -1; 400 401 return 0; 402 } 403 404 void 405 bfd_pef_print_loader_header (bfd *abfd ATTRIBUTE_UNUSED, 406 bfd_pef_loader_header *header, 407 FILE *file) 408 { 409 fprintf (file, "main_section: %ld\n", header->main_section); 410 fprintf (file, "main_offset: %lu\n", header->main_offset); 411 fprintf (file, "init_section: %ld\n", header->init_section); 412 fprintf (file, "init_offset: %lu\n", header->init_offset); 413 fprintf (file, "term_section: %ld\n", header->term_section); 414 fprintf (file, "term_offset: %lu\n", header->term_offset); 415 fprintf (file, "imported_library_count: %lu\n", 416 header->imported_library_count); 417 fprintf (file, "total_imported_symbol_count: %lu\n", 418 header->total_imported_symbol_count); 419 fprintf (file, "reloc_section_count: %lu\n", header->reloc_section_count); 420 fprintf (file, "reloc_instr_offset: %lu\n", header->reloc_instr_offset); 421 fprintf (file, "loader_strings_offset: %lu\n", 422 header->loader_strings_offset); 423 fprintf (file, "export_hash_offset: %lu\n", header->export_hash_offset); 424 fprintf (file, "export_hash_table_power: %lu\n", 425 header->export_hash_table_power); 426 fprintf (file, "exported_symbol_count: %lu\n", 427 header->exported_symbol_count); 428 } 429 430 int 431 bfd_pef_print_loader_section (bfd *abfd, FILE *file) 432 { 433 bfd_pef_loader_header header; 434 asection *loadersec = NULL; 435 unsigned char *loaderbuf = NULL; 436 size_t loaderlen = 0; 437 438 loadersec = bfd_get_section_by_name (abfd, "loader"); 439 if (loadersec == NULL) 440 return -1; 441 442 loaderlen = loadersec->size; 443 loaderbuf = bfd_malloc (loaderlen); 444 445 if (bfd_seek (abfd, loadersec->filepos, SEEK_SET) < 0 446 || bfd_bread ((void *) loaderbuf, loaderlen, abfd) != loaderlen 447 || loaderlen < 56 448 || bfd_pef_parse_loader_header (abfd, loaderbuf, 56, &header) < 0) 449 { 450 free (loaderbuf); 451 return -1; 452 } 453 454 bfd_pef_print_loader_header (abfd, &header, file); 455 return 0; 456 } 457 458 int 459 bfd_pef_scan_start_address (bfd *abfd) 460 { 461 bfd_pef_loader_header header; 462 asection *section; 463 464 asection *loadersec = NULL; 465 unsigned char *loaderbuf = NULL; 466 size_t loaderlen = 0; 467 int ret; 468 469 loadersec = bfd_get_section_by_name (abfd, "loader"); 470 if (loadersec == NULL) 471 goto end; 472 473 loaderlen = loadersec->size; 474 loaderbuf = bfd_malloc (loaderlen); 475 if (bfd_seek (abfd, loadersec->filepos, SEEK_SET) < 0) 476 goto error; 477 if (bfd_bread ((void *) loaderbuf, loaderlen, abfd) != loaderlen) 478 goto error; 479 480 if (loaderlen < 56) 481 goto error; 482 ret = bfd_pef_parse_loader_header (abfd, loaderbuf, 56, &header); 483 if (ret < 0) 484 goto error; 485 486 if (header.main_section < 0) 487 goto end; 488 489 for (section = abfd->sections; section != NULL; section = section->next) 490 if ((section->index + 1) == header.main_section) 491 break; 492 493 if (section == NULL) 494 goto error; 495 496 abfd->start_address = section->vma + header.main_offset; 497 498 end: 499 if (loaderbuf != NULL) 500 free (loaderbuf); 501 return 0; 502 503 error: 504 if (loaderbuf != NULL) 505 free (loaderbuf); 506 return -1; 507 } 508 509 int 510 bfd_pef_scan (bfd *abfd, 511 bfd_pef_header *header, 512 bfd_pef_data_struct *mdata) 513 { 514 unsigned int i; 515 enum bfd_architecture cputype; 516 unsigned long cpusubtype; 517 518 mdata->header = *header; 519 520 bfd_pef_convert_architecture (header->architecture, &cputype, &cpusubtype); 521 if (cputype == bfd_arch_unknown) 522 { 523 (*_bfd_error_handler) (_("bfd_pef_scan: unknown architecture 0x%lx"), 524 header->architecture); 525 return -1; 526 } 527 bfd_set_arch_mach (abfd, cputype, cpusubtype); 528 529 mdata->header = *header; 530 531 abfd->flags = (abfd->xvec->object_flags 532 | (abfd->flags & (BFD_IN_MEMORY | BFD_IO_FUNCS))); 533 534 if (header->section_count != 0) 535 { 536 mdata->sections = bfd_alloc (abfd, header->section_count * sizeof (bfd_pef_section)); 537 538 if (mdata->sections == NULL) 539 return -1; 540 541 for (i = 0; i < header->section_count; i++) 542 { 543 bfd_pef_section *cur = &mdata->sections[i]; 544 cur->header_offset = 40 + (i * 28); 545 if (bfd_pef_scan_section (abfd, cur) < 0) 546 return -1; 547 } 548 } 549 550 if (bfd_pef_scan_start_address (abfd) < 0) 551 return -1; 552 553 abfd->tdata.pef_data = mdata; 554 555 return 0; 556 } 557 558 static int 559 bfd_pef_read_header (bfd *abfd, bfd_pef_header *header) 560 { 561 unsigned char buf[40]; 562 563 bfd_seek (abfd, 0, SEEK_SET); 564 565 if (bfd_bread ((void *) buf, 40, abfd) != 40) 566 return -1; 567 568 header->tag1 = bfd_getb32 (buf); 569 header->tag2 = bfd_getb32 (buf + 4); 570 header->architecture = bfd_getb32 (buf + 8); 571 header->format_version = bfd_getb32 (buf + 12); 572 header->timestamp = bfd_getb32 (buf + 16); 573 header->old_definition_version = bfd_getb32 (buf + 20); 574 header->old_implementation_version = bfd_getb32 (buf + 24); 575 header->current_version = bfd_getb32 (buf + 28); 576 header->section_count = bfd_getb32 (buf + 32) + 1; 577 header->instantiated_section_count = bfd_getb32 (buf + 34); 578 header->reserved = bfd_getb32 (buf + 36); 579 580 return 0; 581 } 582 583 static const bfd_target * 584 bfd_pef_object_p (bfd *abfd) 585 { 586 bfd_pef_header header; 587 bfd_pef_data_struct *mdata; 588 589 if (bfd_pef_read_header (abfd, &header) != 0) 590 goto wrong; 591 592 if (header.tag1 != BFD_PEF_TAG1 || header.tag2 != BFD_PEF_TAG2) 593 goto wrong; 594 595 mdata = (bfd_pef_data_struct *) bfd_zalloc (abfd, sizeof (*mdata)); 596 if (mdata == NULL) 597 goto fail; 598 599 if (bfd_pef_scan (abfd, &header, mdata)) 600 goto wrong; 601 602 return abfd->xvec; 603 604 wrong: 605 bfd_set_error (bfd_error_wrong_format); 606 607 fail: 608 return NULL; 609 } 610 611 static int 612 bfd_pef_parse_traceback_tables (bfd *abfd, 613 asection *sec, 614 unsigned char *buf, 615 size_t len, 616 long *nsym, 617 asymbol **csym) 618 { 619 char *name; 620 621 asymbol function; 622 asymbol traceback; 623 624 const char *const tbprefix = "__traceback_"; 625 size_t tbnamelen; 626 627 size_t pos = 0; 628 unsigned long count = 0; 629 int ret; 630 631 for (;;) 632 { 633 /* We're reading symbols two at a time. */ 634 if (csym && ((csym[count] == NULL) || (csym[count + 1] == NULL))) 635 break; 636 637 pos += 3; 638 pos -= (pos % 4); 639 640 while ((pos + 4) <= len) 641 { 642 if (bfd_getb32 (buf + pos) == 0) 643 break; 644 pos += 4; 645 } 646 647 if ((pos + 4) > len) 648 break; 649 650 ret = bfd_pef_parse_traceback_table (abfd, sec, buf, len, pos + 4, 651 &function, 0); 652 if (ret < 0) 653 { 654 /* Skip over 0x0L to advance to next possible traceback table. */ 655 pos += 4; 656 continue; 657 } 658 659 BFD_ASSERT (function.name != NULL); 660 661 /* Don't bother to compute the name if we are just 662 counting symbols. */ 663 if (csym) 664 { 665 tbnamelen = strlen (tbprefix) + strlen (function.name); 666 name = bfd_alloc (abfd, tbnamelen + 1); 667 if (name == NULL) 668 { 669 bfd_release (abfd, (void *) function.name); 670 function.name = NULL; 671 break; 672 } 673 snprintf (name, tbnamelen + 1, "%s%s", tbprefix, function.name); 674 traceback.name = name; 675 traceback.value = pos; 676 traceback.the_bfd = abfd; 677 traceback.section = sec; 678 traceback.flags = 0; 679 traceback.udata.i = ret; 680 681 *(csym[count]) = function; 682 *(csym[count + 1]) = traceback; 683 } 684 685 pos += ret; 686 count += 2; 687 } 688 689 *nsym = count; 690 return 0; 691 } 692 693 static int 694 bfd_pef_parse_function_stub (bfd *abfd ATTRIBUTE_UNUSED, 695 unsigned char *buf, 696 size_t len, 697 unsigned long *offset) 698 { 699 BFD_ASSERT (len == 24); 700 701 if ((bfd_getb32 (buf) & 0xffff0000) != 0x81820000) 702 return -1; 703 if (bfd_getb32 (buf + 4) != 0x90410014) 704 return -1; 705 if (bfd_getb32 (buf + 8) != 0x800c0000) 706 return -1; 707 if (bfd_getb32 (buf + 12) != 0x804c0004) 708 return -1; 709 if (bfd_getb32 (buf + 16) != 0x7c0903a6) 710 return -1; 711 if (bfd_getb32 (buf + 20) != 0x4e800420) 712 return -1; 713 714 if (offset != NULL) 715 *offset = (bfd_getb32 (buf) & 0x0000ffff) / 4; 716 717 return 0; 718 } 719 720 static int 721 bfd_pef_parse_function_stubs (bfd *abfd, 722 asection *codesec, 723 unsigned char *codebuf, 724 size_t codelen, 725 unsigned char *loaderbuf, 726 size_t loaderlen, 727 unsigned long *nsym, 728 asymbol **csym) 729 { 730 const char *const sprefix = "__stub_"; 731 size_t codepos = 0; 732 unsigned long count = 0; 733 bfd_pef_loader_header header; 734 bfd_pef_imported_library *libraries = NULL; 735 bfd_pef_imported_symbol *imports = NULL; 736 unsigned long i; 737 int ret; 738 739 if (loaderlen < 56) 740 goto error; 741 742 ret = bfd_pef_parse_loader_header (abfd, loaderbuf, 56, &header); 743 if (ret < 0) 744 goto error; 745 746 libraries = bfd_malloc 747 (header.imported_library_count * sizeof (bfd_pef_imported_library)); 748 imports = bfd_malloc 749 (header.total_imported_symbol_count * sizeof (bfd_pef_imported_symbol)); 750 751 if (loaderlen < (56 + (header.imported_library_count * 24))) 752 goto error; 753 for (i = 0; i < header.imported_library_count; i++) 754 { 755 ret = bfd_pef_parse_imported_library 756 (abfd, loaderbuf + 56 + (i * 24), 24, &libraries[i]); 757 if (ret < 0) 758 goto error; 759 } 760 761 if (loaderlen < (56 + (header.imported_library_count * 24) 762 + (header.total_imported_symbol_count * 4))) 763 goto error; 764 for (i = 0; i < header.total_imported_symbol_count; i++) 765 { 766 ret = (bfd_pef_parse_imported_symbol 767 (abfd, 768 loaderbuf + 56 + (header.imported_library_count * 24) + (i * 4), 769 4, &imports[i])); 770 if (ret < 0) 771 goto error; 772 } 773 774 codepos = 0; 775 776 for (;;) 777 { 778 asymbol sym; 779 const char *symname; 780 char *name; 781 unsigned long sym_index; 782 783 if (csym && (csym[count] == NULL)) 784 break; 785 786 codepos += 3; 787 codepos -= (codepos % 4); 788 789 while ((codepos + 4) <= codelen) 790 { 791 if ((bfd_getb32 (codebuf + codepos) & 0xffff0000) == 0x81820000) 792 break; 793 codepos += 4; 794 } 795 796 if ((codepos + 4) > codelen) 797 break; 798 799 ret = bfd_pef_parse_function_stub (abfd, codebuf + codepos, 24, &sym_index); 800 if (ret < 0) 801 { 802 codepos += 24; 803 continue; 804 } 805 806 if (sym_index >= header.total_imported_symbol_count) 807 { 808 codepos += 24; 809 continue; 810 } 811 812 { 813 size_t max, namelen; 814 const char *s; 815 816 if (loaderlen < (header.loader_strings_offset + imports[sym_index].name)) 817 goto error; 818 819 max = loaderlen - (header.loader_strings_offset + imports[sym_index].name); 820 symname = (char *) loaderbuf; 821 symname += header.loader_strings_offset + imports[sym_index].name; 822 namelen = 0; 823 for (s = symname; s < (symname + max); s++) 824 { 825 if (*s == '\0') 826 break; 827 if (! ISPRINT (*s)) 828 goto error; 829 namelen++; 830 } 831 if (*s != '\0') 832 goto error; 833 834 name = bfd_alloc (abfd, strlen (sprefix) + namelen + 1); 835 if (name == NULL) 836 break; 837 838 snprintf (name, strlen (sprefix) + namelen + 1, "%s%s", 839 sprefix, symname); 840 sym.name = name; 841 } 842 843 sym.value = codepos; 844 sym.the_bfd = abfd; 845 sym.section = codesec; 846 sym.flags = 0; 847 sym.udata.i = 0; 848 849 codepos += 24; 850 851 if (csym != NULL) 852 *(csym[count]) = sym; 853 854 count++; 855 } 856 857 goto end; 858 859 end: 860 if (libraries != NULL) 861 free (libraries); 862 if (imports != NULL) 863 free (imports); 864 *nsym = count; 865 return 0; 866 867 error: 868 if (libraries != NULL) 869 free (libraries); 870 if (imports != NULL) 871 free (imports); 872 *nsym = count; 873 return -1; 874 } 875 876 static long 877 bfd_pef_parse_symbols (bfd *abfd, asymbol **csym) 878 { 879 unsigned long count = 0; 880 881 asection *codesec = NULL; 882 unsigned char *codebuf = NULL; 883 size_t codelen = 0; 884 885 asection *loadersec = NULL; 886 unsigned char *loaderbuf = NULL; 887 size_t loaderlen = 0; 888 889 codesec = bfd_get_section_by_name (abfd, "code"); 890 if (codesec != NULL) 891 { 892 codelen = codesec->size; 893 codebuf = bfd_malloc (codelen); 894 if (bfd_seek (abfd, codesec->filepos, SEEK_SET) < 0) 895 goto end; 896 if (bfd_bread ((void *) codebuf, codelen, abfd) != codelen) 897 goto end; 898 } 899 900 loadersec = bfd_get_section_by_name (abfd, "loader"); 901 if (loadersec != NULL) 902 { 903 loaderlen = loadersec->size; 904 loaderbuf = bfd_malloc (loaderlen); 905 if (bfd_seek (abfd, loadersec->filepos, SEEK_SET) < 0) 906 goto end; 907 if (bfd_bread ((void *) loaderbuf, loaderlen, abfd) != loaderlen) 908 goto end; 909 } 910 911 count = 0; 912 if (codesec != NULL) 913 { 914 long ncount = 0; 915 bfd_pef_parse_traceback_tables (abfd, codesec, codebuf, codelen, 916 &ncount, csym); 917 count += ncount; 918 } 919 920 if ((codesec != NULL) && (loadersec != NULL)) 921 { 922 unsigned long ncount = 0; 923 bfd_pef_parse_function_stubs 924 (abfd, codesec, codebuf, codelen, loaderbuf, loaderlen, &ncount, 925 (csym != NULL) ? (csym + count) : NULL); 926 count += ncount; 927 } 928 929 if (csym != NULL) 930 csym[count] = NULL; 931 932 end: 933 if (codebuf != NULL) 934 free (codebuf); 935 936 if (loaderbuf != NULL) 937 free (loaderbuf); 938 939 return count; 940 } 941 942 static long 943 bfd_pef_count_symbols (bfd *abfd) 944 { 945 return bfd_pef_parse_symbols (abfd, NULL); 946 } 947 948 static long 949 bfd_pef_get_symtab_upper_bound (bfd *abfd) 950 { 951 long nsyms = bfd_pef_count_symbols (abfd); 952 953 if (nsyms < 0) 954 return nsyms; 955 return ((nsyms + 1) * sizeof (asymbol *)); 956 } 957 958 static long 959 bfd_pef_canonicalize_symtab (bfd *abfd, asymbol **alocation) 960 { 961 long i; 962 asymbol *syms; 963 long ret; 964 long nsyms = bfd_pef_count_symbols (abfd); 965 966 if (nsyms < 0) 967 return nsyms; 968 969 syms = bfd_alloc (abfd, nsyms * sizeof (asymbol)); 970 if (syms == NULL) 971 return -1; 972 973 for (i = 0; i < nsyms; i++) 974 alocation[i] = &syms[i]; 975 976 alocation[nsyms] = NULL; 977 978 ret = bfd_pef_parse_symbols (abfd, alocation); 979 if (ret != nsyms) 980 return 0; 981 982 return ret; 983 } 984 985 #define bfd_pef_make_empty_symbol _bfd_generic_make_empty_symbol 986 987 static void 988 bfd_pef_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED, 989 asymbol *symbol, 990 symbol_info *ret) 991 { 992 bfd_symbol_info (symbol, ret); 993 } 994 995 static int 996 bfd_pef_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED, 997 struct bfd_link_info *info ATTRIBUTE_UNUSED) 998 { 999 return 0; 1000 } 1001 1002 const bfd_target pef_vec = 1003 { 1004 "pef", /* Name. */ 1005 bfd_target_pef_flavour, /* Flavour. */ 1006 BFD_ENDIAN_BIG, /* Byteorder. */ 1007 BFD_ENDIAN_BIG, /* Header_byteorder. */ 1008 (HAS_RELOC | EXEC_P | /* Object flags. */ 1009 HAS_LINENO | HAS_DEBUG | 1010 HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED), 1011 (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE | SEC_DATA 1012 | SEC_ROM | SEC_HAS_CONTENTS), /* Section_flags. */ 1013 0, /* Symbol_leading_char. */ 1014 ' ', /* AR_pad_char. */ 1015 16, /* AR_max_namelen. */ 1016 0, /* match priority. */ 1017 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 1018 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 1019 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */ 1020 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 1021 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 1022 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers. */ 1023 { /* bfd_check_format. */ 1024 _bfd_dummy_target, 1025 bfd_pef_object_p, /* bfd_check_format. */ 1026 _bfd_dummy_target, 1027 _bfd_dummy_target, 1028 }, 1029 { /* bfd_set_format. */ 1030 bfd_false, 1031 bfd_pef_mkobject, 1032 bfd_false, 1033 bfd_false, 1034 }, 1035 { /* bfd_write_contents. */ 1036 bfd_false, 1037 bfd_true, 1038 bfd_false, 1039 bfd_false, 1040 }, 1041 1042 BFD_JUMP_TABLE_GENERIC (bfd_pef), 1043 BFD_JUMP_TABLE_COPY (_bfd_generic), 1044 BFD_JUMP_TABLE_CORE (_bfd_nocore), 1045 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive), 1046 BFD_JUMP_TABLE_SYMBOLS (bfd_pef), 1047 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs), 1048 BFD_JUMP_TABLE_WRITE (bfd_pef), 1049 BFD_JUMP_TABLE_LINK (bfd_pef), 1050 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 1051 1052 NULL, 1053 1054 NULL 1055 }; 1056 1057 #define bfd_pef_xlib_close_and_cleanup _bfd_generic_close_and_cleanup 1058 #define bfd_pef_xlib_bfd_free_cached_info _bfd_generic_bfd_free_cached_info 1059 #define bfd_pef_xlib_new_section_hook _bfd_generic_new_section_hook 1060 #define bfd_pef_xlib_get_section_contents _bfd_generic_get_section_contents 1061 #define bfd_pef_xlib_set_section_contents _bfd_generic_set_section_contents 1062 #define bfd_pef_xlib_get_section_contents_in_window _bfd_generic_get_section_contents_in_window 1063 #define bfd_pef_xlib_set_section_contents_in_window _bfd_generic_set_section_contents_in_window 1064 1065 static int 1066 bfd_pef_xlib_read_header (bfd *abfd, bfd_pef_xlib_header *header) 1067 { 1068 unsigned char buf[76]; 1069 1070 bfd_seek (abfd, 0, SEEK_SET); 1071 1072 if (bfd_bread ((void *) buf, 76, abfd) != 76) 1073 return -1; 1074 1075 header->tag1 = bfd_getb32 (buf); 1076 header->tag2 = bfd_getb32 (buf + 4); 1077 header->current_format = bfd_getb32 (buf + 8); 1078 header->container_strings_offset = bfd_getb32 (buf + 12); 1079 header->export_hash_offset = bfd_getb32 (buf + 16); 1080 header->export_key_offset = bfd_getb32 (buf + 20); 1081 header->export_symbol_offset = bfd_getb32 (buf + 24); 1082 header->export_names_offset = bfd_getb32 (buf + 28); 1083 header->export_hash_table_power = bfd_getb32 (buf + 32); 1084 header->exported_symbol_count = bfd_getb32 (buf + 36); 1085 header->frag_name_offset = bfd_getb32 (buf + 40); 1086 header->frag_name_length = bfd_getb32 (buf + 44); 1087 header->dylib_path_offset = bfd_getb32 (buf + 48); 1088 header->dylib_path_length = bfd_getb32 (buf + 52); 1089 header->cpu_family = bfd_getb32 (buf + 56); 1090 header->cpu_model = bfd_getb32 (buf + 60); 1091 header->date_time_stamp = bfd_getb32 (buf + 64); 1092 header->current_version = bfd_getb32 (buf + 68); 1093 header->old_definition_version = bfd_getb32 (buf + 72); 1094 header->old_implementation_version = bfd_getb32 (buf + 76); 1095 1096 return 0; 1097 } 1098 1099 static int 1100 bfd_pef_xlib_scan (bfd *abfd, bfd_pef_xlib_header *header) 1101 { 1102 bfd_pef_xlib_data_struct *mdata = NULL; 1103 1104 mdata = bfd_alloc (abfd, sizeof (* mdata)); 1105 if (mdata == NULL) 1106 return -1; 1107 1108 mdata->header = *header; 1109 1110 abfd->flags = (abfd->xvec->object_flags 1111 | (abfd->flags & (BFD_IN_MEMORY | BFD_IO_FUNCS))); 1112 1113 abfd->tdata.pef_xlib_data = mdata; 1114 1115 return 0; 1116 } 1117 1118 static const bfd_target * 1119 bfd_pef_xlib_object_p (bfd *abfd) 1120 { 1121 bfd_pef_xlib_header header; 1122 1123 if (bfd_pef_xlib_read_header (abfd, &header) != 0) 1124 { 1125 bfd_set_error (bfd_error_wrong_format); 1126 return NULL; 1127 } 1128 1129 if ((header.tag1 != BFD_PEF_XLIB_TAG1) 1130 || ((header.tag2 != BFD_PEF_VLIB_TAG2) 1131 && (header.tag2 != BFD_PEF_BLIB_TAG2))) 1132 { 1133 bfd_set_error (bfd_error_wrong_format); 1134 return NULL; 1135 } 1136 1137 if (bfd_pef_xlib_scan (abfd, &header) != 0) 1138 { 1139 bfd_set_error (bfd_error_wrong_format); 1140 return NULL; 1141 } 1142 1143 return abfd->xvec; 1144 } 1145 1146 const bfd_target pef_xlib_vec = 1147 { 1148 "pef-xlib", /* Name. */ 1149 bfd_target_pef_xlib_flavour, /* Flavour. */ 1150 BFD_ENDIAN_BIG, /* Byteorder */ 1151 BFD_ENDIAN_BIG, /* Header_byteorder. */ 1152 (HAS_RELOC | EXEC_P | /* Object flags. */ 1153 HAS_LINENO | HAS_DEBUG | 1154 HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED), 1155 (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE | SEC_DATA 1156 | SEC_ROM | SEC_HAS_CONTENTS),/* Section_flags. */ 1157 0, /* Symbol_leading_char. */ 1158 ' ', /* AR_pad_char. */ 1159 16, /* AR_max_namelen. */ 1160 0, /* match priority. */ 1161 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 1162 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 1163 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */ 1164 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 1165 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 1166 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers. */ 1167 { /* bfd_check_format. */ 1168 _bfd_dummy_target, 1169 bfd_pef_xlib_object_p, /* bfd_check_format. */ 1170 _bfd_dummy_target, 1171 _bfd_dummy_target, 1172 }, 1173 { /* bfd_set_format. */ 1174 bfd_false, 1175 bfd_pef_mkobject, 1176 bfd_false, 1177 bfd_false, 1178 }, 1179 { /* bfd_write_contents. */ 1180 bfd_false, 1181 bfd_true, 1182 bfd_false, 1183 bfd_false, 1184 }, 1185 1186 BFD_JUMP_TABLE_GENERIC (bfd_pef_xlib), 1187 BFD_JUMP_TABLE_COPY (_bfd_generic), 1188 BFD_JUMP_TABLE_CORE (_bfd_nocore), 1189 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive), 1190 BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols), 1191 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs), 1192 BFD_JUMP_TABLE_WRITE (_bfd_nowrite), 1193 BFD_JUMP_TABLE_LINK (_bfd_nolink), 1194 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 1195 1196 NULL, 1197 1198 NULL 1199 }; 1200