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 struct bfd_preserve preserve; 587 bfd_pef_header header; 588 589 preserve.marker = NULL; 590 if (bfd_pef_read_header (abfd, &header) != 0) 591 goto wrong; 592 593 if (header.tag1 != BFD_PEF_TAG1 || header.tag2 != BFD_PEF_TAG2) 594 goto wrong; 595 596 preserve.marker = bfd_zalloc (abfd, sizeof (bfd_pef_data_struct)); 597 if (preserve.marker == NULL 598 || !bfd_preserve_save (abfd, &preserve)) 599 goto fail; 600 601 if (bfd_pef_scan (abfd, &header, 602 (bfd_pef_data_struct *) preserve.marker) != 0) 603 goto wrong; 604 605 bfd_preserve_finish (abfd, &preserve); 606 return abfd->xvec; 607 608 wrong: 609 bfd_set_error (bfd_error_wrong_format); 610 611 fail: 612 if (preserve.marker != NULL) 613 bfd_preserve_restore (abfd, &preserve); 614 return NULL; 615 } 616 617 static int 618 bfd_pef_parse_traceback_tables (bfd *abfd, 619 asection *sec, 620 unsigned char *buf, 621 size_t len, 622 long *nsym, 623 asymbol **csym) 624 { 625 char *name; 626 627 asymbol function; 628 asymbol traceback; 629 630 const char *const tbprefix = "__traceback_"; 631 size_t tbnamelen; 632 633 size_t pos = 0; 634 unsigned long count = 0; 635 int ret; 636 637 for (;;) 638 { 639 /* We're reading symbols two at a time. */ 640 if (csym && ((csym[count] == NULL) || (csym[count + 1] == NULL))) 641 break; 642 643 pos += 3; 644 pos -= (pos % 4); 645 646 while ((pos + 4) <= len) 647 { 648 if (bfd_getb32 (buf + pos) == 0) 649 break; 650 pos += 4; 651 } 652 653 if ((pos + 4) > len) 654 break; 655 656 ret = bfd_pef_parse_traceback_table (abfd, sec, buf, len, pos + 4, 657 &function, 0); 658 if (ret < 0) 659 { 660 /* Skip over 0x0L to advance to next possible traceback table. */ 661 pos += 4; 662 continue; 663 } 664 665 BFD_ASSERT (function.name != NULL); 666 667 /* Don't bother to compute the name if we are just 668 counting symbols. */ 669 if (csym) 670 { 671 tbnamelen = strlen (tbprefix) + strlen (function.name); 672 name = bfd_alloc (abfd, tbnamelen + 1); 673 if (name == NULL) 674 { 675 bfd_release (abfd, (void *) function.name); 676 function.name = NULL; 677 break; 678 } 679 snprintf (name, tbnamelen + 1, "%s%s", tbprefix, function.name); 680 traceback.name = name; 681 traceback.value = pos; 682 traceback.the_bfd = abfd; 683 traceback.section = sec; 684 traceback.flags = 0; 685 traceback.udata.i = ret; 686 687 *(csym[count]) = function; 688 *(csym[count + 1]) = traceback; 689 } 690 691 pos += ret; 692 count += 2; 693 } 694 695 *nsym = count; 696 return 0; 697 } 698 699 static int 700 bfd_pef_parse_function_stub (bfd *abfd ATTRIBUTE_UNUSED, 701 unsigned char *buf, 702 size_t len, 703 unsigned long *offset) 704 { 705 BFD_ASSERT (len == 24); 706 707 if ((bfd_getb32 (buf) & 0xffff0000) != 0x81820000) 708 return -1; 709 if (bfd_getb32 (buf + 4) != 0x90410014) 710 return -1; 711 if (bfd_getb32 (buf + 8) != 0x800c0000) 712 return -1; 713 if (bfd_getb32 (buf + 12) != 0x804c0004) 714 return -1; 715 if (bfd_getb32 (buf + 16) != 0x7c0903a6) 716 return -1; 717 if (bfd_getb32 (buf + 20) != 0x4e800420) 718 return -1; 719 720 if (offset != NULL) 721 *offset = (bfd_getb32 (buf) & 0x0000ffff) / 4; 722 723 return 0; 724 } 725 726 static int 727 bfd_pef_parse_function_stubs (bfd *abfd, 728 asection *codesec, 729 unsigned char *codebuf, 730 size_t codelen, 731 unsigned char *loaderbuf, 732 size_t loaderlen, 733 unsigned long *nsym, 734 asymbol **csym) 735 { 736 const char *const sprefix = "__stub_"; 737 size_t codepos = 0; 738 unsigned long count = 0; 739 bfd_pef_loader_header header; 740 bfd_pef_imported_library *libraries = NULL; 741 bfd_pef_imported_symbol *imports = NULL; 742 unsigned long i; 743 int ret; 744 745 if (loaderlen < 56) 746 goto error; 747 748 ret = bfd_pef_parse_loader_header (abfd, loaderbuf, 56, &header); 749 if (ret < 0) 750 goto error; 751 752 libraries = bfd_malloc 753 (header.imported_library_count * sizeof (bfd_pef_imported_library)); 754 imports = bfd_malloc 755 (header.total_imported_symbol_count * sizeof (bfd_pef_imported_symbol)); 756 757 if (loaderlen < (56 + (header.imported_library_count * 24))) 758 goto error; 759 for (i = 0; i < header.imported_library_count; i++) 760 { 761 ret = bfd_pef_parse_imported_library 762 (abfd, loaderbuf + 56 + (i * 24), 24, &libraries[i]); 763 if (ret < 0) 764 goto error; 765 } 766 767 if (loaderlen < (56 + (header.imported_library_count * 24) 768 + (header.total_imported_symbol_count * 4))) 769 goto error; 770 for (i = 0; i < header.total_imported_symbol_count; i++) 771 { 772 ret = (bfd_pef_parse_imported_symbol 773 (abfd, 774 loaderbuf + 56 + (header.imported_library_count * 24) + (i * 4), 775 4, &imports[i])); 776 if (ret < 0) 777 goto error; 778 } 779 780 codepos = 0; 781 782 for (;;) 783 { 784 asymbol sym; 785 const char *symname; 786 char *name; 787 unsigned long sym_index; 788 789 if (csym && (csym[count] == NULL)) 790 break; 791 792 codepos += 3; 793 codepos -= (codepos % 4); 794 795 while ((codepos + 4) <= codelen) 796 { 797 if ((bfd_getb32 (codebuf + codepos) & 0xffff0000) == 0x81820000) 798 break; 799 codepos += 4; 800 } 801 802 if ((codepos + 4) > codelen) 803 break; 804 805 ret = bfd_pef_parse_function_stub (abfd, codebuf + codepos, 24, &sym_index); 806 if (ret < 0) 807 { 808 codepos += 24; 809 continue; 810 } 811 812 if (sym_index >= header.total_imported_symbol_count) 813 { 814 codepos += 24; 815 continue; 816 } 817 818 { 819 size_t max, namelen; 820 const char *s; 821 822 if (loaderlen < (header.loader_strings_offset + imports[sym_index].name)) 823 goto error; 824 825 max = loaderlen - (header.loader_strings_offset + imports[sym_index].name); 826 symname = (char *) loaderbuf; 827 symname += header.loader_strings_offset + imports[sym_index].name; 828 namelen = 0; 829 for (s = symname; s < (symname + max); s++) 830 { 831 if (*s == '\0') 832 break; 833 if (! ISPRINT (*s)) 834 goto error; 835 namelen++; 836 } 837 if (*s != '\0') 838 goto error; 839 840 name = bfd_alloc (abfd, strlen (sprefix) + namelen + 1); 841 if (name == NULL) 842 break; 843 844 snprintf (name, strlen (sprefix) + namelen + 1, "%s%s", 845 sprefix, symname); 846 sym.name = name; 847 } 848 849 sym.value = codepos; 850 sym.the_bfd = abfd; 851 sym.section = codesec; 852 sym.flags = 0; 853 sym.udata.i = 0; 854 855 codepos += 24; 856 857 if (csym != NULL) 858 *(csym[count]) = sym; 859 860 count++; 861 } 862 863 goto end; 864 865 end: 866 if (libraries != NULL) 867 free (libraries); 868 if (imports != NULL) 869 free (imports); 870 *nsym = count; 871 return 0; 872 873 error: 874 if (libraries != NULL) 875 free (libraries); 876 if (imports != NULL) 877 free (imports); 878 *nsym = count; 879 return -1; 880 } 881 882 static long 883 bfd_pef_parse_symbols (bfd *abfd, asymbol **csym) 884 { 885 unsigned long count = 0; 886 887 asection *codesec = NULL; 888 unsigned char *codebuf = NULL; 889 size_t codelen = 0; 890 891 asection *loadersec = NULL; 892 unsigned char *loaderbuf = NULL; 893 size_t loaderlen = 0; 894 895 codesec = bfd_get_section_by_name (abfd, "code"); 896 if (codesec != NULL) 897 { 898 codelen = codesec->size; 899 codebuf = bfd_malloc (codelen); 900 if (bfd_seek (abfd, codesec->filepos, SEEK_SET) < 0) 901 goto end; 902 if (bfd_bread ((void *) codebuf, codelen, abfd) != codelen) 903 goto end; 904 } 905 906 loadersec = bfd_get_section_by_name (abfd, "loader"); 907 if (loadersec != NULL) 908 { 909 loaderlen = loadersec->size; 910 loaderbuf = bfd_malloc (loaderlen); 911 if (bfd_seek (abfd, loadersec->filepos, SEEK_SET) < 0) 912 goto end; 913 if (bfd_bread ((void *) loaderbuf, loaderlen, abfd) != loaderlen) 914 goto end; 915 } 916 917 count = 0; 918 if (codesec != NULL) 919 { 920 long ncount = 0; 921 bfd_pef_parse_traceback_tables (abfd, codesec, codebuf, codelen, 922 &ncount, csym); 923 count += ncount; 924 } 925 926 if ((codesec != NULL) && (loadersec != NULL)) 927 { 928 unsigned long ncount = 0; 929 bfd_pef_parse_function_stubs 930 (abfd, codesec, codebuf, codelen, loaderbuf, loaderlen, &ncount, 931 (csym != NULL) ? (csym + count) : NULL); 932 count += ncount; 933 } 934 935 if (csym != NULL) 936 csym[count] = NULL; 937 938 end: 939 if (codebuf != NULL) 940 free (codebuf); 941 942 if (loaderbuf != NULL) 943 free (loaderbuf); 944 945 return count; 946 } 947 948 static long 949 bfd_pef_count_symbols (bfd *abfd) 950 { 951 return bfd_pef_parse_symbols (abfd, NULL); 952 } 953 954 static long 955 bfd_pef_get_symtab_upper_bound (bfd *abfd) 956 { 957 long nsyms = bfd_pef_count_symbols (abfd); 958 959 if (nsyms < 0) 960 return nsyms; 961 return ((nsyms + 1) * sizeof (asymbol *)); 962 } 963 964 static long 965 bfd_pef_canonicalize_symtab (bfd *abfd, asymbol **alocation) 966 { 967 long i; 968 asymbol *syms; 969 long ret; 970 long nsyms = bfd_pef_count_symbols (abfd); 971 972 if (nsyms < 0) 973 return nsyms; 974 975 syms = bfd_alloc (abfd, nsyms * sizeof (asymbol)); 976 if (syms == NULL) 977 return -1; 978 979 for (i = 0; i < nsyms; i++) 980 alocation[i] = &syms[i]; 981 982 alocation[nsyms] = NULL; 983 984 ret = bfd_pef_parse_symbols (abfd, alocation); 985 if (ret != nsyms) 986 return 0; 987 988 return ret; 989 } 990 991 #define bfd_pef_make_empty_symbol _bfd_generic_make_empty_symbol 992 993 static void 994 bfd_pef_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED, 995 asymbol *symbol, 996 symbol_info *ret) 997 { 998 bfd_symbol_info (symbol, ret); 999 } 1000 1001 static int 1002 bfd_pef_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED, 1003 struct bfd_link_info *info ATTRIBUTE_UNUSED) 1004 { 1005 return 0; 1006 } 1007 1008 const bfd_target pef_vec = 1009 { 1010 "pef", /* Name. */ 1011 bfd_target_pef_flavour, /* Flavour. */ 1012 BFD_ENDIAN_BIG, /* Byteorder. */ 1013 BFD_ENDIAN_BIG, /* Header_byteorder. */ 1014 (HAS_RELOC | EXEC_P | /* Object flags. */ 1015 HAS_LINENO | HAS_DEBUG | 1016 HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED), 1017 (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE | SEC_DATA 1018 | SEC_ROM | SEC_HAS_CONTENTS), /* Section_flags. */ 1019 0, /* Symbol_leading_char. */ 1020 ' ', /* AR_pad_char. */ 1021 16, /* AR_max_namelen. */ 1022 0, /* match priority. */ 1023 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 1024 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 1025 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */ 1026 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 1027 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 1028 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers. */ 1029 { /* bfd_check_format. */ 1030 _bfd_dummy_target, 1031 bfd_pef_object_p, /* bfd_check_format. */ 1032 _bfd_dummy_target, 1033 _bfd_dummy_target, 1034 }, 1035 { /* bfd_set_format. */ 1036 bfd_false, 1037 bfd_pef_mkobject, 1038 bfd_false, 1039 bfd_false, 1040 }, 1041 { /* bfd_write_contents. */ 1042 bfd_false, 1043 bfd_true, 1044 bfd_false, 1045 bfd_false, 1046 }, 1047 1048 BFD_JUMP_TABLE_GENERIC (bfd_pef), 1049 BFD_JUMP_TABLE_COPY (_bfd_generic), 1050 BFD_JUMP_TABLE_CORE (_bfd_nocore), 1051 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive), 1052 BFD_JUMP_TABLE_SYMBOLS (bfd_pef), 1053 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs), 1054 BFD_JUMP_TABLE_WRITE (bfd_pef), 1055 BFD_JUMP_TABLE_LINK (bfd_pef), 1056 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 1057 1058 NULL, 1059 1060 NULL 1061 }; 1062 1063 #define bfd_pef_xlib_close_and_cleanup _bfd_generic_close_and_cleanup 1064 #define bfd_pef_xlib_bfd_free_cached_info _bfd_generic_bfd_free_cached_info 1065 #define bfd_pef_xlib_new_section_hook _bfd_generic_new_section_hook 1066 #define bfd_pef_xlib_get_section_contents _bfd_generic_get_section_contents 1067 #define bfd_pef_xlib_set_section_contents _bfd_generic_set_section_contents 1068 #define bfd_pef_xlib_get_section_contents_in_window _bfd_generic_get_section_contents_in_window 1069 #define bfd_pef_xlib_set_section_contents_in_window _bfd_generic_set_section_contents_in_window 1070 1071 static int 1072 bfd_pef_xlib_read_header (bfd *abfd, bfd_pef_xlib_header *header) 1073 { 1074 unsigned char buf[76]; 1075 1076 bfd_seek (abfd, 0, SEEK_SET); 1077 1078 if (bfd_bread ((void *) buf, 76, abfd) != 76) 1079 return -1; 1080 1081 header->tag1 = bfd_getb32 (buf); 1082 header->tag2 = bfd_getb32 (buf + 4); 1083 header->current_format = bfd_getb32 (buf + 8); 1084 header->container_strings_offset = bfd_getb32 (buf + 12); 1085 header->export_hash_offset = bfd_getb32 (buf + 16); 1086 header->export_key_offset = bfd_getb32 (buf + 20); 1087 header->export_symbol_offset = bfd_getb32 (buf + 24); 1088 header->export_names_offset = bfd_getb32 (buf + 28); 1089 header->export_hash_table_power = bfd_getb32 (buf + 32); 1090 header->exported_symbol_count = bfd_getb32 (buf + 36); 1091 header->frag_name_offset = bfd_getb32 (buf + 40); 1092 header->frag_name_length = bfd_getb32 (buf + 44); 1093 header->dylib_path_offset = bfd_getb32 (buf + 48); 1094 header->dylib_path_length = bfd_getb32 (buf + 52); 1095 header->cpu_family = bfd_getb32 (buf + 56); 1096 header->cpu_model = bfd_getb32 (buf + 60); 1097 header->date_time_stamp = bfd_getb32 (buf + 64); 1098 header->current_version = bfd_getb32 (buf + 68); 1099 header->old_definition_version = bfd_getb32 (buf + 72); 1100 header->old_implementation_version = bfd_getb32 (buf + 76); 1101 1102 return 0; 1103 } 1104 1105 static int 1106 bfd_pef_xlib_scan (bfd *abfd, bfd_pef_xlib_header *header) 1107 { 1108 bfd_pef_xlib_data_struct *mdata = NULL; 1109 1110 mdata = bfd_alloc (abfd, sizeof (* mdata)); 1111 if (mdata == NULL) 1112 return -1; 1113 1114 mdata->header = *header; 1115 1116 abfd->flags = (abfd->xvec->object_flags 1117 | (abfd->flags & (BFD_IN_MEMORY | BFD_IO_FUNCS))); 1118 1119 abfd->tdata.pef_xlib_data = mdata; 1120 1121 return 0; 1122 } 1123 1124 static const bfd_target * 1125 bfd_pef_xlib_object_p (bfd *abfd) 1126 { 1127 struct bfd_preserve preserve; 1128 bfd_pef_xlib_header header; 1129 1130 if (bfd_pef_xlib_read_header (abfd, &header) != 0) 1131 { 1132 bfd_set_error (bfd_error_wrong_format); 1133 return NULL; 1134 } 1135 1136 if ((header.tag1 != BFD_PEF_XLIB_TAG1) 1137 || ((header.tag2 != BFD_PEF_VLIB_TAG2) 1138 && (header.tag2 != BFD_PEF_BLIB_TAG2))) 1139 { 1140 bfd_set_error (bfd_error_wrong_format); 1141 return NULL; 1142 } 1143 1144 if (! bfd_preserve_save (abfd, &preserve)) 1145 { 1146 bfd_set_error (bfd_error_wrong_format); 1147 return NULL; 1148 } 1149 1150 if (bfd_pef_xlib_scan (abfd, &header) != 0) 1151 { 1152 bfd_preserve_restore (abfd, &preserve); 1153 bfd_set_error (bfd_error_wrong_format); 1154 return NULL; 1155 } 1156 1157 bfd_preserve_finish (abfd, &preserve); 1158 return abfd->xvec; 1159 } 1160 1161 const bfd_target pef_xlib_vec = 1162 { 1163 "pef-xlib", /* Name. */ 1164 bfd_target_pef_xlib_flavour, /* Flavour. */ 1165 BFD_ENDIAN_BIG, /* Byteorder */ 1166 BFD_ENDIAN_BIG, /* Header_byteorder. */ 1167 (HAS_RELOC | EXEC_P | /* Object flags. */ 1168 HAS_LINENO | HAS_DEBUG | 1169 HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED), 1170 (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE | SEC_DATA 1171 | SEC_ROM | SEC_HAS_CONTENTS),/* Section_flags. */ 1172 0, /* Symbol_leading_char. */ 1173 ' ', /* AR_pad_char. */ 1174 16, /* AR_max_namelen. */ 1175 0, /* match priority. */ 1176 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 1177 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 1178 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */ 1179 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 1180 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 1181 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers. */ 1182 { /* bfd_check_format. */ 1183 _bfd_dummy_target, 1184 bfd_pef_xlib_object_p, /* bfd_check_format. */ 1185 _bfd_dummy_target, 1186 _bfd_dummy_target, 1187 }, 1188 { /* bfd_set_format. */ 1189 bfd_false, 1190 bfd_pef_mkobject, 1191 bfd_false, 1192 bfd_false, 1193 }, 1194 { /* bfd_write_contents. */ 1195 bfd_false, 1196 bfd_true, 1197 bfd_false, 1198 bfd_false, 1199 }, 1200 1201 BFD_JUMP_TABLE_GENERIC (bfd_pef_xlib), 1202 BFD_JUMP_TABLE_COPY (_bfd_generic), 1203 BFD_JUMP_TABLE_CORE (_bfd_nocore), 1204 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive), 1205 BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols), 1206 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs), 1207 BFD_JUMP_TABLE_WRITE (_bfd_nowrite), 1208 BFD_JUMP_TABLE_LINK (_bfd_nolink), 1209 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 1210 1211 NULL, 1212 1213 NULL 1214 }; 1215