1
/* BFD back-end for MIPS Extended-Coff files.
2
Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4
Free Software Foundation, Inc.
5
Original version by Per Bothner.
6
Full support added by Ian Lance Taylor, ian@cygnus.com.
8
This file is part of BFD, the Binary File Descriptor library.
10
This program is free software; you can redistribute it and/or modify
11
it under the terms of the GNU General Public License as published by
12
the Free Software Foundation; either version 2 of the License, or
13
(at your option) any later version.
15
This program is distributed in the hope that it will be useful,
16
but WITHOUT ANY WARRANTY; without even the implied warranty of
17
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18
GNU General Public License for more details.
20
You should have received a copy of the GNU General Public License
21
along with this program; if not, write to the Free Software
22
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28
#include "coff/internal.h"
30
#include "coff/symconst.h"
31
#include "coff/ecoff.h"
32
#include "coff/mips.h"
36
/* Prototypes for static functions. */
38
static boolean mips_ecoff_bad_format_hook PARAMS ((bfd *abfd, PTR filehdr));
39
static void mips_ecoff_swap_reloc_in PARAMS ((bfd *, PTR,
40
struct internal_reloc *));
41
static void mips_ecoff_swap_reloc_out PARAMS ((bfd *,
42
const struct internal_reloc *,
44
static void mips_adjust_reloc_in PARAMS ((bfd *,
45
const struct internal_reloc *,
47
static void mips_adjust_reloc_out PARAMS ((bfd *, const arelent *,
48
struct internal_reloc *));
49
static bfd_reloc_status_type mips_generic_reloc PARAMS ((bfd *abfd,
56
static bfd_reloc_status_type mips_refhi_reloc PARAMS ((bfd *abfd,
63
static bfd_reloc_status_type mips_reflo_reloc PARAMS ((bfd *abfd,
70
static bfd_reloc_status_type mips_gprel_reloc PARAMS ((bfd *abfd,
77
static bfd_reloc_status_type mips_relhi_reloc PARAMS ((bfd *abfd,
84
static bfd_reloc_status_type mips_rello_reloc PARAMS ((bfd *abfd,
91
static bfd_reloc_status_type mips_switch_reloc PARAMS ((bfd *abfd,
98
static void mips_relocate_hi PARAMS ((struct internal_reloc *refhi,
99
struct internal_reloc *reflo,
101
asection *input_section,
106
static boolean mips_relocate_section PARAMS ((bfd *, struct bfd_link_info *,
109
static boolean mips_read_relocs PARAMS ((bfd *, asection *));
110
static boolean mips_relax_section PARAMS ((bfd *, asection *,
111
struct bfd_link_info *,
113
static boolean mips_relax_pcrel16 PARAMS ((struct bfd_link_info *, bfd *,
115
struct ecoff_link_hash_entry *,
116
bfd_byte *, bfd_vma));
117
static reloc_howto_type *mips_bfd_reloc_type_lookup
118
PARAMS ((bfd *, bfd_reloc_code_real_type));
120
/* ECOFF has COFF sections, but the debugging information is stored in
121
a completely different format. ECOFF targets use some of the
122
swapping routines from coffswap.h, and some of the generic COFF
123
routines in coffgen.c, but, unlike the real COFF targets, do not
124
use coffcode.h itself.
126
Get the generic COFF swapping routines, except for the reloc,
127
symbol, and lineno ones. Give them ECOFF names. */
129
#define NO_COFF_RELOCS
130
#define NO_COFF_SYMBOLS
131
#define NO_COFF_LINENOS
132
#define coff_swap_filehdr_in mips_ecoff_swap_filehdr_in
133
#define coff_swap_filehdr_out mips_ecoff_swap_filehdr_out
134
#define coff_swap_aouthdr_in mips_ecoff_swap_aouthdr_in
135
#define coff_swap_aouthdr_out mips_ecoff_swap_aouthdr_out
136
#define coff_swap_scnhdr_in mips_ecoff_swap_scnhdr_in
137
#define coff_swap_scnhdr_out mips_ecoff_swap_scnhdr_out
138
#include "coffswap.h"
140
/* Get the ECOFF swapping routines. */
142
#include "ecoffswap.h"
144
/* How to process the various relocs types. */
146
static reloc_howto_type mips_howto_table[] =
148
/* Reloc type 0 is ignored. The reloc reading code ensures that
149
this is a reference to the .abs section, which will cause
150
bfd_perform_relocation to do nothing. */
151
HOWTO (MIPS_R_IGNORE, /* type */
153
0, /* size (0 = byte, 1 = short, 2 = long) */
155
false, /* pc_relative */
157
complain_overflow_dont, /* complain_on_overflow */
158
0, /* special_function */
160
false, /* partial_inplace */
163
false), /* pcrel_offset */
165
/* A 16 bit reference to a symbol, normally from a data section. */
166
HOWTO (MIPS_R_REFHALF, /* type */
168
1, /* size (0 = byte, 1 = short, 2 = long) */
170
false, /* pc_relative */
172
complain_overflow_bitfield, /* complain_on_overflow */
173
mips_generic_reloc, /* special_function */
174
"REFHALF", /* name */
175
true, /* partial_inplace */
176
0xffff, /* src_mask */
177
0xffff, /* dst_mask */
178
false), /* pcrel_offset */
180
/* A 32 bit reference to a symbol, normally from a data section. */
181
HOWTO (MIPS_R_REFWORD, /* type */
183
2, /* size (0 = byte, 1 = short, 2 = long) */
185
false, /* pc_relative */
187
complain_overflow_bitfield, /* complain_on_overflow */
188
mips_generic_reloc, /* special_function */
189
"REFWORD", /* name */
190
true, /* partial_inplace */
191
0xffffffff, /* src_mask */
192
0xffffffff, /* dst_mask */
193
false), /* pcrel_offset */
195
/* A 26 bit absolute jump address. */
196
HOWTO (MIPS_R_JMPADDR, /* type */
198
2, /* size (0 = byte, 1 = short, 2 = long) */
200
false, /* pc_relative */
202
complain_overflow_dont, /* complain_on_overflow */
203
/* This needs complex overflow
204
detection, because the upper four
205
bits must match the PC. */
206
mips_generic_reloc, /* special_function */
207
"JMPADDR", /* name */
208
true, /* partial_inplace */
209
0x3ffffff, /* src_mask */
210
0x3ffffff, /* dst_mask */
211
false), /* pcrel_offset */
213
/* The high 16 bits of a symbol value. Handled by the function
215
HOWTO (MIPS_R_REFHI, /* type */
217
2, /* size (0 = byte, 1 = short, 2 = long) */
219
false, /* pc_relative */
221
complain_overflow_bitfield, /* complain_on_overflow */
222
mips_refhi_reloc, /* special_function */
224
true, /* partial_inplace */
225
0xffff, /* src_mask */
226
0xffff, /* dst_mask */
227
false), /* pcrel_offset */
229
/* The low 16 bits of a symbol value. */
230
HOWTO (MIPS_R_REFLO, /* type */
232
2, /* size (0 = byte, 1 = short, 2 = long) */
234
false, /* pc_relative */
236
complain_overflow_dont, /* complain_on_overflow */
237
mips_reflo_reloc, /* special_function */
239
true, /* partial_inplace */
240
0xffff, /* src_mask */
241
0xffff, /* dst_mask */
242
false), /* pcrel_offset */
244
/* A reference to an offset from the gp register. Handled by the
245
function mips_gprel_reloc. */
246
HOWTO (MIPS_R_GPREL, /* type */
248
2, /* size (0 = byte, 1 = short, 2 = long) */
250
false, /* pc_relative */
252
complain_overflow_signed, /* complain_on_overflow */
253
mips_gprel_reloc, /* special_function */
255
true, /* partial_inplace */
256
0xffff, /* src_mask */
257
0xffff, /* dst_mask */
258
false), /* pcrel_offset */
260
/* A reference to a literal using an offset from the gp register.
261
Handled by the function mips_gprel_reloc. */
262
HOWTO (MIPS_R_LITERAL, /* type */
264
2, /* size (0 = byte, 1 = short, 2 = long) */
266
false, /* pc_relative */
268
complain_overflow_signed, /* complain_on_overflow */
269
mips_gprel_reloc, /* special_function */
270
"LITERAL", /* name */
271
true, /* partial_inplace */
272
0xffff, /* src_mask */
273
0xffff, /* dst_mask */
274
false), /* pcrel_offset */
281
/* This reloc is a Cygnus extension used when generating position
282
independent code for embedded systems. It represents a 16 bit PC
283
relative reloc rightshifted twice as used in the MIPS branch
285
HOWTO (MIPS_R_PCREL16, /* type */
287
2, /* size (0 = byte, 1 = short, 2 = long) */
289
true, /* pc_relative */
291
complain_overflow_signed, /* complain_on_overflow */
292
mips_generic_reloc, /* special_function */
293
"PCREL16", /* name */
294
true, /* partial_inplace */
295
0xffff, /* src_mask */
296
0xffff, /* dst_mask */
297
true), /* pcrel_offset */
299
/* This reloc is a Cygnus extension used when generating position
300
independent code for embedded systems. It represents the high 16
301
bits of a PC relative reloc. The next reloc must be
302
MIPS_R_RELLO, and the addend is formed from the addends of the
303
two instructions, just as in MIPS_R_REFHI and MIPS_R_REFLO. The
304
final value is actually PC relative to the location of the
305
MIPS_R_RELLO reloc, not the MIPS_R_RELHI reloc. */
306
HOWTO (MIPS_R_RELHI, /* type */
308
2, /* size (0 = byte, 1 = short, 2 = long) */
310
true, /* pc_relative */
312
complain_overflow_bitfield, /* complain_on_overflow */
313
mips_relhi_reloc, /* special_function */
315
true, /* partial_inplace */
316
0xffff, /* src_mask */
317
0xffff, /* dst_mask */
318
true), /* pcrel_offset */
320
/* This reloc is a Cygnus extension used when generating position
321
independent code for embedded systems. It represents the low 16
322
bits of a PC relative reloc. */
323
HOWTO (MIPS_R_RELLO, /* type */
325
2, /* size (0 = byte, 1 = short, 2 = long) */
327
true, /* pc_relative */
329
complain_overflow_dont, /* complain_on_overflow */
330
mips_rello_reloc, /* special_function */
332
true, /* partial_inplace */
333
0xffff, /* src_mask */
334
0xffff, /* dst_mask */
335
true), /* pcrel_offset */
345
/* This reloc is a Cygnus extension used when generating position
346
independent code for embedded systems. It represents an entry in
347
a switch table, which is the difference between two symbols in
348
the .text section. The symndx is actually the offset from the
349
reloc address to the subtrahend. See include/coff/mips.h for
351
HOWTO (MIPS_R_SWITCH, /* type */
353
2, /* size (0 = byte, 1 = short, 2 = long) */
355
true, /* pc_relative */
357
complain_overflow_dont, /* complain_on_overflow */
358
mips_switch_reloc, /* special_function */
360
true, /* partial_inplace */
361
0xffffffff, /* src_mask */
362
0xffffffff, /* dst_mask */
363
true) /* pcrel_offset */
366
#define MIPS_HOWTO_COUNT \
367
(sizeof mips_howto_table / sizeof mips_howto_table[0])
369
/* When the linker is doing relaxing, it may change an external PCREL16
370
reloc. This typically represents an instruction like
375
lui $at,%hi(foo - $L1)
377
addiu $at,%lo(foo - $L1)
380
PCREL16_EXPANSION_ADJUSTMENT is the number of bytes this changes the
383
#define PCREL16_EXPANSION_ADJUSTMENT (4 * 4)
385
/* See whether the magic number matches. */
388
mips_ecoff_bad_format_hook (abfd, filehdr)
392
struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
394
switch (internal_f->f_magic)
397
/* I don't know what endianness this implies. */
401
case MIPS_MAGIC_BIG2:
402
case MIPS_MAGIC_BIG3:
403
return bfd_big_endian (abfd);
405
case MIPS_MAGIC_LITTLE:
406
case MIPS_MAGIC_LITTLE2:
407
case MIPS_MAGIC_LITTLE3:
408
return bfd_little_endian (abfd);
415
/* Reloc handling. MIPS ECOFF relocs are packed into 8 bytes in
416
external form. They use a bit which indicates whether the symbol
419
/* Swap a reloc in. */
422
mips_ecoff_swap_reloc_in (abfd, ext_ptr, intern)
425
struct internal_reloc *intern;
427
const RELOC *ext = (RELOC *) ext_ptr;
429
intern->r_vaddr = H_GET_32 (abfd, ext->r_vaddr);
430
if (bfd_header_big_endian (abfd))
432
intern->r_symndx = (((int) ext->r_bits[0]
433
<< RELOC_BITS0_SYMNDX_SH_LEFT_BIG)
434
| ((int) ext->r_bits[1]
435
<< RELOC_BITS1_SYMNDX_SH_LEFT_BIG)
436
| ((int) ext->r_bits[2]
437
<< RELOC_BITS2_SYMNDX_SH_LEFT_BIG));
438
intern->r_type = ((ext->r_bits[3] & RELOC_BITS3_TYPE_BIG)
439
>> RELOC_BITS3_TYPE_SH_BIG);
440
intern->r_extern = (ext->r_bits[3] & RELOC_BITS3_EXTERN_BIG) != 0;
444
intern->r_symndx = (((int) ext->r_bits[0]
445
<< RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE)
446
| ((int) ext->r_bits[1]
447
<< RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE)
448
| ((int) ext->r_bits[2]
449
<< RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE));
450
intern->r_type = (((ext->r_bits[3] & RELOC_BITS3_TYPE_LITTLE)
451
>> RELOC_BITS3_TYPE_SH_LITTLE)
452
| ((ext->r_bits[3] & RELOC_BITS3_TYPEHI_LITTLE)
453
<< RELOC_BITS3_TYPEHI_SH_LITTLE));
454
intern->r_extern = (ext->r_bits[3] & RELOC_BITS3_EXTERN_LITTLE) != 0;
457
/* If this is a MIPS_R_SWITCH reloc, or an internal MIPS_R_RELHI or
458
MIPS_R_RELLO reloc, r_symndx is actually the offset from the
459
reloc address to the base of the difference (see
460
include/coff/mips.h for more details). We copy symndx into the
461
r_offset field so as not to confuse ecoff_slurp_reloc_table in
462
ecoff.c. In adjust_reloc_in we then copy r_offset into the reloc
464
if (intern->r_type == MIPS_R_SWITCH
465
|| (! intern->r_extern
466
&& (intern->r_type == MIPS_R_RELLO
467
|| intern->r_type == MIPS_R_RELHI)))
469
BFD_ASSERT (! intern->r_extern);
470
intern->r_offset = intern->r_symndx;
471
if (intern->r_offset & 0x800000)
472
intern->r_offset -= 0x1000000;
473
intern->r_symndx = RELOC_SECTION_TEXT;
477
/* Swap a reloc out. */
480
mips_ecoff_swap_reloc_out (abfd, intern, dst)
482
const struct internal_reloc *intern;
485
RELOC *ext = (RELOC *) dst;
488
BFD_ASSERT (intern->r_extern
489
|| (intern->r_symndx >= 0 && intern->r_symndx <= 12));
491
/* If this is a MIPS_R_SWITCH reloc, or an internal MIPS_R_RELLO or
492
MIPS_R_RELHI reloc, we actually want to write the contents of
493
r_offset out as the symbol index. This undoes the change made by
494
mips_ecoff_swap_reloc_in. */
495
if (intern->r_type != MIPS_R_SWITCH
497
|| (intern->r_type != MIPS_R_RELHI
498
&& intern->r_type != MIPS_R_RELLO)))
499
r_symndx = intern->r_symndx;
502
BFD_ASSERT (intern->r_symndx == RELOC_SECTION_TEXT);
503
r_symndx = intern->r_offset & 0xffffff;
506
H_PUT_32 (abfd, intern->r_vaddr, ext->r_vaddr);
507
if (bfd_header_big_endian (abfd))
509
ext->r_bits[0] = r_symndx >> RELOC_BITS0_SYMNDX_SH_LEFT_BIG;
510
ext->r_bits[1] = r_symndx >> RELOC_BITS1_SYMNDX_SH_LEFT_BIG;
511
ext->r_bits[2] = r_symndx >> RELOC_BITS2_SYMNDX_SH_LEFT_BIG;
512
ext->r_bits[3] = (((intern->r_type << RELOC_BITS3_TYPE_SH_BIG)
513
& RELOC_BITS3_TYPE_BIG)
514
| (intern->r_extern ? RELOC_BITS3_EXTERN_BIG : 0));
518
ext->r_bits[0] = r_symndx >> RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE;
519
ext->r_bits[1] = r_symndx >> RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE;
520
ext->r_bits[2] = r_symndx >> RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE;
521
ext->r_bits[3] = (((intern->r_type << RELOC_BITS3_TYPE_SH_LITTLE)
522
& RELOC_BITS3_TYPE_LITTLE)
523
| ((intern->r_type >> RELOC_BITS3_TYPEHI_SH_LITTLE
524
& RELOC_BITS3_TYPEHI_LITTLE))
525
| (intern->r_extern ? RELOC_BITS3_EXTERN_LITTLE : 0));
529
/* Finish canonicalizing a reloc. Part of this is generic to all
530
ECOFF targets, and that part is in ecoff.c. The rest is done in
531
this backend routine. It must fill in the howto field. */
534
mips_adjust_reloc_in (abfd, intern, rptr)
536
const struct internal_reloc *intern;
539
if (intern->r_type > MIPS_R_SWITCH)
542
if (! intern->r_extern
543
&& (intern->r_type == MIPS_R_GPREL
544
|| intern->r_type == MIPS_R_LITERAL))
545
rptr->addend += ecoff_data (abfd)->gp;
547
/* If the type is MIPS_R_IGNORE, make sure this is a reference to
548
the absolute section so that the reloc is ignored. */
549
if (intern->r_type == MIPS_R_IGNORE)
550
rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
552
/* If this is a MIPS_R_SWITCH reloc, or an internal MIPS_R_RELHI or
553
MIPS_R_RELLO reloc, we want the addend field of the BFD relocto
554
hold the value which was originally in the symndx field of the
555
internal MIPS ECOFF reloc. This value was copied into
556
intern->r_offset by mips_swap_reloc_in, and here we copy it into
558
if (intern->r_type == MIPS_R_SWITCH
559
|| (! intern->r_extern
560
&& (intern->r_type == MIPS_R_RELHI
561
|| intern->r_type == MIPS_R_RELLO)))
562
rptr->addend = intern->r_offset;
564
rptr->howto = &mips_howto_table[intern->r_type];
567
/* Make any adjustments needed to a reloc before writing it out. None
568
are needed for MIPS. */
571
mips_adjust_reloc_out (abfd, rel, intern)
572
bfd *abfd ATTRIBUTE_UNUSED;
574
struct internal_reloc *intern;
576
/* For a MIPS_R_SWITCH reloc, or an internal MIPS_R_RELHI or
577
MIPS_R_RELLO reloc, we must copy rel->addend into
578
intern->r_offset. This will then be written out as the symbol
579
index by mips_ecoff_swap_reloc_out. This operation parallels the
580
action of mips_adjust_reloc_in. */
581
if (intern->r_type == MIPS_R_SWITCH
582
|| (! intern->r_extern
583
&& (intern->r_type == MIPS_R_RELHI
584
|| intern->r_type == MIPS_R_RELLO)))
585
intern->r_offset = rel->addend;
588
/* ECOFF relocs are either against external symbols, or against
589
sections. If we are producing relocateable output, and the reloc
590
is against an external symbol, and nothing has given us any
591
additional addend, the resulting reloc will also be against the
592
same symbol. In such a case, we don't want to change anything
593
about the way the reloc is handled, since it will all be done at
594
final link time. Rather than put special case code into
595
bfd_perform_relocation, all the reloc types use this howto
596
function. It just short circuits the reloc if producing
597
relocateable output against an external symbol. */
599
static bfd_reloc_status_type
600
mips_generic_reloc (abfd,
607
bfd *abfd ATTRIBUTE_UNUSED;
608
arelent *reloc_entry;
610
PTR data ATTRIBUTE_UNUSED;
611
asection *input_section;
613
char **error_message ATTRIBUTE_UNUSED;
615
if (output_bfd != (bfd *) NULL
616
&& (symbol->flags & BSF_SECTION_SYM) == 0
617
&& reloc_entry->addend == 0)
619
reloc_entry->address += input_section->output_offset;
623
return bfd_reloc_continue;
626
/* Do a REFHI relocation. This has to be done in combination with a
627
REFLO reloc, because there is a carry from the REFLO to the REFHI.
628
Here we just save the information we need; we do the actual
629
relocation when we see the REFLO. MIPS ECOFF requires that the
630
REFLO immediately follow the REFHI. As a GNU extension, we permit
631
an arbitrary number of HI relocs to be associated with a single LO
632
reloc. This extension permits gcc to output the HI and LO relocs
637
struct mips_hi *next;
642
/* FIXME: This should not be a static variable. */
644
static struct mips_hi *mips_refhi_list;
646
static bfd_reloc_status_type
647
mips_refhi_reloc (abfd,
654
bfd *abfd ATTRIBUTE_UNUSED;
655
arelent *reloc_entry;
658
asection *input_section;
660
char **error_message ATTRIBUTE_UNUSED;
662
bfd_reloc_status_type ret;
666
/* If we're relocating, and this an external symbol, we don't want
667
to change anything. */
668
if (output_bfd != (bfd *) NULL
669
&& (symbol->flags & BSF_SECTION_SYM) == 0
670
&& reloc_entry->addend == 0)
672
reloc_entry->address += input_section->output_offset;
677
if (bfd_is_und_section (symbol->section)
678
&& output_bfd == (bfd *) NULL)
679
ret = bfd_reloc_undefined;
681
if (bfd_is_com_section (symbol->section))
684
relocation = symbol->value;
686
relocation += symbol->section->output_section->vma;
687
relocation += symbol->section->output_offset;
688
relocation += reloc_entry->addend;
690
if (reloc_entry->address > input_section->_cooked_size)
691
return bfd_reloc_outofrange;
693
/* Save the information, and let REFLO do the actual relocation. */
694
n = (struct mips_hi *) bfd_malloc ((bfd_size_type) sizeof *n);
696
return bfd_reloc_outofrange;
697
n->addr = (bfd_byte *) data + reloc_entry->address;
698
n->addend = relocation;
699
n->next = mips_refhi_list;
702
if (output_bfd != (bfd *) NULL)
703
reloc_entry->address += input_section->output_offset;
708
/* Do a REFLO relocation. This is a straightforward 16 bit inplace
709
relocation; this function exists in order to do the REFHI
710
relocation described above. */
712
static bfd_reloc_status_type
713
mips_reflo_reloc (abfd,
721
arelent *reloc_entry;
724
asection *input_section;
726
char **error_message;
728
if (mips_refhi_list != NULL)
738
struct mips_hi *next;
740
/* Do the REFHI relocation. Note that we actually don't
741
need to know anything about the REFLO itself, except
742
where to find the low 16 bits of the addend needed by the
744
insn = bfd_get_32 (abfd, l->addr);
745
vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
747
val = ((insn & 0xffff) << 16) + vallo;
750
/* The low order 16 bits are always treated as a signed
751
value. Therefore, a negative value in the low order bits
752
requires an adjustment in the high order bits. We need
753
to make this adjustment in two ways: once for the bits we
754
took from the data, and once for the bits we are putting
755
back in to the data. */
756
if ((vallo & 0x8000) != 0)
758
if ((val & 0x8000) != 0)
761
insn = (insn &~ (unsigned) 0xffff) | ((val >> 16) & 0xffff);
762
bfd_put_32 (abfd, (bfd_vma) insn, l->addr);
769
mips_refhi_list = NULL;
772
/* Now do the REFLO reloc in the usual way. */
773
return mips_generic_reloc (abfd, reloc_entry, symbol, data,
774
input_section, output_bfd, error_message);
777
/* Do a GPREL relocation. This is a 16 bit value which must become
778
the offset from the gp register. */
780
static bfd_reloc_status_type
781
mips_gprel_reloc (abfd,
789
arelent *reloc_entry;
792
asection *input_section;
794
char **error_message;
796
boolean relocateable;
802
/* If we're relocating, and this is an external symbol with no
803
addend, we don't want to change anything. We will only have an
804
addend if this is a newly created reloc, not read from an ECOFF
806
if (output_bfd != (bfd *) NULL
807
&& (symbol->flags & BSF_SECTION_SYM) == 0
808
&& reloc_entry->addend == 0)
810
reloc_entry->address += input_section->output_offset;
814
if (output_bfd != (bfd *) NULL)
818
relocateable = false;
819
output_bfd = symbol->section->output_section->owner;
822
if (bfd_is_und_section (symbol->section) && ! relocateable)
823
return bfd_reloc_undefined;
825
/* We have to figure out the gp value, so that we can adjust the
826
symbol value correctly. We look up the symbol _gp in the output
827
BFD. If we can't find it, we're stuck. We cache it in the ECOFF
828
target data. We don't need to adjust the symbol value for an
829
external symbol if we are producing relocateable output. */
830
gp = _bfd_get_gp_value (output_bfd);
833
|| (symbol->flags & BSF_SECTION_SYM) != 0))
837
/* Make up a value. */
838
gp = symbol->section->output_section->vma + 0x4000;
839
_bfd_set_gp_value (output_bfd, gp);
847
count = bfd_get_symcount (output_bfd);
848
sym = bfd_get_outsymbols (output_bfd);
850
if (sym == (asymbol **) NULL)
854
for (i = 0; i < count; i++, sym++)
856
register const char *name;
858
name = bfd_asymbol_name (*sym);
859
if (*name == '_' && strcmp (name, "_gp") == 0)
861
gp = bfd_asymbol_value (*sym);
862
_bfd_set_gp_value (output_bfd, gp);
870
/* Only get the error once. */
872
_bfd_set_gp_value (output_bfd, gp);
874
(char *) _("GP relative relocation when _gp not defined");
875
return bfd_reloc_dangerous;
880
if (bfd_is_com_section (symbol->section))
883
relocation = symbol->value;
885
relocation += symbol->section->output_section->vma;
886
relocation += symbol->section->output_offset;
888
if (reloc_entry->address > input_section->_cooked_size)
889
return bfd_reloc_outofrange;
891
insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
893
/* Set val to the offset into the section or symbol. */
894
val = ((insn & 0xffff) + reloc_entry->addend) & 0xffff;
898
/* Adjust val for the final section location and GP value. If we
899
are producing relocateable output, we don't want to do this for
900
an external symbol. */
902
|| (symbol->flags & BSF_SECTION_SYM) != 0)
903
val += relocation - gp;
905
insn = (insn &~ (unsigned) 0xffff) | (val & 0xffff);
906
bfd_put_32 (abfd, (bfd_vma) insn, (bfd_byte *) data + reloc_entry->address);
909
reloc_entry->address += input_section->output_offset;
911
/* Make sure it fit in 16 bits. */
912
if ((long) val >= 0x8000 || (long) val < -0x8000)
913
return bfd_reloc_overflow;
918
/* Do a RELHI relocation. We do this in conjunction with a RELLO
919
reloc, just as REFHI and REFLO are done together. RELHI and RELLO
920
are Cygnus extensions used when generating position independent
921
code for embedded systems. */
923
/* FIXME: This should not be a static variable. */
925
static struct mips_hi *mips_relhi_list;
927
static bfd_reloc_status_type
928
mips_relhi_reloc (abfd,
935
bfd *abfd ATTRIBUTE_UNUSED;
936
arelent *reloc_entry;
939
asection *input_section;
941
char **error_message ATTRIBUTE_UNUSED;
943
bfd_reloc_status_type ret;
947
/* If this is a reloc against a section symbol, then it is correct
948
in the object file. The only time we want to change this case is
949
when we are relaxing, and that is handled entirely by
950
mips_relocate_section and never calls this function. */
951
if ((symbol->flags & BSF_SECTION_SYM) != 0)
953
if (output_bfd != (bfd *) NULL)
954
reloc_entry->address += input_section->output_offset;
958
/* This is an external symbol. If we're relocating, we don't want
959
to change anything. */
960
if (output_bfd != (bfd *) NULL)
962
reloc_entry->address += input_section->output_offset;
967
if (bfd_is_und_section (symbol->section)
968
&& output_bfd == (bfd *) NULL)
969
ret = bfd_reloc_undefined;
971
if (bfd_is_com_section (symbol->section))
974
relocation = symbol->value;
976
relocation += symbol->section->output_section->vma;
977
relocation += symbol->section->output_offset;
978
relocation += reloc_entry->addend;
980
if (reloc_entry->address > input_section->_cooked_size)
981
return bfd_reloc_outofrange;
983
/* Save the information, and let RELLO do the actual relocation. */
984
n = (struct mips_hi *) bfd_malloc ((bfd_size_type) sizeof *n);
986
return bfd_reloc_outofrange;
987
n->addr = (bfd_byte *) data + reloc_entry->address;
988
n->addend = relocation;
989
n->next = mips_relhi_list;
992
if (output_bfd != (bfd *) NULL)
993
reloc_entry->address += input_section->output_offset;
998
/* Do a RELLO relocation. This is a straightforward 16 bit PC
999
relative relocation; this function exists in order to do the RELHI
1000
relocation described above. */
1002
static bfd_reloc_status_type
1003
mips_rello_reloc (abfd,
1011
arelent *reloc_entry;
1014
asection *input_section;
1016
char **error_message;
1018
if (mips_relhi_list != NULL)
1022
l = mips_relhi_list;
1027
unsigned long vallo;
1028
struct mips_hi *next;
1030
/* Do the RELHI relocation. Note that we actually don't
1031
need to know anything about the RELLO itself, except
1032
where to find the low 16 bits of the addend needed by the
1034
insn = bfd_get_32 (abfd, l->addr);
1035
vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
1037
val = ((insn & 0xffff) << 16) + vallo;
1040
/* If the symbol is defined, make val PC relative. If the
1041
symbol is not defined we don't want to do this, because
1042
we don't want the value in the object file to incorporate
1043
the address of the reloc. */
1044
if (! bfd_is_und_section (bfd_get_section (symbol))
1045
&& ! bfd_is_com_section (bfd_get_section (symbol)))
1046
val -= (input_section->output_section->vma
1047
+ input_section->output_offset
1048
+ reloc_entry->address);
1050
/* The low order 16 bits are always treated as a signed
1051
value. Therefore, a negative value in the low order bits
1052
requires an adjustment in the high order bits. We need
1053
to make this adjustment in two ways: once for the bits we
1054
took from the data, and once for the bits we are putting
1055
back in to the data. */
1056
if ((vallo & 0x8000) != 0)
1058
if ((val & 0x8000) != 0)
1061
insn = (insn &~ (unsigned) 0xffff) | ((val >> 16) & 0xffff);
1062
bfd_put_32 (abfd, (bfd_vma) insn, l->addr);
1069
mips_relhi_list = NULL;
1072
/* If this is a reloc against a section symbol, then it is correct
1073
in the object file. The only time we want to change this case is
1074
when we are relaxing, and that is handled entirely by
1075
mips_relocate_section and never calls this function. */
1076
if ((symbol->flags & BSF_SECTION_SYM) != 0)
1078
if (output_bfd != (bfd *) NULL)
1079
reloc_entry->address += input_section->output_offset;
1080
return bfd_reloc_ok;
1083
/* bfd_perform_relocation does not handle pcrel_offset relocations
1084
correctly when generating a relocateable file, so handle them
1086
if (output_bfd != (bfd *) NULL)
1088
reloc_entry->address += input_section->output_offset;
1089
return bfd_reloc_ok;
1092
/* Now do the RELLO reloc in the usual way. */
1093
return mips_generic_reloc (abfd, reloc_entry, symbol, data,
1094
input_section, output_bfd, error_message);
1097
/* This is the special function for the MIPS_R_SWITCH reloc. This
1098
special reloc is normally correct in the object file, and only
1099
requires special handling when relaxing. We don't want
1100
bfd_perform_relocation to tamper with it at all. */
1102
static bfd_reloc_status_type
1103
mips_switch_reloc (abfd,
1110
bfd *abfd ATTRIBUTE_UNUSED;
1111
arelent *reloc_entry ATTRIBUTE_UNUSED;
1112
asymbol *symbol ATTRIBUTE_UNUSED;
1113
PTR data ATTRIBUTE_UNUSED;
1114
asection *input_section ATTRIBUTE_UNUSED;
1115
bfd *output_bfd ATTRIBUTE_UNUSED;
1116
char **error_message ATTRIBUTE_UNUSED;
1118
return bfd_reloc_ok;
1121
/* Get the howto structure for a generic reloc type. */
1123
static reloc_howto_type *
1124
mips_bfd_reloc_type_lookup (abfd, code)
1125
bfd *abfd ATTRIBUTE_UNUSED;
1126
bfd_reloc_code_real_type code;
1133
mips_type = MIPS_R_REFHALF;
1136
case BFD_RELOC_CTOR:
1137
mips_type = MIPS_R_REFWORD;
1139
case BFD_RELOC_MIPS_JMP:
1140
mips_type = MIPS_R_JMPADDR;
1142
case BFD_RELOC_HI16_S:
1143
mips_type = MIPS_R_REFHI;
1145
case BFD_RELOC_LO16:
1146
mips_type = MIPS_R_REFLO;
1148
case BFD_RELOC_GPREL16:
1149
mips_type = MIPS_R_GPREL;
1151
case BFD_RELOC_MIPS_LITERAL:
1152
mips_type = MIPS_R_LITERAL;
1154
case BFD_RELOC_16_PCREL_S2:
1155
mips_type = MIPS_R_PCREL16;
1157
case BFD_RELOC_PCREL_HI16_S:
1158
mips_type = MIPS_R_RELHI;
1160
case BFD_RELOC_PCREL_LO16:
1161
mips_type = MIPS_R_RELLO;
1163
case BFD_RELOC_GPREL32:
1164
mips_type = MIPS_R_SWITCH;
1167
return (reloc_howto_type *) NULL;
1170
return &mips_howto_table[mips_type];
1173
/* A helper routine for mips_relocate_section which handles the REFHI
1174
and RELHI relocations. The REFHI relocation must be followed by a
1175
REFLO relocation (and RELHI by a RELLO), and the addend used is
1176
formed from the addends of both instructions. */
1179
mips_relocate_hi (refhi, reflo, input_bfd, input_section, contents, adjust,
1181
struct internal_reloc *refhi;
1182
struct internal_reloc *reflo;
1184
asection *input_section;
1192
unsigned long vallo;
1197
insn = bfd_get_32 (input_bfd,
1198
contents + adjust + refhi->r_vaddr - input_section->vma);
1202
vallo = (bfd_get_32 (input_bfd,
1203
contents + adjust + reflo->r_vaddr - input_section->vma)
1206
val = ((insn & 0xffff) << 16) + vallo;
1209
/* The low order 16 bits are always treated as a signed value.
1210
Therefore, a negative value in the low order bits requires an
1211
adjustment in the high order bits. We need to make this
1212
adjustment in two ways: once for the bits we took from the data,
1213
and once for the bits we are putting back in to the data. */
1214
if ((vallo & 0x8000) != 0)
1218
val -= (input_section->output_section->vma
1219
+ input_section->output_offset
1220
+ (reflo->r_vaddr - input_section->vma + adjust));
1222
if ((val & 0x8000) != 0)
1225
insn = (insn &~ (unsigned) 0xffff) | ((val >> 16) & 0xffff);
1226
bfd_put_32 (input_bfd, (bfd_vma) insn,
1227
contents + adjust + refhi->r_vaddr - input_section->vma);
1230
/* Relocate a section while linking a MIPS ECOFF file. */
1233
mips_relocate_section (output_bfd, info, input_bfd, input_section,
1234
contents, external_relocs)
1236
struct bfd_link_info *info;
1238
asection *input_section;
1240
PTR external_relocs;
1242
asection **symndx_to_section;
1243
struct ecoff_link_hash_entry **sym_hashes;
1245
boolean gp_undefined;
1248
struct external_reloc *ext_rel;
1249
struct external_reloc *ext_rel_end;
1252
struct internal_reloc lo_int_rel;
1255
BFD_ASSERT (input_bfd->xvec->byteorder
1256
== output_bfd->xvec->byteorder);
1258
/* We keep a table mapping the symndx found in an internal reloc to
1259
the appropriate section. This is faster than looking up the
1260
section by name each time. */
1261
symndx_to_section = ecoff_data (input_bfd)->symndx_to_section;
1262
if (symndx_to_section == (asection **) NULL)
1264
amt = NUM_RELOC_SECTIONS * sizeof (asection *);
1265
symndx_to_section = (asection **) bfd_alloc (input_bfd, amt);
1266
if (!symndx_to_section)
1269
symndx_to_section[RELOC_SECTION_NONE] = NULL;
1270
symndx_to_section[RELOC_SECTION_TEXT] =
1271
bfd_get_section_by_name (input_bfd, ".text");
1272
symndx_to_section[RELOC_SECTION_RDATA] =
1273
bfd_get_section_by_name (input_bfd, ".rdata");
1274
symndx_to_section[RELOC_SECTION_DATA] =
1275
bfd_get_section_by_name (input_bfd, ".data");
1276
symndx_to_section[RELOC_SECTION_SDATA] =
1277
bfd_get_section_by_name (input_bfd, ".sdata");
1278
symndx_to_section[RELOC_SECTION_SBSS] =
1279
bfd_get_section_by_name (input_bfd, ".sbss");
1280
symndx_to_section[RELOC_SECTION_BSS] =
1281
bfd_get_section_by_name (input_bfd, ".bss");
1282
symndx_to_section[RELOC_SECTION_INIT] =
1283
bfd_get_section_by_name (input_bfd, ".init");
1284
symndx_to_section[RELOC_SECTION_LIT8] =
1285
bfd_get_section_by_name (input_bfd, ".lit8");
1286
symndx_to_section[RELOC_SECTION_LIT4] =
1287
bfd_get_section_by_name (input_bfd, ".lit4");
1288
symndx_to_section[RELOC_SECTION_XDATA] = NULL;
1289
symndx_to_section[RELOC_SECTION_PDATA] = NULL;
1290
symndx_to_section[RELOC_SECTION_FINI] =
1291
bfd_get_section_by_name (input_bfd, ".fini");
1292
symndx_to_section[RELOC_SECTION_LITA] = NULL;
1293
symndx_to_section[RELOC_SECTION_ABS] = NULL;
1295
ecoff_data (input_bfd)->symndx_to_section = symndx_to_section;
1298
sym_hashes = ecoff_data (input_bfd)->sym_hashes;
1300
gp = _bfd_get_gp_value (output_bfd);
1302
gp_undefined = true;
1304
gp_undefined = false;
1310
if (ecoff_section_data (input_bfd, input_section) == NULL)
1313
offsets = ecoff_section_data (input_bfd, input_section)->offsets;
1315
ext_rel = (struct external_reloc *) external_relocs;
1316
ext_rel_end = ext_rel + input_section->reloc_count;
1317
for (i = 0; ext_rel < ext_rel_end; ext_rel++, i++)
1319
struct internal_reloc int_rel;
1320
boolean use_lo = false;
1322
reloc_howto_type *howto;
1323
struct ecoff_link_hash_entry *h = NULL;
1326
bfd_reloc_status_type r;
1329
mips_ecoff_swap_reloc_in (input_bfd, (PTR) ext_rel, &int_rel);
1332
int_rel = lo_int_rel;
1336
BFD_ASSERT (int_rel.r_type
1337
< sizeof mips_howto_table / sizeof mips_howto_table[0]);
1339
/* The REFHI and RELHI relocs requires special handling. they
1340
must be followed by a REFLO or RELLO reloc, respectively, and
1341
the addend is formed from both relocs. */
1342
if (int_rel.r_type == MIPS_R_REFHI
1343
|| int_rel.r_type == MIPS_R_RELHI)
1345
struct external_reloc *lo_ext_rel;
1347
/* As a GNU extension, permit an arbitrary number of REFHI
1348
or RELHI relocs before the REFLO or RELLO reloc. This
1349
permits gcc to emit the HI and LO relocs itself. */
1350
for (lo_ext_rel = ext_rel + 1;
1351
lo_ext_rel < ext_rel_end;
1354
mips_ecoff_swap_reloc_in (input_bfd, (PTR) lo_ext_rel,
1356
if (lo_int_rel.r_type != int_rel.r_type)
1360
if (lo_ext_rel < ext_rel_end
1361
&& (lo_int_rel.r_type
1362
== (int_rel.r_type == MIPS_R_REFHI
1365
&& int_rel.r_extern == lo_int_rel.r_extern
1366
&& int_rel.r_symndx == lo_int_rel.r_symndx)
1369
if (lo_ext_rel == ext_rel + 1)
1374
howto = &mips_howto_table[int_rel.r_type];
1376
/* The SWITCH reloc must be handled specially. This reloc is
1377
marks the location of a difference between two portions of an
1378
object file. The symbol index does not reference a symbol,
1379
but is actually the offset from the reloc to the subtrahend
1380
of the difference. This reloc is correct in the object file,
1381
and needs no further adjustment, unless we are relaxing. If
1382
we are relaxing, we may have to add in an offset. Since no
1383
symbols are involved in this reloc, we handle it completely
1385
if (int_rel.r_type == MIPS_R_SWITCH)
1390
r = _bfd_relocate_contents (howto, input_bfd,
1391
(bfd_vma) offsets[i],
1395
- input_section->vma));
1396
BFD_ASSERT (r == bfd_reloc_ok);
1402
if (int_rel.r_extern)
1404
h = sym_hashes[int_rel.r_symndx];
1405
/* If h is NULL, that means that there is a reloc against an
1406
external symbol which we thought was just a debugging
1407
symbol. This should not happen. */
1408
if (h == (struct ecoff_link_hash_entry *) NULL)
1413
if (int_rel.r_symndx < 0 || int_rel.r_symndx >= NUM_RELOC_SECTIONS)
1416
s = symndx_to_section[int_rel.r_symndx];
1418
if (s == (asection *) NULL)
1422
/* The GPREL reloc uses an addend: the difference in the GP
1424
if (int_rel.r_type != MIPS_R_GPREL
1425
&& int_rel.r_type != MIPS_R_LITERAL)
1431
if (! ((*info->callbacks->reloc_dangerous)
1432
(info, _("GP relative relocation used when GP not defined"),
1433
input_bfd, input_section,
1434
int_rel.r_vaddr - input_section->vma)))
1436
/* Only give the error once per link. */
1438
_bfd_set_gp_value (output_bfd, gp);
1439
gp_undefined = false;
1441
if (! int_rel.r_extern)
1443
/* This is a relocation against a section. The current
1444
addend in the instruction is the difference between
1445
INPUT_SECTION->vma and the GP value of INPUT_BFD. We
1446
must change this to be the difference between the
1447
final definition (which will end up in RELOCATION)
1448
and the GP value of OUTPUT_BFD (which is in GP). */
1449
addend = ecoff_data (input_bfd)->gp - gp;
1451
else if (! info->relocateable
1452
|| h->root.type == bfd_link_hash_defined
1453
|| h->root.type == bfd_link_hash_defweak)
1455
/* This is a relocation against a defined symbol. The
1456
current addend in the instruction is simply the
1457
desired offset into the symbol (normally zero). We
1458
are going to change this into a relocation against a
1459
defined symbol, so we want the instruction to hold
1460
the difference between the final definition of the
1461
symbol (which will end up in RELOCATION) and the GP
1462
value of OUTPUT_BFD (which is in GP). */
1467
/* This is a relocation against an undefined or common
1468
symbol. The current addend in the instruction is
1469
simply the desired offset into the symbol (normally
1470
zero). We are generating relocateable output, and we
1471
aren't going to define this symbol, so we just leave
1472
the instruction alone. */
1477
/* If we are relaxing, mips_relax_section may have set
1478
offsets[i] to some value. A value of 1 means we must expand
1479
a PC relative branch into a multi-instruction of sequence,
1480
and any other value is an addend. */
1484
BFD_ASSERT (! info->relocateable);
1485
BFD_ASSERT (int_rel.r_type == MIPS_R_PCREL16
1486
|| int_rel.r_type == MIPS_R_RELHI
1487
|| int_rel.r_type == MIPS_R_RELLO);
1488
if (offsets[i] != 1)
1489
addend += offsets[i];
1494
BFD_ASSERT (int_rel.r_extern
1495
&& int_rel.r_type == MIPS_R_PCREL16);
1497
/* Move the rest of the instructions up. */
1501
- input_section->vma);
1502
memmove (here + PCREL16_EXPANSION_ADJUSTMENT, here,
1503
(size_t) (input_section->_raw_size
1504
- (int_rel.r_vaddr - input_section->vma)));
1506
/* Generate the new instructions. */
1507
if (! mips_relax_pcrel16 (info, input_bfd, input_section,
1509
(input_section->output_section->vma
1510
+ input_section->output_offset
1512
- input_section->vma)
1516
/* We must adjust everything else up a notch. */
1517
adjust += PCREL16_EXPANSION_ADJUSTMENT;
1519
/* mips_relax_pcrel16 handles all the details of this
1525
/* If we are relaxing, and this is a reloc against the .text
1526
segment, we may need to adjust it if some branches have been
1527
expanded. The reloc types which are likely to occur in the
1528
.text section are handled efficiently by mips_relax_section,
1529
and thus do not need to be handled here. */
1530
if (ecoff_data (input_bfd)->debug_info.adjust != NULL
1531
&& ! int_rel.r_extern
1532
&& int_rel.r_symndx == RELOC_SECTION_TEXT
1533
&& (strcmp (bfd_get_section_name (input_bfd, input_section),
1535
|| (int_rel.r_type != MIPS_R_PCREL16
1536
&& int_rel.r_type != MIPS_R_SWITCH
1537
&& int_rel.r_type != MIPS_R_RELHI
1538
&& int_rel.r_type != MIPS_R_RELLO)))
1541
struct ecoff_value_adjust *a;
1543
/* We need to get the addend so that we know whether we need
1544
to adjust the address. */
1545
BFD_ASSERT (int_rel.r_type == MIPS_R_REFWORD);
1547
adr = bfd_get_32 (input_bfd,
1551
- input_section->vma));
1553
for (a = ecoff_data (input_bfd)->debug_info.adjust;
1554
a != (struct ecoff_value_adjust *) NULL;
1557
if (adr >= a->start && adr < a->end)
1558
addend += a->adjust;
1562
if (info->relocateable)
1564
/* We are generating relocateable output, and must convert
1565
the existing reloc. */
1566
if (int_rel.r_extern)
1568
if ((h->root.type == bfd_link_hash_defined
1569
|| h->root.type == bfd_link_hash_defweak)
1570
&& ! bfd_is_abs_section (h->root.u.def.section))
1574
/* This symbol is defined in the output. Convert
1575
the reloc from being against the symbol to being
1576
against the section. */
1578
/* Clear the r_extern bit. */
1579
int_rel.r_extern = 0;
1581
/* Compute a new r_symndx value. */
1582
s = h->root.u.def.section;
1583
name = bfd_get_section_name (output_bfd,
1586
int_rel.r_symndx = -1;
1590
if (strcmp (name, ".bss") == 0)
1591
int_rel.r_symndx = RELOC_SECTION_BSS;
1594
if (strcmp (name, ".data") == 0)
1595
int_rel.r_symndx = RELOC_SECTION_DATA;
1598
if (strcmp (name, ".fini") == 0)
1599
int_rel.r_symndx = RELOC_SECTION_FINI;
1602
if (strcmp (name, ".init") == 0)
1603
int_rel.r_symndx = RELOC_SECTION_INIT;
1606
if (strcmp (name, ".lit8") == 0)
1607
int_rel.r_symndx = RELOC_SECTION_LIT8;
1608
else if (strcmp (name, ".lit4") == 0)
1609
int_rel.r_symndx = RELOC_SECTION_LIT4;
1612
if (strcmp (name, ".rdata") == 0)
1613
int_rel.r_symndx = RELOC_SECTION_RDATA;
1616
if (strcmp (name, ".sdata") == 0)
1617
int_rel.r_symndx = RELOC_SECTION_SDATA;
1618
else if (strcmp (name, ".sbss") == 0)
1619
int_rel.r_symndx = RELOC_SECTION_SBSS;
1622
if (strcmp (name, ".text") == 0)
1623
int_rel.r_symndx = RELOC_SECTION_TEXT;
1627
if (int_rel.r_symndx == -1)
1630
/* Add the section VMA and the symbol value. */
1631
relocation = (h->root.u.def.value
1632
+ s->output_section->vma
1633
+ s->output_offset);
1635
/* For a PC relative relocation, the object file
1636
currently holds just the addend. We must adjust
1637
by the address to get the right value. */
1638
if (howto->pc_relative)
1640
relocation -= int_rel.r_vaddr - input_section->vma;
1642
/* If we are converting a RELHI or RELLO reloc
1643
from being against an external symbol to
1644
being against a section, we must put a
1645
special value into the r_offset field. This
1646
value is the old addend. The r_offset for
1647
both the RELHI and RELLO relocs are the same,
1648
and we set both when we see RELHI. */
1649
if (int_rel.r_type == MIPS_R_RELHI)
1653
addhi = bfd_get_32 (input_bfd,
1657
- input_section->vma));
1667
addlo = bfd_get_32 (input_bfd,
1670
+ lo_int_rel.r_vaddr
1671
- input_section->vma));
1676
lo_int_rel.r_offset = addhi + addlo;
1679
int_rel.r_offset = addhi + addlo;
1687
/* Change the symndx value to the right one for the
1689
int_rel.r_symndx = h->indx;
1690
if (int_rel.r_symndx == -1)
1692
/* This symbol is not being written out. */
1693
if (! ((*info->callbacks->unattached_reloc)
1694
(info, h->root.root.string, input_bfd,
1696
int_rel.r_vaddr - input_section->vma)))
1698
int_rel.r_symndx = 0;
1705
/* This is a relocation against a section. Adjust the
1706
value by the amount the section moved. */
1707
relocation = (s->output_section->vma
1712
relocation += addend;
1715
/* Adjust a PC relative relocation by removing the reference
1716
to the original address in the section and including the
1717
reference to the new address. However, external RELHI
1718
and RELLO relocs are PC relative, but don't include any
1719
reference to the address. The addend is merely an
1721
if (howto->pc_relative
1722
&& (! int_rel.r_extern
1723
|| (int_rel.r_type != MIPS_R_RELHI
1724
&& int_rel.r_type != MIPS_R_RELLO)))
1725
relocation -= (input_section->output_section->vma
1726
+ input_section->output_offset
1727
- input_section->vma);
1729
/* Adjust the contents. */
1730
if (relocation == 0)
1734
if (int_rel.r_type != MIPS_R_REFHI
1735
&& int_rel.r_type != MIPS_R_RELHI)
1736
r = _bfd_relocate_contents (howto, input_bfd, relocation,
1740
- input_section->vma));
1743
mips_relocate_hi (&int_rel,
1744
use_lo ? &lo_int_rel : NULL,
1745
input_bfd, input_section, contents,
1747
int_rel.r_type == MIPS_R_RELHI);
1752
/* Adjust the reloc address. */
1753
int_rel.r_vaddr += (input_section->output_section->vma
1754
+ input_section->output_offset
1755
- input_section->vma);
1757
/* Save the changed reloc information. */
1758
mips_ecoff_swap_reloc_out (input_bfd, &int_rel, (PTR) ext_rel);
1762
/* We are producing a final executable. */
1763
if (int_rel.r_extern)
1765
/* This is a reloc against a symbol. */
1766
if (h->root.type == bfd_link_hash_defined
1767
|| h->root.type == bfd_link_hash_defweak)
1771
hsec = h->root.u.def.section;
1772
relocation = (h->root.u.def.value
1773
+ hsec->output_section->vma
1774
+ hsec->output_offset);
1778
if (! ((*info->callbacks->undefined_symbol)
1779
(info, h->root.root.string, input_bfd,
1781
int_rel.r_vaddr - input_section->vma, true)))
1788
/* This is a reloc against a section. */
1789
relocation = (s->output_section->vma
1793
/* A PC relative reloc is already correct in the object
1794
file. Make it look like a pcrel_offset relocation by
1795
adding in the start address. */
1796
if (howto->pc_relative)
1798
if (int_rel.r_type != MIPS_R_RELHI || ! use_lo)
1799
relocation += int_rel.r_vaddr + adjust;
1801
relocation += lo_int_rel.r_vaddr + adjust;
1805
if (int_rel.r_type != MIPS_R_REFHI
1806
&& int_rel.r_type != MIPS_R_RELHI)
1807
r = _bfd_final_link_relocate (howto,
1812
- input_section->vma
1818
mips_relocate_hi (&int_rel,
1819
use_lo ? &lo_int_rel : NULL,
1820
input_bfd, input_section, contents, adjust,
1822
int_rel.r_type == MIPS_R_RELHI);
1827
/* MIPS_R_JMPADDR requires peculiar overflow detection. The
1828
instruction provides a 28 bit address (the two lower bits are
1829
implicit zeroes) which is combined with the upper four bits
1830
of the instruction address. */
1831
if (r == bfd_reloc_ok
1832
&& int_rel.r_type == MIPS_R_JMPADDR
1835
+ (int_rel.r_extern ? 0 : s->vma))
1837
!= ((input_section->output_section->vma
1838
+ input_section->output_offset
1839
+ (int_rel.r_vaddr - input_section->vma)
1842
r = bfd_reloc_overflow;
1844
if (r != bfd_reloc_ok)
1849
case bfd_reloc_outofrange:
1851
case bfd_reloc_overflow:
1855
if (int_rel.r_extern)
1856
name = h->root.root.string;
1858
name = bfd_section_name (input_bfd, s);
1859
if (! ((*info->callbacks->reloc_overflow)
1860
(info, name, howto->name, (bfd_vma) 0,
1861
input_bfd, input_section,
1862
int_rel.r_vaddr - input_section->vma)))
1873
/* Read in the relocs for a section. */
1876
mips_read_relocs (abfd, sec)
1880
struct ecoff_section_tdata *section_tdata;
1883
section_tdata = ecoff_section_data (abfd, sec);
1884
if (section_tdata == (struct ecoff_section_tdata *) NULL)
1886
amt = sizeof (struct ecoff_section_tdata);
1887
sec->used_by_bfd = (PTR) bfd_alloc (abfd, amt);
1888
if (sec->used_by_bfd == NULL)
1891
section_tdata = ecoff_section_data (abfd, sec);
1892
section_tdata->external_relocs = NULL;
1893
section_tdata->contents = NULL;
1894
section_tdata->offsets = NULL;
1897
if (section_tdata->external_relocs == NULL)
1899
amt = ecoff_backend (abfd)->external_reloc_size;
1900
amt *= sec->reloc_count;
1901
section_tdata->external_relocs = (PTR) bfd_alloc (abfd, amt);
1902
if (section_tdata->external_relocs == NULL && amt != 0)
1905
if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
1906
|| bfd_bread (section_tdata->external_relocs, amt, abfd) != amt)
1913
/* Relax a section when linking a MIPS ECOFF file. This is used for
1914
embedded PIC code, which always uses PC relative branches which
1915
only have an 18 bit range on MIPS. If a branch is not in range, we
1916
generate a long instruction sequence to compensate. Each time we
1917
find a branch to expand, we have to check all the others again to
1918
make sure they are still in range. This is slow, but it only has
1919
to be done when -relax is passed to the linker.
1921
This routine figures out which branches need to expand; the actual
1922
expansion is done in mips_relocate_section when the section
1923
contents are relocated. The information is stored in the offsets
1924
field of the ecoff_section_tdata structure. An offset of 1 means
1925
that the branch must be expanded into a multi-instruction PC
1926
relative branch (such an offset will only occur for a PC relative
1927
branch to an external symbol). Any other offset must be a multiple
1928
of four, and is the amount to change the branch by (such an offset
1929
will only occur for a PC relative branch within the same section).
1931
We do not modify the section relocs or contents themselves so that
1932
if memory usage becomes an issue we can discard them and read them
1933
again. The only information we must save in memory between this
1934
routine and the mips_relocate_section routine is the table of
1938
mips_relax_section (abfd, sec, info, again)
1941
struct bfd_link_info *info;
1944
struct ecoff_section_tdata *section_tdata;
1945
bfd_byte *contents = NULL;
1947
struct external_reloc *ext_rel;
1948
struct external_reloc *ext_rel_end;
1951
/* Assume we are not going to need another pass. */
1954
/* If we are not generating an ECOFF file, this is much too
1955
confusing to deal with. */
1956
if (info->hash->creator->flavour != bfd_get_flavour (abfd))
1959
/* If there are no relocs, there is nothing to do. */
1960
if (sec->reloc_count == 0)
1963
/* We are only interested in PC relative relocs, and why would there
1964
ever be one from anything but the .text section? */
1965
if (strcmp (bfd_get_section_name (abfd, sec), ".text") != 0)
1968
/* Read in the relocs, if we haven't already got them. */
1969
section_tdata = ecoff_section_data (abfd, sec);
1970
if (section_tdata == (struct ecoff_section_tdata *) NULL
1971
|| section_tdata->external_relocs == NULL)
1973
if (! mips_read_relocs (abfd, sec))
1975
section_tdata = ecoff_section_data (abfd, sec);
1978
if (sec->_cooked_size == 0)
1980
/* We must initialize _cooked_size only the first time we are
1982
sec->_cooked_size = sec->_raw_size;
1985
contents = section_tdata->contents;
1986
offsets = section_tdata->offsets;
1988
/* Look for any external PC relative relocs. Internal PC relative
1989
relocs are already correct in the object file, so they certainly
1990
can not overflow. */
1991
ext_rel = (struct external_reloc *) section_tdata->external_relocs;
1992
ext_rel_end = ext_rel + sec->reloc_count;
1993
for (i = 0; ext_rel < ext_rel_end; ext_rel++, i++)
1995
struct internal_reloc int_rel;
1996
struct ecoff_link_hash_entry *h;
1998
bfd_signed_vma relocation;
1999
struct external_reloc *adj_ext_rel;
2001
unsigned long ext_count;
2002
struct ecoff_link_hash_entry **adj_h_ptr;
2003
struct ecoff_link_hash_entry **adj_h_ptr_end;
2004
struct ecoff_value_adjust *adjust;
2007
/* If we have already expanded this reloc, we certainly don't
2008
need to do it again. */
2009
if (offsets != (long *) NULL && offsets[i] == 1)
2012
/* Quickly check that this reloc is external PCREL16. */
2013
if (bfd_header_big_endian (abfd))
2015
if ((ext_rel->r_bits[3] & RELOC_BITS3_EXTERN_BIG) == 0
2016
|| (((ext_rel->r_bits[3] & RELOC_BITS3_TYPE_BIG)
2017
>> RELOC_BITS3_TYPE_SH_BIG)
2023
if ((ext_rel->r_bits[3] & RELOC_BITS3_EXTERN_LITTLE) == 0
2024
|| (((ext_rel->r_bits[3] & RELOC_BITS3_TYPE_LITTLE)
2025
>> RELOC_BITS3_TYPE_SH_LITTLE)
2030
mips_ecoff_swap_reloc_in (abfd, (PTR) ext_rel, &int_rel);
2032
h = ecoff_data (abfd)->sym_hashes[int_rel.r_symndx];
2033
if (h == (struct ecoff_link_hash_entry *) NULL)
2036
if (h->root.type != bfd_link_hash_defined
2037
&& h->root.type != bfd_link_hash_defweak)
2039
/* Just ignore undefined symbols. These will presumably
2040
generate an error later in the link. */
2044
/* Get the value of the symbol. */
2045
hsec = h->root.u.def.section;
2046
relocation = (h->root.u.def.value
2047
+ hsec->output_section->vma
2048
+ hsec->output_offset);
2050
/* Subtract out the current address. */
2051
relocation -= (sec->output_section->vma
2052
+ sec->output_offset
2053
+ (int_rel.r_vaddr - sec->vma));
2055
/* The addend is stored in the object file. In the normal case
2056
of ``bal symbol'', the addend will be -4. It will only be
2057
different in the case of ``bal symbol+constant''. To avoid
2058
always reading in the section contents, we don't check the
2059
addend in the object file (we could easily check the contents
2060
if we happen to have already read them in, but I fear that
2061
this could be confusing). This means we will screw up if
2062
there is a branch to a symbol that is in range, but added to
2063
a constant which puts it out of range; in such a case the
2064
link will fail with a reloc overflow error. Since the
2065
compiler will never generate such code, it should be easy
2066
enough to work around it by changing the assembly code in the
2070
/* Now RELOCATION is the number we want to put in the object
2071
file. See whether it fits. */
2072
if (relocation >= -0x20000 && relocation < 0x20000)
2075
/* Now that we know this reloc needs work, which will rarely
2076
happen, go ahead and grab the section contents. */
2077
if (contents == (bfd_byte *) NULL)
2079
if (info->keep_memory)
2080
contents = (bfd_byte *) bfd_alloc (abfd, sec->_raw_size);
2082
contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
2083
if (contents == (bfd_byte *) NULL)
2085
if (! bfd_get_section_contents (abfd, sec, (PTR) contents,
2086
(file_ptr) 0, sec->_raw_size))
2088
if (info->keep_memory)
2089
section_tdata->contents = contents;
2092
/* We only support changing the bal instruction. It would be
2093
possible to handle other PC relative branches, but some of
2094
them (the conditional branches) would require a different
2095
length instruction sequence which would complicate both this
2096
routine and mips_relax_pcrel16. It could be written if
2097
somebody felt it were important. Ignoring this reloc will
2098
presumably cause a reloc overflow error later on. */
2099
if (bfd_get_32 (abfd, contents + int_rel.r_vaddr - sec->vma)
2100
!= 0x0411ffff) /* bgezal $0,. == bal . */
2103
/* Bother. We need to expand this reloc, and we will need to
2104
make another relaxation pass since this change may put other
2105
relocs out of range. We need to examine the local branches
2106
and we need to allocate memory to hold the offsets we must
2107
add to them. We also need to adjust the values of all
2108
symbols in the object file following this location. */
2110
sec->_cooked_size += PCREL16_EXPANSION_ADJUSTMENT;
2113
if (offsets == (long *) NULL)
2117
size = (bfd_size_type) sec->reloc_count * sizeof (long);
2118
offsets = (long *) bfd_zalloc (abfd, size);
2119
if (offsets == (long *) NULL)
2121
section_tdata->offsets = offsets;
2126
/* Now look for all PC relative references that cross this reloc
2127
and adjust their offsets. */
2128
adj_ext_rel = (struct external_reloc *) section_tdata->external_relocs;
2129
for (adj_i = 0; adj_ext_rel < ext_rel_end; adj_ext_rel++, adj_i++)
2131
struct internal_reloc adj_int_rel;
2132
bfd_vma start, stop;
2135
mips_ecoff_swap_reloc_in (abfd, (PTR) adj_ext_rel, &adj_int_rel);
2137
if (adj_int_rel.r_type == MIPS_R_PCREL16)
2141
/* We only care about local references. External ones
2142
will be relocated correctly anyhow. */
2143
if (adj_int_rel.r_extern)
2146
/* We are only interested in a PC relative reloc within
2147
this section. FIXME: Cross section PC relative
2148
relocs may not be handled correctly; does anybody
2150
if (adj_int_rel.r_symndx != RELOC_SECTION_TEXT)
2153
start = adj_int_rel.r_vaddr;
2155
insn = bfd_get_32 (abfd,
2156
contents + adj_int_rel.r_vaddr - sec->vma);
2158
stop = (insn & 0xffff) << 2;
2159
if ((stop & 0x20000) != 0)
2161
stop += adj_int_rel.r_vaddr + 4;
2163
else if (adj_int_rel.r_type == MIPS_R_RELHI)
2165
struct internal_reloc rello;
2168
/* The next reloc must be MIPS_R_RELLO, and we handle
2170
BFD_ASSERT (adj_ext_rel + 1 < ext_rel_end);
2172
mips_ecoff_swap_reloc_in (abfd, (PTR) (adj_ext_rel + 1), &rello);
2174
BFD_ASSERT (rello.r_type == MIPS_R_RELLO);
2176
addhi = bfd_get_32 (abfd,
2177
contents + adj_int_rel.r_vaddr - sec->vma);
2183
addlo = bfd_get_32 (abfd, contents + rello.r_vaddr - sec->vma);
2188
if (adj_int_rel.r_extern)
2190
/* The value we want here is
2191
sym - RELLOaddr + addend
2192
which we can express as
2193
sym - (RELLOaddr - addend)
2194
Therefore if we are expanding the area between
2195
RELLOaddr and RELLOaddr - addend we must adjust
2196
the addend. This is admittedly ambiguous, since
2197
we might mean (sym + addend) - RELLOaddr, but in
2198
practice we don't, and there is no way to handle
2199
that case correctly since at this point we have
2200
no idea whether any reloc is being expanded
2201
between sym and sym + addend. */
2202
start = rello.r_vaddr - (addhi + addlo);
2203
stop = rello.r_vaddr;
2207
/* An internal RELHI/RELLO pair represents the
2208
difference between two addresses, $LC0 - foo.
2209
The symndx value is actually the difference
2210
between the reloc address and $LC0. This lets us
2211
compute $LC0, and, by considering the addend,
2212
foo. If the reloc we are expanding falls between
2213
those two relocs, we must adjust the addend. At
2214
this point, the symndx value is actually in the
2215
r_offset field, where it was put by
2216
mips_ecoff_swap_reloc_in. */
2217
start = rello.r_vaddr - adj_int_rel.r_offset;
2218
stop = start + addhi + addlo;
2221
else if (adj_int_rel.r_type == MIPS_R_SWITCH)
2223
/* A MIPS_R_SWITCH reloc represents a word of the form
2225
The value in the object file is correct, assuming the
2226
original value of $L3. The symndx value is actually
2227
the difference between the reloc address and $LS12.
2228
This lets us compute the original value of $LS12 as
2230
and the original value of $L3 as
2231
vaddr - symndx + addend
2232
where addend is the value from the object file. At
2233
this point, the symndx value is actually found in the
2234
r_offset field, since it was moved by
2235
mips_ecoff_swap_reloc_in. */
2236
start = adj_int_rel.r_vaddr - adj_int_rel.r_offset;
2237
stop = start + bfd_get_32 (abfd,
2239
+ adj_int_rel.r_vaddr
2245
/* If the range expressed by this reloc, which is the
2246
distance between START and STOP crosses the reloc we are
2247
expanding, we must adjust the offset. The sign of the
2248
adjustment depends upon the direction in which the range
2249
crosses the reloc being expanded. */
2250
if (start <= int_rel.r_vaddr && stop > int_rel.r_vaddr)
2251
change = PCREL16_EXPANSION_ADJUSTMENT;
2252
else if (start > int_rel.r_vaddr && stop <= int_rel.r_vaddr)
2253
change = - PCREL16_EXPANSION_ADJUSTMENT;
2257
offsets[adj_i] += change;
2259
if (adj_int_rel.r_type == MIPS_R_RELHI)
2263
offsets[adj_i] += change;
2267
/* Find all symbols in this section defined by this object file
2268
and adjust their values. Note that we decide whether to
2269
adjust the value based on the value stored in the ECOFF EXTR
2270
structure, because the value stored in the hash table may
2271
have been changed by an earlier expanded reloc and thus may
2272
no longer correctly indicate whether the symbol is before or
2273
after the expanded reloc. */
2274
ext_count = ecoff_data (abfd)->debug_info.symbolic_header.iextMax;
2275
adj_h_ptr = ecoff_data (abfd)->sym_hashes;
2276
adj_h_ptr_end = adj_h_ptr + ext_count;
2277
for (; adj_h_ptr < adj_h_ptr_end; adj_h_ptr++)
2279
struct ecoff_link_hash_entry *adj_h;
2282
if (adj_h != (struct ecoff_link_hash_entry *) NULL
2283
&& (adj_h->root.type == bfd_link_hash_defined
2284
|| adj_h->root.type == bfd_link_hash_defweak)
2285
&& adj_h->root.u.def.section == sec
2286
&& adj_h->esym.asym.value > int_rel.r_vaddr)
2287
adj_h->root.u.def.value += PCREL16_EXPANSION_ADJUSTMENT;
2290
/* Add an entry to the symbol value adjust list. This is used
2291
by bfd_ecoff_debug_accumulate to adjust the values of
2292
internal symbols and FDR's. */
2293
amt = sizeof (struct ecoff_value_adjust);
2294
adjust = (struct ecoff_value_adjust *) bfd_alloc (abfd, amt);
2295
if (adjust == (struct ecoff_value_adjust *) NULL)
2298
adjust->start = int_rel.r_vaddr;
2299
adjust->end = sec->vma + sec->_raw_size;
2300
adjust->adjust = PCREL16_EXPANSION_ADJUSTMENT;
2302
adjust->next = ecoff_data (abfd)->debug_info.adjust;
2303
ecoff_data (abfd)->debug_info.adjust = adjust;
2306
if (contents != (bfd_byte *) NULL && ! info->keep_memory)
2312
if (contents != (bfd_byte *) NULL && ! info->keep_memory)
2317
/* This routine is called from mips_relocate_section when a PC
2318
relative reloc must be expanded into the five instruction sequence.
2319
It handles all the details of the expansion, including resolving
2323
mips_relax_pcrel16 (info, input_bfd, input_section, h, location, address)
2324
struct bfd_link_info *info ATTRIBUTE_UNUSED;
2326
asection *input_section ATTRIBUTE_UNUSED;
2327
struct ecoff_link_hash_entry *h;
2333
/* 0x0411ffff is bgezal $0,. == bal . */
2334
BFD_ASSERT (bfd_get_32 (input_bfd, location) == 0x0411ffff);
2336
/* We need to compute the distance between the symbol and the
2337
current address plus eight. */
2338
relocation = (h->root.u.def.value
2339
+ h->root.u.def.section->output_section->vma
2340
+ h->root.u.def.section->output_offset);
2341
relocation -= address + 8;
2343
/* If the lower half is negative, increment the upper 16 half. */
2344
if ((relocation & 0x8000) != 0)
2345
relocation += 0x10000;
2347
bfd_put_32 (input_bfd, (bfd_vma) 0x04110001, location); /* bal .+8 */
2348
bfd_put_32 (input_bfd,
2349
0x3c010000 | ((relocation >> 16) & 0xffff), /* lui $at,XX */
2351
bfd_put_32 (input_bfd,
2352
0x24210000 | (relocation & 0xffff), /* addiu $at,$at,XX */
2354
bfd_put_32 (input_bfd,
2355
(bfd_vma) 0x003f0821, location + 12); /* addu $at,$at,$ra */
2356
bfd_put_32 (input_bfd,
2357
(bfd_vma) 0x0020f809, location + 16); /* jalr $at */
2362
/* Given a .sdata section and a .rel.sdata in-memory section, store
2363
relocation information into the .rel.sdata section which can be
2364
used at runtime to relocate the section. This is called by the
2365
linker when the --embedded-relocs switch is used. This is called
2366
after the add_symbols entry point has been called for all the
2367
objects, and before the final_link entry point is called. This
2368
function presumes that the object was compiled using
2372
bfd_mips_ecoff_create_embedded_relocs (abfd, info, datasec, relsec, errmsg)
2374
struct bfd_link_info *info;
2379
struct ecoff_link_hash_entry **sym_hashes;
2380
struct ecoff_section_tdata *section_tdata;
2381
struct external_reloc *ext_rel;
2382
struct external_reloc *ext_rel_end;
2386
BFD_ASSERT (! info->relocateable);
2390
if (datasec->reloc_count == 0)
2393
sym_hashes = ecoff_data (abfd)->sym_hashes;
2395
if (! mips_read_relocs (abfd, datasec))
2398
amt = (bfd_size_type) datasec->reloc_count * 4;
2399
relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
2400
if (relsec->contents == NULL)
2403
p = relsec->contents;
2405
section_tdata = ecoff_section_data (abfd, datasec);
2406
ext_rel = (struct external_reloc *) section_tdata->external_relocs;
2407
ext_rel_end = ext_rel + datasec->reloc_count;
2408
for (; ext_rel < ext_rel_end; ext_rel++, p += 4)
2410
struct internal_reloc int_rel;
2411
boolean text_relative;
2413
mips_ecoff_swap_reloc_in (abfd, (PTR) ext_rel, &int_rel);
2415
/* We are going to write a four byte word into the runtime reloc
2416
section. The word will be the address in the data section
2417
which must be relocated. This must be on a word boundary,
2418
which means the lower two bits must be zero. We use the
2419
least significant bit to indicate how the value in the data
2420
section must be relocated. A 0 means that the value is
2421
relative to the text section, while a 1 indicates that the
2422
value is relative to the data section. Given that we are
2423
assuming the code was compiled using -membedded-pic, there
2424
should not be any other possibilities. */
2426
/* We can only relocate REFWORD relocs at run time. */
2427
if (int_rel.r_type != MIPS_R_REFWORD)
2429
*errmsg = _("unsupported reloc type");
2430
bfd_set_error (bfd_error_bad_value);
2434
if (int_rel.r_extern)
2436
struct ecoff_link_hash_entry *h;
2438
h = sym_hashes[int_rel.r_symndx];
2439
/* If h is NULL, that means that there is a reloc against an
2440
external symbol which we thought was just a debugging
2441
symbol. This should not happen. */
2442
if (h == (struct ecoff_link_hash_entry *) NULL)
2444
if ((h->root.type == bfd_link_hash_defined
2445
|| h->root.type == bfd_link_hash_defweak)
2446
&& (h->root.u.def.section->flags & SEC_CODE) != 0)
2447
text_relative = true;
2449
text_relative = false;
2453
switch (int_rel.r_symndx)
2455
case RELOC_SECTION_TEXT:
2456
text_relative = true;
2458
case RELOC_SECTION_SDATA:
2459
case RELOC_SECTION_SBSS:
2460
case RELOC_SECTION_LIT8:
2461
text_relative = false;
2464
/* No other sections should appear in -membedded-pic
2466
*errmsg = _("reloc against unsupported section");
2467
bfd_set_error (bfd_error_bad_value);
2472
if ((int_rel.r_offset & 3) != 0)
2474
*errmsg = _("reloc not properly aligned");
2475
bfd_set_error (bfd_error_bad_value);
2480
(int_rel.r_vaddr - datasec->vma + datasec->output_offset
2481
+ (text_relative ? 0 : 1)),
2488
/* This is the ECOFF backend structure. The backend field of the
2489
target vector points to this. */
2491
static const struct ecoff_backend_data mips_ecoff_backend_data =
2493
/* COFF backend structure. */
2495
(void (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR))) bfd_void, /* aux_in */
2496
(void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_in */
2497
(void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_in */
2498
(unsigned (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR)))bfd_void,/*aux_out*/
2499
(unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_out */
2500
(unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_out */
2501
(unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* reloc_out */
2502
mips_ecoff_swap_filehdr_out, mips_ecoff_swap_aouthdr_out,
2503
mips_ecoff_swap_scnhdr_out,
2504
FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, 0, FILNMLEN, true, false, 4, false, 2,
2505
mips_ecoff_swap_filehdr_in, mips_ecoff_swap_aouthdr_in,
2506
mips_ecoff_swap_scnhdr_in, NULL,
2507
mips_ecoff_bad_format_hook, _bfd_ecoff_set_arch_mach_hook,
2508
_bfd_ecoff_mkobject_hook, _bfd_ecoff_styp_to_sec_flags,
2509
_bfd_ecoff_set_alignment_hook, _bfd_ecoff_slurp_symbol_table,
2510
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2513
/* Supported architecture. */
2515
/* Initial portion of armap string. */
2517
/* The page boundary used to align sections in a demand-paged
2518
executable file. E.g., 0x1000. */
2520
/* True if the .rdata section is part of the text segment, as on the
2521
Alpha. False if .rdata is part of the data segment, as on the
2524
/* Bitsize of constructor entries. */
2526
/* Reloc to use for constructor entries. */
2527
&mips_howto_table[MIPS_R_REFWORD],
2529
/* Symbol table magic number. */
2531
/* Alignment of debugging information. E.g., 4. */
2533
/* Sizes of external symbolic information. */
2534
sizeof (struct hdr_ext),
2535
sizeof (struct dnr_ext),
2536
sizeof (struct pdr_ext),
2537
sizeof (struct sym_ext),
2538
sizeof (struct opt_ext),
2539
sizeof (struct fdr_ext),
2540
sizeof (struct rfd_ext),
2541
sizeof (struct ext_ext),
2542
/* Functions to swap in external symbolic data. */
2551
_bfd_ecoff_swap_tir_in,
2552
_bfd_ecoff_swap_rndx_in,
2553
/* Functions to swap out external symbolic data. */
2562
_bfd_ecoff_swap_tir_out,
2563
_bfd_ecoff_swap_rndx_out,
2564
/* Function to read in symbolic data. */
2565
_bfd_ecoff_slurp_symbolic_info
2567
/* External reloc size. */
2569
/* Reloc swapping functions. */
2570
mips_ecoff_swap_reloc_in,
2571
mips_ecoff_swap_reloc_out,
2572
/* Backend reloc tweaking. */
2573
mips_adjust_reloc_in,
2574
mips_adjust_reloc_out,
2575
/* Relocate section contents while linking. */
2576
mips_relocate_section,
2577
/* Do final adjustments to filehdr and aouthdr. */
2579
/* Read an element from an archive at a given file position. */
2580
_bfd_get_elt_at_filepos
2583
/* Looking up a reloc type is MIPS specific. */
2584
#define _bfd_ecoff_bfd_reloc_type_lookup mips_bfd_reloc_type_lookup
2586
/* Getting relocated section contents is generic. */
2587
#define _bfd_ecoff_bfd_get_relocated_section_contents \
2588
bfd_generic_get_relocated_section_contents
2590
/* Handling file windows is generic. */
2591
#define _bfd_ecoff_get_section_contents_in_window \
2592
_bfd_generic_get_section_contents_in_window
2594
/* Relaxing sections is MIPS specific. */
2595
#define _bfd_ecoff_bfd_relax_section mips_relax_section
2597
/* GC of sections is not done. */
2598
#define _bfd_ecoff_bfd_gc_sections bfd_generic_gc_sections
2600
/* Merging of sections is not done. */
2601
#define _bfd_ecoff_bfd_merge_sections bfd_generic_merge_sections
2603
#define _bfd_ecoff_bfd_discard_group bfd_generic_discard_group
2605
extern const bfd_target ecoff_big_vec;
2607
const bfd_target ecoff_little_vec =
2609
"ecoff-littlemips", /* name */
2610
bfd_target_ecoff_flavour,
2611
BFD_ENDIAN_LITTLE, /* data byte order is little */
2612
BFD_ENDIAN_LITTLE, /* header byte order is little */
2614
(HAS_RELOC | EXEC_P | /* object flags */
2615
HAS_LINENO | HAS_DEBUG |
2616
HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
2618
(SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
2619
0, /* leading underscore */
2620
' ', /* ar_pad_char */
2621
15, /* ar_max_namelen */
2622
bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2623
bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2624
bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2625
bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2626
bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2627
bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
2629
{_bfd_dummy_target, coff_object_p, /* bfd_check_format */
2630
_bfd_ecoff_archive_p, _bfd_dummy_target},
2631
{bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
2632
_bfd_generic_mkarchive, bfd_false},
2633
{bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
2634
_bfd_write_archive_contents, bfd_false},
2636
BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
2637
BFD_JUMP_TABLE_COPY (_bfd_ecoff),
2638
BFD_JUMP_TABLE_CORE (_bfd_nocore),
2639
BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
2640
BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
2641
BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
2642
BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
2643
BFD_JUMP_TABLE_LINK (_bfd_ecoff),
2644
BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2648
(PTR) &mips_ecoff_backend_data
2651
const bfd_target ecoff_big_vec =
2653
"ecoff-bigmips", /* name */
2654
bfd_target_ecoff_flavour,
2655
BFD_ENDIAN_BIG, /* data byte order is big */
2656
BFD_ENDIAN_BIG, /* header byte order is big */
2658
(HAS_RELOC | EXEC_P | /* object flags */
2659
HAS_LINENO | HAS_DEBUG |
2660
HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
2662
(SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
2663
0, /* leading underscore */
2664
' ', /* ar_pad_char */
2665
15, /* ar_max_namelen */
2666
bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2667
bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2668
bfd_getb16, bfd_getb_signed_16, bfd_putb16,
2669
bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2670
bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2671
bfd_getb16, bfd_getb_signed_16, bfd_putb16,
2672
{_bfd_dummy_target, coff_object_p, /* bfd_check_format */
2673
_bfd_ecoff_archive_p, _bfd_dummy_target},
2674
{bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
2675
_bfd_generic_mkarchive, bfd_false},
2676
{bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
2677
_bfd_write_archive_contents, bfd_false},
2679
BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
2680
BFD_JUMP_TABLE_COPY (_bfd_ecoff),
2681
BFD_JUMP_TABLE_CORE (_bfd_nocore),
2682
BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
2683
BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
2684
BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
2685
BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
2686
BFD_JUMP_TABLE_LINK (_bfd_ecoff),
2687
BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2691
(PTR) &mips_ecoff_backend_data
2694
const bfd_target ecoff_biglittle_vec =
2696
"ecoff-biglittlemips", /* name */
2697
bfd_target_ecoff_flavour,
2698
BFD_ENDIAN_LITTLE, /* data byte order is little */
2699
BFD_ENDIAN_BIG, /* header byte order is big */
2701
(HAS_RELOC | EXEC_P | /* object flags */
2702
HAS_LINENO | HAS_DEBUG |
2703
HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
2705
(SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
2706
0, /* leading underscore */
2707
' ', /* ar_pad_char */
2708
15, /* ar_max_namelen */
2709
bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2710
bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2711
bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2712
bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2713
bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2714
bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
2716
{_bfd_dummy_target, coff_object_p, /* bfd_check_format */
2717
_bfd_ecoff_archive_p, _bfd_dummy_target},
2718
{bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
2719
_bfd_generic_mkarchive, bfd_false},
2720
{bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
2721
_bfd_write_archive_contents, bfd_false},
2723
BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
2724
BFD_JUMP_TABLE_COPY (_bfd_ecoff),
2725
BFD_JUMP_TABLE_CORE (_bfd_nocore),
2726
BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
2727
BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
2728
BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
2729
BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
2730
BFD_JUMP_TABLE_LINK (_bfd_ecoff),
2731
BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2735
(PTR) &mips_ecoff_backend_data
added
removed
binutils/bfd/coff-mips.c
