1 /* BFD back-end for MIPS PE COFF files.
2 Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000 Free Software Foundation, Inc.
3 Modified from coff-i386.c by DJ Delorie, dj@cygnus.com
5 This file is part of BFD, the Binary File Descriptor library.
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 2 of the License, or
10 (at your option) any later version.
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.
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 #define COFF_LONG_SECTION_NAMES
23 #define PCRELOFFSET true
29 #include "coff/mipspe.h"
31 #include "coff/internal.h"
37 static bfd_reloc_status_type coff_mips_reloc
38 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
39 static reloc_howto_type
*coff_mips_rtype_to_howto
40 PARAMS ((bfd
*, asection
*, struct internal_reloc
*,
41 struct coff_link_hash_entry
*, struct internal_syment
*,
45 static void mips_ecoff_swap_reloc_in
PARAMS ((bfd
*, PTR
,
46 struct internal_reloc
*));
47 static void mips_ecoff_swap_reloc_out
PARAMS ((bfd
*,
48 const struct internal_reloc
*,
50 static void mips_adjust_reloc_in
PARAMS ((bfd
*,
51 const struct internal_reloc
*,
53 static void mips_adjust_reloc_out
PARAMS ((bfd
*, const arelent
*,
54 struct internal_reloc
*));
56 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
57 /* The page size is a guess based on ELF. */
59 #define COFF_PAGE_SIZE 0x1000
61 /* For some reason when using mips COFF the value stored in the .text
62 section for a reference to a common symbol is the value itself plus
63 any desired offset. Ian Taylor, Cygnus Support. */
65 /* If we are producing relocateable output, we need to do some
66 adjustments to the object file that are not done by the
67 bfd_perform_relocation function. This function is called by every
68 reloc type to make any required adjustments. */
70 static bfd_reloc_status_type
71 coff_mips_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
, output_bfd
,
77 asection
*input_section
;
83 if (output_bfd
== (bfd
*) NULL
)
84 return bfd_reloc_continue
;
86 if (bfd_is_com_section (symbol
->section
))
89 /* We are relocating a common symbol. The current value in the
90 object file is ORIG + OFFSET, where ORIG is the value of the
91 common symbol as seen by the object file when it was compiled
92 (this may be zero if the symbol was undefined) and OFFSET is
93 the offset into the common symbol (normally zero, but may be
94 non-zero when referring to a field in a common structure).
95 ORIG is the negative of reloc_entry->addend, which is set by
96 the CALC_ADDEND macro below. We want to replace the value in
97 the object file with NEW + OFFSET, where NEW is the value of
98 the common symbol which we are going to put in the final
99 object file. NEW is symbol->value. */
100 diff
= symbol
->value
+ reloc_entry
->addend
;
102 /* In PE mode, we do not offset the common symbol. */
103 diff
= reloc_entry
->addend
;
108 /* For some reason bfd_perform_relocation always effectively
109 ignores the addend for a COFF target when producing
110 relocateable output. This seems to be always wrong for 386
111 COFF, so we handle the addend here instead. */
112 diff
= reloc_entry
->addend
;
117 /* dj - handle it like any other reloc? */
118 /* FIXME: How should this case be handled? */
119 if (reloc_entry
->howto
->type
== MIPS_R_RVA
&& diff
!= 0)
125 x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + (diff >> howto->rightshift)) & howto->dst_mask))
129 reloc_howto_type
*howto
= reloc_entry
->howto
;
130 unsigned char *addr
= (unsigned char *) data
+ reloc_entry
->address
;
136 char x
= bfd_get_8 (abfd
, addr
);
138 bfd_put_8 (abfd
, x
, addr
);
144 short x
= bfd_get_16 (abfd
, addr
);
146 bfd_put_16 (abfd
, x
, addr
);
152 long x
= bfd_get_32 (abfd
, addr
);
154 bfd_put_32 (abfd
, x
, addr
);
163 /* Now let bfd_perform_relocation finish everything up. */
164 return bfd_reloc_continue
;
168 /* Return true if this relocation should
169 appear in the output .reloc section. */
171 static boolean
in_reloc_p(abfd
, howto
)
173 reloc_howto_type
*howto
;
175 return ! howto
->pc_relative
&& howto
->type
!= MIPS_R_RVA
;
180 #define PCRELOFFSET false
183 static reloc_howto_type howto_table
[] =
185 /* Reloc type 0 is ignored. The reloc reading code ensures that
186 this is a reference to the .abs section, which will cause
187 bfd_perform_relocation to do nothing. */
188 HOWTO (MIPS_R_ABSOLUTE
, /* type */
190 0, /* size (0 = byte, 1 = short, 2 = long) */
192 false, /* pc_relative */
194 complain_overflow_dont
, /* complain_on_overflow */
195 0, /* special_function */
197 false, /* partial_inplace */
200 false), /* pcrel_offset */
202 /* A 16 bit reference to a symbol, normally from a data section. */
203 HOWTO (MIPS_R_REFHALF
, /* type */
205 1, /* size (0 = byte, 1 = short, 2 = long) */
207 false, /* pc_relative */
209 complain_overflow_bitfield
, /* complain_on_overflow */
210 coff_mips_reloc
, /* special_function */
211 "REFHALF", /* name */
212 true, /* partial_inplace */
213 0xffff, /* src_mask */
214 0xffff, /* dst_mask */
215 false), /* pcrel_offset */
217 /* A 32 bit reference to a symbol, normally from a data section. */
218 HOWTO (MIPS_R_REFWORD
, /* type */
220 2, /* size (0 = byte, 1 = short, 2 = long) */
222 false, /* pc_relative */
224 complain_overflow_bitfield
, /* complain_on_overflow */
225 coff_mips_reloc
, /* special_function */
226 "REFWORD", /* name */
227 true, /* partial_inplace */
228 0xffffffff, /* src_mask */
229 0xffffffff, /* dst_mask */
230 false), /* pcrel_offset */
232 /* A 26 bit absolute jump address. */
233 HOWTO (MIPS_R_JMPADDR
, /* type */
235 2, /* size (0 = byte, 1 = short, 2 = long) */
237 false, /* pc_relative */
239 complain_overflow_dont
, /* complain_on_overflow */
240 /* This needs complex overflow
241 detection, because the upper four
242 bits must match the PC. */
243 coff_mips_reloc
, /* special_function */
244 "JMPADDR", /* name */
245 true, /* partial_inplace */
246 0x3ffffff, /* src_mask */
247 0x3ffffff, /* dst_mask */
248 false), /* pcrel_offset */
250 /* The high 16 bits of a symbol value. Handled by the function
252 HOWTO (MIPS_R_REFHI
, /* type */
254 2, /* size (0 = byte, 1 = short, 2 = long) */
256 false, /* pc_relative */
258 complain_overflow_bitfield
, /* complain_on_overflow */
259 coff_mips_reloc
, /* special_function */
261 true, /* partial_inplace */
262 0xffff, /* src_mask */
263 0xffff, /* dst_mask */
264 false), /* pcrel_offset */
266 /* The low 16 bits of a symbol value. */
267 HOWTO (MIPS_R_REFLO
, /* type */
269 2, /* size (0 = byte, 1 = short, 2 = long) */
271 false, /* pc_relative */
273 complain_overflow_dont
, /* complain_on_overflow */
274 coff_mips_reloc
, /* special_function */
276 true, /* partial_inplace */
277 0xffff, /* src_mask */
278 0xffff, /* dst_mask */
279 false), /* pcrel_offset */
281 /* A reference to an offset from the gp register. Handled by the
282 function mips_gprel_reloc. */
283 HOWTO (MIPS_R_GPREL
, /* type */
285 2, /* size (0 = byte, 1 = short, 2 = long) */
287 false, /* pc_relative */
289 complain_overflow_signed
, /* complain_on_overflow */
290 coff_mips_reloc
, /* special_function */
292 true, /* partial_inplace */
293 0xffff, /* src_mask */
294 0xffff, /* dst_mask */
295 false), /* pcrel_offset */
297 /* A reference to a literal using an offset from the gp register.
298 Handled by the function mips_gprel_reloc. */
299 HOWTO (MIPS_R_LITERAL
, /* type */
301 2, /* size (0 = byte, 1 = short, 2 = long) */
303 false, /* pc_relative */
305 complain_overflow_signed
, /* complain_on_overflow */
306 coff_mips_reloc
, /* special_function */
307 "LITERAL", /* name */
308 true, /* partial_inplace */
309 0xffff, /* src_mask */
310 0xffff, /* dst_mask */
311 false), /* pcrel_offset */
339 HOWTO (MIPS_R_RVA
, /* type */
341 2, /* size (0 = byte, 1 = short, 2 = long) */
343 false, /* pc_relative */
345 complain_overflow_bitfield
, /* complain_on_overflow */
346 coff_mips_reloc
, /* special_function */
348 true, /* partial_inplace */
349 0xffffffff, /* src_mask */
350 0xffffffff, /* dst_mask */
351 false), /* pcrel_offset */
354 HOWTO (MIPS_R_PAIR
, /* type */
356 2, /* size (0 = byte, 1 = short, 2 = long) */
358 false, /* pc_relative */
360 complain_overflow_bitfield
, /* complain_on_overflow */
361 coff_mips_reloc
, /* special_function */
363 true, /* partial_inplace */
364 0xffffffff, /* src_mask */
365 0xffffffff, /* dst_mask */
366 false), /* pcrel_offset */
369 /* Turn a howto into a reloc nunmber */
371 #define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
372 #define BADMAG(x) MIPSBADMAG(x)
373 #define MIPS 1 /* Customize coffcode.h */
375 #define RTYPE2HOWTO(cache_ptr, dst) \
376 (cache_ptr)->howto = howto_table + (dst)->r_type;
378 /* Compute the addend of a reloc. If the reloc is to a common symbol,
379 the object file contains the value of the common symbol. By the
380 time this is called, the linker may be using a different symbol
381 from a different object file with a different value. Therefore, we
382 hack wildly to locate the original symbol from this file so that we
383 can make the correct adjustment. This macro sets coffsym to the
384 symbol from the original file, and uses it to set the addend value
385 correctly. If this is not a common symbol, the usual addend
386 calculation is done, except that an additional tweak is needed for
388 FIXME: This macro refers to symbols and asect; these are from the
389 calling function, not the macro arguments. */
391 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
393 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
394 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
395 coffsym = (obj_symbols (abfd) \
396 + (cache_ptr->sym_ptr_ptr - symbols)); \
398 coffsym = coff_symbol_from (abfd, ptr); \
399 if (coffsym != (coff_symbol_type *) NULL \
400 && coffsym->native->u.syment.n_scnum == 0) \
401 cache_ptr->addend = - coffsym->native->u.syment.n_value; \
402 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
403 && ptr->section != (asection *) NULL) \
404 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
406 cache_ptr->addend = 0; \
407 if (ptr && howto_table[reloc.r_type].pc_relative) \
408 cache_ptr->addend += asect->vma; \
412 /* Convert an rtype to howto for the COFF backend linker. */
414 static reloc_howto_type
*
415 coff_mips_rtype_to_howto (abfd
, sec
, rel
, h
, sym
, addendp
)
418 struct internal_reloc
*rel
;
419 struct coff_link_hash_entry
*h
;
420 struct internal_syment
*sym
;
424 reloc_howto_type
*howto
;
426 howto
= howto_table
+ rel
->r_type
;
432 if (howto
->pc_relative
)
433 *addendp
+= sec
->vma
;
435 if (sym
!= NULL
&& sym
->n_scnum
== 0 && sym
->n_value
!= 0)
437 /* This is a common symbol. The section contents include the
438 size (sym->n_value) as an addend. The relocate_section
439 function will be adding in the final value of the symbol. We
440 need to subtract out the current size in order to get the
443 BFD_ASSERT (h
!= NULL
);
446 /* I think we *do* want to bypass this. If we don't, I have
447 seen some data parameters get the wrong relocation address.
448 If I link two versions with and without this section bypassed
449 and then do a binary comparison, the addresses which are
450 different can be looked up in the map. The case in which
451 this section has been bypassed has addresses which correspond
452 to values I can find in the map. */
453 *addendp
-= sym
->n_value
;
458 /* If the output symbol is common (in which case this must be a
459 relocateable link), we need to add in the final size of the
461 if (h
!= NULL
&& h
->root
.type
== bfd_link_hash_common
)
462 *addendp
+= h
->root
.u
.c
.size
;
466 if (howto
->pc_relative
)
470 /* If the symbol is defined, then the generic code is going to
471 add back the symbol value in order to cancel out an
472 adjustment it made to the addend. However, we set the addend
473 to 0 at the start of this function. We need to adjust here,
474 to avoid the adjustment the generic code will make. FIXME:
475 This is getting a bit hackish. */
476 if (sym
!= NULL
&& sym
->n_scnum
!= 0)
477 *addendp
-= sym
->n_value
;
480 if (rel
->r_type
== MIPS_R_RVA
)
482 *addendp
-= pe_data(sec
->output_section
->owner
)->pe_opthdr
.ImageBase
;
489 #define coff_rtype_to_howto coff_mips_rtype_to_howto
492 #define coff_bfd_reloc_type_lookup coff_mips_reloc_type_lookup
496 /* Get the howto structure for a generic reloc type. */
498 static reloc_howto_type
*
499 coff_mips_reloc_type_lookup (abfd
, code
)
501 bfd_reloc_code_real_type code
;
508 mips_type
= MIPS_R_REFHALF
;
512 mips_type
= MIPS_R_REFWORD
;
514 case BFD_RELOC_MIPS_JMP
:
515 mips_type
= MIPS_R_JMPADDR
;
517 case BFD_RELOC_HI16_S
:
518 mips_type
= MIPS_R_REFHI
;
521 mips_type
= MIPS_R_REFLO
;
523 case BFD_RELOC_MIPS_GPREL
:
524 mips_type
= MIPS_R_GPREL
;
526 case BFD_RELOC_MIPS_LITERAL
:
527 mips_type
= MIPS_R_LITERAL
;
530 case BFD_RELOC_16_PCREL_S2:
531 mips_type = MIPS_R_PCREL16;
533 case BFD_RELOC_PCREL_HI16_S:
534 mips_type = MIPS_R_RELHI;
536 case BFD_RELOC_PCREL_LO16:
537 mips_type = MIPS_R_RELLO;
539 case BFD_RELOC_GPREL32:
540 mips_type = MIPS_R_SWITCH;
544 mips_type
= MIPS_R_RVA
;
547 return (reloc_howto_type
*) NULL
;
550 return &howto_table
[mips_type
];
554 mips_swap_reloc_in (abfd
, src
, dst
)
559 static struct internal_reloc pair_prev
;
560 RELOC
*reloc_src
= (RELOC
*) src
;
561 struct internal_reloc
*reloc_dst
= (struct internal_reloc
*) dst
;
563 reloc_dst
->r_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*)reloc_src
->r_vaddr
);
564 reloc_dst
->r_symndx
=
565 bfd_h_get_signed_32(abfd
, (bfd_byte
*) reloc_src
->r_symndx
);
566 reloc_dst
->r_type
= bfd_h_get_16(abfd
, (bfd_byte
*) reloc_src
->r_type
);
567 reloc_dst
->r_size
= 0;
568 reloc_dst
->r_extern
= 0;
569 reloc_dst
->r_offset
= 0;
571 switch (reloc_dst
->r_type
)
574 pair_prev
= *reloc_dst
;
577 reloc_dst
->r_offset
= reloc_dst
->r_symndx
;
578 if (reloc_dst
->r_offset
& 0x8000)
579 reloc_dst
->r_offset
-= 0x10000;
580 /*printf("dj: pair offset is %08x\n", reloc_dst->r_offset);*/
581 reloc_dst
->r_symndx
= pair_prev
.r_symndx
;
587 mips_swap_reloc_out (abfd
, src
, dst
)
592 static int prev_offset
= 1;
593 static bfd_vma prev_addr
= 0;
594 struct internal_reloc
*reloc_src
= (struct internal_reloc
*)src
;
595 struct external_reloc
*reloc_dst
= (struct external_reloc
*)dst
;
597 switch (reloc_src
->r_type
)
600 prev_addr
= reloc_src
->r_vaddr
;
601 prev_offset
= reloc_src
->r_offset
;
604 if (reloc_src
->r_vaddr
== prev_addr
)
606 /* FIXME: only slightly hackish. If we see a REFLO pointing to
607 the same address as a REFHI, we assume this is the matching
608 PAIR reloc and output it accordingly. The symndx is really
609 the low 16 bits of the addend */
610 bfd_h_put_32 (abfd
, reloc_src
->r_vaddr
,
611 (bfd_byte
*) reloc_dst
->r_vaddr
);
612 bfd_h_put_32 (abfd
, reloc_src
->r_symndx
,
613 (bfd_byte
*) reloc_dst
->r_symndx
);
615 bfd_h_put_16(abfd
, MIPS_R_PAIR
, (bfd_byte
*)
622 bfd_h_put_32(abfd
, reloc_src
->r_vaddr
, (bfd_byte
*) reloc_dst
->r_vaddr
);
623 bfd_h_put_32(abfd
, reloc_src
->r_symndx
, (bfd_byte
*) reloc_dst
->r_symndx
);
625 bfd_h_put_16(abfd
, reloc_src
->r_type
, (bfd_byte
*)
630 #define coff_swap_reloc_in mips_swap_reloc_in
631 #define coff_swap_reloc_out mips_swap_reloc_out
632 #define NO_COFF_RELOCS
635 coff_pe_mips_relocate_section (output_bfd
, info
, input_bfd
,
636 input_section
, contents
, relocs
, syms
,
639 struct bfd_link_info
*info
;
641 asection
*input_section
;
643 struct internal_reloc
*relocs
;
644 struct internal_syment
*syms
;
647 asection
**symndx_to_section
;
648 struct ecoff_link_hash_entry
**sym_hashes
;
649 struct coff_link_hash_entry
*h
;
651 boolean gp_undefined
;
654 struct internal_reloc
*rel
;
655 struct internal_reloc
*rel_end
;
658 struct internal_reloc lo_int_rel
;
660 if (info
->relocateable
)
662 (*_bfd_error_handler
)(_("\
663 %s: `ld -r' not supported with PE MIPS objects\n"),
664 bfd_get_filename (input_bfd
));
665 bfd_set_error (bfd_error_bad_value
);
669 BFD_ASSERT (input_bfd
->xvec
->byteorder
670 == output_bfd
->xvec
->byteorder
);
673 printf("dj: relocate %s(%s) %08x\n",
674 input_bfd
->filename
, input_section
->name
,
675 input_section
->output_section
->vma
+ input_section
->output_offset
);
678 gp
= _bfd_get_gp_value (output_bfd
);
682 gp_undefined
= false;
689 rel_end
= rel
+ input_section
->reloc_count
;
690 for (i
= 0; rel
< rel_end
; rel
++, i
++)
693 struct coff_link_hash_entry
*h
;
694 struct internal_syment
*sym
;
696 bfd_vma val
, tmp
, targ
, src
, low
;
697 reloc_howto_type
*howto
;
698 bfd_reloc_status_type rstat
;
699 unsigned char *mem
= contents
+ rel
->r_vaddr
;
701 symndx
= rel
->r_symndx
;
710 h
= obj_coff_sym_hashes (input_bfd
)[symndx
];
714 /* COFF treats common symbols in one of two ways. Either the
715 size of the symbol is included in the section contents, or it
716 is not. We assume that the size is not included, and force
717 the rtype_to_howto function to adjust the addend as needed. */
719 if (sym
!= NULL
&& sym
->n_scnum
!= 0)
720 addend
= - sym
->n_value
;
725 howto
= bfd_coff_rtype_to_howto (input_bfd
, input_section
, rel
, h
,
730 /* If we are doing a relocateable link, then we can just ignore
731 a PC relative reloc that is pcrel_offset. It will already
732 have the correct value. If this is not a relocateable link,
733 then we should ignore the symbol value. */
734 if (howto
->pc_relative
&& howto
->pcrel_offset
)
736 if (info
->relocateable
)
738 if (sym
!= NULL
&& sym
->n_scnum
!= 0)
739 addend
+= sym
->n_value
;
750 sec
= bfd_abs_section_ptr
;
755 sec
= sections
[symndx
];
756 val
= (sec
->output_section
->vma
759 if (! obj_pe (input_bfd
))
765 if (h
->root
.type
== bfd_link_hash_defined
766 || h
->root
.type
== bfd_link_hash_defweak
)
770 sec
= h
->root
.u
.def
.section
;
771 val
= (h
->root
.u
.def
.value
772 + sec
->output_section
->vma
773 + sec
->output_offset
);
776 else if (! info
->relocateable
)
778 if (! ((*info
->callbacks
->undefined_symbol
)
779 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
780 rel
->r_vaddr
- input_section
->vma
, true)))
785 src
= rel
->r_vaddr
+ input_section
->output_section
->vma
786 + input_section
->output_offset
;
788 printf("dj: reloc %02x %-8s a=%08x/%08x(%08x) v=%08x+%08x %s\n",
789 rel
->r_type
, howto_table
[rel
->r_type
].name
,
790 src
, rel
->r_vaddr
, *(unsigned long *)mem
, val
, rel
->r_offset
,
791 h
?h
->root
.root
.string
:"(none)");
794 /* OK, at this point the following variables are set up:
795 src = VMA of the memory we're fixing up
796 mem = pointer to memory we're fixing up
797 val = VMA of what we need to refer to
800 #define UI(x) (*_bfd_error_handler)(_("%s: unimplemented %s\n"), \
801 bfd_get_filename (input_bfd), x); \
802 bfd_set_error (bfd_error_bad_value);
806 case MIPS_R_ABSOLUTE
:
815 tmp
= bfd_get_32(input_bfd
, mem
);
816 /* printf("refword: src=%08x targ=%08x+%08x\n", src, tmp, val); */
818 bfd_put_32(input_bfd
, tmp
, mem
);
822 tmp
= bfd_get_32(input_bfd
, mem
);
823 targ
= val
+ (tmp
&0x03ffffff)*4;
824 if (src
& 0xf0000000 != targ
& 0xf0000000)
826 (*_bfd_error_handler
)(_("%s: jump too far away\n"),
827 bfd_get_filename (input_bfd
));
828 bfd_set_error (bfd_error_bad_value
);
832 tmp
|= (targ
/4) & 0x3ffffff;
833 bfd_put_32(input_bfd
, tmp
, mem
);
837 tmp
= bfd_get_32(input_bfd
, mem
);
838 switch (rel
[1].r_type
)
842 targ
= val
+ rel
[1].r_offset
+ ((tmp
& 0xffff) << 16);
845 /* GNU COFF object */
846 low
= bfd_get_32(input_bfd
, contents
+ rel
[1].r_vaddr
);
850 targ
= val
+ low
+ ((tmp
& 0xffff) << 16);
853 (*_bfd_error_handler
)(_("%s: bad pair/reflo after refhi\n"),
854 bfd_get_filename (input_bfd
));
855 bfd_set_error (bfd_error_bad_value
);
859 tmp
|= (targ
>> 16) & 0xffff;
860 bfd_put_32(input_bfd
, tmp
, mem
);
864 tmp
= bfd_get_32(input_bfd
, mem
);
865 targ
= val
+ (tmp
& 0xffff);
866 /* printf("refword: src=%08x targ=%08x\n", src, targ); */
868 tmp
|= targ
& 0xffff;
869 bfd_put_32(input_bfd
, tmp
, mem
);
885 case MIPS_R_SECRELLO
:
889 case MIPS_R_SECRELHI
:
894 tmp
= bfd_get_32 (input_bfd
, mem
);
895 /* printf("rva: src=%08x targ=%08x+%08x\n", src, tmp, val); */
897 - pe_data (input_section
->output_section
->owner
)->pe_opthdr
.ImageBase
;
898 bfd_put_32 (input_bfd
, tmp
, mem
);
910 #define coff_relocate_section coff_pe_mips_relocate_section
912 #ifdef TARGET_UNDERSCORE
914 /* If mips gcc uses underscores for symbol names, then it does not use
915 a leading dot for local labels, so if TARGET_UNDERSCORE is defined
916 we treat all symbols starting with L as local. */
918 static boolean coff_mips_is_local_label_name
PARAMS ((bfd
*, const char *));
921 coff_mips_is_local_label_name (abfd
, name
)
928 return _bfd_coff_is_local_label_name (abfd
, name
);
931 #define coff_bfd_is_local_label_name coff_mips_is_local_label_name
933 #endif /* TARGET_UNDERSCORE */
935 #define COFF_NO_HACK_SCNHDR_SIZE
937 #include "coffcode.h"
949 "pe-mips", /* name */
951 bfd_target_coff_flavour
,
952 BFD_ENDIAN_LITTLE
, /* data byte order is little */
953 BFD_ENDIAN_LITTLE
, /* header byte order is little */
955 (HAS_RELOC
| EXEC_P
| /* object flags */
956 HAS_LINENO
| HAS_DEBUG
|
957 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
| D_PAGED
),
960 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
/* section flags */
961 | SEC_CODE
| SEC_DATA
),
963 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
/* section flags */
964 | SEC_CODE
| SEC_DATA
965 | SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
),
968 #ifdef TARGET_UNDERSCORE
969 TARGET_UNDERSCORE
, /* leading underscore */
971 0, /* leading underscore */
973 '/', /* ar_pad_char */
974 15, /* ar_max_namelen */
976 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
977 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
978 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* data */
979 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
980 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
981 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* hdrs */
983 /* Note that we allow an object file to be treated as a core file as well. */
984 {_bfd_dummy_target
, coff_object_p
, /* bfd_check_format */
985 bfd_generic_archive_p
, coff_object_p
},
986 {bfd_false
, coff_mkobject
, _bfd_generic_mkarchive
, /* bfd_set_format */
988 {bfd_false
, coff_write_object_contents
, /* bfd_write_contents */
989 _bfd_write_archive_contents
, bfd_false
},
991 BFD_JUMP_TABLE_GENERIC (coff
),
992 BFD_JUMP_TABLE_COPY (coff
),
993 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
994 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff
),
995 BFD_JUMP_TABLE_SYMBOLS (coff
),
996 BFD_JUMP_TABLE_RELOCS (coff
),
997 BFD_JUMP_TABLE_WRITE (coff
),
998 BFD_JUMP_TABLE_LINK (coff
),
999 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),