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