projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Check unit->addr_size to read in the proper number of prologue bytes.
[deliverable/binutils-gdb.git] / bfd / pe-mips.c
CommitLineData
17505c5c 1/* BFD back-end for MIPS PE COFF files.
7898deda
NC		 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001 Free Software Foundation, Inc.
17505c5c
NC		 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
892339ee 38static bfd_reloc_status_type coff_mips_reloc
17505c5c
NC		 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 *));
86033394 45#if 0
17505c5c
NC		 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 *));
86033394 56#endif
42ef282f
NC		 57
58static boolean in_reloc_p PARAMS ((bfd *, reloc_howto_type *));
59static reloc_howto_type * coff_mips_reloc_type_lookup PARAMS ((bfd *, bfd_reloc_code_real_type));
60static void mips_swap_reloc_in PARAMS ((bfd *, PTR, PTR));
61static unsigned int mips_swap_reloc_out PARAMS ((bfd *, PTR, PTR));
62static 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 **));
65
17505c5c
NC		 66#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
67/* The page size is a guess based on ELF. */
68
69#define COFF_PAGE_SIZE 0x1000
70
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. */
74
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. */
79
80static bfd_reloc_status_type
81coff_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;
86033394 87 asection *input_section ATTRIBUTE_UNUSED;
17505c5c 88 bfd *output_bfd;
86033394 89 char **error_message ATTRIBUTE_UNUSED;
17505c5c
NC		 90{
91 symvalue diff;
92
93 if (output_bfd == (bfd *) NULL)
94 return bfd_reloc_continue;
95
96 if (bfd_is_com_section (symbol->section))
97 {
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
115 }
116 else
117 {
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;
123 }
124
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
133
134#define DOIT(x) \
135 x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + (diff >> howto->rightshift)) & howto->dst_mask))
136
137 if (diff != 0)
138 {
139 reloc_howto_type *howto = reloc_entry->howto;
140 unsigned char *addr = (unsigned char *) data + reloc_entry->address;
141
142 switch (howto->size)
143 {
144 case 0:
145 {
146 char x = bfd_get_8 (abfd, addr);
147 DOIT (x);
148 bfd_put_8 (abfd, x, addr);
149 }
150 break;
151
152 case 1:
153 {
154 short x = bfd_get_16 (abfd, addr);
155 DOIT (x);
dc810e39 156 bfd_put_16 (abfd, (bfd_vma) x, addr);
17505c5c
NC		 157 }
158 break;
159
160 case 2:
161 {
162 long x = bfd_get_32 (abfd, addr);
163 DOIT (x);
dc810e39 164 bfd_put_32 (abfd, (bfd_vma) x, addr);
17505c5c
NC		 165 }
166 break;
167
168 default:
169 abort ();
170 }
171 }
172
173 /* Now let bfd_perform_relocation finish everything up. */
174 return bfd_reloc_continue;
175}
176
177#ifdef COFF_WITH_PE
178/* Return true if this relocation should
892339ee 179 appear in the output .reloc section. */
17505c5c 180
42ef282f
NC		 181static boolean
182in_reloc_p (abfd, howto)
86033394 183 bfd * abfd ATTRIBUTE_UNUSED;
17505c5c
NC		 184 reloc_howto_type *howto;
185{
186 return ! howto->pc_relative && howto->type != MIPS_R_RVA;
892339ee 187}
17505c5c
NC		 188#endif
189
190#ifndef PCRELOFFSET
191#define PCRELOFFSET false
192#endif
193
892339ee 194static reloc_howto_type howto_table[] =
17505c5c
NC		 195{
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 */
212
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 */
227
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 */
242
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 */
260
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 */
276
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 */
291
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 */
307
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 */
323
86033394
NC		 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),
892339ee
KH		 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 */
17505c5c 356 complain_overflow_bitfield, /* complain_on_overflow */
892339ee
KH		 357 coff_mips_reloc, /* special_function */
358 "rva32", /* name */
359 true, /* partial_inplace */
360 0xffffffff, /* src_mask */
361 0xffffffff, /* dst_mask */
17505c5c 362 false), /* pcrel_offset */
86033394
NC		 363 EMPTY_HOWTO (35),
364 EMPTY_HOWTO (36),
892339ee
KH		 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 */
17505c5c 371 complain_overflow_bitfield, /* complain_on_overflow */
892339ee
KH		 372 coff_mips_reloc, /* special_function */
373 "PAIR", /* name */
374 true, /* partial_inplace */
375 0xffffffff, /* src_mask */
376 0xffffffff, /* dst_mask */
17505c5c
NC		 377 false), /* pcrel_offset */
378};
379
380/* Turn a howto into a reloc nunmber */
381
382#define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
383#define BADMAG(x) MIPSBADMAG(x)
384#define MIPS 1 /* Customize coffcode.h */
385
386#define RTYPE2HOWTO(cache_ptr, dst) \
387 (cache_ptr)->howto = howto_table + (dst)->r_type;
388
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. */
401
402#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
403 { \
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; \
420 }
421
17505c5c
NC		 422/* Convert an rtype to howto for the COFF backend linker. */
423
424static reloc_howto_type *
425coff_mips_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
86033394 426 bfd *abfd ATTRIBUTE_UNUSED;
17505c5c
NC		 427 asection *sec;
428 struct internal_reloc *rel;
429 struct coff_link_hash_entry *h;
430 struct internal_syment *sym;
431 bfd_vma *addendp;
432{
433
434 reloc_howto_type *howto;
435
436 howto = howto_table + rel->r_type;
437
438#ifdef COFF_WITH_PE
439 *addendp = 0;
440#endif
441
442 if (howto->pc_relative)
443 *addendp += sec->vma;
444
445 if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0)
446 {
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. */
892339ee 452
17505c5c
NC		 453 BFD_ASSERT (h != NULL);
454
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
465 }
466
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. */
892339ee 471 if (h != NULL && h->root.type == bfd_link_hash_common)
17505c5c
NC		 472 *addendp += h->root.u.c.size;
473#endif
474
475#ifdef COFF_WITH_PE
476 if (howto->pc_relative)
477 {
478 *addendp -= 4;
479
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;
488 }
489
490 if (rel->r_type == MIPS_R_RVA)
491 {
492 *addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
493 }
494#endif
495
496 return howto;
497}
498
499#define coff_rtype_to_howto coff_mips_rtype_to_howto
500
17505c5c
NC		 501#define coff_bfd_reloc_type_lookup coff_mips_reloc_type_lookup
502
17505c5c
NC		 503/* Get the howto structure for a generic reloc type. */
504
505static reloc_howto_type *
506coff_mips_reloc_type_lookup (abfd, code)
86033394 507 bfd *abfd ATTRIBUTE_UNUSED;
17505c5c
NC		 508 bfd_reloc_code_real_type code;
509{
510 int mips_type;
511
512 switch (code)
513 {
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;
cdf6fd85 530 case BFD_RELOC_GPREL16:
17505c5c
NC		 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;
549*/
550 case BFD_RELOC_RVA:
551 mips_type = MIPS_R_RVA;
552 break;
553 default:
554 return (reloc_howto_type *) NULL;
555 }
556
557 return &howto_table[mips_type];
558}
559
560static void
561mips_swap_reloc_in (abfd, src, dst)
562 bfd *abfd;
563 PTR src;
564 PTR dst;
565{
566 static struct internal_reloc pair_prev;
567 RELOC *reloc_src = (RELOC *) src;
568 struct internal_reloc *reloc_dst = (struct internal_reloc *) dst;
569
dc810e39
AM		 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);
17505c5c
NC		 573 reloc_dst->r_size = 0;
574 reloc_dst->r_extern = 0;
575 reloc_dst->r_offset = 0;
576
577 switch (reloc_dst->r_type)
578 {
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;
892339ee 586 /*printf ("dj: pair offset is %08x\n", reloc_dst->r_offset);*/
17505c5c
NC		 587 reloc_dst->r_symndx = pair_prev.r_symndx;
588 break;
589 }
590}
591
592static unsigned int
593mips_swap_reloc_out (abfd, src, dst)
594 bfd *abfd;
595 PTR src;
596 PTR dst;
597{
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;
602
603 switch (reloc_src->r_type)
604 {
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)
611 {
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 */
dc810e39
AM		 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);
17505c5c
NC		 619 return RELSZ;
620 }
621 break;
622 }
623
dc810e39
AM		 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);
17505c5c 626
dc810e39 627 H_PUT_16 (abfd, reloc_src->r_type, reloc_dst->r_type);
17505c5c
NC		 628 return RELSZ;
629}
630
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
634
635static boolean
636coff_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;
647{
17505c5c
NC		 648 bfd_vma gp;
649 boolean gp_undefined;
650 size_t adjust;
17505c5c
NC		 651 struct internal_reloc *rel;
652 struct internal_reloc *rel_end;
653 unsigned int i;
654 boolean got_lo;
17505c5c
NC		 655
656 if (info->relocateable)
657 {
892339ee 658 (*_bfd_error_handler) (_("\
17505c5c 659%s: `ld -r' not supported with PE MIPS objects\n"),
8f615d07 660 bfd_archive_filename (input_bfd));
17505c5c
NC		 661 bfd_set_error (bfd_error_bad_value);
662 return false;
663 }
664
665 BFD_ASSERT (input_bfd->xvec->byteorder
666 == output_bfd->xvec->byteorder);
667
668#if 0
892339ee 669 printf ("dj: relocate %s(%s) %08x\n",
17505c5c
NC		 670 input_bfd->filename, input_section->name,
671 input_section->output_section->vma + input_section->output_offset);
672#endif
673
674 gp = _bfd_get_gp_value (output_bfd);
675 if (gp == 0)
676 gp_undefined = true;
677 else
678 gp_undefined = false;
679
680 got_lo = false;
681
682 adjust = 0;
683
684 rel = relocs;
685 rel_end = rel + input_section->reloc_count;
686 for (i = 0; rel < rel_end; rel++, i++)
687 {
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;
17505c5c
NC		 694 unsigned char *mem = contents + rel->r_vaddr;
695
696 symndx = rel->r_symndx;
697
698 if (symndx == -1)
699 {
700 h = NULL;
701 sym = NULL;
702 }
703 else
892339ee 704 {
17505c5c
NC		 705 h = obj_coff_sym_hashes (input_bfd)[symndx];
706 sym = syms + symndx;
707 }
708
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. */
713
714 if (sym != NULL && sym->n_scnum != 0)
715 addend = - sym->n_value;
716 else
717 addend = 0;
718
17505c5c
NC		 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,
5cc7c785 774 rel->r_vaddr - input_section->vma, true)))
17505c5c
NC		 775 return false;
776 }
777 }
778
779 src = rel->r_vaddr + input_section->output_section->vma
780 + input_section->output_offset;
781#if 0
892339ee 782 printf ("dj: reloc %02x %-8s a=%08x/%08x(%08x) v=%08x+%08x %s\n",
17505c5c
NC		 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
892339ee 794#define UI(x) (*_bfd_error_handler) (_("%s: unimplemented %s\n"), \
8f615d07 795 bfd_archive_filename (input_bfd), x); \
17505c5c
NC		 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);
892339ee 810 /* printf ("refword: src=%08x targ=%08x+%08x\n", src, tmp, val); */
17505c5c
NC		 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;
86033394 818 if ((src & 0xf0000000) != (targ & 0xf0000000))
17505c5c 819 {
892339ee 820 (*_bfd_error_handler) (_("%s: jump too far away\n"),
8f615d07 821 bfd_archive_filename (input_bfd));
17505c5c
NC		 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:
892339ee 847 (*_bfd_error_handler) (_("%s: bad pair/reflo after refhi\n"),
8f615d07 848 bfd_archive_filename (input_bfd));
17505c5c
NC		 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);
892339ee 860 /* printf ("refword: src=%08x targ=%08x\n", src, targ); */
17505c5c
NC		 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);
892339ee 889 /* printf ("rva: src=%08x targ=%08x+%08x\n", src, tmp, val); */
17505c5c 890 tmp += val
86033394 891 - pe_data (input_section->output_section->owner)->pe_opthdr.ImageBase;
17505c5c
NC		 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
912static boolean coff_mips_is_local_label_name PARAMS ((bfd *, const char *));
913
914static boolean
915coff_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
933const 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
892339ee 977/* Note that we allow an object file to be treated as a core file as well. */
17505c5c
NC		 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,
892339ee 996
17505c5c
NC		 997 COFF_SWAP_TABLE
998};
GDB Binutils - Deliverables
This page took 0.163102 seconds and 4 git commands to generate.