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