projects / deliverable / binutils-gdb.git / blob
? search:


9b89369b37b60e0911c62489581f7a014cd47e82
[deliverable/binutils-gdb.git] / bfd / pe-mips.c
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
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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21 #define COFF_WITH_PE
22 #define COFF_LONG_SECTION_NAMES
23 #define PCRELOFFSET true
24
25 #include "bfd.h"
26 #include "sysdep.h"
27 #include "libbfd.h"
28
29 #include "coff/mipspe.h"
30
31 #include "coff/internal.h"
32
33 #include "coff/pe.h"
34
35 #include "libcoff.h"
36
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 *,
42
43 bfd_vma *));
44 #if 0
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 *,
49 PTR));
50 static void mips_adjust_reloc_in PARAMS ((bfd *,
51 const struct internal_reloc *,
52 arelent *));
53 static void mips_adjust_reloc_out PARAMS ((bfd *, const arelent *,
54 struct internal_reloc *));
55 #endif
56 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
57 /* The page size is a guess based on ELF. */
58
59 #define COFF_PAGE_SIZE 0x1000
60
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. */
64
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. */
69
70 static bfd_reloc_status_type
71 coff_mips_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd,
72 error_message)
73 bfd *abfd;
74 arelent *reloc_entry;
75 asymbol *symbol;
76 PTR data;
77 asection *input_section ATTRIBUTE_UNUSED;
78 bfd *output_bfd;
79 char **error_message ATTRIBUTE_UNUSED;
80 {
81 symvalue diff;
82
83 if (output_bfd == (bfd *) NULL)
84 return bfd_reloc_continue;
85
86 if (bfd_is_com_section (symbol->section))
87 {
88 #ifndef COFF_WITH_PE
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;
101 #else
102 /* In PE mode, we do not offset the common symbol. */
103 diff = reloc_entry->addend;
104 #endif
105 }
106 else
107 {
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;
113 }
114
115 #ifdef COFF_WITH_PE
116 #if 0
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)
120 abort ();
121 #endif
122 #endif
123
124 #define DOIT(x) \
125 x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + (diff >> howto->rightshift)) & howto->dst_mask))
126
127 if (diff != 0)
128 {
129 reloc_howto_type *howto = reloc_entry->howto;
130 unsigned char *addr = (unsigned char *) data + reloc_entry->address;
131
132 switch (howto->size)
133 {
134 case 0:
135 {
136 char x = bfd_get_8 (abfd, addr);
137 DOIT (x);
138 bfd_put_8 (abfd, x, addr);
139 }
140 break;
141
142 case 1:
143 {
144 short x = bfd_get_16 (abfd, addr);
145 DOIT (x);
146 bfd_put_16 (abfd, x, addr);
147 }
148 break;
149
150 case 2:
151 {
152 long x = bfd_get_32 (abfd, addr);
153 DOIT (x);
154 bfd_put_32 (abfd, x, addr);
155 }
156 break;
157
158 default:
159 abort ();
160 }
161 }
162
163 /* Now let bfd_perform_relocation finish everything up. */
164 return bfd_reloc_continue;
165 }
166
167 #ifdef COFF_WITH_PE
168 /* Return true if this relocation should
169 appear in the output .reloc section. */
170
171 static boolean in_reloc_p(abfd, howto)
172 bfd * abfd ATTRIBUTE_UNUSED;
173 reloc_howto_type *howto;
174 {
175 return ! howto->pc_relative && howto->type != MIPS_R_RVA;
176 }
177 #endif
178
179 #ifndef PCRELOFFSET
180 #define PCRELOFFSET false
181 #endif
182
183 static reloc_howto_type howto_table[] =
184 {
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 */
189 0, /* rightshift */
190 0, /* size (0 = byte, 1 = short, 2 = long) */
191 8, /* bitsize */
192 false, /* pc_relative */
193 0, /* bitpos */
194 complain_overflow_dont, /* complain_on_overflow */
195 0, /* special_function */
196 "IGNORE", /* name */
197 false, /* partial_inplace */
198 0, /* src_mask */
199 0, /* dst_mask */
200 false), /* pcrel_offset */
201
202 /* A 16 bit reference to a symbol, normally from a data section. */
203 HOWTO (MIPS_R_REFHALF, /* type */
204 0, /* rightshift */
205 1, /* size (0 = byte, 1 = short, 2 = long) */
206 16, /* bitsize */
207 false, /* pc_relative */
208 0, /* bitpos */
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 */
216
217 /* A 32 bit reference to a symbol, normally from a data section. */
218 HOWTO (MIPS_R_REFWORD, /* type */
219 0, /* rightshift */
220 2, /* size (0 = byte, 1 = short, 2 = long) */
221 32, /* bitsize */
222 false, /* pc_relative */
223 0, /* bitpos */
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 */
231
232 /* A 26 bit absolute jump address. */
233 HOWTO (MIPS_R_JMPADDR, /* type */
234 2, /* rightshift */
235 2, /* size (0 = byte, 1 = short, 2 = long) */
236 26, /* bitsize */
237 false, /* pc_relative */
238 0, /* bitpos */
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 */
249
250 /* The high 16 bits of a symbol value. Handled by the function
251 mips_refhi_reloc. */
252 HOWTO (MIPS_R_REFHI, /* type */
253 16, /* rightshift */
254 2, /* size (0 = byte, 1 = short, 2 = long) */
255 16, /* bitsize */
256 false, /* pc_relative */
257 0, /* bitpos */
258 complain_overflow_bitfield, /* complain_on_overflow */
259 coff_mips_reloc, /* special_function */
260 "REFHI", /* name */
261 true, /* partial_inplace */
262 0xffff, /* src_mask */
263 0xffff, /* dst_mask */
264 false), /* pcrel_offset */
265
266 /* The low 16 bits of a symbol value. */
267 HOWTO (MIPS_R_REFLO, /* type */
268 0, /* rightshift */
269 2, /* size (0 = byte, 1 = short, 2 = long) */
270 16, /* bitsize */
271 false, /* pc_relative */
272 0, /* bitpos */
273 complain_overflow_dont, /* complain_on_overflow */
274 coff_mips_reloc, /* special_function */
275 "REFLO", /* name */
276 true, /* partial_inplace */
277 0xffff, /* src_mask */
278 0xffff, /* dst_mask */
279 false), /* pcrel_offset */
280
281 /* A reference to an offset from the gp register. Handled by the
282 function mips_gprel_reloc. */
283 HOWTO (MIPS_R_GPREL, /* type */
284 0, /* rightshift */
285 2, /* size (0 = byte, 1 = short, 2 = long) */
286 16, /* bitsize */
287 false, /* pc_relative */
288 0, /* bitpos */
289 complain_overflow_signed, /* complain_on_overflow */
290 coff_mips_reloc, /* special_function */
291 "GPREL", /* name */
292 true, /* partial_inplace */
293 0xffff, /* src_mask */
294 0xffff, /* dst_mask */
295 false), /* pcrel_offset */
296
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 */
300 0, /* rightshift */
301 2, /* size (0 = byte, 1 = short, 2 = long) */
302 16, /* bitsize */
303 false, /* pc_relative */
304 0, /* bitpos */
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 */
312
313 EMPTY_HOWTO (8),
314 EMPTY_HOWTO (9),
315 EMPTY_HOWTO (10),
316 EMPTY_HOWTO (11),
317 EMPTY_HOWTO (12),
318 EMPTY_HOWTO (13),
319 EMPTY_HOWTO (14),
320 EMPTY_HOWTO (15),
321 EMPTY_HOWTO (16),
322 EMPTY_HOWTO (17),
323 EMPTY_HOWTO (18),
324 EMPTY_HOWTO (19),
325 EMPTY_HOWTO (20),
326 EMPTY_HOWTO (21),
327 EMPTY_HOWTO (22),
328 EMPTY_HOWTO (23),
329 EMPTY_HOWTO (24),
330 EMPTY_HOWTO (25),
331 EMPTY_HOWTO (26),
332 EMPTY_HOWTO (27),
333 EMPTY_HOWTO (28),
334 EMPTY_HOWTO (29),
335 EMPTY_HOWTO (30),
336 EMPTY_HOWTO (31),
337 EMPTY_HOWTO (32),
338 EMPTY_HOWTO (33),
339 HOWTO (MIPS_R_RVA, /* type */
340 0, /* rightshift */
341 2, /* size (0 = byte, 1 = short, 2 = long) */
342 32, /* bitsize */
343 false, /* pc_relative */
344 0, /* bitpos */
345 complain_overflow_bitfield, /* complain_on_overflow */
346 coff_mips_reloc, /* special_function */
347 "rva32", /* name */
348 true, /* partial_inplace */
349 0xffffffff, /* src_mask */
350 0xffffffff, /* dst_mask */
351 false), /* pcrel_offset */
352 EMPTY_HOWTO (35),
353 EMPTY_HOWTO (36),
354 HOWTO (MIPS_R_PAIR, /* type */
355 0, /* rightshift */
356 2, /* size (0 = byte, 1 = short, 2 = long) */
357 32, /* bitsize */
358 false, /* pc_relative */
359 0, /* bitpos */
360 complain_overflow_bitfield, /* complain_on_overflow */
361 coff_mips_reloc, /* special_function */
362 "PAIR", /* name */
363 true, /* partial_inplace */
364 0xffffffff, /* src_mask */
365 0xffffffff, /* dst_mask */
366 false), /* pcrel_offset */
367 };
368
369 /* Turn a howto into a reloc nunmber */
370
371 #define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
372 #define BADMAG(x) MIPSBADMAG(x)
373 #define MIPS 1 /* Customize coffcode.h */
374
375 #define RTYPE2HOWTO(cache_ptr, dst) \
376 (cache_ptr)->howto = howto_table + (dst)->r_type;
377
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
387 PC relative relocs.
388 FIXME: This macro refers to symbols and asect; these are from the
389 calling function, not the macro arguments. */
390
391 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
392 { \
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)); \
397 else if (ptr) \
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); \
405 else \
406 cache_ptr->addend = 0; \
407 if (ptr && howto_table[reloc.r_type].pc_relative) \
408 cache_ptr->addend += asect->vma; \
409 }
410
411
412 /* Convert an rtype to howto for the COFF backend linker. */
413
414 static reloc_howto_type *
415 coff_mips_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
416 bfd *abfd ATTRIBUTE_UNUSED;
417 asection *sec;
418 struct internal_reloc *rel;
419 struct coff_link_hash_entry *h;
420 struct internal_syment *sym;
421 bfd_vma *addendp;
422 {
423
424 reloc_howto_type *howto;
425
426 howto = howto_table + rel->r_type;
427
428 #ifdef COFF_WITH_PE
429 *addendp = 0;
430 #endif
431
432 if (howto->pc_relative)
433 *addendp += sec->vma;
434
435 if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0)
436 {
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
441 correct result. */
442
443 BFD_ASSERT (h != NULL);
444
445 #ifndef COFF_WITH_PE
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;
454 #endif
455 }
456
457 #ifndef COFF_WITH_PE
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
460 common symbol. */
461 if (h != NULL && h->root.type == bfd_link_hash_common)
462 *addendp += h->root.u.c.size;
463 #endif
464
465 #ifdef COFF_WITH_PE
466 if (howto->pc_relative)
467 {
468 *addendp -= 4;
469
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;
478 }
479
480 if (rel->r_type == MIPS_R_RVA)
481 {
482 *addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
483 }
484 #endif
485
486 return howto;
487 }
488
489 #define coff_rtype_to_howto coff_mips_rtype_to_howto
490
491
492 #define coff_bfd_reloc_type_lookup coff_mips_reloc_type_lookup
493
494
495
496 /* Get the howto structure for a generic reloc type. */
497
498 static reloc_howto_type *
499 coff_mips_reloc_type_lookup (abfd, code)
500 bfd *abfd ATTRIBUTE_UNUSED;
501 bfd_reloc_code_real_type code;
502 {
503 int mips_type;
504
505 switch (code)
506 {
507 case BFD_RELOC_16:
508 mips_type = MIPS_R_REFHALF;
509 break;
510 case BFD_RELOC_32:
511 case BFD_RELOC_CTOR:
512 mips_type = MIPS_R_REFWORD;
513 break;
514 case BFD_RELOC_MIPS_JMP:
515 mips_type = MIPS_R_JMPADDR;
516 break;
517 case BFD_RELOC_HI16_S:
518 mips_type = MIPS_R_REFHI;
519 break;
520 case BFD_RELOC_LO16:
521 mips_type = MIPS_R_REFLO;
522 break;
523 case BFD_RELOC_MIPS_GPREL:
524 mips_type = MIPS_R_GPREL;
525 break;
526 case BFD_RELOC_MIPS_LITERAL:
527 mips_type = MIPS_R_LITERAL;
528 break;
529 /* FIXME?
530 case BFD_RELOC_16_PCREL_S2:
531 mips_type = MIPS_R_PCREL16;
532 break;
533 case BFD_RELOC_PCREL_HI16_S:
534 mips_type = MIPS_R_RELHI;
535 break;
536 case BFD_RELOC_PCREL_LO16:
537 mips_type = MIPS_R_RELLO;
538 break;
539 case BFD_RELOC_GPREL32:
540 mips_type = MIPS_R_SWITCH;
541 break;
542 */
543 case BFD_RELOC_RVA:
544 mips_type = MIPS_R_RVA;
545 break;
546 default:
547 return (reloc_howto_type *) NULL;
548 }
549
550 return &howto_table[mips_type];
551 }
552
553 static void
554 mips_swap_reloc_in (abfd, src, dst)
555 bfd *abfd;
556 PTR src;
557 PTR dst;
558 {
559 static struct internal_reloc pair_prev;
560 RELOC *reloc_src = (RELOC *) src;
561 struct internal_reloc *reloc_dst = (struct internal_reloc *) dst;
562
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;
570
571 switch (reloc_dst->r_type)
572 {
573 case MIPS_R_REFHI:
574 pair_prev = *reloc_dst;
575 break;
576 case MIPS_R_PAIR:
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;
582 break;
583 }
584 }
585
586 static unsigned int
587 mips_swap_reloc_out (abfd, src, dst)
588 bfd *abfd;
589 PTR src;
590 PTR dst;
591 {
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;
596
597 switch (reloc_src->r_type)
598 {
599 case MIPS_R_REFHI:
600 prev_addr = reloc_src->r_vaddr;
601 prev_offset = reloc_src->r_offset;
602 break;
603 case MIPS_R_REFLO:
604 if (reloc_src->r_vaddr == prev_addr)
605 {
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);
614
615 bfd_h_put_16(abfd, MIPS_R_PAIR, (bfd_byte *)
616 reloc_dst->r_type);
617 return RELSZ;
618 }
619 break;
620 }
621
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);
624
625 bfd_h_put_16(abfd, reloc_src->r_type, (bfd_byte *)
626 reloc_dst->r_type);
627 return RELSZ;
628 }
629
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
633
634 static boolean
635 coff_pe_mips_relocate_section (output_bfd, info, input_bfd,
636 input_section, contents, relocs, syms,
637 sections)
638 bfd *output_bfd;
639 struct bfd_link_info *info;
640 bfd *input_bfd;
641 asection *input_section;
642 bfd_byte *contents;
643 struct internal_reloc *relocs;
644 struct internal_syment *syms;
645 asection **sections;
646 {
647 bfd_vma gp;
648 boolean gp_undefined;
649 size_t adjust;
650 struct internal_reloc *rel;
651 struct internal_reloc *rel_end;
652 unsigned int i;
653 boolean got_lo;
654
655 if (info->relocateable)
656 {
657 (*_bfd_error_handler)(_("\
658 %s: `ld -r' not supported with PE MIPS objects\n"),
659 bfd_get_filename (input_bfd));
660 bfd_set_error (bfd_error_bad_value);
661 return false;
662 }
663
664 BFD_ASSERT (input_bfd->xvec->byteorder
665 == output_bfd->xvec->byteorder);
666
667 #if 0
668 printf("dj: relocate %s(%s) %08x\n",
669 input_bfd->filename, input_section->name,
670 input_section->output_section->vma + input_section->output_offset);
671 #endif
672
673 gp = _bfd_get_gp_value (output_bfd);
674 if (gp == 0)
675 gp_undefined = true;
676 else
677 gp_undefined = false;
678
679 got_lo = false;
680
681 adjust = 0;
682
683 rel = relocs;
684 rel_end = rel + input_section->reloc_count;
685 for (i = 0; rel < rel_end; rel++, i++)
686 {
687 long symndx;
688 struct coff_link_hash_entry *h;
689 struct internal_syment *sym;
690 bfd_vma addend = 0;
691 bfd_vma val, tmp, targ, src, low;
692 reloc_howto_type *howto;
693 unsigned char *mem = contents + rel->r_vaddr;
694
695 symndx = rel->r_symndx;
696
697 if (symndx == -1)
698 {
699 h = NULL;
700 sym = NULL;
701 }
702 else
703 {
704 h = obj_coff_sym_hashes (input_bfd)[symndx];
705 sym = syms + symndx;
706 }
707
708 /* COFF treats common symbols in one of two ways. Either the
709 size of the symbol is included in the section contents, or it
710 is not. We assume that the size is not included, and force
711 the rtype_to_howto function to adjust the addend as needed. */
712
713 if (sym != NULL && sym->n_scnum != 0)
714 addend = - sym->n_value;
715 else
716 addend = 0;
717
718
719 howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
720 sym, &addend);
721 if (howto == NULL)
722 return false;
723
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)
729 {
730 if (info->relocateable)
731 continue;
732 if (sym != NULL && sym->n_scnum != 0)
733 addend += sym->n_value;
734 }
735
736 val = 0;
737
738 if (h == NULL)
739 {
740 asection *sec;
741
742 if (symndx == -1)
743 {
744 sec = bfd_abs_section_ptr;
745 val = 0;
746 }
747 else
748 {
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;
755 }
756 }
757 else
758 {
759 if (h->root.type == bfd_link_hash_defined
760 || h->root.type == bfd_link_hash_defweak)
761 {
762 asection *sec;
763
764 sec = h->root.u.def.section;
765 val = (h->root.u.def.value
766 + sec->output_section->vma
767 + sec->output_offset);
768 }
769
770 else if (! info->relocateable)
771 {
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;
776 }
777 }
778
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
787
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
792 */
793
794 #define UI(x) (*_bfd_error_handler)(_("%s: unimplemented %s\n"), \
795 bfd_get_filename (input_bfd), x); \
796 bfd_set_error (bfd_error_bad_value);
797
798 switch (rel->r_type)
799 {
800 case MIPS_R_ABSOLUTE:
801 /* ignore these */
802 break;
803
804 case MIPS_R_REFHALF:
805 UI("refhalf");
806 break;
807
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;
814
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))
819 {
820 (*_bfd_error_handler)(_("%s: jump too far away\n"),
821 bfd_get_filename (input_bfd));
822 bfd_set_error (bfd_error_bad_value);
823 return false;
824 }
825 tmp &= 0xfc000000;
826 tmp |= (targ/4) & 0x3ffffff;
827 bfd_put_32(input_bfd, tmp, mem);
828 break;
829
830 case MIPS_R_REFHI:
831 tmp = bfd_get_32(input_bfd, mem);
832 switch (rel[1].r_type)
833 {
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_get_filename (input_bfd));
849 bfd_set_error (bfd_error_bad_value);
850 return false;
851 }
852 tmp &= 0xffff0000;
853 tmp |= (targ >> 16) & 0xffff;
854 bfd_put_32(input_bfd, tmp, mem);
855 break;
856
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;
865
866 case MIPS_R_GPREL:
867 case MIPS_R_LITERAL:
868 UI("gprel");
869 break;
870
871 case MIPS_R_SECTION:
872 UI("section");
873 break;
874
875 case MIPS_R_SECREL:
876 UI("secrel");
877 break;
878
879 case MIPS_R_SECRELLO:
880 UI("secrello");
881 break;
882
883 case MIPS_R_SECRELHI:
884 UI("secrelhi");
885 break;
886
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;
894
895 case MIPS_R_PAIR:
896 /* ignore these */
897 break;
898 }
899 }
900
901 return true;
902 }
903
904 #define coff_relocate_section coff_pe_mips_relocate_section
905
906 #ifdef TARGET_UNDERSCORE
907
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. */
911
912 static boolean coff_mips_is_local_label_name PARAMS ((bfd *, const char *));
913
914 static boolean
915 coff_mips_is_local_label_name (abfd, name)
916 bfd *abfd;
917 const char *name;
918 {
919 if (name[0] == 'L')
920 return true;
921
922 return _bfd_coff_is_local_label_name (abfd, name);
923 }
924
925 #define coff_bfd_is_local_label_name coff_mips_is_local_label_name
926
927 #endif /* TARGET_UNDERSCORE */
928
929 #define COFF_NO_HACK_SCNHDR_SIZE
930
931 #include "coffcode.h"
932
933 const bfd_target
934 #ifdef TARGET_SYM
935 TARGET_SYM =
936 #else
937 mipslpe_vec =
938 #endif
939 {
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 */
948
949 (HAS_RELOC | EXEC_P | /* object flags */
950 HAS_LINENO | HAS_DEBUG |
951 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
952
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
961
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 */
969
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 */
976
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},
984
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),
994
995 NULL,
996
997 COFF_SWAP_TABLE
998 };
GDB Binutils - Deliverables
This page took 0.051934 seconds and 3 git commands to generate.