1 /* BFD back-end for Intel 386 COFF files. 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 3 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011, 2012 4 Free Software Foundation, Inc. 5 Written by Cygnus Support. 6 7 This file is part of BFD, the Binary File Descriptor library. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 22 MA 02110-1301, USA. */ 23 24 #include "sysdep.h" 25 #include "bfd.h" 26 #include "libbfd.h" 27 28 #include "coff/i386.h" 29 30 #include "coff/internal.h" 31 32 #ifdef COFF_WITH_PE 33 #include "coff/pe.h" 34 #endif 35 36 #ifdef COFF_GO32_EXE 37 #include "coff/go32exe.h" 38 #endif 39 40 #ifndef bfd_pe_print_pdata 41 #define bfd_pe_print_pdata NULL 42 #endif 43 44 #include "libcoff.h" 45 46 static reloc_howto_type *coff_i386_rtype_to_howto 47 (bfd *, asection *, struct internal_reloc *, 48 struct coff_link_hash_entry *, struct internal_syment *, 49 bfd_vma *); 50 static reloc_howto_type *coff_i386_reloc_type_lookup 51 (bfd *, bfd_reloc_code_real_type); 52 53 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2) 54 /* The page size is a guess based on ELF. */ 55 56 #define COFF_PAGE_SIZE 0x1000 57 58 /* For some reason when using i386 COFF the value stored in the .text 59 section for a reference to a common symbol is the value itself plus 60 any desired offset. Ian Taylor, Cygnus Support. */ 61 62 /* If we are producing relocatable output, we need to do some 63 adjustments to the object file that are not done by the 64 bfd_perform_relocation function. This function is called by every 65 reloc type to make any required adjustments. */ 66 67 static bfd_reloc_status_type 68 coff_i386_reloc (bfd *abfd, 69 arelent *reloc_entry, 70 asymbol *symbol, 71 void * data, 72 asection *input_section ATTRIBUTE_UNUSED, 73 bfd *output_bfd, 74 char **error_message ATTRIBUTE_UNUSED) 75 { 76 symvalue diff; 77 78 #ifndef COFF_WITH_PE 79 if (output_bfd == (bfd *) NULL) 80 return bfd_reloc_continue; 81 #endif 82 83 if (bfd_is_com_section (symbol->section)) 84 { 85 #ifndef COFF_WITH_PE 86 /* We are relocating a common symbol. The current value in the 87 object file is ORIG + OFFSET, where ORIG is the value of the 88 common symbol as seen by the object file when it was compiled 89 (this may be zero if the symbol was undefined) and OFFSET is 90 the offset into the common symbol (normally zero, but may be 91 non-zero when referring to a field in a common structure). 92 ORIG is the negative of reloc_entry->addend, which is set by 93 the CALC_ADDEND macro below. We want to replace the value in 94 the object file with NEW + OFFSET, where NEW is the value of 95 the common symbol which we are going to put in the final 96 object file. NEW is symbol->value. */ 97 diff = symbol->value + reloc_entry->addend; 98 #else 99 /* In PE mode, we do not offset the common symbol. */ 100 diff = reloc_entry->addend; 101 #endif 102 } 103 else 104 { 105 /* For some reason bfd_perform_relocation always effectively 106 ignores the addend for a COFF target when producing 107 relocatable output. This seems to be always wrong for 386 108 COFF, so we handle the addend here instead. */ 109 #ifdef COFF_WITH_PE 110 if (output_bfd == (bfd *) NULL) 111 { 112 reloc_howto_type *howto = reloc_entry->howto; 113 114 /* Although PC relative relocations are very similar between 115 PE and non-PE formats, but they are off by 1 << howto->size 116 bytes. For the external relocation, PE is very different 117 from others. See md_apply_fix3 () in gas/config/tc-i386.c. 118 When we link PE and non-PE object files together to 119 generate a non-PE executable, we have to compensate it 120 here. */ 121 if (howto->pc_relative && howto->pcrel_offset) 122 diff = -(1 << howto->size); 123 else if (symbol->flags & BSF_WEAK) 124 diff = reloc_entry->addend - symbol->value; 125 else 126 diff = -reloc_entry->addend; 127 } 128 else 129 #endif 130 diff = reloc_entry->addend; 131 } 132 133 #ifdef COFF_WITH_PE 134 /* FIXME: How should this case be handled? */ 135 if (reloc_entry->howto->type == R_IMAGEBASE 136 && output_bfd != NULL 137 && bfd_get_flavour(output_bfd) == bfd_target_coff_flavour) 138 diff -= pe_data (output_bfd)->pe_opthdr.ImageBase; 139 #endif 140 141 #define DOIT(x) \ 142 x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + diff) & howto->dst_mask)) 143 144 if (diff != 0) 145 { 146 reloc_howto_type *howto = reloc_entry->howto; 147 unsigned char *addr = (unsigned char *) data + reloc_entry->address; 148 149 switch (howto->size) 150 { 151 case 0: 152 { 153 char x = bfd_get_8 (abfd, addr); 154 DOIT (x); 155 bfd_put_8 (abfd, x, addr); 156 } 157 break; 158 159 case 1: 160 { 161 short x = bfd_get_16 (abfd, addr); 162 DOIT (x); 163 bfd_put_16 (abfd, (bfd_vma) x, addr); 164 } 165 break; 166 167 case 2: 168 { 169 long x = bfd_get_32 (abfd, addr); 170 DOIT (x); 171 bfd_put_32 (abfd, (bfd_vma) x, addr); 172 } 173 break; 174 175 default: 176 abort (); 177 } 178 } 179 180 /* Now let bfd_perform_relocation finish everything up. */ 181 return bfd_reloc_continue; 182 } 183 184 #ifdef COFF_WITH_PE 185 /* Return TRUE if this relocation should appear in the output .reloc 186 section. */ 187 188 static bfd_boolean in_reloc_p (bfd * abfd ATTRIBUTE_UNUSED, 189 reloc_howto_type *howto) 190 { 191 return ! howto->pc_relative && howto->type != R_IMAGEBASE 192 && howto->type != R_SECREL32; 193 } 194 #endif /* COFF_WITH_PE */ 195 196 #ifndef PCRELOFFSET 197 #define PCRELOFFSET FALSE 198 #endif 199 200 static reloc_howto_type howto_table[] = 201 { 202 EMPTY_HOWTO (0), 203 EMPTY_HOWTO (1), 204 EMPTY_HOWTO (2), 205 EMPTY_HOWTO (3), 206 EMPTY_HOWTO (4), 207 EMPTY_HOWTO (5), 208 HOWTO (R_DIR32, /* type */ 209 0, /* rightshift */ 210 2, /* size (0 = byte, 1 = short, 2 = long) */ 211 32, /* bitsize */ 212 FALSE, /* pc_relative */ 213 0, /* bitpos */ 214 complain_overflow_bitfield, /* complain_on_overflow */ 215 coff_i386_reloc, /* special_function */ 216 "dir32", /* name */ 217 TRUE, /* partial_inplace */ 218 0xffffffff, /* src_mask */ 219 0xffffffff, /* dst_mask */ 220 TRUE), /* pcrel_offset */ 221 /* PE IMAGE_REL_I386_DIR32NB relocation (7). */ 222 HOWTO (R_IMAGEBASE, /* type */ 223 0, /* rightshift */ 224 2, /* size (0 = byte, 1 = short, 2 = long) */ 225 32, /* bitsize */ 226 FALSE, /* pc_relative */ 227 0, /* bitpos */ 228 complain_overflow_bitfield, /* complain_on_overflow */ 229 coff_i386_reloc, /* special_function */ 230 "rva32", /* name */ 231 TRUE, /* partial_inplace */ 232 0xffffffff, /* src_mask */ 233 0xffffffff, /* dst_mask */ 234 FALSE), /* pcrel_offset */ 235 EMPTY_HOWTO (010), 236 EMPTY_HOWTO (011), 237 EMPTY_HOWTO (012), 238 #ifdef COFF_WITH_PE 239 /* 32-bit longword section relative relocation (013). */ 240 HOWTO (R_SECREL32, /* type */ 241 0, /* rightshift */ 242 2, /* size (0 = byte, 1 = short, 2 = long) */ 243 32, /* bitsize */ 244 FALSE, /* pc_relative */ 245 0, /* bitpos */ 246 complain_overflow_bitfield, /* complain_on_overflow */ 247 coff_i386_reloc, /* special_function */ 248 "secrel32", /* name */ 249 TRUE, /* partial_inplace */ 250 0xffffffff, /* src_mask */ 251 0xffffffff, /* dst_mask */ 252 TRUE), /* pcrel_offset */ 253 #else 254 EMPTY_HOWTO (013), 255 #endif 256 EMPTY_HOWTO (014), 257 EMPTY_HOWTO (015), 258 EMPTY_HOWTO (016), 259 /* Byte relocation (017). */ 260 HOWTO (R_RELBYTE, /* type */ 261 0, /* rightshift */ 262 0, /* size (0 = byte, 1 = short, 2 = long) */ 263 8, /* bitsize */ 264 FALSE, /* pc_relative */ 265 0, /* bitpos */ 266 complain_overflow_bitfield, /* complain_on_overflow */ 267 coff_i386_reloc, /* special_function */ 268 "8", /* name */ 269 TRUE, /* partial_inplace */ 270 0x000000ff, /* src_mask */ 271 0x000000ff, /* dst_mask */ 272 PCRELOFFSET), /* pcrel_offset */ 273 /* 16-bit word relocation (020). */ 274 HOWTO (R_RELWORD, /* type */ 275 0, /* rightshift */ 276 1, /* size (0 = byte, 1 = short, 2 = long) */ 277 16, /* bitsize */ 278 FALSE, /* pc_relative */ 279 0, /* bitpos */ 280 complain_overflow_bitfield, /* complain_on_overflow */ 281 coff_i386_reloc, /* special_function */ 282 "16", /* name */ 283 TRUE, /* partial_inplace */ 284 0x0000ffff, /* src_mask */ 285 0x0000ffff, /* dst_mask */ 286 PCRELOFFSET), /* pcrel_offset */ 287 /* 32-bit longword relocation (021). */ 288 HOWTO (R_RELLONG, /* type */ 289 0, /* rightshift */ 290 2, /* size (0 = byte, 1 = short, 2 = long) */ 291 32, /* bitsize */ 292 FALSE, /* pc_relative */ 293 0, /* bitpos */ 294 complain_overflow_bitfield, /* complain_on_overflow */ 295 coff_i386_reloc, /* special_function */ 296 "32", /* name */ 297 TRUE, /* partial_inplace */ 298 0xffffffff, /* src_mask */ 299 0xffffffff, /* dst_mask */ 300 PCRELOFFSET), /* pcrel_offset */ 301 /* Byte PC relative relocation (022). */ 302 HOWTO (R_PCRBYTE, /* type */ 303 0, /* rightshift */ 304 0, /* size (0 = byte, 1 = short, 2 = long) */ 305 8, /* bitsize */ 306 TRUE, /* pc_relative */ 307 0, /* bitpos */ 308 complain_overflow_signed, /* complain_on_overflow */ 309 coff_i386_reloc, /* special_function */ 310 "DISP8", /* name */ 311 TRUE, /* partial_inplace */ 312 0x000000ff, /* src_mask */ 313 0x000000ff, /* dst_mask */ 314 PCRELOFFSET), /* pcrel_offset */ 315 /* 16-bit word PC relative relocation (023). */ 316 HOWTO (R_PCRWORD, /* type */ 317 0, /* rightshift */ 318 1, /* size (0 = byte, 1 = short, 2 = long) */ 319 16, /* bitsize */ 320 TRUE, /* pc_relative */ 321 0, /* bitpos */ 322 complain_overflow_signed, /* complain_on_overflow */ 323 coff_i386_reloc, /* special_function */ 324 "DISP16", /* name */ 325 TRUE, /* partial_inplace */ 326 0x0000ffff, /* src_mask */ 327 0x0000ffff, /* dst_mask */ 328 PCRELOFFSET), /* pcrel_offset */ 329 /* 32-bit longword PC relative relocation (024). */ 330 HOWTO (R_PCRLONG, /* type */ 331 0, /* rightshift */ 332 2, /* size (0 = byte, 1 = short, 2 = long) */ 333 32, /* bitsize */ 334 TRUE, /* pc_relative */ 335 0, /* bitpos */ 336 complain_overflow_signed, /* complain_on_overflow */ 337 coff_i386_reloc, /* special_function */ 338 "DISP32", /* name */ 339 TRUE, /* partial_inplace */ 340 0xffffffff, /* src_mask */ 341 0xffffffff, /* dst_mask */ 342 PCRELOFFSET) /* pcrel_offset */ 343 }; 344 345 /* Turn a howto into a reloc nunmber */ 346 347 #define SELECT_RELOC(x,howto) { x.r_type = howto->type; } 348 #define BADMAG(x) I386BADMAG(x) 349 #define I386 1 /* Customize coffcode.h */ 350 351 #define RTYPE2HOWTO(cache_ptr, dst) \ 352 ((cache_ptr)->howto = \ 353 ((dst)->r_type < sizeof (howto_table) / sizeof (howto_table[0]) \ 354 ? howto_table + (dst)->r_type \ 355 : NULL)) 356 357 /* For 386 COFF a STYP_NOLOAD | STYP_BSS section is part of a shared 358 library. On some other COFF targets STYP_BSS is normally 359 STYP_NOLOAD. */ 360 #define BSS_NOLOAD_IS_SHARED_LIBRARY 361 362 /* Compute the addend of a reloc. If the reloc is to a common symbol, 363 the object file contains the value of the common symbol. By the 364 time this is called, the linker may be using a different symbol 365 from a different object file with a different value. Therefore, we 366 hack wildly to locate the original symbol from this file so that we 367 can make the correct adjustment. This macro sets coffsym to the 368 symbol from the original file, and uses it to set the addend value 369 correctly. If this is not a common symbol, the usual addend 370 calculation is done, except that an additional tweak is needed for 371 PC relative relocs. 372 FIXME: This macro refers to symbols and asect; these are from the 373 calling function, not the macro arguments. */ 374 375 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \ 376 { \ 377 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \ 378 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \ 379 coffsym = (obj_symbols (abfd) \ 380 + (cache_ptr->sym_ptr_ptr - symbols)); \ 381 else if (ptr) \ 382 coffsym = coff_symbol_from (abfd, ptr); \ 383 if (coffsym != (coff_symbol_type *) NULL \ 384 && coffsym->native->u.syment.n_scnum == 0) \ 385 cache_ptr->addend = - coffsym->native->u.syment.n_value; \ 386 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \ 387 && ptr->section != (asection *) NULL) \ 388 cache_ptr->addend = - (ptr->section->vma + ptr->value); \ 389 else \ 390 cache_ptr->addend = 0; \ 391 if (ptr && howto_table[reloc.r_type].pc_relative) \ 392 cache_ptr->addend += asect->vma; \ 393 } 394 395 /* We use the special COFF backend linker. For normal i386 COFF, we 396 can use the generic relocate_section routine. For PE, we need our 397 own routine. */ 398 399 #ifndef COFF_WITH_PE 400 401 #define coff_relocate_section _bfd_coff_generic_relocate_section 402 403 #else /* COFF_WITH_PE */ 404 405 /* The PE relocate section routine. The only difference between this 406 and the regular routine is that we don't want to do anything for a 407 relocatable link. */ 408 409 static bfd_boolean 410 coff_pe_i386_relocate_section (bfd *output_bfd, 411 struct bfd_link_info *info, 412 bfd *input_bfd, 413 asection *input_section, 414 bfd_byte *contents, 415 struct internal_reloc *relocs, 416 struct internal_syment *syms, 417 asection **sections) 418 { 419 if (info->relocatable) 420 return TRUE; 421 422 return _bfd_coff_generic_relocate_section (output_bfd, info, input_bfd, 423 input_section, contents, 424 relocs, syms, sections); 425 } 426 427 #define coff_relocate_section coff_pe_i386_relocate_section 428 429 #endif /* COFF_WITH_PE */ 430 431 /* Convert an rtype to howto for the COFF backend linker. */ 432 433 static reloc_howto_type * 434 coff_i386_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED, 435 asection *sec, 436 struct internal_reloc *rel, 437 struct coff_link_hash_entry *h, 438 struct internal_syment *sym, 439 bfd_vma *addendp) 440 { 441 reloc_howto_type *howto; 442 443 if (rel->r_type >= sizeof (howto_table) / sizeof (howto_table[0])) 444 { 445 bfd_set_error (bfd_error_bad_value); 446 return NULL; 447 } 448 449 howto = howto_table + rel->r_type; 450 451 #ifdef COFF_WITH_PE 452 /* Cancel out code in _bfd_coff_generic_relocate_section. */ 453 *addendp = 0; 454 #endif 455 456 if (howto->pc_relative) 457 *addendp += sec->vma; 458 459 if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0) 460 { 461 /* This is a common symbol. The section contents include the 462 size (sym->n_value) as an addend. The relocate_section 463 function will be adding in the final value of the symbol. We 464 need to subtract out the current size in order to get the 465 correct result. */ 466 467 BFD_ASSERT (h != NULL); 468 469 #ifndef COFF_WITH_PE 470 /* I think we *do* want to bypass this. If we don't, I have 471 seen some data parameters get the wrong relocation address. 472 If I link two versions with and without this section bypassed 473 and then do a binary comparison, the addresses which are 474 different can be looked up in the map. The case in which 475 this section has been bypassed has addresses which correspond 476 to values I can find in the map. */ 477 *addendp -= sym->n_value; 478 #endif 479 } 480 481 #ifndef COFF_WITH_PE 482 /* If the output symbol is common (in which case this must be a 483 relocatable link), we need to add in the final size of the 484 common symbol. */ 485 if (h != NULL && h->root.type == bfd_link_hash_common) 486 *addendp += h->root.u.c.size; 487 #endif 488 489 #ifdef COFF_WITH_PE 490 if (howto->pc_relative) 491 { 492 *addendp -= 4; 493 494 /* If the symbol is defined, then the generic code is going to 495 add back the symbol value in order to cancel out an 496 adjustment it made to the addend. However, we set the addend 497 to 0 at the start of this function. We need to adjust here, 498 to avoid the adjustment the generic code will make. FIXME: 499 This is getting a bit hackish. */ 500 if (sym != NULL && sym->n_scnum != 0) 501 *addendp -= sym->n_value; 502 } 503 504 if (rel->r_type == R_IMAGEBASE 505 && (bfd_get_flavour(sec->output_section->owner) 506 == bfd_target_coff_flavour)) 507 { 508 *addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase; 509 } 510 511 BFD_ASSERT (sym != NULL); 512 if (rel->r_type == R_SECREL32 && sym != NULL) 513 { 514 bfd_vma osect_vma; 515 516 if (h && (h->root.type == bfd_link_hash_defined 517 || h->root.type == bfd_link_hash_defweak)) 518 osect_vma = h->root.u.def.section->output_section->vma; 519 else 520 { 521 asection *s; 522 int i; 523 524 /* Sigh, the only way to get the section to offset against 525 is to find it the hard way. */ 526 527 for (s = abfd->sections, i = 1; i < sym->n_scnum; i++) 528 s = s->next; 529 530 osect_vma = s->output_section->vma; 531 } 532 533 *addendp -= osect_vma; 534 } 535 #endif 536 537 return howto; 538 } 539 540 #define coff_bfd_reloc_type_lookup coff_i386_reloc_type_lookup 541 #define coff_bfd_reloc_name_lookup coff_i386_reloc_name_lookup 542 543 static reloc_howto_type * 544 coff_i386_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, 545 bfd_reloc_code_real_type code) 546 { 547 switch (code) 548 { 549 case BFD_RELOC_RVA: 550 return howto_table + R_IMAGEBASE; 551 case BFD_RELOC_32: 552 return howto_table + R_DIR32; 553 case BFD_RELOC_32_PCREL: 554 return howto_table + R_PCRLONG; 555 case BFD_RELOC_16: 556 return howto_table + R_RELWORD; 557 case BFD_RELOC_16_PCREL: 558 return howto_table + R_PCRWORD; 559 case BFD_RELOC_8: 560 return howto_table + R_RELBYTE; 561 case BFD_RELOC_8_PCREL: 562 return howto_table + R_PCRBYTE; 563 #ifdef COFF_WITH_PE 564 case BFD_RELOC_32_SECREL: 565 return howto_table + R_SECREL32; 566 #endif 567 default: 568 BFD_FAIL (); 569 return 0; 570 } 571 } 572 573 static reloc_howto_type * 574 coff_i386_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 575 const char *r_name) 576 { 577 unsigned int i; 578 579 for (i = 0; i < sizeof (howto_table) / sizeof (howto_table[0]); i++) 580 if (howto_table[i].name != NULL 581 && strcasecmp (howto_table[i].name, r_name) == 0) 582 return &howto_table[i]; 583 584 return NULL; 585 } 586 587 #define coff_rtype_to_howto coff_i386_rtype_to_howto 588 589 #ifdef TARGET_UNDERSCORE 590 591 /* If i386 gcc uses underscores for symbol names, then it does not use 592 a leading dot for local labels, so if TARGET_UNDERSCORE is defined 593 we treat all symbols starting with L as local. */ 594 595 static bfd_boolean 596 coff_i386_is_local_label_name (bfd *abfd, const char *name) 597 { 598 if (name[0] == 'L') 599 return TRUE; 600 601 return _bfd_coff_is_local_label_name (abfd, name); 602 } 603 604 #define coff_bfd_is_local_label_name coff_i386_is_local_label_name 605 606 #endif /* TARGET_UNDERSCORE */ 607 608 #include "coffcode.h" 609 610 const bfd_target 611 #ifdef TARGET_SYM 612 TARGET_SYM = 613 #else 614 i386coff_vec = 615 #endif 616 { 617 #ifdef TARGET_NAME 618 TARGET_NAME, 619 #else 620 "coff-i386", /* name */ 621 #endif 622 bfd_target_coff_flavour, 623 BFD_ENDIAN_LITTLE, /* data byte order is little */ 624 BFD_ENDIAN_LITTLE, /* header byte order is little */ 625 626 (HAS_RELOC | EXEC_P | /* object flags */ 627 HAS_LINENO | HAS_DEBUG | 628 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED), 629 630 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */ 631 #ifdef COFF_WITH_PE 632 | SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_READONLY 633 #endif 634 | SEC_CODE | SEC_DATA), 635 636 #ifdef TARGET_UNDERSCORE 637 TARGET_UNDERSCORE, /* leading underscore */ 638 #else 639 0, /* leading underscore */ 640 #endif 641 '/', /* ar_pad_char */ 642 15, /* ar_max_namelen */ 643 0, /* match priority. */ 644 645 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 646 bfd_getl32, bfd_getl_signed_32, bfd_putl32, 647 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */ 648 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 649 bfd_getl32, bfd_getl_signed_32, bfd_putl32, 650 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */ 651 652 /* Note that we allow an object file to be treated as a core file as well. */ 653 /* bfd_check_format */ 654 #ifdef COFF_CHECK_FORMAT 655 {_bfd_dummy_target, COFF_CHECK_FORMAT, 656 bfd_generic_archive_p, COFF_CHECK_FORMAT}, 657 #else 658 {_bfd_dummy_target, coff_object_p, bfd_generic_archive_p, coff_object_p}, 659 #endif 660 {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */ 661 bfd_false}, 662 {bfd_false, coff_write_object_contents, /* bfd_write_contents */ 663 _bfd_write_archive_contents, bfd_false}, 664 665 BFD_JUMP_TABLE_GENERIC (coff), 666 BFD_JUMP_TABLE_COPY (coff), 667 BFD_JUMP_TABLE_CORE (_bfd_nocore), 668 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), 669 BFD_JUMP_TABLE_SYMBOLS (coff), 670 BFD_JUMP_TABLE_RELOCS (coff), 671 BFD_JUMP_TABLE_WRITE (coff), 672 BFD_JUMP_TABLE_LINK (coff), 673 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 674 675 NULL, 676 677 COFF_SWAP_TABLE 678 }; 679