daily update
[binutils.git] / bfd / coff-mips.c
blob6b01d44ec91822d15f1a952df40850ec67d8e9f6
1 /* BFD back-end for MIPS Extended-Coff files.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2007
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 3 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., 51 Franklin Street - Fifth Floor, Boston,
23 MA 02110-1301, USA. */
25 #include "sysdep.h"
26 #include "bfd.h"
27 #include "bfdlink.h"
28 #include "libbfd.h"
29 #include "coff/internal.h"
30 #include "coff/sym.h"
31 #include "coff/symconst.h"
32 #include "coff/ecoff.h"
33 #include "coff/mips.h"
34 #include "libcoff.h"
35 #include "libecoff.h"
37 /* Prototypes for static functions. */
39 static bfd_boolean mips_ecoff_bad_format_hook
40 PARAMS ((bfd *abfd, PTR filehdr));
41 static void mips_ecoff_swap_reloc_in
42 PARAMS ((bfd *, PTR, struct internal_reloc *));
43 static void mips_ecoff_swap_reloc_out
44 PARAMS ((bfd *, const struct internal_reloc *, PTR));
45 static void mips_adjust_reloc_in
46 PARAMS ((bfd *, const struct internal_reloc *, arelent *));
47 static void mips_adjust_reloc_out
48 PARAMS ((bfd *, const arelent *, struct internal_reloc *));
49 static bfd_reloc_status_type mips_generic_reloc
50 PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,
51 asection *section, bfd *output_bfd, char **error));
52 static bfd_reloc_status_type mips_refhi_reloc
53 PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,
54 asection *section, bfd *output_bfd, char **error));
55 static bfd_reloc_status_type mips_reflo_reloc
56 PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,
57 asection *section, bfd *output_bfd, char **error));
58 static bfd_reloc_status_type mips_gprel_reloc
59 PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,
60 asection *section, bfd *output_bfd, char **error));
61 static void mips_relocate_hi
62 PARAMS ((struct internal_reloc *refhi, struct internal_reloc *reflo,
63 bfd *input_bfd, asection *input_section, bfd_byte *contents,
64 bfd_vma relocation));
65 static bfd_boolean mips_relocate_section
66 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, PTR));
67 static reloc_howto_type *mips_bfd_reloc_type_lookup
68 PARAMS ((bfd *, bfd_reloc_code_real_type));
70 /* ECOFF has COFF sections, but the debugging information is stored in
71 a completely different format. ECOFF targets use some of the
72 swapping routines from coffswap.h, and some of the generic COFF
73 routines in coffgen.c, but, unlike the real COFF targets, do not
74 use coffcode.h itself.
76 Get the generic COFF swapping routines, except for the reloc,
77 symbol, and lineno ones. Give them ECOFF names. */
78 #define MIPSECOFF
79 #define NO_COFF_RELOCS
80 #define NO_COFF_SYMBOLS
81 #define NO_COFF_LINENOS
82 #define coff_swap_filehdr_in mips_ecoff_swap_filehdr_in
83 #define coff_swap_filehdr_out mips_ecoff_swap_filehdr_out
84 #define coff_swap_aouthdr_in mips_ecoff_swap_aouthdr_in
85 #define coff_swap_aouthdr_out mips_ecoff_swap_aouthdr_out
86 #define coff_swap_scnhdr_in mips_ecoff_swap_scnhdr_in
87 #define coff_swap_scnhdr_out mips_ecoff_swap_scnhdr_out
88 #include "coffswap.h"
90 /* Get the ECOFF swapping routines. */
91 #define ECOFF_32
92 #include "ecoffswap.h"
94 /* How to process the various relocs types. */
96 static reloc_howto_type mips_howto_table[] =
98 /* Reloc type 0 is ignored. The reloc reading code ensures that
99 this is a reference to the .abs section, which will cause
100 bfd_perform_relocation to do nothing. */
101 HOWTO (MIPS_R_IGNORE, /* type */
102 0, /* rightshift */
103 0, /* size (0 = byte, 1 = short, 2 = long) */
104 8, /* bitsize */
105 FALSE, /* pc_relative */
106 0, /* bitpos */
107 complain_overflow_dont, /* complain_on_overflow */
108 0, /* special_function */
109 "IGNORE", /* name */
110 FALSE, /* partial_inplace */
111 0, /* src_mask */
112 0, /* dst_mask */
113 FALSE), /* pcrel_offset */
115 /* A 16 bit reference to a symbol, normally from a data section. */
116 HOWTO (MIPS_R_REFHALF, /* type */
117 0, /* rightshift */
118 1, /* size (0 = byte, 1 = short, 2 = long) */
119 16, /* bitsize */
120 FALSE, /* pc_relative */
121 0, /* bitpos */
122 complain_overflow_bitfield, /* complain_on_overflow */
123 mips_generic_reloc, /* special_function */
124 "REFHALF", /* name */
125 TRUE, /* partial_inplace */
126 0xffff, /* src_mask */
127 0xffff, /* dst_mask */
128 FALSE), /* pcrel_offset */
130 /* A 32 bit reference to a symbol, normally from a data section. */
131 HOWTO (MIPS_R_REFWORD, /* type */
132 0, /* rightshift */
133 2, /* size (0 = byte, 1 = short, 2 = long) */
134 32, /* bitsize */
135 FALSE, /* pc_relative */
136 0, /* bitpos */
137 complain_overflow_bitfield, /* complain_on_overflow */
138 mips_generic_reloc, /* special_function */
139 "REFWORD", /* name */
140 TRUE, /* partial_inplace */
141 0xffffffff, /* src_mask */
142 0xffffffff, /* dst_mask */
143 FALSE), /* pcrel_offset */
145 /* A 26 bit absolute jump address. */
146 HOWTO (MIPS_R_JMPADDR, /* type */
147 2, /* rightshift */
148 2, /* size (0 = byte, 1 = short, 2 = long) */
149 26, /* bitsize */
150 FALSE, /* pc_relative */
151 0, /* bitpos */
152 complain_overflow_dont, /* complain_on_overflow */
153 /* This needs complex overflow
154 detection, because the upper four
155 bits must match the PC. */
156 mips_generic_reloc, /* special_function */
157 "JMPADDR", /* name */
158 TRUE, /* partial_inplace */
159 0x3ffffff, /* src_mask */
160 0x3ffffff, /* dst_mask */
161 FALSE), /* pcrel_offset */
163 /* The high 16 bits of a symbol value. Handled by the function
164 mips_refhi_reloc. */
165 HOWTO (MIPS_R_REFHI, /* type */
166 16, /* rightshift */
167 2, /* size (0 = byte, 1 = short, 2 = long) */
168 16, /* bitsize */
169 FALSE, /* pc_relative */
170 0, /* bitpos */
171 complain_overflow_bitfield, /* complain_on_overflow */
172 mips_refhi_reloc, /* special_function */
173 "REFHI", /* name */
174 TRUE, /* partial_inplace */
175 0xffff, /* src_mask */
176 0xffff, /* dst_mask */
177 FALSE), /* pcrel_offset */
179 /* The low 16 bits of a symbol value. */
180 HOWTO (MIPS_R_REFLO, /* type */
181 0, /* rightshift */
182 2, /* size (0 = byte, 1 = short, 2 = long) */
183 16, /* bitsize */
184 FALSE, /* pc_relative */
185 0, /* bitpos */
186 complain_overflow_dont, /* complain_on_overflow */
187 mips_reflo_reloc, /* special_function */
188 "REFLO", /* name */
189 TRUE, /* partial_inplace */
190 0xffff, /* src_mask */
191 0xffff, /* dst_mask */
192 FALSE), /* pcrel_offset */
194 /* A reference to an offset from the gp register. Handled by the
195 function mips_gprel_reloc. */
196 HOWTO (MIPS_R_GPREL, /* type */
197 0, /* rightshift */
198 2, /* size (0 = byte, 1 = short, 2 = long) */
199 16, /* bitsize */
200 FALSE, /* pc_relative */
201 0, /* bitpos */
202 complain_overflow_signed, /* complain_on_overflow */
203 mips_gprel_reloc, /* special_function */
204 "GPREL", /* name */
205 TRUE, /* partial_inplace */
206 0xffff, /* src_mask */
207 0xffff, /* dst_mask */
208 FALSE), /* pcrel_offset */
210 /* A reference to a literal using an offset from the gp register.
211 Handled by the function mips_gprel_reloc. */
212 HOWTO (MIPS_R_LITERAL, /* type */
213 0, /* rightshift */
214 2, /* size (0 = byte, 1 = short, 2 = long) */
215 16, /* bitsize */
216 FALSE, /* pc_relative */
217 0, /* bitpos */
218 complain_overflow_signed, /* complain_on_overflow */
219 mips_gprel_reloc, /* special_function */
220 "LITERAL", /* name */
221 TRUE, /* partial_inplace */
222 0xffff, /* src_mask */
223 0xffff, /* dst_mask */
224 FALSE), /* pcrel_offset */
226 EMPTY_HOWTO (8),
227 EMPTY_HOWTO (9),
228 EMPTY_HOWTO (10),
229 EMPTY_HOWTO (11),
231 /* FIXME: This relocation is used (internally only) to represent branches
232 when assembling. It should never appear in output files, and
233 be removed. (It used to be used for embedded-PIC support.) */
234 HOWTO (MIPS_R_PCREL16, /* type */
235 2, /* rightshift */
236 2, /* size (0 = byte, 1 = short, 2 = long) */
237 16, /* bitsize */
238 TRUE, /* pc_relative */
239 0, /* bitpos */
240 complain_overflow_signed, /* complain_on_overflow */
241 mips_generic_reloc, /* special_function */
242 "PCREL16", /* name */
243 TRUE, /* partial_inplace */
244 0xffff, /* src_mask */
245 0xffff, /* dst_mask */
246 TRUE), /* pcrel_offset */
249 #define MIPS_HOWTO_COUNT \
250 (sizeof mips_howto_table / sizeof mips_howto_table[0])
252 /* See whether the magic number matches. */
254 static bfd_boolean
255 mips_ecoff_bad_format_hook (abfd, filehdr)
256 bfd *abfd;
257 PTR filehdr;
259 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
261 switch (internal_f->f_magic)
263 case MIPS_MAGIC_1:
264 /* I don't know what endianness this implies. */
265 return TRUE;
267 case MIPS_MAGIC_BIG:
268 case MIPS_MAGIC_BIG2:
269 case MIPS_MAGIC_BIG3:
270 return bfd_big_endian (abfd);
272 case MIPS_MAGIC_LITTLE:
273 case MIPS_MAGIC_LITTLE2:
274 case MIPS_MAGIC_LITTLE3:
275 return bfd_little_endian (abfd);
277 default:
278 return FALSE;
282 /* Reloc handling. MIPS ECOFF relocs are packed into 8 bytes in
283 external form. They use a bit which indicates whether the symbol
284 is external. */
286 /* Swap a reloc in. */
288 static void
289 mips_ecoff_swap_reloc_in (abfd, ext_ptr, intern)
290 bfd *abfd;
291 PTR ext_ptr;
292 struct internal_reloc *intern;
294 const RELOC *ext = (RELOC *) ext_ptr;
296 intern->r_vaddr = H_GET_32 (abfd, ext->r_vaddr);
297 if (bfd_header_big_endian (abfd))
299 intern->r_symndx = (((int) ext->r_bits[0]
300 << RELOC_BITS0_SYMNDX_SH_LEFT_BIG)
301 | ((int) ext->r_bits[1]
302 << RELOC_BITS1_SYMNDX_SH_LEFT_BIG)
303 | ((int) ext->r_bits[2]
304 << RELOC_BITS2_SYMNDX_SH_LEFT_BIG));
305 intern->r_type = ((ext->r_bits[3] & RELOC_BITS3_TYPE_BIG)
306 >> RELOC_BITS3_TYPE_SH_BIG);
307 intern->r_extern = (ext->r_bits[3] & RELOC_BITS3_EXTERN_BIG) != 0;
309 else
311 intern->r_symndx = (((int) ext->r_bits[0]
312 << RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE)
313 | ((int) ext->r_bits[1]
314 << RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE)
315 | ((int) ext->r_bits[2]
316 << RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE));
317 intern->r_type = (((ext->r_bits[3] & RELOC_BITS3_TYPE_LITTLE)
318 >> RELOC_BITS3_TYPE_SH_LITTLE)
319 | ((ext->r_bits[3] & RELOC_BITS3_TYPEHI_LITTLE)
320 << RELOC_BITS3_TYPEHI_SH_LITTLE));
321 intern->r_extern = (ext->r_bits[3] & RELOC_BITS3_EXTERN_LITTLE) != 0;
325 /* Swap a reloc out. */
327 static void
328 mips_ecoff_swap_reloc_out (abfd, intern, dst)
329 bfd *abfd;
330 const struct internal_reloc *intern;
331 PTR dst;
333 RELOC *ext = (RELOC *) dst;
334 long r_symndx;
336 BFD_ASSERT (intern->r_extern
337 || (intern->r_symndx >= 0 && intern->r_symndx <= 12));
339 r_symndx = intern->r_symndx;
341 H_PUT_32 (abfd, intern->r_vaddr, ext->r_vaddr);
342 if (bfd_header_big_endian (abfd))
344 ext->r_bits[0] = r_symndx >> RELOC_BITS0_SYMNDX_SH_LEFT_BIG;
345 ext->r_bits[1] = r_symndx >> RELOC_BITS1_SYMNDX_SH_LEFT_BIG;
346 ext->r_bits[2] = r_symndx >> RELOC_BITS2_SYMNDX_SH_LEFT_BIG;
347 ext->r_bits[3] = (((intern->r_type << RELOC_BITS3_TYPE_SH_BIG)
348 & RELOC_BITS3_TYPE_BIG)
349 | (intern->r_extern ? RELOC_BITS3_EXTERN_BIG : 0));
351 else
353 ext->r_bits[0] = r_symndx >> RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE;
354 ext->r_bits[1] = r_symndx >> RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE;
355 ext->r_bits[2] = r_symndx >> RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE;
356 ext->r_bits[3] = (((intern->r_type << RELOC_BITS3_TYPE_SH_LITTLE)
357 & RELOC_BITS3_TYPE_LITTLE)
358 | ((intern->r_type >> RELOC_BITS3_TYPEHI_SH_LITTLE
359 & RELOC_BITS3_TYPEHI_LITTLE))
360 | (intern->r_extern ? RELOC_BITS3_EXTERN_LITTLE : 0));
364 /* Finish canonicalizing a reloc. Part of this is generic to all
365 ECOFF targets, and that part is in ecoff.c. The rest is done in
366 this backend routine. It must fill in the howto field. */
368 static void
369 mips_adjust_reloc_in (abfd, intern, rptr)
370 bfd *abfd;
371 const struct internal_reloc *intern;
372 arelent *rptr;
374 if (intern->r_type > MIPS_R_PCREL16)
375 abort ();
377 if (! intern->r_extern
378 && (intern->r_type == MIPS_R_GPREL
379 || intern->r_type == MIPS_R_LITERAL))
380 rptr->addend += ecoff_data (abfd)->gp;
382 /* If the type is MIPS_R_IGNORE, make sure this is a reference to
383 the absolute section so that the reloc is ignored. */
384 if (intern->r_type == MIPS_R_IGNORE)
385 rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
387 rptr->howto = &mips_howto_table[intern->r_type];
390 /* Make any adjustments needed to a reloc before writing it out. None
391 are needed for MIPS. */
393 static void
394 mips_adjust_reloc_out (abfd, rel, intern)
395 bfd *abfd ATTRIBUTE_UNUSED;
396 const arelent *rel ATTRIBUTE_UNUSED;
397 struct internal_reloc *intern ATTRIBUTE_UNUSED;
401 /* ECOFF relocs are either against external symbols, or against
402 sections. If we are producing relocatable output, and the reloc
403 is against an external symbol, and nothing has given us any
404 additional addend, the resulting reloc will also be against the
405 same symbol. In such a case, we don't want to change anything
406 about the way the reloc is handled, since it will all be done at
407 final link time. Rather than put special case code into
408 bfd_perform_relocation, all the reloc types use this howto
409 function. It just short circuits the reloc if producing
410 relocatable output against an external symbol. */
412 static bfd_reloc_status_type
413 mips_generic_reloc (abfd,
414 reloc_entry,
415 symbol,
416 data,
417 input_section,
418 output_bfd,
419 error_message)
420 bfd *abfd ATTRIBUTE_UNUSED;
421 arelent *reloc_entry;
422 asymbol *symbol;
423 PTR data ATTRIBUTE_UNUSED;
424 asection *input_section;
425 bfd *output_bfd;
426 char **error_message ATTRIBUTE_UNUSED;
428 if (output_bfd != (bfd *) NULL
429 && (symbol->flags & BSF_SECTION_SYM) == 0
430 && reloc_entry->addend == 0)
432 reloc_entry->address += input_section->output_offset;
433 return bfd_reloc_ok;
436 return bfd_reloc_continue;
439 /* Do a REFHI relocation. This has to be done in combination with a
440 REFLO reloc, because there is a carry from the REFLO to the REFHI.
441 Here we just save the information we need; we do the actual
442 relocation when we see the REFLO. MIPS ECOFF requires that the
443 REFLO immediately follow the REFHI. As a GNU extension, we permit
444 an arbitrary number of HI relocs to be associated with a single LO
445 reloc. This extension permits gcc to output the HI and LO relocs
446 itself. */
448 struct mips_hi
450 struct mips_hi *next;
451 bfd_byte *addr;
452 bfd_vma addend;
455 /* FIXME: This should not be a static variable. */
457 static struct mips_hi *mips_refhi_list;
459 static bfd_reloc_status_type
460 mips_refhi_reloc (abfd,
461 reloc_entry,
462 symbol,
463 data,
464 input_section,
465 output_bfd,
466 error_message)
467 bfd *abfd ATTRIBUTE_UNUSED;
468 arelent *reloc_entry;
469 asymbol *symbol;
470 PTR data;
471 asection *input_section;
472 bfd *output_bfd;
473 char **error_message ATTRIBUTE_UNUSED;
475 bfd_reloc_status_type ret;
476 bfd_vma relocation;
477 struct mips_hi *n;
479 /* If we're relocating, and this an external symbol, we don't want
480 to change anything. */
481 if (output_bfd != (bfd *) NULL
482 && (symbol->flags & BSF_SECTION_SYM) == 0
483 && reloc_entry->addend == 0)
485 reloc_entry->address += input_section->output_offset;
486 return bfd_reloc_ok;
489 ret = bfd_reloc_ok;
490 if (bfd_is_und_section (symbol->section)
491 && output_bfd == (bfd *) NULL)
492 ret = bfd_reloc_undefined;
494 if (bfd_is_com_section (symbol->section))
495 relocation = 0;
496 else
497 relocation = symbol->value;
499 relocation += symbol->section->output_section->vma;
500 relocation += symbol->section->output_offset;
501 relocation += reloc_entry->addend;
503 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
504 return bfd_reloc_outofrange;
506 /* Save the information, and let REFLO do the actual relocation. */
507 n = (struct mips_hi *) bfd_malloc ((bfd_size_type) sizeof *n);
508 if (n == NULL)
509 return bfd_reloc_outofrange;
510 n->addr = (bfd_byte *) data + reloc_entry->address;
511 n->addend = relocation;
512 n->next = mips_refhi_list;
513 mips_refhi_list = n;
515 if (output_bfd != (bfd *) NULL)
516 reloc_entry->address += input_section->output_offset;
518 return ret;
521 /* Do a REFLO relocation. This is a straightforward 16 bit inplace
522 relocation; this function exists in order to do the REFHI
523 relocation described above. */
525 static bfd_reloc_status_type
526 mips_reflo_reloc (abfd,
527 reloc_entry,
528 symbol,
529 data,
530 input_section,
531 output_bfd,
532 error_message)
533 bfd *abfd;
534 arelent *reloc_entry;
535 asymbol *symbol;
536 PTR data;
537 asection *input_section;
538 bfd *output_bfd;
539 char **error_message;
541 if (mips_refhi_list != NULL)
543 struct mips_hi *l;
545 l = mips_refhi_list;
546 while (l != NULL)
548 unsigned long insn;
549 unsigned long val;
550 unsigned long vallo;
551 struct mips_hi *next;
553 /* Do the REFHI relocation. Note that we actually don't
554 need to know anything about the REFLO itself, except
555 where to find the low 16 bits of the addend needed by the
556 REFHI. */
557 insn = bfd_get_32 (abfd, l->addr);
558 vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
559 & 0xffff);
560 val = ((insn & 0xffff) << 16) + vallo;
561 val += l->addend;
563 /* The low order 16 bits are always treated as a signed
564 value. Therefore, a negative value in the low order bits
565 requires an adjustment in the high order bits. We need
566 to make this adjustment in two ways: once for the bits we
567 took from the data, and once for the bits we are putting
568 back in to the data. */
569 if ((vallo & 0x8000) != 0)
570 val -= 0x10000;
571 if ((val & 0x8000) != 0)
572 val += 0x10000;
574 insn = (insn &~ (unsigned) 0xffff) | ((val >> 16) & 0xffff);
575 bfd_put_32 (abfd, (bfd_vma) insn, l->addr);
577 next = l->next;
578 free (l);
579 l = next;
582 mips_refhi_list = NULL;
585 /* Now do the REFLO reloc in the usual way. */
586 return mips_generic_reloc (abfd, reloc_entry, symbol, data,
587 input_section, output_bfd, error_message);
590 /* Do a GPREL relocation. This is a 16 bit value which must become
591 the offset from the gp register. */
593 static bfd_reloc_status_type
594 mips_gprel_reloc (abfd,
595 reloc_entry,
596 symbol,
597 data,
598 input_section,
599 output_bfd,
600 error_message)
601 bfd *abfd;
602 arelent *reloc_entry;
603 asymbol *symbol;
604 PTR data;
605 asection *input_section;
606 bfd *output_bfd;
607 char **error_message;
609 bfd_boolean relocatable;
610 bfd_vma gp;
611 bfd_vma relocation;
612 unsigned long val;
613 unsigned long insn;
615 /* If we're relocating, and this is an external symbol with no
616 addend, we don't want to change anything. We will only have an
617 addend if this is a newly created reloc, not read from an ECOFF
618 file. */
619 if (output_bfd != (bfd *) NULL
620 && (symbol->flags & BSF_SECTION_SYM) == 0
621 && reloc_entry->addend == 0)
623 reloc_entry->address += input_section->output_offset;
624 return bfd_reloc_ok;
627 if (output_bfd != (bfd *) NULL)
628 relocatable = TRUE;
629 else
631 relocatable = FALSE;
632 output_bfd = symbol->section->output_section->owner;
635 if (bfd_is_und_section (symbol->section) && ! relocatable)
636 return bfd_reloc_undefined;
638 /* We have to figure out the gp value, so that we can adjust the
639 symbol value correctly. We look up the symbol _gp in the output
640 BFD. If we can't find it, we're stuck. We cache it in the ECOFF
641 target data. We don't need to adjust the symbol value for an
642 external symbol if we are producing relocatable output. */
643 gp = _bfd_get_gp_value (output_bfd);
644 if (gp == 0
645 && (! relocatable
646 || (symbol->flags & BSF_SECTION_SYM) != 0))
648 if (relocatable)
650 /* Make up a value. */
651 gp = symbol->section->output_section->vma + 0x4000;
652 _bfd_set_gp_value (output_bfd, gp);
654 else
656 unsigned int count;
657 asymbol **sym;
658 unsigned int i;
660 count = bfd_get_symcount (output_bfd);
661 sym = bfd_get_outsymbols (output_bfd);
663 if (sym == (asymbol **) NULL)
664 i = count;
665 else
667 for (i = 0; i < count; i++, sym++)
669 register const char *name;
671 name = bfd_asymbol_name (*sym);
672 if (*name == '_' && strcmp (name, "_gp") == 0)
674 gp = bfd_asymbol_value (*sym);
675 _bfd_set_gp_value (output_bfd, gp);
676 break;
681 if (i >= count)
683 /* Only get the error once. */
684 gp = 4;
685 _bfd_set_gp_value (output_bfd, gp);
686 *error_message =
687 (char *) _("GP relative relocation when _gp not defined");
688 return bfd_reloc_dangerous;
693 if (bfd_is_com_section (symbol->section))
694 relocation = 0;
695 else
696 relocation = symbol->value;
698 relocation += symbol->section->output_section->vma;
699 relocation += symbol->section->output_offset;
701 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
702 return bfd_reloc_outofrange;
704 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
706 /* Set val to the offset into the section or symbol. */
707 val = ((insn & 0xffff) + reloc_entry->addend) & 0xffff;
708 if (val & 0x8000)
709 val -= 0x10000;
711 /* Adjust val for the final section location and GP value. If we
712 are producing relocatable output, we don't want to do this for
713 an external symbol. */
714 if (! relocatable
715 || (symbol->flags & BSF_SECTION_SYM) != 0)
716 val += relocation - gp;
718 insn = (insn &~ (unsigned) 0xffff) | (val & 0xffff);
719 bfd_put_32 (abfd, (bfd_vma) insn, (bfd_byte *) data + reloc_entry->address);
721 if (relocatable)
722 reloc_entry->address += input_section->output_offset;
724 /* Make sure it fit in 16 bits. */
725 if ((long) val >= 0x8000 || (long) val < -0x8000)
726 return bfd_reloc_overflow;
728 return bfd_reloc_ok;
731 /* Get the howto structure for a generic reloc type. */
733 static reloc_howto_type *
734 mips_bfd_reloc_type_lookup (abfd, code)
735 bfd *abfd ATTRIBUTE_UNUSED;
736 bfd_reloc_code_real_type code;
738 int mips_type;
740 switch (code)
742 case BFD_RELOC_16:
743 mips_type = MIPS_R_REFHALF;
744 break;
745 case BFD_RELOC_32:
746 case BFD_RELOC_CTOR:
747 mips_type = MIPS_R_REFWORD;
748 break;
749 case BFD_RELOC_MIPS_JMP:
750 mips_type = MIPS_R_JMPADDR;
751 break;
752 case BFD_RELOC_HI16_S:
753 mips_type = MIPS_R_REFHI;
754 break;
755 case BFD_RELOC_LO16:
756 mips_type = MIPS_R_REFLO;
757 break;
758 case BFD_RELOC_GPREL16:
759 mips_type = MIPS_R_GPREL;
760 break;
761 case BFD_RELOC_MIPS_LITERAL:
762 mips_type = MIPS_R_LITERAL;
763 break;
764 case BFD_RELOC_16_PCREL_S2:
765 mips_type = MIPS_R_PCREL16;
766 break;
767 default:
768 return (reloc_howto_type *) NULL;
771 return &mips_howto_table[mips_type];
774 static reloc_howto_type *
775 mips_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
776 const char *r_name)
778 unsigned int i;
780 for (i = 0;
781 i < sizeof (mips_howto_table) / sizeof (mips_howto_table[0]);
782 i++)
783 if (mips_howto_table[i].name != NULL
784 && strcasecmp (mips_howto_table[i].name, r_name) == 0)
785 return &mips_howto_table[i];
787 return NULL;
790 /* A helper routine for mips_relocate_section which handles the REFHI
791 relocations. The REFHI relocation must be followed by a REFLO
792 relocation, and the addend used is formed from the addends of both
793 instructions. */
795 static void
796 mips_relocate_hi (refhi, reflo, input_bfd, input_section, contents,
797 relocation)
798 struct internal_reloc *refhi;
799 struct internal_reloc *reflo;
800 bfd *input_bfd;
801 asection *input_section;
802 bfd_byte *contents;
803 bfd_vma relocation;
805 unsigned long insn;
806 unsigned long val;
807 unsigned long vallo;
809 if (refhi == NULL)
810 return;
812 insn = bfd_get_32 (input_bfd,
813 contents + refhi->r_vaddr - input_section->vma);
814 if (reflo == NULL)
815 vallo = 0;
816 else
817 vallo = (bfd_get_32 (input_bfd,
818 contents + reflo->r_vaddr - input_section->vma)
819 & 0xffff);
821 val = ((insn & 0xffff) << 16) + vallo;
822 val += relocation;
824 /* The low order 16 bits are always treated as a signed value.
825 Therefore, a negative value in the low order bits requires an
826 adjustment in the high order bits. We need to make this
827 adjustment in two ways: once for the bits we took from the data,
828 and once for the bits we are putting back in to the data. */
829 if ((vallo & 0x8000) != 0)
830 val -= 0x10000;
832 if ((val & 0x8000) != 0)
833 val += 0x10000;
835 insn = (insn &~ (unsigned) 0xffff) | ((val >> 16) & 0xffff);
836 bfd_put_32 (input_bfd, (bfd_vma) insn,
837 contents + refhi->r_vaddr - input_section->vma);
840 /* Relocate a section while linking a MIPS ECOFF file. */
842 static bfd_boolean
843 mips_relocate_section (output_bfd, info, input_bfd, input_section,
844 contents, external_relocs)
845 bfd *output_bfd;
846 struct bfd_link_info *info;
847 bfd *input_bfd;
848 asection *input_section;
849 bfd_byte *contents;
850 PTR external_relocs;
852 asection **symndx_to_section;
853 struct ecoff_link_hash_entry **sym_hashes;
854 bfd_vma gp;
855 bfd_boolean gp_undefined;
856 struct external_reloc *ext_rel;
857 struct external_reloc *ext_rel_end;
858 unsigned int i;
859 bfd_boolean got_lo;
860 struct internal_reloc lo_int_rel;
861 bfd_size_type amt;
863 BFD_ASSERT (input_bfd->xvec->byteorder
864 == output_bfd->xvec->byteorder);
866 /* We keep a table mapping the symndx found in an internal reloc to
867 the appropriate section. This is faster than looking up the
868 section by name each time. */
869 symndx_to_section = ecoff_data (input_bfd)->symndx_to_section;
870 if (symndx_to_section == (asection **) NULL)
872 amt = NUM_RELOC_SECTIONS * sizeof (asection *);
873 symndx_to_section = (asection **) bfd_alloc (input_bfd, amt);
874 if (!symndx_to_section)
875 return FALSE;
877 symndx_to_section[RELOC_SECTION_NONE] = NULL;
878 symndx_to_section[RELOC_SECTION_TEXT] =
879 bfd_get_section_by_name (input_bfd, ".text");
880 symndx_to_section[RELOC_SECTION_RDATA] =
881 bfd_get_section_by_name (input_bfd, ".rdata");
882 symndx_to_section[RELOC_SECTION_DATA] =
883 bfd_get_section_by_name (input_bfd, ".data");
884 symndx_to_section[RELOC_SECTION_SDATA] =
885 bfd_get_section_by_name (input_bfd, ".sdata");
886 symndx_to_section[RELOC_SECTION_SBSS] =
887 bfd_get_section_by_name (input_bfd, ".sbss");
888 symndx_to_section[RELOC_SECTION_BSS] =
889 bfd_get_section_by_name (input_bfd, ".bss");
890 symndx_to_section[RELOC_SECTION_INIT] =
891 bfd_get_section_by_name (input_bfd, ".init");
892 symndx_to_section[RELOC_SECTION_LIT8] =
893 bfd_get_section_by_name (input_bfd, ".lit8");
894 symndx_to_section[RELOC_SECTION_LIT4] =
895 bfd_get_section_by_name (input_bfd, ".lit4");
896 symndx_to_section[RELOC_SECTION_XDATA] = NULL;
897 symndx_to_section[RELOC_SECTION_PDATA] = NULL;
898 symndx_to_section[RELOC_SECTION_FINI] =
899 bfd_get_section_by_name (input_bfd, ".fini");
900 symndx_to_section[RELOC_SECTION_LITA] = NULL;
901 symndx_to_section[RELOC_SECTION_ABS] = NULL;
903 ecoff_data (input_bfd)->symndx_to_section = symndx_to_section;
906 sym_hashes = ecoff_data (input_bfd)->sym_hashes;
908 gp = _bfd_get_gp_value (output_bfd);
909 if (gp == 0)
910 gp_undefined = TRUE;
911 else
912 gp_undefined = FALSE;
914 got_lo = FALSE;
916 ext_rel = (struct external_reloc *) external_relocs;
917 ext_rel_end = ext_rel + input_section->reloc_count;
918 for (i = 0; ext_rel < ext_rel_end; ext_rel++, i++)
920 struct internal_reloc int_rel;
921 bfd_boolean use_lo = FALSE;
922 bfd_vma addend;
923 reloc_howto_type *howto;
924 struct ecoff_link_hash_entry *h = NULL;
925 asection *s = NULL;
926 bfd_vma relocation;
927 bfd_reloc_status_type r;
929 if (! got_lo)
930 mips_ecoff_swap_reloc_in (input_bfd, (PTR) ext_rel, &int_rel);
931 else
933 int_rel = lo_int_rel;
934 got_lo = FALSE;
937 BFD_ASSERT (int_rel.r_type
938 < sizeof mips_howto_table / sizeof mips_howto_table[0]);
940 /* The REFHI reloc requires special handling. It must be followed
941 by a REFLO reloc, and the addend is formed from both relocs. */
942 if (int_rel.r_type == MIPS_R_REFHI)
944 struct external_reloc *lo_ext_rel;
946 /* As a GNU extension, permit an arbitrary number of REFHI
947 relocs before the REFLO reloc. This permits gcc to emit
948 the HI and LO relocs itself. */
949 for (lo_ext_rel = ext_rel + 1;
950 lo_ext_rel < ext_rel_end;
951 lo_ext_rel++)
953 mips_ecoff_swap_reloc_in (input_bfd, (PTR) lo_ext_rel,
954 &lo_int_rel);
955 if (lo_int_rel.r_type != int_rel.r_type)
956 break;
959 if (lo_ext_rel < ext_rel_end
960 && lo_int_rel.r_type == MIPS_R_REFLO
961 && int_rel.r_extern == lo_int_rel.r_extern
962 && int_rel.r_symndx == lo_int_rel.r_symndx)
964 use_lo = TRUE;
965 if (lo_ext_rel == ext_rel + 1)
966 got_lo = TRUE;
970 howto = &mips_howto_table[int_rel.r_type];
972 if (int_rel.r_extern)
974 h = sym_hashes[int_rel.r_symndx];
975 /* If h is NULL, that means that there is a reloc against an
976 external symbol which we thought was just a debugging
977 symbol. This should not happen. */
978 if (h == (struct ecoff_link_hash_entry *) NULL)
979 abort ();
981 else
983 if (int_rel.r_symndx < 0 || int_rel.r_symndx >= NUM_RELOC_SECTIONS)
984 s = NULL;
985 else
986 s = symndx_to_section[int_rel.r_symndx];
988 if (s == (asection *) NULL)
989 abort ();
992 /* The GPREL reloc uses an addend: the difference in the GP
993 values. */
994 if (int_rel.r_type != MIPS_R_GPREL
995 && int_rel.r_type != MIPS_R_LITERAL)
996 addend = 0;
997 else
999 if (gp_undefined)
1001 if (! ((*info->callbacks->reloc_dangerous)
1002 (info, _("GP relative relocation used when GP not defined"),
1003 input_bfd, input_section,
1004 int_rel.r_vaddr - input_section->vma)))
1005 return FALSE;
1006 /* Only give the error once per link. */
1007 gp = 4;
1008 _bfd_set_gp_value (output_bfd, gp);
1009 gp_undefined = FALSE;
1011 if (! int_rel.r_extern)
1013 /* This is a relocation against a section. The current
1014 addend in the instruction is the difference between
1015 INPUT_SECTION->vma and the GP value of INPUT_BFD. We
1016 must change this to be the difference between the
1017 final definition (which will end up in RELOCATION)
1018 and the GP value of OUTPUT_BFD (which is in GP). */
1019 addend = ecoff_data (input_bfd)->gp - gp;
1021 else if (! info->relocatable
1022 || h->root.type == bfd_link_hash_defined
1023 || h->root.type == bfd_link_hash_defweak)
1025 /* This is a relocation against a defined symbol. The
1026 current addend in the instruction is simply the
1027 desired offset into the symbol (normally zero). We
1028 are going to change this into a relocation against a
1029 defined symbol, so we want the instruction to hold
1030 the difference between the final definition of the
1031 symbol (which will end up in RELOCATION) and the GP
1032 value of OUTPUT_BFD (which is in GP). */
1033 addend = - gp;
1035 else
1037 /* This is a relocation against an undefined or common
1038 symbol. The current addend in the instruction is
1039 simply the desired offset into the symbol (normally
1040 zero). We are generating relocatable output, and we
1041 aren't going to define this symbol, so we just leave
1042 the instruction alone. */
1043 addend = 0;
1047 if (info->relocatable)
1049 /* We are generating relocatable output, and must convert
1050 the existing reloc. */
1051 if (int_rel.r_extern)
1053 if ((h->root.type == bfd_link_hash_defined
1054 || h->root.type == bfd_link_hash_defweak)
1055 && ! bfd_is_abs_section (h->root.u.def.section))
1057 const char *name;
1059 /* This symbol is defined in the output. Convert
1060 the reloc from being against the symbol to being
1061 against the section. */
1063 /* Clear the r_extern bit. */
1064 int_rel.r_extern = 0;
1066 /* Compute a new r_symndx value. */
1067 s = h->root.u.def.section;
1068 name = bfd_get_section_name (output_bfd,
1069 s->output_section);
1071 int_rel.r_symndx = -1;
1072 switch (name[1])
1074 case 'b':
1075 if (strcmp (name, ".bss") == 0)
1076 int_rel.r_symndx = RELOC_SECTION_BSS;
1077 break;
1078 case 'd':
1079 if (strcmp (name, ".data") == 0)
1080 int_rel.r_symndx = RELOC_SECTION_DATA;
1081 break;
1082 case 'f':
1083 if (strcmp (name, ".fini") == 0)
1084 int_rel.r_symndx = RELOC_SECTION_FINI;
1085 break;
1086 case 'i':
1087 if (strcmp (name, ".init") == 0)
1088 int_rel.r_symndx = RELOC_SECTION_INIT;
1089 break;
1090 case 'l':
1091 if (strcmp (name, ".lit8") == 0)
1092 int_rel.r_symndx = RELOC_SECTION_LIT8;
1093 else if (strcmp (name, ".lit4") == 0)
1094 int_rel.r_symndx = RELOC_SECTION_LIT4;
1095 break;
1096 case 'r':
1097 if (strcmp (name, ".rdata") == 0)
1098 int_rel.r_symndx = RELOC_SECTION_RDATA;
1099 break;
1100 case 's':
1101 if (strcmp (name, ".sdata") == 0)
1102 int_rel.r_symndx = RELOC_SECTION_SDATA;
1103 else if (strcmp (name, ".sbss") == 0)
1104 int_rel.r_symndx = RELOC_SECTION_SBSS;
1105 break;
1106 case 't':
1107 if (strcmp (name, ".text") == 0)
1108 int_rel.r_symndx = RELOC_SECTION_TEXT;
1109 break;
1112 if (int_rel.r_symndx == -1)
1113 abort ();
1115 /* Add the section VMA and the symbol value. */
1116 relocation = (h->root.u.def.value
1117 + s->output_section->vma
1118 + s->output_offset);
1120 /* For a PC relative relocation, the object file
1121 currently holds just the addend. We must adjust
1122 by the address to get the right value. */
1123 if (howto->pc_relative)
1124 relocation -= int_rel.r_vaddr - input_section->vma;
1126 h = NULL;
1128 else
1130 /* Change the symndx value to the right one for the
1131 output BFD. */
1132 int_rel.r_symndx = h->indx;
1133 if (int_rel.r_symndx == -1)
1135 /* This symbol is not being written out. */
1136 if (! ((*info->callbacks->unattached_reloc)
1137 (info, h->root.root.string, input_bfd,
1138 input_section,
1139 int_rel.r_vaddr - input_section->vma)))
1140 return FALSE;
1141 int_rel.r_symndx = 0;
1143 relocation = 0;
1146 else
1148 /* This is a relocation against a section. Adjust the
1149 value by the amount the section moved. */
1150 relocation = (s->output_section->vma
1151 + s->output_offset
1152 - s->vma);
1155 relocation += addend;
1156 addend = 0;
1158 /* Adjust a PC relative relocation by removing the reference
1159 to the original address in the section and including the
1160 reference to the new address. */
1161 if (howto->pc_relative)
1162 relocation -= (input_section->output_section->vma
1163 + input_section->output_offset
1164 - input_section->vma);
1166 /* Adjust the contents. */
1167 if (relocation == 0)
1168 r = bfd_reloc_ok;
1169 else
1171 if (int_rel.r_type != MIPS_R_REFHI)
1172 r = _bfd_relocate_contents (howto, input_bfd, relocation,
1173 (contents
1174 + int_rel.r_vaddr
1175 - input_section->vma));
1176 else
1178 mips_relocate_hi (&int_rel,
1179 use_lo ? &lo_int_rel : NULL,
1180 input_bfd, input_section, contents,
1181 relocation);
1182 r = bfd_reloc_ok;
1186 /* Adjust the reloc address. */
1187 int_rel.r_vaddr += (input_section->output_section->vma
1188 + input_section->output_offset
1189 - input_section->vma);
1191 /* Save the changed reloc information. */
1192 mips_ecoff_swap_reloc_out (input_bfd, &int_rel, (PTR) ext_rel);
1194 else
1196 /* We are producing a final executable. */
1197 if (int_rel.r_extern)
1199 /* This is a reloc against a symbol. */
1200 if (h->root.type == bfd_link_hash_defined
1201 || h->root.type == bfd_link_hash_defweak)
1203 asection *hsec;
1205 hsec = h->root.u.def.section;
1206 relocation = (h->root.u.def.value
1207 + hsec->output_section->vma
1208 + hsec->output_offset);
1210 else
1212 if (! ((*info->callbacks->undefined_symbol)
1213 (info, h->root.root.string, input_bfd,
1214 input_section,
1215 int_rel.r_vaddr - input_section->vma, TRUE)))
1216 return FALSE;
1217 relocation = 0;
1220 else
1222 /* This is a reloc against a section. */
1223 relocation = (s->output_section->vma
1224 + s->output_offset
1225 - s->vma);
1227 /* A PC relative reloc is already correct in the object
1228 file. Make it look like a pcrel_offset relocation by
1229 adding in the start address. */
1230 if (howto->pc_relative)
1231 relocation += int_rel.r_vaddr;
1234 if (int_rel.r_type != MIPS_R_REFHI)
1235 r = _bfd_final_link_relocate (howto,
1236 input_bfd,
1237 input_section,
1238 contents,
1239 (int_rel.r_vaddr
1240 - input_section->vma),
1241 relocation,
1242 addend);
1243 else
1245 mips_relocate_hi (&int_rel,
1246 use_lo ? &lo_int_rel : NULL,
1247 input_bfd, input_section, contents,
1248 relocation);
1249 r = bfd_reloc_ok;
1253 /* MIPS_R_JMPADDR requires peculiar overflow detection. The
1254 instruction provides a 28 bit address (the two lower bits are
1255 implicit zeroes) which is combined with the upper four bits
1256 of the instruction address. */
1257 if (r == bfd_reloc_ok
1258 && int_rel.r_type == MIPS_R_JMPADDR
1259 && (((relocation
1260 + addend
1261 + (int_rel.r_extern ? 0 : s->vma))
1262 & 0xf0000000)
1263 != ((input_section->output_section->vma
1264 + input_section->output_offset
1265 + (int_rel.r_vaddr - input_section->vma))
1266 & 0xf0000000)))
1267 r = bfd_reloc_overflow;
1269 if (r != bfd_reloc_ok)
1271 switch (r)
1273 default:
1274 case bfd_reloc_outofrange:
1275 abort ();
1276 case bfd_reloc_overflow:
1278 const char *name;
1280 if (int_rel.r_extern)
1281 name = NULL;
1282 else
1283 name = bfd_section_name (input_bfd, s);
1284 if (! ((*info->callbacks->reloc_overflow)
1285 (info, (h ? &h->root : NULL), name, howto->name,
1286 (bfd_vma) 0, input_bfd, input_section,
1287 int_rel.r_vaddr - input_section->vma)))
1288 return FALSE;
1290 break;
1295 return TRUE;
1298 /* This is the ECOFF backend structure. The backend field of the
1299 target vector points to this. */
1301 static const struct ecoff_backend_data mips_ecoff_backend_data =
1303 /* COFF backend structure. */
1305 (void (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR))) bfd_void, /* aux_in */
1306 (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_in */
1307 (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_in */
1308 (unsigned (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR)))bfd_void,/*aux_out*/
1309 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_out */
1310 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_out */
1311 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* reloc_out */
1312 mips_ecoff_swap_filehdr_out, mips_ecoff_swap_aouthdr_out,
1313 mips_ecoff_swap_scnhdr_out,
1314 FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, 0, FILNMLEN, TRUE, FALSE, 4, FALSE, 2,
1315 mips_ecoff_swap_filehdr_in, mips_ecoff_swap_aouthdr_in,
1316 mips_ecoff_swap_scnhdr_in, NULL,
1317 mips_ecoff_bad_format_hook, _bfd_ecoff_set_arch_mach_hook,
1318 _bfd_ecoff_mkobject_hook, _bfd_ecoff_styp_to_sec_flags,
1319 _bfd_ecoff_set_alignment_hook, _bfd_ecoff_slurp_symbol_table,
1320 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1321 NULL, NULL
1323 /* Supported architecture. */
1324 bfd_arch_mips,
1325 /* Initial portion of armap string. */
1326 "__________",
1327 /* The page boundary used to align sections in a demand-paged
1328 executable file. E.g., 0x1000. */
1329 0x1000,
1330 /* TRUE if the .rdata section is part of the text segment, as on the
1331 Alpha. FALSE if .rdata is part of the data segment, as on the
1332 MIPS. */
1333 FALSE,
1334 /* Bitsize of constructor entries. */
1336 /* Reloc to use for constructor entries. */
1337 &mips_howto_table[MIPS_R_REFWORD],
1339 /* Symbol table magic number. */
1340 magicSym,
1341 /* Alignment of debugging information. E.g., 4. */
1343 /* Sizes of external symbolic information. */
1344 sizeof (struct hdr_ext),
1345 sizeof (struct dnr_ext),
1346 sizeof (struct pdr_ext),
1347 sizeof (struct sym_ext),
1348 sizeof (struct opt_ext),
1349 sizeof (struct fdr_ext),
1350 sizeof (struct rfd_ext),
1351 sizeof (struct ext_ext),
1352 /* Functions to swap in external symbolic data. */
1353 ecoff_swap_hdr_in,
1354 ecoff_swap_dnr_in,
1355 ecoff_swap_pdr_in,
1356 ecoff_swap_sym_in,
1357 ecoff_swap_opt_in,
1358 ecoff_swap_fdr_in,
1359 ecoff_swap_rfd_in,
1360 ecoff_swap_ext_in,
1361 _bfd_ecoff_swap_tir_in,
1362 _bfd_ecoff_swap_rndx_in,
1363 /* Functions to swap out external symbolic data. */
1364 ecoff_swap_hdr_out,
1365 ecoff_swap_dnr_out,
1366 ecoff_swap_pdr_out,
1367 ecoff_swap_sym_out,
1368 ecoff_swap_opt_out,
1369 ecoff_swap_fdr_out,
1370 ecoff_swap_rfd_out,
1371 ecoff_swap_ext_out,
1372 _bfd_ecoff_swap_tir_out,
1373 _bfd_ecoff_swap_rndx_out,
1374 /* Function to read in symbolic data. */
1375 _bfd_ecoff_slurp_symbolic_info
1377 /* External reloc size. */
1378 RELSZ,
1379 /* Reloc swapping functions. */
1380 mips_ecoff_swap_reloc_in,
1381 mips_ecoff_swap_reloc_out,
1382 /* Backend reloc tweaking. */
1383 mips_adjust_reloc_in,
1384 mips_adjust_reloc_out,
1385 /* Relocate section contents while linking. */
1386 mips_relocate_section,
1387 /* Do final adjustments to filehdr and aouthdr. */
1388 NULL,
1389 /* Read an element from an archive at a given file position. */
1390 _bfd_get_elt_at_filepos
1393 /* Looking up a reloc type is MIPS specific. */
1394 #define _bfd_ecoff_bfd_reloc_type_lookup mips_bfd_reloc_type_lookup
1395 #define _bfd_ecoff_bfd_reloc_name_lookup mips_bfd_reloc_name_lookup
1397 /* Getting relocated section contents is generic. */
1398 #define _bfd_ecoff_bfd_get_relocated_section_contents \
1399 bfd_generic_get_relocated_section_contents
1401 /* Handling file windows is generic. */
1402 #define _bfd_ecoff_get_section_contents_in_window \
1403 _bfd_generic_get_section_contents_in_window
1405 /* Relaxing sections is MIPS specific. */
1406 #define _bfd_ecoff_bfd_relax_section bfd_generic_relax_section
1408 /* GC of sections is not done. */
1409 #define _bfd_ecoff_bfd_gc_sections bfd_generic_gc_sections
1411 /* Merging of sections is not done. */
1412 #define _bfd_ecoff_bfd_merge_sections bfd_generic_merge_sections
1414 #define _bfd_ecoff_bfd_is_group_section bfd_generic_is_group_section
1415 #define _bfd_ecoff_bfd_discard_group bfd_generic_discard_group
1416 #define _bfd_ecoff_section_already_linked \
1417 _bfd_generic_section_already_linked
1419 extern const bfd_target ecoff_big_vec;
1421 const bfd_target ecoff_little_vec =
1423 "ecoff-littlemips", /* name */
1424 bfd_target_ecoff_flavour,
1425 BFD_ENDIAN_LITTLE, /* data byte order is little */
1426 BFD_ENDIAN_LITTLE, /* header byte order is little */
1428 (HAS_RELOC | EXEC_P | /* object flags */
1429 HAS_LINENO | HAS_DEBUG |
1430 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1432 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
1433 0, /* leading underscore */
1434 ' ', /* ar_pad_char */
1435 15, /* ar_max_namelen */
1436 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1437 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1438 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
1439 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1440 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1441 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
1443 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
1444 _bfd_ecoff_archive_p, _bfd_dummy_target},
1445 {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
1446 _bfd_generic_mkarchive, bfd_false},
1447 {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
1448 _bfd_write_archive_contents, bfd_false},
1450 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
1451 BFD_JUMP_TABLE_COPY (_bfd_ecoff),
1452 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1453 BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
1454 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
1455 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
1456 BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
1457 BFD_JUMP_TABLE_LINK (_bfd_ecoff),
1458 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1460 & ecoff_big_vec,
1462 (PTR) &mips_ecoff_backend_data
1465 const bfd_target ecoff_big_vec =
1467 "ecoff-bigmips", /* name */
1468 bfd_target_ecoff_flavour,
1469 BFD_ENDIAN_BIG, /* data byte order is big */
1470 BFD_ENDIAN_BIG, /* header byte order is big */
1472 (HAS_RELOC | EXEC_P | /* object flags */
1473 HAS_LINENO | HAS_DEBUG |
1474 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1476 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
1477 0, /* leading underscore */
1478 ' ', /* ar_pad_char */
1479 15, /* ar_max_namelen */
1480 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1481 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1482 bfd_getb16, bfd_getb_signed_16, bfd_putb16,
1483 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1484 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1485 bfd_getb16, bfd_getb_signed_16, bfd_putb16,
1486 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
1487 _bfd_ecoff_archive_p, _bfd_dummy_target},
1488 {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
1489 _bfd_generic_mkarchive, bfd_false},
1490 {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
1491 _bfd_write_archive_contents, bfd_false},
1493 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
1494 BFD_JUMP_TABLE_COPY (_bfd_ecoff),
1495 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1496 BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
1497 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
1498 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
1499 BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
1500 BFD_JUMP_TABLE_LINK (_bfd_ecoff),
1501 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1503 & ecoff_little_vec,
1505 (PTR) &mips_ecoff_backend_data
1508 const bfd_target ecoff_biglittle_vec =
1510 "ecoff-biglittlemips", /* name */
1511 bfd_target_ecoff_flavour,
1512 BFD_ENDIAN_LITTLE, /* data byte order is little */
1513 BFD_ENDIAN_BIG, /* header byte order is big */
1515 (HAS_RELOC | EXEC_P | /* object flags */
1516 HAS_LINENO | HAS_DEBUG |
1517 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1519 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
1520 0, /* leading underscore */
1521 ' ', /* ar_pad_char */
1522 15, /* ar_max_namelen */
1523 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1524 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1525 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
1526 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1527 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1528 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1530 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
1531 _bfd_ecoff_archive_p, _bfd_dummy_target},
1532 {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
1533 _bfd_generic_mkarchive, bfd_false},
1534 {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
1535 _bfd_write_archive_contents, bfd_false},
1537 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
1538 BFD_JUMP_TABLE_COPY (_bfd_ecoff),
1539 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1540 BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
1541 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
1542 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
1543 BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
1544 BFD_JUMP_TABLE_LINK (_bfd_ecoff),
1545 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1547 NULL,
1549 (PTR) &mips_ecoff_backend_data