Disable sym_vec too.
[binutils.git] / bfd / pe-mips.c
blobc78726d1c3b398365c7d4db8f1a7accdf3e917b2
1 /* BFD back-end for MIPS PE COFF files.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001 Free Software Foundation, Inc.
4 Modified from coff-i386.c by DJ Delorie, dj@cygnus.com
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 #define COFF_WITH_PE
23 #define COFF_LONG_SECTION_NAMES
24 #define PCRELOFFSET true
26 #include "bfd.h"
27 #include "sysdep.h"
28 #include "libbfd.h"
30 #include "coff/mipspe.h"
32 #include "coff/internal.h"
34 #include "coff/pe.h"
36 #include "libcoff.h"
38 static bfd_reloc_status_type coff_mips_reloc
39 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
40 static reloc_howto_type *coff_mips_rtype_to_howto
41 PARAMS ((bfd *, asection *, struct internal_reloc *,
42 struct coff_link_hash_entry *, struct internal_syment *,
44 bfd_vma *));
45 #if 0
46 static void mips_ecoff_swap_reloc_in PARAMS ((bfd *, PTR,
47 struct internal_reloc *));
48 static void mips_ecoff_swap_reloc_out PARAMS ((bfd *,
49 const struct internal_reloc *,
50 PTR));
51 static void mips_adjust_reloc_in PARAMS ((bfd *,
52 const struct internal_reloc *,
53 arelent *));
54 static void mips_adjust_reloc_out PARAMS ((bfd *, const arelent *,
55 struct internal_reloc *));
56 #endif
58 static boolean in_reloc_p PARAMS ((bfd *, reloc_howto_type *));
59 static reloc_howto_type * coff_mips_reloc_type_lookup PARAMS ((bfd *, bfd_reloc_code_real_type));
60 static void mips_swap_reloc_in PARAMS ((bfd *, PTR, PTR));
61 static unsigned int mips_swap_reloc_out PARAMS ((bfd *, PTR, PTR));
62 static boolean coff_pe_mips_relocate_section
63 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
64 struct internal_reloc *, struct internal_syment *, asection **));
66 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
67 /* The page size is a guess based on ELF. */
69 #define COFF_PAGE_SIZE 0x1000
71 /* For some reason when using mips COFF the value stored in the .text
72 section for a reference to a common symbol is the value itself plus
73 any desired offset. Ian Taylor, Cygnus Support. */
75 /* If we are producing relocateable output, we need to do some
76 adjustments to the object file that are not done by the
77 bfd_perform_relocation function. This function is called by every
78 reloc type to make any required adjustments. */
80 static bfd_reloc_status_type
81 coff_mips_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd,
82 error_message)
83 bfd *abfd;
84 arelent *reloc_entry;
85 asymbol *symbol;
86 PTR data;
87 asection *input_section ATTRIBUTE_UNUSED;
88 bfd *output_bfd;
89 char **error_message ATTRIBUTE_UNUSED;
91 symvalue diff;
93 if (output_bfd == (bfd *) NULL)
94 return bfd_reloc_continue;
96 if (bfd_is_com_section (symbol->section))
98 #ifndef COFF_WITH_PE
99 /* We are relocating a common symbol. The current value in the
100 object file is ORIG + OFFSET, where ORIG is the value of the
101 common symbol as seen by the object file when it was compiled
102 (this may be zero if the symbol was undefined) and OFFSET is
103 the offset into the common symbol (normally zero, but may be
104 non-zero when referring to a field in a common structure).
105 ORIG is the negative of reloc_entry->addend, which is set by
106 the CALC_ADDEND macro below. We want to replace the value in
107 the object file with NEW + OFFSET, where NEW is the value of
108 the common symbol which we are going to put in the final
109 object file. NEW is symbol->value. */
110 diff = symbol->value + reloc_entry->addend;
111 #else
112 /* In PE mode, we do not offset the common symbol. */
113 diff = reloc_entry->addend;
114 #endif
116 else
118 /* For some reason bfd_perform_relocation always effectively
119 ignores the addend for a COFF target when producing
120 relocateable output. This seems to be always wrong for 386
121 COFF, so we handle the addend here instead. */
122 diff = reloc_entry->addend;
125 #ifdef COFF_WITH_PE
126 #if 0
127 /* dj - handle it like any other reloc? */
128 /* FIXME: How should this case be handled? */
129 if (reloc_entry->howto->type == MIPS_R_RVA && diff != 0)
130 abort ();
131 #endif
132 #endif
134 #define DOIT(x) \
135 x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + (diff >> howto->rightshift)) & howto->dst_mask))
137 if (diff != 0)
139 reloc_howto_type *howto = reloc_entry->howto;
140 unsigned char *addr = (unsigned char *) data + reloc_entry->address;
142 switch (howto->size)
144 case 0:
146 char x = bfd_get_8 (abfd, addr);
147 DOIT (x);
148 bfd_put_8 (abfd, x, addr);
150 break;
152 case 1:
154 short x = bfd_get_16 (abfd, addr);
155 DOIT (x);
156 bfd_put_16 (abfd, (bfd_vma) x, addr);
158 break;
160 case 2:
162 long x = bfd_get_32 (abfd, addr);
163 DOIT (x);
164 bfd_put_32 (abfd, (bfd_vma) x, addr);
166 break;
168 default:
169 abort ();
173 /* Now let bfd_perform_relocation finish everything up. */
174 return bfd_reloc_continue;
177 #ifdef COFF_WITH_PE
178 /* Return true if this relocation should
179 appear in the output .reloc section. */
181 static boolean
182 in_reloc_p (abfd, howto)
183 bfd * abfd ATTRIBUTE_UNUSED;
184 reloc_howto_type *howto;
186 return ! howto->pc_relative && howto->type != MIPS_R_RVA;
188 #endif
190 #ifndef PCRELOFFSET
191 #define PCRELOFFSET false
192 #endif
194 static reloc_howto_type howto_table[] =
196 /* Reloc type 0 is ignored. The reloc reading code ensures that
197 this is a reference to the .abs section, which will cause
198 bfd_perform_relocation to do nothing. */
199 HOWTO (MIPS_R_ABSOLUTE, /* type */
200 0, /* rightshift */
201 0, /* size (0 = byte, 1 = short, 2 = long) */
202 8, /* bitsize */
203 false, /* pc_relative */
204 0, /* bitpos */
205 complain_overflow_dont, /* complain_on_overflow */
206 0, /* special_function */
207 "IGNORE", /* name */
208 false, /* partial_inplace */
209 0, /* src_mask */
210 0, /* dst_mask */
211 false), /* pcrel_offset */
213 /* A 16 bit reference to a symbol, normally from a data section. */
214 HOWTO (MIPS_R_REFHALF, /* type */
215 0, /* rightshift */
216 1, /* size (0 = byte, 1 = short, 2 = long) */
217 16, /* bitsize */
218 false, /* pc_relative */
219 0, /* bitpos */
220 complain_overflow_bitfield, /* complain_on_overflow */
221 coff_mips_reloc, /* special_function */
222 "REFHALF", /* name */
223 true, /* partial_inplace */
224 0xffff, /* src_mask */
225 0xffff, /* dst_mask */
226 false), /* pcrel_offset */
228 /* A 32 bit reference to a symbol, normally from a data section. */
229 HOWTO (MIPS_R_REFWORD, /* 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_mips_reloc, /* special_function */
237 "REFWORD", /* name */
238 true, /* partial_inplace */
239 0xffffffff, /* src_mask */
240 0xffffffff, /* dst_mask */
241 false), /* pcrel_offset */
243 /* A 26 bit absolute jump address. */
244 HOWTO (MIPS_R_JMPADDR, /* type */
245 2, /* rightshift */
246 2, /* size (0 = byte, 1 = short, 2 = long) */
247 26, /* bitsize */
248 false, /* pc_relative */
249 0, /* bitpos */
250 complain_overflow_dont, /* complain_on_overflow */
251 /* This needs complex overflow
252 detection, because the upper four
253 bits must match the PC. */
254 coff_mips_reloc, /* special_function */
255 "JMPADDR", /* name */
256 true, /* partial_inplace */
257 0x3ffffff, /* src_mask */
258 0x3ffffff, /* dst_mask */
259 false), /* pcrel_offset */
261 /* The high 16 bits of a symbol value. Handled by the function
262 mips_refhi_reloc. */
263 HOWTO (MIPS_R_REFHI, /* type */
264 16, /* rightshift */
265 2, /* size (0 = byte, 1 = short, 2 = long) */
266 16, /* bitsize */
267 false, /* pc_relative */
268 0, /* bitpos */
269 complain_overflow_bitfield, /* complain_on_overflow */
270 coff_mips_reloc, /* special_function */
271 "REFHI", /* name */
272 true, /* partial_inplace */
273 0xffff, /* src_mask */
274 0xffff, /* dst_mask */
275 false), /* pcrel_offset */
277 /* The low 16 bits of a symbol value. */
278 HOWTO (MIPS_R_REFLO, /* type */
279 0, /* rightshift */
280 2, /* size (0 = byte, 1 = short, 2 = long) */
281 16, /* bitsize */
282 false, /* pc_relative */
283 0, /* bitpos */
284 complain_overflow_dont, /* complain_on_overflow */
285 coff_mips_reloc, /* special_function */
286 "REFLO", /* name */
287 true, /* partial_inplace */
288 0xffff, /* src_mask */
289 0xffff, /* dst_mask */
290 false), /* pcrel_offset */
292 /* A reference to an offset from the gp register. Handled by the
293 function mips_gprel_reloc. */
294 HOWTO (MIPS_R_GPREL, /* type */
295 0, /* rightshift */
296 2, /* size (0 = byte, 1 = short, 2 = long) */
297 16, /* bitsize */
298 false, /* pc_relative */
299 0, /* bitpos */
300 complain_overflow_signed, /* complain_on_overflow */
301 coff_mips_reloc, /* special_function */
302 "GPREL", /* name */
303 true, /* partial_inplace */
304 0xffff, /* src_mask */
305 0xffff, /* dst_mask */
306 false), /* pcrel_offset */
308 /* A reference to a literal using an offset from the gp register.
309 Handled by the function mips_gprel_reloc. */
310 HOWTO (MIPS_R_LITERAL, /* type */
311 0, /* rightshift */
312 2, /* size (0 = byte, 1 = short, 2 = long) */
313 16, /* bitsize */
314 false, /* pc_relative */
315 0, /* bitpos */
316 complain_overflow_signed, /* complain_on_overflow */
317 coff_mips_reloc, /* special_function */
318 "LITERAL", /* name */
319 true, /* partial_inplace */
320 0xffff, /* src_mask */
321 0xffff, /* dst_mask */
322 false), /* pcrel_offset */
324 EMPTY_HOWTO (8),
325 EMPTY_HOWTO (9),
326 EMPTY_HOWTO (10),
327 EMPTY_HOWTO (11),
328 EMPTY_HOWTO (12),
329 EMPTY_HOWTO (13),
330 EMPTY_HOWTO (14),
331 EMPTY_HOWTO (15),
332 EMPTY_HOWTO (16),
333 EMPTY_HOWTO (17),
334 EMPTY_HOWTO (18),
335 EMPTY_HOWTO (19),
336 EMPTY_HOWTO (20),
337 EMPTY_HOWTO (21),
338 EMPTY_HOWTO (22),
339 EMPTY_HOWTO (23),
340 EMPTY_HOWTO (24),
341 EMPTY_HOWTO (25),
342 EMPTY_HOWTO (26),
343 EMPTY_HOWTO (27),
344 EMPTY_HOWTO (28),
345 EMPTY_HOWTO (29),
346 EMPTY_HOWTO (30),
347 EMPTY_HOWTO (31),
348 EMPTY_HOWTO (32),
349 EMPTY_HOWTO (33),
350 HOWTO (MIPS_R_RVA, /* type */
351 0, /* rightshift */
352 2, /* size (0 = byte, 1 = short, 2 = long) */
353 32, /* bitsize */
354 false, /* pc_relative */
355 0, /* bitpos */
356 complain_overflow_bitfield, /* complain_on_overflow */
357 coff_mips_reloc, /* special_function */
358 "rva32", /* name */
359 true, /* partial_inplace */
360 0xffffffff, /* src_mask */
361 0xffffffff, /* dst_mask */
362 false), /* pcrel_offset */
363 EMPTY_HOWTO (35),
364 EMPTY_HOWTO (36),
365 HOWTO (MIPS_R_PAIR, /* type */
366 0, /* rightshift */
367 2, /* size (0 = byte, 1 = short, 2 = long) */
368 32, /* bitsize */
369 false, /* pc_relative */
370 0, /* bitpos */
371 complain_overflow_bitfield, /* complain_on_overflow */
372 coff_mips_reloc, /* special_function */
373 "PAIR", /* name */
374 true, /* partial_inplace */
375 0xffffffff, /* src_mask */
376 0xffffffff, /* dst_mask */
377 false), /* pcrel_offset */
380 /* Turn a howto into a reloc nunmber */
382 #define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
383 #define BADMAG(x) MIPSBADMAG(x)
384 #define MIPS 1 /* Customize coffcode.h */
386 #define RTYPE2HOWTO(cache_ptr, dst) \
387 (cache_ptr)->howto = howto_table + (dst)->r_type;
389 /* Compute the addend of a reloc. If the reloc is to a common symbol,
390 the object file contains the value of the common symbol. By the
391 time this is called, the linker may be using a different symbol
392 from a different object file with a different value. Therefore, we
393 hack wildly to locate the original symbol from this file so that we
394 can make the correct adjustment. This macro sets coffsym to the
395 symbol from the original file, and uses it to set the addend value
396 correctly. If this is not a common symbol, the usual addend
397 calculation is done, except that an additional tweak is needed for
398 PC relative relocs.
399 FIXME: This macro refers to symbols and asect; these are from the
400 calling function, not the macro arguments. */
402 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
404 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
405 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
406 coffsym = (obj_symbols (abfd) \
407 + (cache_ptr->sym_ptr_ptr - symbols)); \
408 else if (ptr) \
409 coffsym = coff_symbol_from (abfd, ptr); \
410 if (coffsym != (coff_symbol_type *) NULL \
411 && coffsym->native->u.syment.n_scnum == 0) \
412 cache_ptr->addend = - coffsym->native->u.syment.n_value; \
413 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
414 && ptr->section != (asection *) NULL) \
415 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
416 else \
417 cache_ptr->addend = 0; \
418 if (ptr && howto_table[reloc.r_type].pc_relative) \
419 cache_ptr->addend += asect->vma; \
422 /* Convert an rtype to howto for the COFF backend linker. */
424 static reloc_howto_type *
425 coff_mips_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
426 bfd *abfd ATTRIBUTE_UNUSED;
427 asection *sec;
428 struct internal_reloc *rel;
429 struct coff_link_hash_entry *h;
430 struct internal_syment *sym;
431 bfd_vma *addendp;
434 reloc_howto_type *howto;
436 howto = howto_table + rel->r_type;
438 #ifdef COFF_WITH_PE
439 *addendp = 0;
440 #endif
442 if (howto->pc_relative)
443 *addendp += sec->vma;
445 if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0)
447 /* This is a common symbol. The section contents include the
448 size (sym->n_value) as an addend. The relocate_section
449 function will be adding in the final value of the symbol. We
450 need to subtract out the current size in order to get the
451 correct result. */
453 BFD_ASSERT (h != NULL);
455 #ifndef COFF_WITH_PE
456 /* I think we *do* want to bypass this. If we don't, I have
457 seen some data parameters get the wrong relocation address.
458 If I link two versions with and without this section bypassed
459 and then do a binary comparison, the addresses which are
460 different can be looked up in the map. The case in which
461 this section has been bypassed has addresses which correspond
462 to values I can find in the map. */
463 *addendp -= sym->n_value;
464 #endif
467 #ifndef COFF_WITH_PE
468 /* If the output symbol is common (in which case this must be a
469 relocateable link), we need to add in the final size of the
470 common symbol. */
471 if (h != NULL && h->root.type == bfd_link_hash_common)
472 *addendp += h->root.u.c.size;
473 #endif
475 #ifdef COFF_WITH_PE
476 if (howto->pc_relative)
478 *addendp -= 4;
480 /* If the symbol is defined, then the generic code is going to
481 add back the symbol value in order to cancel out an
482 adjustment it made to the addend. However, we set the addend
483 to 0 at the start of this function. We need to adjust here,
484 to avoid the adjustment the generic code will make. FIXME:
485 This is getting a bit hackish. */
486 if (sym != NULL && sym->n_scnum != 0)
487 *addendp -= sym->n_value;
490 if (rel->r_type == MIPS_R_RVA)
492 *addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
494 #endif
496 return howto;
499 #define coff_rtype_to_howto coff_mips_rtype_to_howto
501 #define coff_bfd_reloc_type_lookup coff_mips_reloc_type_lookup
503 /* Get the howto structure for a generic reloc type. */
505 static reloc_howto_type *
506 coff_mips_reloc_type_lookup (abfd, code)
507 bfd *abfd ATTRIBUTE_UNUSED;
508 bfd_reloc_code_real_type code;
510 int mips_type;
512 switch (code)
514 case BFD_RELOC_16:
515 mips_type = MIPS_R_REFHALF;
516 break;
517 case BFD_RELOC_32:
518 case BFD_RELOC_CTOR:
519 mips_type = MIPS_R_REFWORD;
520 break;
521 case BFD_RELOC_MIPS_JMP:
522 mips_type = MIPS_R_JMPADDR;
523 break;
524 case BFD_RELOC_HI16_S:
525 mips_type = MIPS_R_REFHI;
526 break;
527 case BFD_RELOC_LO16:
528 mips_type = MIPS_R_REFLO;
529 break;
530 case BFD_RELOC_GPREL16:
531 mips_type = MIPS_R_GPREL;
532 break;
533 case BFD_RELOC_MIPS_LITERAL:
534 mips_type = MIPS_R_LITERAL;
535 break;
536 /* FIXME?
537 case BFD_RELOC_16_PCREL_S2:
538 mips_type = MIPS_R_PCREL16;
539 break;
540 case BFD_RELOC_PCREL_HI16_S:
541 mips_type = MIPS_R_RELHI;
542 break;
543 case BFD_RELOC_PCREL_LO16:
544 mips_type = MIPS_R_RELLO;
545 break;
546 case BFD_RELOC_GPREL32:
547 mips_type = MIPS_R_SWITCH;
548 break;
550 case BFD_RELOC_RVA:
551 mips_type = MIPS_R_RVA;
552 break;
553 default:
554 return (reloc_howto_type *) NULL;
557 return &howto_table[mips_type];
560 static void
561 mips_swap_reloc_in (abfd, src, dst)
562 bfd *abfd;
563 PTR src;
564 PTR dst;
566 static struct internal_reloc pair_prev;
567 RELOC *reloc_src = (RELOC *) src;
568 struct internal_reloc *reloc_dst = (struct internal_reloc *) dst;
570 reloc_dst->r_vaddr = H_GET_32 (abfd, reloc_src->r_vaddr);
571 reloc_dst->r_symndx = H_GET_S32 (abfd, reloc_src->r_symndx);
572 reloc_dst->r_type = H_GET_16 (abfd, reloc_src->r_type);
573 reloc_dst->r_size = 0;
574 reloc_dst->r_extern = 0;
575 reloc_dst->r_offset = 0;
577 switch (reloc_dst->r_type)
579 case MIPS_R_REFHI:
580 pair_prev = *reloc_dst;
581 break;
582 case MIPS_R_PAIR:
583 reloc_dst->r_offset = reloc_dst->r_symndx;
584 if (reloc_dst->r_offset & 0x8000)
585 reloc_dst->r_offset -= 0x10000;
586 /*printf ("dj: pair offset is %08x\n", reloc_dst->r_offset);*/
587 reloc_dst->r_symndx = pair_prev.r_symndx;
588 break;
592 static unsigned int
593 mips_swap_reloc_out (abfd, src, dst)
594 bfd *abfd;
595 PTR src;
596 PTR dst;
598 static int prev_offset = 1;
599 static bfd_vma prev_addr = 0;
600 struct internal_reloc *reloc_src = (struct internal_reloc *)src;
601 struct external_reloc *reloc_dst = (struct external_reloc *)dst;
603 switch (reloc_src->r_type)
605 case MIPS_R_REFHI:
606 prev_addr = reloc_src->r_vaddr;
607 prev_offset = reloc_src->r_offset;
608 break;
609 case MIPS_R_REFLO:
610 if (reloc_src->r_vaddr == prev_addr)
612 /* FIXME: only slightly hackish. If we see a REFLO pointing to
613 the same address as a REFHI, we assume this is the matching
614 PAIR reloc and output it accordingly. The symndx is really
615 the low 16 bits of the addend */
616 H_PUT_32 (abfd, reloc_src->r_vaddr, reloc_dst->r_vaddr);
617 H_PUT_32 (abfd, reloc_src->r_symndx, reloc_dst->r_symndx);
618 H_PUT_16 (abfd, MIPS_R_PAIR, reloc_dst->r_type);
619 return RELSZ;
621 break;
624 H_PUT_32 (abfd, reloc_src->r_vaddr, reloc_dst->r_vaddr);
625 H_PUT_32 (abfd, reloc_src->r_symndx, reloc_dst->r_symndx);
627 H_PUT_16 (abfd, reloc_src->r_type, reloc_dst->r_type);
628 return RELSZ;
631 #define coff_swap_reloc_in mips_swap_reloc_in
632 #define coff_swap_reloc_out mips_swap_reloc_out
633 #define NO_COFF_RELOCS
635 static boolean
636 coff_pe_mips_relocate_section (output_bfd, info, input_bfd,
637 input_section, contents, relocs, syms,
638 sections)
639 bfd *output_bfd;
640 struct bfd_link_info *info;
641 bfd *input_bfd;
642 asection *input_section;
643 bfd_byte *contents;
644 struct internal_reloc *relocs;
645 struct internal_syment *syms;
646 asection **sections;
648 bfd_vma gp;
649 boolean gp_undefined;
650 size_t adjust;
651 struct internal_reloc *rel;
652 struct internal_reloc *rel_end;
653 unsigned int i;
654 boolean got_lo;
656 if (info->relocateable)
658 (*_bfd_error_handler) (_("\
659 %s: `ld -r' not supported with PE MIPS objects\n"),
660 bfd_archive_filename (input_bfd));
661 bfd_set_error (bfd_error_bad_value);
662 return false;
665 BFD_ASSERT (input_bfd->xvec->byteorder
666 == output_bfd->xvec->byteorder);
668 #if 0
669 printf ("dj: relocate %s(%s) %08x\n",
670 input_bfd->filename, input_section->name,
671 input_section->output_section->vma + input_section->output_offset);
672 #endif
674 gp = _bfd_get_gp_value (output_bfd);
675 if (gp == 0)
676 gp_undefined = true;
677 else
678 gp_undefined = false;
680 got_lo = false;
682 adjust = 0;
684 rel = relocs;
685 rel_end = rel + input_section->reloc_count;
686 for (i = 0; rel < rel_end; rel++, i++)
688 long symndx;
689 struct coff_link_hash_entry *h;
690 struct internal_syment *sym;
691 bfd_vma addend = 0;
692 bfd_vma val, tmp, targ, src, low;
693 reloc_howto_type *howto;
694 unsigned char *mem = contents + rel->r_vaddr;
696 symndx = rel->r_symndx;
698 if (symndx == -1)
700 h = NULL;
701 sym = NULL;
703 else
705 h = obj_coff_sym_hashes (input_bfd)[symndx];
706 sym = syms + symndx;
709 /* COFF treats common symbols in one of two ways. Either the
710 size of the symbol is included in the section contents, or it
711 is not. We assume that the size is not included, and force
712 the rtype_to_howto function to adjust the addend as needed. */
714 if (sym != NULL && sym->n_scnum != 0)
715 addend = - sym->n_value;
716 else
717 addend = 0;
719 howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
720 sym, &addend);
721 if (howto == NULL)
722 return false;
724 /* If we are doing a relocateable link, then we can just ignore
725 a PC relative reloc that is pcrel_offset. It will already
726 have the correct value. If this is not a relocateable link,
727 then we should ignore the symbol value. */
728 if (howto->pc_relative && howto->pcrel_offset)
730 if (info->relocateable)
731 continue;
732 if (sym != NULL && sym->n_scnum != 0)
733 addend += sym->n_value;
736 val = 0;
738 if (h == NULL)
740 asection *sec;
742 if (symndx == -1)
744 sec = bfd_abs_section_ptr;
745 val = 0;
747 else
749 sec = sections[symndx];
750 val = (sec->output_section->vma
751 + sec->output_offset
752 + sym->n_value);
753 if (! obj_pe (input_bfd))
754 val -= sec->vma;
757 else
759 if (h->root.type == bfd_link_hash_defined
760 || h->root.type == bfd_link_hash_defweak)
762 asection *sec;
764 sec = h->root.u.def.section;
765 val = (h->root.u.def.value
766 + sec->output_section->vma
767 + sec->output_offset);
770 else if (! info->relocateable)
772 if (! ((*info->callbacks->undefined_symbol)
773 (info, h->root.root.string, input_bfd, input_section,
774 rel->r_vaddr - input_section->vma, true)))
775 return false;
779 src = rel->r_vaddr + input_section->output_section->vma
780 + input_section->output_offset;
781 #if 0
782 printf ("dj: reloc %02x %-8s a=%08x/%08x(%08x) v=%08x+%08x %s\n",
783 rel->r_type, howto_table[rel->r_type].name,
784 src, rel->r_vaddr, *(unsigned long *)mem, val, rel->r_offset,
785 h?h->root.root.string:"(none)");
786 #endif
788 /* OK, at this point the following variables are set up:
789 src = VMA of the memory we're fixing up
790 mem = pointer to memory we're fixing up
791 val = VMA of what we need to refer to
794 #define UI(x) (*_bfd_error_handler) (_("%s: unimplemented %s\n"), \
795 bfd_archive_filename (input_bfd), x); \
796 bfd_set_error (bfd_error_bad_value);
798 switch (rel->r_type)
800 case MIPS_R_ABSOLUTE:
801 /* ignore these */
802 break;
804 case MIPS_R_REFHALF:
805 UI("refhalf");
806 break;
808 case MIPS_R_REFWORD:
809 tmp = bfd_get_32(input_bfd, mem);
810 /* printf ("refword: src=%08x targ=%08x+%08x\n", src, tmp, val); */
811 tmp += val;
812 bfd_put_32(input_bfd, tmp, mem);
813 break;
815 case MIPS_R_JMPADDR:
816 tmp = bfd_get_32(input_bfd, mem);
817 targ = val + (tmp&0x03ffffff)*4;
818 if ((src & 0xf0000000) != (targ & 0xf0000000))
820 (*_bfd_error_handler) (_("%s: jump too far away\n"),
821 bfd_archive_filename (input_bfd));
822 bfd_set_error (bfd_error_bad_value);
823 return false;
825 tmp &= 0xfc000000;
826 tmp |= (targ/4) & 0x3ffffff;
827 bfd_put_32(input_bfd, tmp, mem);
828 break;
830 case MIPS_R_REFHI:
831 tmp = bfd_get_32(input_bfd, mem);
832 switch (rel[1].r_type)
834 case MIPS_R_PAIR:
835 /* MS PE object */
836 targ = val + rel[1].r_offset + ((tmp & 0xffff) << 16);
837 break;
838 case MIPS_R_REFLO:
839 /* GNU COFF object */
840 low = bfd_get_32(input_bfd, contents + rel[1].r_vaddr);
841 low &= 0xffff;
842 if (low & 0x8000)
843 low -= 0x10000;
844 targ = val + low + ((tmp & 0xffff) << 16);
845 break;
846 default:
847 (*_bfd_error_handler) (_("%s: bad pair/reflo after refhi\n"),
848 bfd_archive_filename (input_bfd));
849 bfd_set_error (bfd_error_bad_value);
850 return false;
852 tmp &= 0xffff0000;
853 tmp |= (targ >> 16) & 0xffff;
854 bfd_put_32(input_bfd, tmp, mem);
855 break;
857 case MIPS_R_REFLO:
858 tmp = bfd_get_32(input_bfd, mem);
859 targ = val + (tmp & 0xffff);
860 /* printf ("refword: src=%08x targ=%08x\n", src, targ); */
861 tmp &= 0xffff0000;
862 tmp |= targ & 0xffff;
863 bfd_put_32(input_bfd, tmp, mem);
864 break;
866 case MIPS_R_GPREL:
867 case MIPS_R_LITERAL:
868 UI("gprel");
869 break;
871 case MIPS_R_SECTION:
872 UI("section");
873 break;
875 case MIPS_R_SECREL:
876 UI("secrel");
877 break;
879 case MIPS_R_SECRELLO:
880 UI("secrello");
881 break;
883 case MIPS_R_SECRELHI:
884 UI("secrelhi");
885 break;
887 case MIPS_R_RVA:
888 tmp = bfd_get_32 (input_bfd, mem);
889 /* printf ("rva: src=%08x targ=%08x+%08x\n", src, tmp, val); */
890 tmp += val
891 - pe_data (input_section->output_section->owner)->pe_opthdr.ImageBase;
892 bfd_put_32 (input_bfd, tmp, mem);
893 break;
895 case MIPS_R_PAIR:
896 /* ignore these */
897 break;
901 return true;
904 #define coff_relocate_section coff_pe_mips_relocate_section
906 #ifdef TARGET_UNDERSCORE
908 /* If mips gcc uses underscores for symbol names, then it does not use
909 a leading dot for local labels, so if TARGET_UNDERSCORE is defined
910 we treat all symbols starting with L as local. */
912 static boolean coff_mips_is_local_label_name PARAMS ((bfd *, const char *));
914 static boolean
915 coff_mips_is_local_label_name (abfd, name)
916 bfd *abfd;
917 const char *name;
919 if (name[0] == 'L')
920 return true;
922 return _bfd_coff_is_local_label_name (abfd, name);
925 #define coff_bfd_is_local_label_name coff_mips_is_local_label_name
927 #endif /* TARGET_UNDERSCORE */
929 #define COFF_NO_HACK_SCNHDR_SIZE
931 #include "coffcode.h"
933 const bfd_target
934 #ifdef TARGET_SYM
935 TARGET_SYM =
936 #else
937 mipslpe_vec =
938 #endif
940 #ifdef TARGET_NAME
941 TARGET_NAME,
942 #else
943 "pe-mips", /* name */
944 #endif
945 bfd_target_coff_flavour,
946 BFD_ENDIAN_LITTLE, /* data byte order is little */
947 BFD_ENDIAN_LITTLE, /* header byte order is little */
949 (HAS_RELOC | EXEC_P | /* object flags */
950 HAS_LINENO | HAS_DEBUG |
951 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
953 #ifndef COFF_WITH_PE
954 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
955 | SEC_CODE | SEC_DATA),
956 #else
957 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
958 | SEC_CODE | SEC_DATA
959 | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
960 #endif
962 #ifdef TARGET_UNDERSCORE
963 TARGET_UNDERSCORE, /* leading underscore */
964 #else
965 0, /* leading underscore */
966 #endif
967 '/', /* ar_pad_char */
968 15, /* ar_max_namelen */
970 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
971 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
972 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
973 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
974 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
975 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
977 /* Note that we allow an object file to be treated as a core file as well. */
978 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
979 bfd_generic_archive_p, coff_object_p},
980 {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
981 bfd_false},
982 {bfd_false, coff_write_object_contents, /* bfd_write_contents */
983 _bfd_write_archive_contents, bfd_false},
985 BFD_JUMP_TABLE_GENERIC (coff),
986 BFD_JUMP_TABLE_COPY (coff),
987 BFD_JUMP_TABLE_CORE (_bfd_nocore),
988 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
989 BFD_JUMP_TABLE_SYMBOLS (coff),
990 BFD_JUMP_TABLE_RELOCS (coff),
991 BFD_JUMP_TABLE_WRITE (coff),
992 BFD_JUMP_TABLE_LINK (coff),
993 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
995 NULL,
997 COFF_SWAP_TABLE