1 /* BFD back-end for MIPS Extended-Coff files.
2 Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 1998
3 Free Software Foundation, Inc.
4 Original version by Per Bothner.
5 Full support added by Ian Lance Taylor, ian@cygnus.com.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27 #include "coff/internal.h"
29 #include "coff/symconst.h"
30 #include "coff/ecoff.h"
31 #include "coff/mips.h"
35 /* Prototypes for static functions. */
37 static boolean mips_ecoff_bad_format_hook PARAMS ((bfd *abfd, PTR filehdr));
38 static void mips_ecoff_swap_reloc_in PARAMS ((bfd *, PTR,
39 struct internal_reloc *));
40 static void mips_ecoff_swap_reloc_out PARAMS ((bfd *,
41 const struct internal_reloc *,
43 static void mips_adjust_reloc_in PARAMS ((bfd *,
44 const struct internal_reloc *,
46 static void mips_adjust_reloc_out PARAMS ((bfd *, const arelent *,
47 struct internal_reloc *));
48 static bfd_reloc_status_type mips_generic_reloc PARAMS ((bfd *abfd,
55 static bfd_reloc_status_type mips_refhi_reloc PARAMS ((bfd *abfd,
62 static bfd_reloc_status_type mips_reflo_reloc PARAMS ((bfd *abfd,
69 static bfd_reloc_status_type mips_gprel_reloc PARAMS ((bfd *abfd,
76 static bfd_reloc_status_type mips_relhi_reloc PARAMS ((bfd *abfd,
83 static bfd_reloc_status_type mips_rello_reloc PARAMS ((bfd *abfd,
90 static bfd_reloc_status_type mips_switch_reloc PARAMS ((bfd *abfd,
97 static void mips_relocate_hi PARAMS ((struct internal_reloc *refhi,
98 struct internal_reloc *reflo,
100 asection *input_section,
105 static boolean mips_relocate_section PARAMS ((bfd *, struct bfd_link_info *,
108 static boolean mips_read_relocs PARAMS ((bfd *, asection *));
109 static boolean mips_relax_section PARAMS ((bfd *, asection *,
110 struct bfd_link_info *,
112 static boolean mips_relax_pcrel16 PARAMS ((struct bfd_link_info *, bfd *,
114 struct ecoff_link_hash_entry *,
115 bfd_byte *, bfd_vma));
116 static reloc_howto_type *mips_bfd_reloc_type_lookup
117 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 a 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 = bfd_h_get_32 (abfd, (bfd_byte *) 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 bfd_h_put_32 (abfd, intern->r_vaddr, (bfd_byte *) 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)
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,
608 arelent *reloc_entry;
611 asection *input_section;
613 char **error_message;
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,
655 arelent *reloc_entry;
658 asection *input_section;
660 char **error_message;
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 (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 &~ 0xffff) | ((val >> 16) & 0xffff);
762 bfd_put_32 (abfd, 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)
823 && relocateable == false)
824 return bfd_reloc_undefined;
826 /* We have to figure out the gp value, so that we can adjust the
827 symbol value correctly. We look up the symbol _gp in the output
828 BFD. If we can't find it, we're stuck. We cache it in the ECOFF
829 target data. We don't need to adjust the symbol value for an
830 external symbol if we are producing relocateable output. */
831 gp = _bfd_get_gp_value (output_bfd);
833 && (relocateable == false
834 || (symbol->flags & BSF_SECTION_SYM) != 0))
836 if (relocateable != false)
838 /* Make up a value. */
839 gp = symbol->section->output_section->vma + 0x4000;
840 _bfd_set_gp_value (output_bfd, gp);
848 count = bfd_get_symcount (output_bfd);
849 sym = bfd_get_outsymbols (output_bfd);
851 if (sym == (asymbol **) NULL)
855 for (i = 0; i < count; i++, sym++)
857 register CONST char *name;
859 name = bfd_asymbol_name (*sym);
860 if (*name == '_' && strcmp (name, "_gp") == 0)
862 gp = bfd_asymbol_value (*sym);
863 _bfd_set_gp_value (output_bfd, gp);
871 /* Only get the error once. */
873 _bfd_set_gp_value (output_bfd, gp);
875 (char *) "GP relative relocation when _gp not defined";
876 return bfd_reloc_dangerous;
881 if (bfd_is_com_section (symbol->section))
884 relocation = symbol->value;
886 relocation += symbol->section->output_section->vma;
887 relocation += symbol->section->output_offset;
889 if (reloc_entry->address > input_section->_cooked_size)
890 return bfd_reloc_outofrange;
892 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
894 /* Set val to the offset into the section or symbol. */
895 val = ((insn & 0xffff) + reloc_entry->addend) & 0xffff;
899 /* Adjust val for the final section location and GP value. If we
900 are producing relocateable output, we don't want to do this for
901 an external symbol. */
902 if (relocateable == false
903 || (symbol->flags & BSF_SECTION_SYM) != 0)
904 val += relocation - gp;
906 insn = (insn &~ 0xffff) | (val & 0xffff);
907 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
909 if (relocateable != false)
910 reloc_entry->address += input_section->output_offset;
912 /* Make sure it fit in 16 bits. */
913 if (val >= 0x8000 && val < 0xffff8000)
914 return bfd_reloc_overflow;
919 /* Do a RELHI relocation. We do this in conjunction with a RELLO
920 reloc, just as REFHI and REFLO are done together. RELHI and RELLO
921 are Cygnus extensions used when generating position independent
922 code for embedded systems. */
924 /* FIXME: This should not be a static variable. */
926 static struct mips_hi *mips_relhi_list;
928 static bfd_reloc_status_type
929 mips_relhi_reloc (abfd,
937 arelent *reloc_entry;
940 asection *input_section;
942 char **error_message;
944 bfd_reloc_status_type ret;
948 /* If this is a reloc against a section symbol, then it is correct
949 in the object file. The only time we want to change this case is
950 when we are relaxing, and that is handled entirely by
951 mips_relocate_section and never calls this function. */
952 if ((symbol->flags & BSF_SECTION_SYM) != 0)
954 if (output_bfd != (bfd *) NULL)
955 reloc_entry->address += input_section->output_offset;
959 /* This is an external symbol. If we're relocating, we don't want
960 to change anything. */
961 if (output_bfd != (bfd *) NULL)
963 reloc_entry->address += input_section->output_offset;
968 if (bfd_is_und_section (symbol->section)
969 && output_bfd == (bfd *) NULL)
970 ret = bfd_reloc_undefined;
972 if (bfd_is_com_section (symbol->section))
975 relocation = symbol->value;
977 relocation += symbol->section->output_section->vma;
978 relocation += symbol->section->output_offset;
979 relocation += reloc_entry->addend;
981 if (reloc_entry->address > input_section->_cooked_size)
982 return bfd_reloc_outofrange;
984 /* Save the information, and let RELLO do the actual relocation. */
985 n = (struct mips_hi *) bfd_malloc (sizeof *n);
987 return bfd_reloc_outofrange;
988 n->addr = (bfd_byte *) data + reloc_entry->address;
989 n->addend = relocation;
990 n->next = mips_relhi_list;
993 if (output_bfd != (bfd *) NULL)
994 reloc_entry->address += input_section->output_offset;
999 /* Do a RELLO relocation. This is a straightforward 16 bit PC
1000 relative relocation; this function exists in order to do the RELHI
1001 relocation described above. */
1003 static bfd_reloc_status_type
1004 mips_rello_reloc (abfd,
1012 arelent *reloc_entry;
1015 asection *input_section;
1017 char **error_message;
1019 if (mips_relhi_list != NULL)
1023 l = mips_relhi_list;
1028 unsigned long vallo;
1029 struct mips_hi *next;
1031 /* Do the RELHI relocation. Note that we actually don't
1032 need to know anything about the RELLO itself, except
1033 where to find the low 16 bits of the addend needed by the
1035 insn = bfd_get_32 (abfd, l->addr);
1036 vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
1038 val = ((insn & 0xffff) << 16) + vallo;
1041 /* If the symbol is defined, make val PC relative. If the
1042 symbol is not defined we don't want to do this, because
1043 we don't want the value in the object file to incorporate
1044 the address of the reloc. */
1045 if (! bfd_is_und_section (bfd_get_section (symbol))
1046 && ! bfd_is_com_section (bfd_get_section (symbol)))
1047 val -= (input_section->output_section->vma
1048 + input_section->output_offset
1049 + reloc_entry->address);
1051 /* The low order 16 bits are always treated as a signed
1052 value. Therefore, a negative value in the low order bits
1053 requires an adjustment in the high order bits. We need
1054 to make this adjustment in two ways: once for the bits we
1055 took from the data, and once for the bits we are putting
1056 back in to the data. */
1057 if ((vallo & 0x8000) != 0)
1059 if ((val & 0x8000) != 0)
1062 insn = (insn &~ 0xffff) | ((val >> 16) & 0xffff);
1063 bfd_put_32 (abfd, insn, l->addr);
1070 mips_relhi_list = NULL;
1073 /* If this is a reloc against a section symbol, then it is correct
1074 in the object file. The only time we want to change this case is
1075 when we are relaxing, and that is handled entirely by
1076 mips_relocate_section and never calls this function. */
1077 if ((symbol->flags & BSF_SECTION_SYM) != 0)
1079 if (output_bfd != (bfd *) NULL)
1080 reloc_entry->address += input_section->output_offset;
1081 return bfd_reloc_ok;
1084 /* bfd_perform_relocation does not handle pcrel_offset relocations
1085 correctly when generating a relocateable file, so handle them
1087 if (output_bfd != (bfd *) NULL)
1089 reloc_entry->address += input_section->output_offset;
1090 return bfd_reloc_ok;
1093 /* Now do the RELLO reloc in the usual way. */
1094 return mips_generic_reloc (abfd, reloc_entry, symbol, data,
1095 input_section, output_bfd, error_message);
1098 /* This is the special function for the MIPS_R_SWITCH reloc. This
1099 special reloc is normally correct in the object file, and only
1100 requires special handling when relaxing. We don't want
1101 bfd_perform_relocation to tamper with it at all. */
1104 static bfd_reloc_status_type
1105 mips_switch_reloc (abfd,
1113 arelent *reloc_entry;
1116 asection *input_section;
1118 char **error_message;
1120 return bfd_reloc_ok;
1123 /* Get the howto structure for a generic reloc type. */
1125 static reloc_howto_type *
1126 mips_bfd_reloc_type_lookup (abfd, code)
1128 bfd_reloc_code_real_type code;
1135 mips_type = MIPS_R_REFHALF;
1138 case BFD_RELOC_CTOR:
1139 mips_type = MIPS_R_REFWORD;
1141 case BFD_RELOC_MIPS_JMP:
1142 mips_type = MIPS_R_JMPADDR;
1144 case BFD_RELOC_HI16_S:
1145 mips_type = MIPS_R_REFHI;
1147 case BFD_RELOC_LO16:
1148 mips_type = MIPS_R_REFLO;
1150 case BFD_RELOC_MIPS_GPREL:
1151 mips_type = MIPS_R_GPREL;
1153 case BFD_RELOC_MIPS_LITERAL:
1154 mips_type = MIPS_R_LITERAL;
1156 case BFD_RELOC_16_PCREL_S2:
1157 mips_type = MIPS_R_PCREL16;
1159 case BFD_RELOC_PCREL_HI16_S:
1160 mips_type = MIPS_R_RELHI;
1162 case BFD_RELOC_PCREL_LO16:
1163 mips_type = MIPS_R_RELLO;
1165 case BFD_RELOC_GPREL32:
1166 mips_type = MIPS_R_SWITCH;
1169 return (reloc_howto_type *) NULL;
1172 return &mips_howto_table[mips_type];
1175 /* A helper routine for mips_relocate_section which handles the REFHI
1176 and RELHI relocations. The REFHI relocation must be followed by a
1177 REFLO relocation (and RELHI by a RELLO), and the addend used is
1178 formed from the addends of both instructions. */
1181 mips_relocate_hi (refhi, reflo, input_bfd, input_section, contents, adjust,
1183 struct internal_reloc *refhi;
1184 struct internal_reloc *reflo;
1186 asection *input_section;
1194 unsigned long vallo;
1196 insn = bfd_get_32 (input_bfd,
1197 contents + adjust + refhi->r_vaddr - input_section->vma);
1198 vallo = (bfd_get_32 (input_bfd,
1199 contents + adjust + reflo->r_vaddr - input_section->vma)
1201 val = ((insn & 0xffff) << 16) + vallo;
1204 /* The low order 16 bits are always treated as a signed value.
1205 Therefore, a negative value in the low order bits requires an
1206 adjustment in the high order bits. We need to make this
1207 adjustment in two ways: once for the bits we took from the data,
1208 and once for the bits we are putting back in to the data. */
1209 if ((vallo & 0x8000) != 0)
1213 val -= (input_section->output_section->vma
1214 + input_section->output_offset
1215 + (reflo->r_vaddr - input_section->vma + adjust));
1217 if ((val & 0x8000) != 0)
1220 insn = (insn &~ 0xffff) | ((val >> 16) & 0xffff);
1221 bfd_put_32 (input_bfd, (bfd_vma) insn,
1222 contents + adjust + refhi->r_vaddr - input_section->vma);
1225 /* Relocate a section while linking a MIPS ECOFF file. */
1228 mips_relocate_section (output_bfd, info, input_bfd, input_section,
1229 contents, external_relocs)
1231 struct bfd_link_info *info;
1233 asection *input_section;
1235 PTR external_relocs;
1237 asection **symndx_to_section;
1238 struct ecoff_link_hash_entry **sym_hashes;
1240 boolean gp_undefined;
1243 struct external_reloc *ext_rel;
1244 struct external_reloc *ext_rel_end;
1247 struct internal_reloc lo_int_rel;
1249 BFD_ASSERT (input_bfd->xvec->byteorder
1250 == output_bfd->xvec->byteorder);
1252 /* We keep a table mapping the symndx found in an internal reloc to
1253 the appropriate section. This is faster than looking up the
1254 section by name each time. */
1255 symndx_to_section = ecoff_data (input_bfd)->symndx_to_section;
1256 if (symndx_to_section == (asection **) NULL)
1258 symndx_to_section = ((asection **)
1259 bfd_alloc (input_bfd,
1261 * sizeof (asection *))));
1262 if (!symndx_to_section)
1265 symndx_to_section[RELOC_SECTION_NONE] = NULL;
1266 symndx_to_section[RELOC_SECTION_TEXT] =
1267 bfd_get_section_by_name (input_bfd, ".text");
1268 symndx_to_section[RELOC_SECTION_RDATA] =
1269 bfd_get_section_by_name (input_bfd, ".rdata");
1270 symndx_to_section[RELOC_SECTION_DATA] =
1271 bfd_get_section_by_name (input_bfd, ".data");
1272 symndx_to_section[RELOC_SECTION_SDATA] =
1273 bfd_get_section_by_name (input_bfd, ".sdata");
1274 symndx_to_section[RELOC_SECTION_SBSS] =
1275 bfd_get_section_by_name (input_bfd, ".sbss");
1276 symndx_to_section[RELOC_SECTION_BSS] =
1277 bfd_get_section_by_name (input_bfd, ".bss");
1278 symndx_to_section[RELOC_SECTION_INIT] =
1279 bfd_get_section_by_name (input_bfd, ".init");
1280 symndx_to_section[RELOC_SECTION_LIT8] =
1281 bfd_get_section_by_name (input_bfd, ".lit8");
1282 symndx_to_section[RELOC_SECTION_LIT4] =
1283 bfd_get_section_by_name (input_bfd, ".lit4");
1284 symndx_to_section[RELOC_SECTION_XDATA] = NULL;
1285 symndx_to_section[RELOC_SECTION_PDATA] = NULL;
1286 symndx_to_section[RELOC_SECTION_FINI] =
1287 bfd_get_section_by_name (input_bfd, ".fini");
1288 symndx_to_section[RELOC_SECTION_LITA] = NULL;
1289 symndx_to_section[RELOC_SECTION_ABS] = NULL;
1291 ecoff_data (input_bfd)->symndx_to_section = symndx_to_section;
1294 sym_hashes = ecoff_data (input_bfd)->sym_hashes;
1296 gp = _bfd_get_gp_value (output_bfd);
1298 gp_undefined = true;
1300 gp_undefined = false;
1306 if (ecoff_section_data (input_bfd, input_section) == NULL)
1309 offsets = ecoff_section_data (input_bfd, input_section)->offsets;
1311 ext_rel = (struct external_reloc *) external_relocs;
1312 ext_rel_end = ext_rel + input_section->reloc_count;
1313 for (i = 0; ext_rel < ext_rel_end; ext_rel++, i++)
1315 struct internal_reloc int_rel;
1316 boolean use_lo = false;
1318 reloc_howto_type *howto;
1319 struct ecoff_link_hash_entry *h = NULL;
1322 bfd_reloc_status_type r;
1325 mips_ecoff_swap_reloc_in (input_bfd, (PTR) ext_rel, &int_rel);
1328 int_rel = lo_int_rel;
1332 BFD_ASSERT (int_rel.r_type
1333 < sizeof mips_howto_table / sizeof mips_howto_table[0]);
1335 /* The REFHI and RELHI relocs requires special handling. they
1336 must be followed by a REFLO or RELLO reloc, respectively, and
1337 the addend is formed from both relocs. */
1338 if (int_rel.r_type == MIPS_R_REFHI
1339 || int_rel.r_type == MIPS_R_RELHI)
1341 struct external_reloc *lo_ext_rel;
1343 /* As a GNU extension, permit an arbitrary number of REFHI
1344 or RELHI relocs before the REFLO or RELLO reloc. This
1345 permits gcc to emit the HI and LO relocs itself. */
1346 for (lo_ext_rel = ext_rel + 1;
1347 lo_ext_rel < ext_rel_end;
1350 mips_ecoff_swap_reloc_in (input_bfd, (PTR) lo_ext_rel,
1352 if (lo_int_rel.r_type != int_rel.r_type)
1356 if (lo_ext_rel < ext_rel_end
1357 && (lo_int_rel.r_type
1358 == (int_rel.r_type == MIPS_R_REFHI
1361 && int_rel.r_extern == lo_int_rel.r_extern
1362 && int_rel.r_symndx == lo_int_rel.r_symndx)
1365 if (lo_ext_rel == ext_rel + 1)
1370 howto = &mips_howto_table[int_rel.r_type];
1372 /* The SWITCH reloc must be handled specially. This reloc is
1373 marks the location of a difference between two portions of an
1374 object file. The symbol index does not reference a symbol,
1375 but is actually the offset from the reloc to the subtrahend
1376 of the difference. This reloc is correct in the object file,
1377 and needs no further adjustment, unless we are relaxing. If
1378 we are relaxing, we may have to add in an offset. Since no
1379 symbols are involved in this reloc, we handle it completely
1381 if (int_rel.r_type == MIPS_R_SWITCH)
1386 r = _bfd_relocate_contents (howto, input_bfd,
1387 (bfd_vma) offsets[i],
1391 - input_section->vma));
1392 BFD_ASSERT (r == bfd_reloc_ok);
1398 if (int_rel.r_extern)
1400 h = sym_hashes[int_rel.r_symndx];
1401 /* If h is NULL, that means that there is a reloc against an
1402 external symbol which we thought was just a debugging
1403 symbol. This should not happen. */
1404 if (h == (struct ecoff_link_hash_entry *) NULL)
1409 if (int_rel.r_symndx < 0 || int_rel.r_symndx >= NUM_RELOC_SECTIONS)
1412 s = symndx_to_section[int_rel.r_symndx];
1414 if (s == (asection *) NULL)
1418 /* The GPREL reloc uses an addend: the difference in the GP
1420 if (int_rel.r_type != MIPS_R_GPREL
1421 && int_rel.r_type != MIPS_R_LITERAL)
1427 if (! ((*info->callbacks->reloc_dangerous)
1428 (info, "GP relative relocation when GP not defined",
1429 input_bfd, input_section,
1430 int_rel.r_vaddr - input_section->vma)))
1432 /* Only give the error once per link. */
1434 _bfd_set_gp_value (output_bfd, gp);
1435 gp_undefined = false;
1437 if (! int_rel.r_extern)
1439 /* This is a relocation against a section. The current
1440 addend in the instruction is the difference between
1441 INPUT_SECTION->vma and the GP value of INPUT_BFD. We
1442 must change this to be the difference between the
1443 final definition (which will end up in RELOCATION)
1444 and the GP value of OUTPUT_BFD (which is in GP). */
1445 addend = ecoff_data (input_bfd)->gp - gp;
1447 else if (! info->relocateable
1448 || h->root.type == bfd_link_hash_defined
1449 || h->root.type == bfd_link_hash_defweak)
1451 /* This is a relocation against a defined symbol. The
1452 current addend in the instruction is simply the
1453 desired offset into the symbol (normally zero). We
1454 are going to change this into a relocation against a
1455 defined symbol, so we want the instruction to hold
1456 the difference between the final definition of the
1457 symbol (which will end up in RELOCATION) and the GP
1458 value of OUTPUT_BFD (which is in GP). */
1463 /* This is a relocation against an undefined or common
1464 symbol. The current addend in the instruction is
1465 simply the desired offset into the symbol (normally
1466 zero). We are generating relocateable output, and we
1467 aren't going to define this symbol, so we just leave
1468 the instruction alone. */
1473 /* If we are relaxing, mips_relax_section may have set
1474 offsets[i] to some value. A value of 1 means we must expand
1475 a PC relative branch into a multi-instruction of sequence,
1476 and any other value is an addend. */
1480 BFD_ASSERT (! info->relocateable);
1481 BFD_ASSERT (int_rel.r_type == MIPS_R_PCREL16
1482 || int_rel.r_type == MIPS_R_RELHI
1483 || int_rel.r_type == MIPS_R_RELLO);
1484 if (offsets[i] != 1)
1485 addend += offsets[i];
1490 BFD_ASSERT (int_rel.r_extern
1491 && int_rel.r_type == MIPS_R_PCREL16);
1493 /* Move the rest of the instructions up. */
1497 - input_section->vma);
1498 memmove (here + PCREL16_EXPANSION_ADJUSTMENT, here,
1499 (size_t) (input_section->_raw_size
1500 - (int_rel.r_vaddr - input_section->vma)));
1502 /* Generate the new instructions. */
1503 if (! mips_relax_pcrel16 (info, input_bfd, input_section,
1505 (input_section->output_section->vma
1506 + input_section->output_offset
1508 - input_section->vma)
1512 /* We must adjust everything else up a notch. */
1513 adjust += PCREL16_EXPANSION_ADJUSTMENT;
1515 /* mips_relax_pcrel16 handles all the details of this
1521 /* If we are relaxing, and this is a reloc against the .text
1522 segment, we may need to adjust it if some branches have been
1523 expanded. The reloc types which are likely to occur in the
1524 .text section are handled efficiently by mips_relax_section,
1525 and thus do not need to be handled here. */
1526 if (ecoff_data (input_bfd)->debug_info.adjust != NULL
1527 && ! int_rel.r_extern
1528 && int_rel.r_symndx == RELOC_SECTION_TEXT
1529 && (strcmp (bfd_get_section_name (input_bfd, input_section),
1531 || (int_rel.r_type != MIPS_R_PCREL16
1532 && int_rel.r_type != MIPS_R_SWITCH
1533 && int_rel.r_type != MIPS_R_RELHI
1534 && int_rel.r_type != MIPS_R_RELLO)))
1537 struct ecoff_value_adjust *a;
1539 /* We need to get the addend so that we know whether we need
1540 to adjust the address. */
1541 BFD_ASSERT (int_rel.r_type == MIPS_R_REFWORD);
1543 adr = bfd_get_32 (input_bfd,
1547 - input_section->vma));
1549 for (a = ecoff_data (input_bfd)->debug_info.adjust;
1550 a != (struct ecoff_value_adjust *) NULL;
1553 if (adr >= a->start && adr < a->end)
1554 addend += a->adjust;
1558 if (info->relocateable)
1560 /* We are generating relocateable output, and must convert
1561 the existing reloc. */
1562 if (int_rel.r_extern)
1564 if ((h->root.type == bfd_link_hash_defined
1565 || h->root.type == bfd_link_hash_defweak)
1566 && ! bfd_is_abs_section (h->root.u.def.section))
1570 /* This symbol is defined in the output. Convert
1571 the reloc from being against the symbol to being
1572 against the section. */
1574 /* Clear the r_extern bit. */
1575 int_rel.r_extern = 0;
1577 /* Compute a new r_symndx value. */
1578 s = h->root.u.def.section;
1579 name = bfd_get_section_name (output_bfd,
1582 int_rel.r_symndx = -1;
1586 if (strcmp (name, ".bss") == 0)
1587 int_rel.r_symndx = RELOC_SECTION_BSS;
1590 if (strcmp (name, ".data") == 0)
1591 int_rel.r_symndx = RELOC_SECTION_DATA;
1594 if (strcmp (name, ".fini") == 0)
1595 int_rel.r_symndx = RELOC_SECTION_FINI;
1598 if (strcmp (name, ".init") == 0)
1599 int_rel.r_symndx = RELOC_SECTION_INIT;
1602 if (strcmp (name, ".lit8") == 0)
1603 int_rel.r_symndx = RELOC_SECTION_LIT8;
1604 else if (strcmp (name, ".lit4") == 0)
1605 int_rel.r_symndx = RELOC_SECTION_LIT4;
1608 if (strcmp (name, ".rdata") == 0)
1609 int_rel.r_symndx = RELOC_SECTION_RDATA;
1612 if (strcmp (name, ".sdata") == 0)
1613 int_rel.r_symndx = RELOC_SECTION_SDATA;
1614 else if (strcmp (name, ".sbss") == 0)
1615 int_rel.r_symndx = RELOC_SECTION_SBSS;
1618 if (strcmp (name, ".text") == 0)
1619 int_rel.r_symndx = RELOC_SECTION_TEXT;
1623 if (int_rel.r_symndx == -1)
1626 /* Add the section VMA and the symbol value. */
1627 relocation = (h->root.u.def.value
1628 + s->output_section->vma
1629 + s->output_offset);
1631 /* For a PC relative relocation, the object file
1632 currently holds just the addend. We must adjust
1633 by the address to get the right value. */
1634 if (howto->pc_relative)
1636 relocation -= int_rel.r_vaddr - input_section->vma;
1638 /* If we are converting a RELHI or RELLO reloc
1639 from being against an external symbol to
1640 being against a section, we must put a
1641 special value into the r_offset field. This
1642 value is the old addend. The r_offset for
1643 both the RELHI and RELLO relocs are the same,
1644 and we set both when we see RELHI. */
1645 if (int_rel.r_type == MIPS_R_RELHI)
1649 addhi = bfd_get_32 (input_bfd,
1653 - input_section->vma));
1663 addlo = bfd_get_32 (input_bfd,
1666 + lo_int_rel.r_vaddr
1667 - input_section->vma));
1672 lo_int_rel.r_offset = addhi + addlo;
1675 int_rel.r_offset = addhi + addlo;
1683 /* Change the symndx value to the right one for the
1685 int_rel.r_symndx = h->indx;
1686 if (int_rel.r_symndx == -1)
1688 /* This symbol is not being written out. */
1689 if (! ((*info->callbacks->unattached_reloc)
1690 (info, h->root.root.string, input_bfd,
1692 int_rel.r_vaddr - input_section->vma)))
1694 int_rel.r_symndx = 0;
1701 /* This is a relocation against a section. Adjust the
1702 value by the amount the section moved. */
1703 relocation = (s->output_section->vma
1708 relocation += addend;
1711 /* Adjust a PC relative relocation by removing the reference
1712 to the original address in the section and including the
1713 reference to the new address. However, external RELHI
1714 and RELLO relocs are PC relative, but don't include any
1715 reference to the address. The addend is merely an
1717 if (howto->pc_relative
1718 && (! int_rel.r_extern
1719 || (int_rel.r_type != MIPS_R_RELHI
1720 && int_rel.r_type != MIPS_R_RELLO)))
1721 relocation -= (input_section->output_section->vma
1722 + input_section->output_offset
1723 - input_section->vma);
1725 /* Adjust the contents. */
1726 if (relocation == 0)
1730 if (int_rel.r_type != MIPS_R_REFHI
1731 && int_rel.r_type != MIPS_R_RELHI)
1732 r = _bfd_relocate_contents (howto, input_bfd, relocation,
1736 - input_section->vma));
1739 mips_relocate_hi (&int_rel,
1740 use_lo ? &lo_int_rel : NULL,
1741 input_bfd, input_section, contents,
1743 int_rel.r_type == MIPS_R_RELHI);
1748 /* Adjust the reloc address. */
1749 int_rel.r_vaddr += (input_section->output_section->vma
1750 + input_section->output_offset
1751 - input_section->vma);
1753 /* Save the changed reloc information. */
1754 mips_ecoff_swap_reloc_out (input_bfd, &int_rel, (PTR) ext_rel);
1758 /* We are producing a final executable. */
1759 if (int_rel.r_extern)
1761 /* This is a reloc against a symbol. */
1762 if (h->root.type == bfd_link_hash_defined
1763 || h->root.type == bfd_link_hash_defweak)
1767 hsec = h->root.u.def.section;
1768 relocation = (h->root.u.def.value
1769 + hsec->output_section->vma
1770 + hsec->output_offset);
1774 if (! ((*info->callbacks->undefined_symbol)
1775 (info, h->root.root.string, input_bfd,
1777 int_rel.r_vaddr - input_section->vma)))
1784 /* This is a reloc against a section. */
1785 relocation = (s->output_section->vma
1789 /* A PC relative reloc is already correct in the object
1790 file. Make it look like a pcrel_offset relocation by
1791 adding in the start address. */
1792 if (howto->pc_relative)
1794 if (int_rel.r_type != MIPS_R_RELHI || ! use_lo)
1795 relocation += int_rel.r_vaddr + adjust;
1797 relocation += lo_int_rel.r_vaddr + adjust;
1801 if (int_rel.r_type != MIPS_R_REFHI
1802 && int_rel.r_type != MIPS_R_RELHI)
1803 r = _bfd_final_link_relocate (howto,
1808 - input_section->vma
1814 mips_relocate_hi (&int_rel,
1815 use_lo ? &lo_int_rel : NULL,
1816 input_bfd, input_section, contents, adjust,
1818 int_rel.r_type == MIPS_R_RELHI);
1823 /* MIPS_R_JMPADDR requires peculiar overflow detection. The
1824 instruction provides a 28 bit address (the two lower bits are
1825 implicit zeroes) which is combined with the upper four bits
1826 of the instruction address. */
1827 if (r == bfd_reloc_ok
1828 && int_rel.r_type == MIPS_R_JMPADDR
1831 + (int_rel.r_extern ? 0 : s->vma))
1833 != ((input_section->output_section->vma
1834 + input_section->output_offset
1835 + (int_rel.r_vaddr - input_section->vma)
1838 r = bfd_reloc_overflow;
1840 if (r != bfd_reloc_ok)
1845 case bfd_reloc_outofrange:
1847 case bfd_reloc_overflow:
1851 if (int_rel.r_extern)
1852 name = h->root.root.string;
1854 name = bfd_section_name (input_bfd, s);
1855 if (! ((*info->callbacks->reloc_overflow)
1856 (info, name, howto->name, (bfd_vma) 0,
1857 input_bfd, input_section,
1858 int_rel.r_vaddr - input_section->vma)))
1869 /* Read in the relocs for a section. */
1872 mips_read_relocs (abfd, sec)
1876 struct ecoff_section_tdata *section_tdata;
1878 section_tdata = ecoff_section_data (abfd, sec);
1879 if (section_tdata == (struct ecoff_section_tdata *) NULL)
1882 (PTR) bfd_alloc (abfd, sizeof (struct ecoff_section_tdata));
1883 if (sec->used_by_bfd == NULL)
1886 section_tdata = ecoff_section_data (abfd, sec);
1887 section_tdata->external_relocs = NULL;
1888 section_tdata->contents = NULL;
1889 section_tdata->offsets = NULL;
1892 if (section_tdata->external_relocs == NULL)
1894 bfd_size_type external_relocs_size;
1896 external_relocs_size = (ecoff_backend (abfd)->external_reloc_size
1897 * sec->reloc_count);
1899 section_tdata->external_relocs =
1900 (PTR) bfd_alloc (abfd, external_relocs_size);
1901 if (section_tdata->external_relocs == NULL && external_relocs_size != 0)
1904 if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
1905 || (bfd_read (section_tdata->external_relocs, 1,
1906 external_relocs_size, abfd)
1907 != external_relocs_size))
1914 /* Relax a section when linking a MIPS ECOFF file. This is used for
1915 embedded PIC code, which always uses PC relative branches which
1916 only have an 18 bit range on MIPS. If a branch is not in range, we
1917 generate a long instruction sequence to compensate. Each time we
1918 find a branch to expand, we have to check all the others again to
1919 make sure they are still in range. This is slow, but it only has
1920 to be done when -relax is passed to the linker.
1922 This routine figures out which branches need to expand; the actual
1923 expansion is done in mips_relocate_section when the section
1924 contents are relocated. The information is stored in the offsets
1925 field of the ecoff_section_tdata structure. An offset of 1 means
1926 that the branch must be expanded into a multi-instruction PC
1927 relative branch (such an offset will only occur for a PC relative
1928 branch to an external symbol). Any other offset must be a multiple
1929 of four, and is the amount to change the branch by (such an offset
1930 will only occur for a PC relative branch within the same section).
1932 We do not modify the section relocs or contents themselves so that
1933 if memory usage becomes an issue we can discard them and read them
1934 again. The only information we must save in memory between this
1935 routine and the mips_relocate_section routine is the table of
1939 mips_relax_section (abfd, sec, info, again)
1942 struct bfd_link_info *info;
1945 struct ecoff_section_tdata *section_tdata;
1946 bfd_byte *contents = NULL;
1948 struct external_reloc *ext_rel;
1949 struct external_reloc *ext_rel_end;
1952 /* Assume we are not going to need another pass. */
1955 /* If we are not generating an ECOFF file, this is much too
1956 confusing to deal with. */
1957 if (info->hash->creator->flavour != bfd_get_flavour (abfd))
1960 /* If there are no relocs, there is nothing to do. */
1961 if (sec->reloc_count == 0)
1964 /* We are only interested in PC relative relocs, and why would there
1965 ever be one from anything but the .text section? */
1966 if (strcmp (bfd_get_section_name (abfd, sec), ".text") != 0)
1969 /* Read in the relocs, if we haven't already got them. */
1970 section_tdata = ecoff_section_data (abfd, sec);
1971 if (section_tdata == (struct ecoff_section_tdata *) NULL
1972 || section_tdata->external_relocs == NULL)
1974 if (! mips_read_relocs (abfd, sec))
1976 section_tdata = ecoff_section_data (abfd, sec);
1979 if (sec->_cooked_size == 0)
1981 /* We must initialize _cooked_size only the first time we are
1983 sec->_cooked_size = sec->_raw_size;
1986 contents = section_tdata->contents;
1987 offsets = section_tdata->offsets;
1989 /* Look for any external PC relative relocs. Internal PC relative
1990 relocs are already correct in the object file, so they certainly
1991 can not overflow. */
1992 ext_rel = (struct external_reloc *) section_tdata->external_relocs;
1993 ext_rel_end = ext_rel + sec->reloc_count;
1994 for (i = 0; ext_rel < ext_rel_end; ext_rel++, i++)
1996 struct internal_reloc int_rel;
1997 struct ecoff_link_hash_entry *h;
1999 bfd_signed_vma relocation;
2000 struct external_reloc *adj_ext_rel;
2002 unsigned long ext_count;
2003 struct ecoff_link_hash_entry **adj_h_ptr;
2004 struct ecoff_link_hash_entry **adj_h_ptr_end;
2005 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 ((size_t) 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 = sec->reloc_count * sizeof (long);
2118 offsets = (long *) bfd_alloc (abfd, size);
2119 if (offsets == (long *) NULL)
2121 memset (offsets, 0, size);
2122 section_tdata->offsets = offsets;
2127 /* Now look for all PC relative references that cross this reloc
2128 and adjust their offsets. */
2129 adj_ext_rel = (struct external_reloc *) section_tdata->external_relocs;
2130 for (adj_i = 0; adj_ext_rel < ext_rel_end; adj_ext_rel++, adj_i++)
2132 struct internal_reloc adj_int_rel;
2133 bfd_vma start, stop;
2136 mips_ecoff_swap_reloc_in (abfd, (PTR) adj_ext_rel, &adj_int_rel);
2138 if (adj_int_rel.r_type == MIPS_R_PCREL16)
2142 /* We only care about local references. External ones
2143 will be relocated correctly anyhow. */
2144 if (adj_int_rel.r_extern)
2147 /* We are only interested in a PC relative reloc within
2148 this section. FIXME: Cross section PC relative
2149 relocs may not be handled correctly; does anybody
2151 if (adj_int_rel.r_symndx != RELOC_SECTION_TEXT)
2154 start = adj_int_rel.r_vaddr;
2156 insn = bfd_get_32 (abfd,
2157 contents + adj_int_rel.r_vaddr - sec->vma);
2159 stop = (insn & 0xffff) << 2;
2160 if ((stop & 0x20000) != 0)
2162 stop += adj_int_rel.r_vaddr + 4;
2164 else if (adj_int_rel.r_type == MIPS_R_RELHI)
2166 struct internal_reloc rello;
2169 /* The next reloc must be MIPS_R_RELLO, and we handle
2171 BFD_ASSERT (adj_ext_rel + 1 < ext_rel_end);
2173 mips_ecoff_swap_reloc_in (abfd, (PTR) (adj_ext_rel + 1), &rello);
2175 BFD_ASSERT (rello.r_type == MIPS_R_RELLO);
2177 addhi = bfd_get_32 (abfd,
2178 contents + adj_int_rel.r_vaddr - sec->vma);
2184 addlo = bfd_get_32 (abfd, contents + rello.r_vaddr - sec->vma);
2189 if (adj_int_rel.r_extern)
2191 /* The value we want here is
2192 sym - RELLOaddr + addend
2193 which we can express as
2194 sym - (RELLOaddr - addend)
2195 Therefore if we are expanding the area between
2196 RELLOaddr and RELLOaddr - addend we must adjust
2197 the addend. This is admittedly ambiguous, since
2198 we might mean (sym + addend) - RELLOaddr, but in
2199 practice we don't, and there is no way to handle
2200 that case correctly since at this point we have
2201 no idea whether any reloc is being expanded
2202 between sym and sym + addend. */
2203 start = rello.r_vaddr - (addhi + addlo);
2204 stop = rello.r_vaddr;
2208 /* An internal RELHI/RELLO pair represents the
2209 difference between two addresses, $LC0 - foo.
2210 The symndx value is actually the difference
2211 between the reloc address and $LC0. This lets us
2212 compute $LC0, and, by considering the addend,
2213 foo. If the reloc we are expanding falls between
2214 those two relocs, we must adjust the addend. At
2215 this point, the symndx value is actually in the
2216 r_offset field, where it was put by
2217 mips_ecoff_swap_reloc_in. */
2218 start = rello.r_vaddr - adj_int_rel.r_offset;
2219 stop = start + addhi + addlo;
2222 else if (adj_int_rel.r_type == MIPS_R_SWITCH)
2224 /* A MIPS_R_SWITCH reloc represents a word of the form
2226 The value in the object file is correct, assuming the
2227 original value of $L3. The symndx value is actually
2228 the difference between the reloc address and $LS12.
2229 This lets us compute the original value of $LS12 as
2231 and the original value of $L3 as
2232 vaddr - symndx + addend
2233 where addend is the value from the object file. At
2234 this point, the symndx value is actually found in the
2235 r_offset field, since it was moved by
2236 mips_ecoff_swap_reloc_in. */
2237 start = adj_int_rel.r_vaddr - adj_int_rel.r_offset;
2238 stop = start + bfd_get_32 (abfd,
2240 + adj_int_rel.r_vaddr
2246 /* If the range expressed by this reloc, which is the
2247 distance between START and STOP crosses the reloc we are
2248 expanding, we must adjust the offset. The sign of the
2249 adjustment depends upon the direction in which the range
2250 crosses the reloc being expanded. */
2251 if (start <= int_rel.r_vaddr && stop > int_rel.r_vaddr)
2252 change = PCREL16_EXPANSION_ADJUSTMENT;
2253 else if (start > int_rel.r_vaddr && stop <= int_rel.r_vaddr)
2254 change = - PCREL16_EXPANSION_ADJUSTMENT;
2258 offsets[adj_i] += change;
2260 if (adj_int_rel.r_type == MIPS_R_RELHI)
2264 offsets[adj_i] += change;
2268 /* Find all symbols in this section defined by this object file
2269 and adjust their values. Note that we decide whether to
2270 adjust the value based on the value stored in the ECOFF EXTR
2271 structure, because the value stored in the hash table may
2272 have been changed by an earlier expanded reloc and thus may
2273 no longer correctly indicate whether the symbol is before or
2274 after the expanded reloc. */
2275 ext_count = ecoff_data (abfd)->debug_info.symbolic_header.iextMax;
2276 adj_h_ptr = ecoff_data (abfd)->sym_hashes;
2277 adj_h_ptr_end = adj_h_ptr + ext_count;
2278 for (; adj_h_ptr < adj_h_ptr_end; adj_h_ptr++)
2280 struct ecoff_link_hash_entry *adj_h;
2283 if (adj_h != (struct ecoff_link_hash_entry *) NULL
2284 && (adj_h->root.type == bfd_link_hash_defined
2285 || adj_h->root.type == bfd_link_hash_defweak)
2286 && adj_h->root.u.def.section == sec
2287 && adj_h->esym.asym.value > int_rel.r_vaddr)
2288 adj_h->root.u.def.value += PCREL16_EXPANSION_ADJUSTMENT;
2291 /* Add an entry to the symbol value adjust list. This is used
2292 by bfd_ecoff_debug_accumulate to adjust the values of
2293 internal symbols and FDR's. */
2294 adjust = ((struct ecoff_value_adjust *)
2295 bfd_alloc (abfd, sizeof (struct ecoff_value_adjust)));
2296 if (adjust == (struct ecoff_value_adjust *) NULL)
2299 adjust->start = int_rel.r_vaddr;
2300 adjust->end = sec->vma + sec->_raw_size;
2301 adjust->adjust = PCREL16_EXPANSION_ADJUSTMENT;
2303 adjust->next = ecoff_data (abfd)->debug_info.adjust;
2304 ecoff_data (abfd)->debug_info.adjust = adjust;
2307 if (contents != (bfd_byte *) NULL && ! info->keep_memory)
2313 if (contents != (bfd_byte *) NULL && ! info->keep_memory)
2318 /* This routine is called from mips_relocate_section when a PC
2319 relative reloc must be expanded into the five instruction sequence.
2320 It handles all the details of the expansion, including resolving
2324 mips_relax_pcrel16 (info, input_bfd, input_section, h, location, address)
2325 struct bfd_link_info *info;
2327 asection *input_section;
2328 struct ecoff_link_hash_entry *h;
2334 /* 0x0411ffff is bgezal $0,. == bal . */
2335 BFD_ASSERT (bfd_get_32 (input_bfd, location) == 0x0411ffff);
2337 /* We need to compute the distance between the symbol and the
2338 current address plus eight. */
2339 relocation = (h->root.u.def.value
2340 + h->root.u.def.section->output_section->vma
2341 + h->root.u.def.section->output_offset);
2342 relocation -= address + 8;
2344 /* If the lower half is negative, increment the upper 16 half. */
2345 if ((relocation & 0x8000) != 0)
2346 relocation += 0x10000;
2348 bfd_put_32 (input_bfd, 0x04110001, location); /* bal .+8 */
2349 bfd_put_32 (input_bfd,
2350 0x3c010000 | ((relocation >> 16) & 0xffff), /* lui $at,XX */
2352 bfd_put_32 (input_bfd,
2353 0x24210000 | (relocation & 0xffff), /* addiu $at,$at,XX */
2355 bfd_put_32 (input_bfd, 0x003f0821, location + 12); /* addu $at,$at,$ra */
2356 bfd_put_32 (input_bfd, 0x0020f809, location + 16); /* jalr $at */
2361 /* Given a .sdata section and a .rel.sdata in-memory section, store
2362 relocation information into the .rel.sdata section which can be
2363 used at runtime to relocate the section. This is called by the
2364 linker when the --embedded-relocs switch is used. This is called
2365 after the add_symbols entry point has been called for all the
2366 objects, and before the final_link entry point is called. This
2367 function presumes that the object was compiled using
2371 bfd_mips_ecoff_create_embedded_relocs (abfd, info, datasec, relsec, errmsg)
2373 struct bfd_link_info *info;
2378 struct ecoff_link_hash_entry **sym_hashes;
2379 struct ecoff_section_tdata *section_tdata;
2380 struct external_reloc *ext_rel;
2381 struct external_reloc *ext_rel_end;
2384 BFD_ASSERT (! info->relocateable);
2388 if (datasec->reloc_count == 0)
2391 sym_hashes = ecoff_data (abfd)->sym_hashes;
2393 if (! mips_read_relocs (abfd, datasec))
2396 relsec->contents = (bfd_byte *) bfd_alloc (abfd, datasec->reloc_count * 4);
2397 if (relsec->contents == NULL)
2400 p = relsec->contents;
2402 section_tdata = ecoff_section_data (abfd, datasec);
2403 ext_rel = (struct external_reloc *) section_tdata->external_relocs;
2404 ext_rel_end = ext_rel + datasec->reloc_count;
2405 for (; ext_rel < ext_rel_end; ext_rel++, p += 4)
2407 struct internal_reloc int_rel;
2408 boolean text_relative;
2410 mips_ecoff_swap_reloc_in (abfd, (PTR) ext_rel, &int_rel);
2412 /* We are going to write a four byte word into the runtime reloc
2413 section. The word will be the address in the data section
2414 which must be relocated. This must be on a word boundary,
2415 which means the lower two bits must be zero. We use the
2416 least significant bit to indicate how the value in the data
2417 section must be relocated. A 0 means that the value is
2418 relative to the text section, while a 1 indicates that the
2419 value is relative to the data section. Given that we are
2420 assuming the code was compiled using -membedded-pic, there
2421 should not be any other possibilities. */
2423 /* We can only relocate REFWORD relocs at run time. */
2424 if (int_rel.r_type != MIPS_R_REFWORD)
2426 *errmsg = "unsupported reloc type";
2427 bfd_set_error (bfd_error_bad_value);
2431 if (int_rel.r_extern)
2433 struct ecoff_link_hash_entry *h;
2435 h = sym_hashes[int_rel.r_symndx];
2436 /* If h is NULL, that means that there is a reloc against an
2437 external symbol which we thought was just a debugging
2438 symbol. This should not happen. */
2439 if (h == (struct ecoff_link_hash_entry *) NULL)
2441 if ((h->root.type == bfd_link_hash_defined
2442 || h->root.type == bfd_link_hash_defweak)
2443 && (h->root.u.def.section->flags & SEC_CODE) != 0)
2444 text_relative = true;
2446 text_relative = false;
2450 switch (int_rel.r_symndx)
2452 case RELOC_SECTION_TEXT:
2453 text_relative = true;
2455 case RELOC_SECTION_SDATA:
2456 case RELOC_SECTION_SBSS:
2457 case RELOC_SECTION_LIT8:
2458 text_relative = false;
2461 /* No other sections should appear in -membedded-pic
2463 *errmsg = "reloc against unsupported section";
2464 bfd_set_error (bfd_error_bad_value);
2469 if ((int_rel.r_offset & 3) != 0)
2471 *errmsg = "reloc not properly aligned";
2472 bfd_set_error (bfd_error_bad_value);
2477 (int_rel.r_vaddr - datasec->vma + datasec->output_offset
2478 + (text_relative ? 0 : 1)),
2485 /* This is the ECOFF backend structure. The backend field of the
2486 target vector points to this. */
2488 static const struct ecoff_backend_data mips_ecoff_backend_data =
2490 /* COFF backend structure. */
2492 (void (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR))) bfd_void, /* aux_in */
2493 (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_in */
2494 (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_in */
2495 (unsigned (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR)))bfd_void,/*aux_out*/
2496 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_out */
2497 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_out */
2498 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* reloc_out */
2499 mips_ecoff_swap_filehdr_out, mips_ecoff_swap_aouthdr_out,
2500 mips_ecoff_swap_scnhdr_out,
2501 FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, 0, true, false, 4,
2502 mips_ecoff_swap_filehdr_in, mips_ecoff_swap_aouthdr_in,
2503 mips_ecoff_swap_scnhdr_in, NULL,
2504 mips_ecoff_bad_format_hook, _bfd_ecoff_set_arch_mach_hook,
2505 _bfd_ecoff_mkobject_hook, _bfd_ecoff_styp_to_sec_flags,
2506 _bfd_ecoff_set_alignment_hook, _bfd_ecoff_slurp_symbol_table,
2507 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
2509 /* Supported architecture. */
2511 /* Initial portion of armap string. */
2513 /* The page boundary used to align sections in a demand-paged
2514 executable file. E.g., 0x1000. */
2516 /* True if the .rdata section is part of the text segment, as on the
2517 Alpha. False if .rdata is part of the data segment, as on the
2520 /* Bitsize of constructor entries. */
2522 /* Reloc to use for constructor entries. */
2523 &mips_howto_table[MIPS_R_REFWORD],
2525 /* Symbol table magic number. */
2527 /* Alignment of debugging information. E.g., 4. */
2529 /* Sizes of external symbolic information. */
2530 sizeof (struct hdr_ext),
2531 sizeof (struct dnr_ext),
2532 sizeof (struct pdr_ext),
2533 sizeof (struct sym_ext),
2534 sizeof (struct opt_ext),
2535 sizeof (struct fdr_ext),
2536 sizeof (struct rfd_ext),
2537 sizeof (struct ext_ext),
2538 /* Functions to swap in external symbolic data. */
2547 _bfd_ecoff_swap_tir_in,
2548 _bfd_ecoff_swap_rndx_in,
2549 /* Functions to swap out external symbolic data. */
2558 _bfd_ecoff_swap_tir_out,
2559 _bfd_ecoff_swap_rndx_out,
2560 /* Function to read in symbolic data. */
2561 _bfd_ecoff_slurp_symbolic_info
2563 /* External reloc size. */
2565 /* Reloc swapping functions. */
2566 mips_ecoff_swap_reloc_in,
2567 mips_ecoff_swap_reloc_out,
2568 /* Backend reloc tweaking. */
2569 mips_adjust_reloc_in,
2570 mips_adjust_reloc_out,
2571 /* Relocate section contents while linking. */
2572 mips_relocate_section,
2573 /* Do final adjustments to filehdr and aouthdr. */
2575 /* Read an element from an archive at a given file position. */
2576 _bfd_get_elt_at_filepos
2579 /* Looking up a reloc type is MIPS specific. */
2580 #define _bfd_ecoff_bfd_reloc_type_lookup mips_bfd_reloc_type_lookup
2582 /* Getting relocated section contents is generic. */
2583 #define _bfd_ecoff_bfd_get_relocated_section_contents \
2584 bfd_generic_get_relocated_section_contents
2586 /* Handling file windows is generic. */
2587 #define _bfd_ecoff_get_section_contents_in_window \
2588 _bfd_generic_get_section_contents_in_window
2590 /* Relaxing sections is MIPS specific. */
2591 #define _bfd_ecoff_bfd_relax_section mips_relax_section
2593 const bfd_target ecoff_little_vec =
2595 "ecoff-littlemips", /* name */
2596 bfd_target_ecoff_flavour,
2597 BFD_ENDIAN_LITTLE, /* data byte order is little */
2598 BFD_ENDIAN_LITTLE, /* header byte order is little */
2600 (HAS_RELOC | EXEC_P | /* object flags */
2601 HAS_LINENO | HAS_DEBUG |
2602 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
2604 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
2605 0, /* leading underscore */
2606 ' ', /* ar_pad_char */
2607 15, /* ar_max_namelen */
2608 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2609 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2610 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2611 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2612 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2613 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
2615 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
2616 _bfd_ecoff_archive_p, _bfd_dummy_target},
2617 {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
2618 _bfd_generic_mkarchive, bfd_false},
2619 {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
2620 _bfd_write_archive_contents, bfd_false},
2622 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
2623 BFD_JUMP_TABLE_COPY (_bfd_ecoff),
2624 BFD_JUMP_TABLE_CORE (_bfd_nocore),
2625 BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
2626 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
2627 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
2628 BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
2629 BFD_JUMP_TABLE_LINK (_bfd_ecoff),
2630 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2632 (PTR) &mips_ecoff_backend_data
2635 const bfd_target ecoff_big_vec =
2637 "ecoff-bigmips", /* name */
2638 bfd_target_ecoff_flavour,
2639 BFD_ENDIAN_BIG, /* data byte order is big */
2640 BFD_ENDIAN_BIG, /* header byte order is big */
2642 (HAS_RELOC | EXEC_P | /* object flags */
2643 HAS_LINENO | HAS_DEBUG |
2644 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
2646 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
2647 0, /* leading underscore */
2648 ' ', /* ar_pad_char */
2649 15, /* ar_max_namelen */
2650 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2651 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2652 bfd_getb16, bfd_getb_signed_16, bfd_putb16,
2653 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2654 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2655 bfd_getb16, bfd_getb_signed_16, bfd_putb16,
2656 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
2657 _bfd_ecoff_archive_p, _bfd_dummy_target},
2658 {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
2659 _bfd_generic_mkarchive, bfd_false},
2660 {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
2661 _bfd_write_archive_contents, bfd_false},
2663 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
2664 BFD_JUMP_TABLE_COPY (_bfd_ecoff),
2665 BFD_JUMP_TABLE_CORE (_bfd_nocore),
2666 BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
2667 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
2668 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
2669 BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
2670 BFD_JUMP_TABLE_LINK (_bfd_ecoff),
2671 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2673 (PTR) &mips_ecoff_backend_data
2676 const bfd_target ecoff_biglittle_vec =
2678 "ecoff-biglittlemips", /* name */
2679 bfd_target_ecoff_flavour,
2680 BFD_ENDIAN_LITTLE, /* data byte order is little */
2681 BFD_ENDIAN_BIG, /* header byte order is big */
2683 (HAS_RELOC | EXEC_P | /* object flags */
2684 HAS_LINENO | HAS_DEBUG |
2685 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
2687 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
2688 0, /* leading underscore */
2689 ' ', /* ar_pad_char */
2690 15, /* ar_max_namelen */
2691 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2692 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2693 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2694 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2695 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2696 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
2698 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
2699 _bfd_ecoff_archive_p, _bfd_dummy_target},
2700 {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
2701 _bfd_generic_mkarchive, bfd_false},
2702 {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
2703 _bfd_write_archive_contents, bfd_false},
2705 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
2706 BFD_JUMP_TABLE_COPY (_bfd_ecoff),
2707 BFD_JUMP_TABLE_CORE (_bfd_nocore),
2708 BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
2709 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
2710 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
2711 BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
2712 BFD_JUMP_TABLE_LINK (_bfd_ecoff),
2713 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2715 (PTR) &mips_ecoff_backend_data