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