source: trunk/src/binutils/bfd/pe-mips.c@ 73

Last change on this file since 73 was 10, checked in by bird, 23 years ago

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