1 /* BFD back-end for Intel 386 COFF files.
2 Copyright (C) 1990-2024 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
coff_i386_reloc(bfd * abfd,arelent * reloc_entry,asymbol * symbol,void * data,asection * input_section,bfd * output_bfd,char ** error_message ATTRIBUTE_UNUSED)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
in_reloc_p(bfd * abfd ATTRIBUTE_UNUSED,reloc_howto_type * howto)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 \
409 + COFF_PE_ADDEND_BIAS (ptr)); \
410 else \
411 cache_ptr->addend = 0; \
412 if (ptr && reloc.r_type < NUM_HOWTOS \
413 && howto_table[reloc.r_type].pc_relative) \
414 cache_ptr->addend += asect->vma; \
415 }
416
417 /* We use the special COFF backend linker. For normal i386 COFF, we
418 can use the generic relocate_section routine. For PE, we need our
419 own routine. */
420
421 #ifndef COFF_WITH_PE
422
423 #define coff_relocate_section _bfd_coff_generic_relocate_section
424
425 #else /* COFF_WITH_PE */
426
427 /* The PE relocate section routine. We handle secidx relocations here,
428 as well as making sure that we don't do anything for a relocatable
429 link. */
430
431 static bool
coff_pe_i386_relocate_section(bfd * output_bfd,struct bfd_link_info * info,bfd * input_bfd,asection * input_section,bfd_byte * contents,struct internal_reloc * relocs,struct internal_syment * syms,asection ** sections)432 coff_pe_i386_relocate_section (bfd *output_bfd,
433 struct bfd_link_info *info,
434 bfd *input_bfd,
435 asection *input_section,
436 bfd_byte *contents,
437 struct internal_reloc *relocs,
438 struct internal_syment *syms,
439 asection **sections)
440 {
441 struct internal_reloc *rel;
442 struct internal_reloc *relend;
443
444 if (bfd_link_relocatable (info))
445 return true;
446
447 rel = relocs;
448 relend = rel + input_section->reloc_count;
449
450 for (; rel < relend; rel++)
451 {
452 long symndx;
453 struct coff_link_hash_entry *h;
454 asection *sec, *s;
455 uint16_t idx = 0, i = 1;
456
457 if (rel->r_type != R_SECTION)
458 continue;
459
460 /* Make sure that _bfd_coff_generic_relocate_section won't parse
461 this reloc after us. */
462 rel->r_type = 0;
463
464 symndx = rel->r_symndx;
465
466 if (symndx < 0
467 || (unsigned long) symndx >= obj_raw_syment_count (input_bfd))
468 continue;
469
470 h = obj_coff_sym_hashes (input_bfd)[symndx];
471
472 if (h == NULL)
473 sec = sections[symndx];
474 else
475 {
476 if (h->root.type == bfd_link_hash_defined
477 || h->root.type == bfd_link_hash_defweak)
478 {
479 /* Defined weak symbols are a GNU extension. */
480 sec = h->root.u.def.section;
481 }
482 else
483 {
484 sec = NULL;
485 }
486 }
487
488 if (!sec)
489 continue;
490
491 if (bfd_is_abs_section (sec))
492 continue;
493
494 if (discarded_section (sec))
495 continue;
496
497 s = output_bfd->sections;
498 while (s)
499 {
500 if (s == sec->output_section)
501 {
502 idx = i;
503 break;
504 }
505
506 i++;
507 s = s->next;
508 }
509
510 bfd_putl16 (idx, contents + rel->r_vaddr - input_section->vma);
511 }
512
513 return _bfd_coff_generic_relocate_section (output_bfd, info, input_bfd,
514 input_section, contents,
515 relocs, syms, sections);
516 }
517
518 #define coff_relocate_section coff_pe_i386_relocate_section
519
520 #endif /* COFF_WITH_PE */
521
522 /* Convert an rtype to howto for the COFF backend linker. */
523
524 static reloc_howto_type *
coff_i386_rtype_to_howto(bfd * abfd ATTRIBUTE_UNUSED,asection * sec,struct internal_reloc * rel,struct coff_link_hash_entry * h,struct internal_syment * sym,bfd_vma * addendp)525 coff_i386_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
526 asection *sec,
527 struct internal_reloc *rel,
528 struct coff_link_hash_entry *h,
529 struct internal_syment *sym,
530 bfd_vma *addendp)
531 {
532 reloc_howto_type *howto;
533
534 if (rel->r_type >= NUM_HOWTOS)
535 {
536 bfd_set_error (bfd_error_bad_value);
537 return NULL;
538 }
539
540 howto = howto_table + rel->r_type;
541
542 #ifdef COFF_WITH_PE
543 /* Cancel out code in _bfd_coff_generic_relocate_section. */
544 *addendp = 0;
545 #endif
546
547 if (howto->pc_relative)
548 *addendp += sec->vma;
549
550 if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0)
551 {
552 /* This is a common symbol. The section contents include the
553 size (sym->n_value) as an addend. The relocate_section
554 function will be adding in the final value of the symbol. We
555 need to subtract out the current size in order to get the
556 correct result. */
557
558 BFD_ASSERT (h != NULL);
559
560 #ifndef COFF_WITH_PE
561 /* I think we *do* want to bypass this. If we don't, I have
562 seen some data parameters get the wrong relocation address.
563 If I link two versions with and without this section bypassed
564 and then do a binary comparison, the addresses which are
565 different can be looked up in the map. The case in which
566 this section has been bypassed has addresses which correspond
567 to values I can find in the map. */
568 *addendp -= sym->n_value;
569 #endif
570 }
571
572 #ifndef COFF_WITH_PE
573 /* If the output symbol is common (in which case this must be a
574 relocatable link), we need to add in the final size of the
575 common symbol. */
576 if (h != NULL && h->root.type == bfd_link_hash_common)
577 *addendp += h->root.u.c.size;
578 #endif
579
580 #ifdef COFF_WITH_PE
581 if (howto->pc_relative)
582 {
583 *addendp -= 4;
584
585 /* If the symbol is defined, then the generic code is going to
586 add back the symbol value in order to cancel out an
587 adjustment it made to the addend. However, we set the addend
588 to 0 at the start of this function. We need to adjust here,
589 to avoid the adjustment the generic code will make. FIXME:
590 This is getting a bit hackish. */
591 if (sym != NULL && sym->n_scnum != 0)
592 *addendp -= sym->n_value;
593 }
594
595 if (rel->r_type == R_IMAGEBASE
596 && (bfd_get_flavour(sec->output_section->owner)
597 == bfd_target_coff_flavour))
598 {
599 *addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
600 }
601
602 /* PR 17099 - Absolute R_PCRLONG relocations do not need a symbol. */
603 if (rel->r_type == R_PCRLONG && sym == NULL)
604 *addendp -= rel->r_vaddr;
605 else
606 BFD_ASSERT (sym != NULL);
607
608 if (rel->r_type == R_SECREL32 && sym != NULL)
609 {
610 bfd_vma osect_vma;
611
612 if (h && (h->root.type == bfd_link_hash_defined
613 || h->root.type == bfd_link_hash_defweak))
614 osect_vma = h->root.u.def.section->output_section->vma;
615 else
616 {
617 asection *s;
618 int i;
619
620 /* Sigh, the only way to get the section to offset against
621 is to find it the hard way. */
622
623 for (s = abfd->sections, i = 1; i < sym->n_scnum; i++)
624 s = s->next;
625
626 osect_vma = s->output_section->vma;
627 }
628
629 *addendp -= osect_vma;
630 }
631 #endif
632
633 return howto;
634 }
635
636 #define coff_bfd_reloc_type_lookup coff_i386_reloc_type_lookup
637 #define coff_bfd_reloc_name_lookup coff_i386_reloc_name_lookup
638
639 static reloc_howto_type *
coff_i386_reloc_type_lookup(bfd * abfd ATTRIBUTE_UNUSED,bfd_reloc_code_real_type code)640 coff_i386_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
641 bfd_reloc_code_real_type code)
642 {
643 switch (code)
644 {
645 case BFD_RELOC_RVA:
646 return howto_table + R_IMAGEBASE;
647 case BFD_RELOC_32:
648 return howto_table + R_DIR32;
649 case BFD_RELOC_32_PCREL:
650 return howto_table + R_PCRLONG;
651 case BFD_RELOC_16:
652 return howto_table + R_RELWORD;
653 case BFD_RELOC_16_PCREL:
654 return howto_table + R_PCRWORD;
655 case BFD_RELOC_8:
656 return howto_table + R_RELBYTE;
657 case BFD_RELOC_8_PCREL:
658 return howto_table + R_PCRBYTE;
659 #ifdef COFF_WITH_PE
660 case BFD_RELOC_32_SECREL:
661 return howto_table + R_SECREL32;
662 case BFD_RELOC_16_SECIDX:
663 return howto_table + R_SECTION;
664 #endif
665 default:
666 BFD_FAIL ();
667 return 0;
668 }
669 }
670
671 static reloc_howto_type *
coff_i386_reloc_name_lookup(bfd * abfd ATTRIBUTE_UNUSED,const char * r_name)672 coff_i386_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
673 const char *r_name)
674 {
675 unsigned int i;
676
677 for (i = 0; i < NUM_HOWTOS; i++)
678 if (howto_table[i].name != NULL
679 && strcasecmp (howto_table[i].name, r_name) == 0)
680 return &howto_table[i];
681
682 return NULL;
683 }
684
685 #define coff_rtype_to_howto coff_i386_rtype_to_howto
686
687 #ifdef TARGET_UNDERSCORE
688
689 /* If i386 gcc uses underscores for symbol names, then it does not use
690 a leading dot for local labels, so if TARGET_UNDERSCORE is defined
691 we treat all symbols starting with L as local. */
692
693 static bool
coff_i386_is_local_label_name(bfd * abfd,const char * name)694 coff_i386_is_local_label_name (bfd *abfd, const char *name)
695 {
696 if (name[0] == 'L')
697 return true;
698
699 return _bfd_coff_is_local_label_name (abfd, name);
700 }
701
702 #define coff_bfd_is_local_label_name coff_i386_is_local_label_name
703
704 #endif /* TARGET_UNDERSCORE */
705
706 #include "coffcode.h"
707
708 const bfd_target
709 #ifdef TARGET_SYM
710 TARGET_SYM =
711 #else
712 i386_coff_vec =
713 #endif
714 {
715 #ifdef TARGET_NAME
716 TARGET_NAME,
717 #else
718 "coff-i386", /* name */
719 #endif
720 bfd_target_coff_flavour,
721 BFD_ENDIAN_LITTLE, /* data byte order is little */
722 BFD_ENDIAN_LITTLE, /* header byte order is little */
723
724 (HAS_RELOC | EXEC_P | /* object flags */
725 HAS_LINENO | HAS_DEBUG |
726 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED | BFD_COMPRESS | BFD_DECOMPRESS ),
727
728 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
729 #ifdef COFF_WITH_PE
730 | SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_READONLY | SEC_DEBUGGING
731 #endif
732 | SEC_CODE | SEC_DATA | SEC_EXCLUDE ),
733
734 #ifdef TARGET_UNDERSCORE
735 TARGET_UNDERSCORE, /* leading underscore */
736 #else
737 0, /* leading underscore */
738 #endif
739 '/', /* ar_pad_char */
740 15, /* ar_max_namelen */
741 0, /* match priority. */
742 TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */
743
744 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
745 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
746 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
747 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
748 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
749 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
750
751 #ifndef COFF_CHECK_FORMAT
752 #define COFF_CHECK_FORMAT coff_object_p
753 #endif
754 #ifndef COFF_WRITE_CONTENTS
755 #define COFF_WRITE_CONTENTS coff_write_object_contents
756 #endif
757
758 /* Note that we allow an object file to be treated as a core file as well. */
759
760 { /* bfd_check_format */
761 _bfd_dummy_target,
762 COFF_CHECK_FORMAT,
763 bfd_generic_archive_p,
764 COFF_CHECK_FORMAT
765 },
766 { /* bfd_set_format */
767 _bfd_bool_bfd_false_error,
768 coff_mkobject,
769 _bfd_generic_mkarchive,
770 _bfd_bool_bfd_false_error
771 },
772 { /* bfd_write_contents */
773 _bfd_bool_bfd_false_error,
774 COFF_WRITE_CONTENTS,
775 _bfd_write_archive_contents,
776 _bfd_bool_bfd_false_error
777 },
778
779 BFD_JUMP_TABLE_GENERIC (coff),
780 BFD_JUMP_TABLE_COPY (coff),
781 BFD_JUMP_TABLE_CORE (_bfd_nocore),
782 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
783 BFD_JUMP_TABLE_SYMBOLS (coff),
784 BFD_JUMP_TABLE_RELOCS (coff),
785 BFD_JUMP_TABLE_WRITE (coff),
786 BFD_JUMP_TABLE_LINK (coff),
787 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
788
789 NULL,
790
791 COFF_SWAP_TABLE
792 };
793
794 #ifdef COFF_WITH_PE_BIGOBJ
795 const bfd_target
796 TARGET_SYM_BIG =
797 {
798 TARGET_NAME_BIG,
799 bfd_target_coff_flavour,
800 BFD_ENDIAN_LITTLE, /* data byte order is little */
801 BFD_ENDIAN_LITTLE, /* header byte order is little */
802
803 (HAS_RELOC | EXEC_P | /* object flags */
804 HAS_LINENO | HAS_DEBUG |
805 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED | BFD_COMPRESS | BFD_DECOMPRESS ),
806
807 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
808 #ifdef COFF_WITH_PE
809 | SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_READONLY | SEC_DEBUGGING
810 #endif
811 | SEC_CODE | SEC_DATA | SEC_EXCLUDE ),
812
813 #ifdef TARGET_UNDERSCORE
814 TARGET_UNDERSCORE, /* leading underscore */
815 #else
816 0, /* leading underscore */
817 #endif
818 '/', /* ar_pad_char */
819 15, /* ar_max_namelen */
820 0, /* match priority. */
821 TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */
822
823 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
824 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
825 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
826 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
827 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
828 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
829
830 /* Note that we allow an object file to be treated as a core file as well. */
831
832 { /* bfd_check_format */
833 _bfd_dummy_target,
834 COFF_CHECK_FORMAT,
835 bfd_generic_archive_p,
836 COFF_CHECK_FORMAT
837 },
838 { /* bfd_set_format */
839 _bfd_bool_bfd_false_error,
840 coff_mkobject,
841 _bfd_generic_mkarchive,
842 _bfd_bool_bfd_false_error
843 },
844 { /* bfd_write_contents */
845 _bfd_bool_bfd_false_error,
846 COFF_WRITE_CONTENTS,
847 _bfd_write_archive_contents,
848 _bfd_bool_bfd_false_error
849 },
850
851 BFD_JUMP_TABLE_GENERIC (coff),
852 BFD_JUMP_TABLE_COPY (coff),
853 BFD_JUMP_TABLE_CORE (_bfd_nocore),
854 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
855 BFD_JUMP_TABLE_SYMBOLS (coff),
856 BFD_JUMP_TABLE_RELOCS (coff),
857 BFD_JUMP_TABLE_WRITE (coff),
858 BFD_JUMP_TABLE_LINK (coff),
859 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
860
861 NULL,
862
863 &bigobj_swap_table
864 };
865 #endif
866