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
4 Free Software Foundation, Inc.
5 Original version by Per Bothner.
6 Full support added by Ian Lance Taylor, ian@cygnus.com.
8 This file is part of BFD, the Binary File Descriptor library.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 #include "coff/internal.h"
30 #include "coff/symconst.h"
31 #include "coff/ecoff.h"
32 #include "coff/mips.h"
36 /* Prototypes for static functions. */
38 static bfd_boolean mips_ecoff_bad_format_hook
39 PARAMS ((bfd
*abfd
, PTR filehdr
));
40 static void mips_ecoff_swap_reloc_in
41 PARAMS ((bfd
*, PTR
, struct internal_reloc
*));
42 static void mips_ecoff_swap_reloc_out
43 PARAMS ((bfd
*, const struct internal_reloc
*, PTR
));
44 static void mips_adjust_reloc_in
45 PARAMS ((bfd
*, const struct internal_reloc
*, arelent
*));
46 static void mips_adjust_reloc_out
47 PARAMS ((bfd
*, const arelent
*, struct internal_reloc
*));
48 static bfd_reloc_status_type mips_generic_reloc
49 PARAMS ((bfd
*abfd
, arelent
*reloc
, asymbol
*symbol
, PTR data
,
50 asection
*section
, bfd
*output_bfd
, char **error
));
51 static bfd_reloc_status_type mips_refhi_reloc
52 PARAMS ((bfd
*abfd
, arelent
*reloc
, asymbol
*symbol
, PTR data
,
53 asection
*section
, bfd
*output_bfd
, char **error
));
54 static bfd_reloc_status_type mips_reflo_reloc
55 PARAMS ((bfd
*abfd
, arelent
*reloc
, asymbol
*symbol
, PTR data
,
56 asection
*section
, bfd
*output_bfd
, char **error
));
57 static bfd_reloc_status_type mips_gprel_reloc
58 PARAMS ((bfd
*abfd
, arelent
*reloc
, asymbol
*symbol
, PTR data
,
59 asection
*section
, bfd
*output_bfd
, char **error
));
60 static void mips_relocate_hi
61 PARAMS ((struct internal_reloc
*refhi
, struct internal_reloc
*reflo
,
62 bfd
*input_bfd
, asection
*input_section
, bfd_byte
*contents
,
64 static bfd_boolean mips_relocate_section
65 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*, PTR
));
66 static reloc_howto_type
*mips_bfd_reloc_type_lookup
67 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
69 /* ECOFF has COFF sections, but the debugging information is stored in
70 a completely different format. ECOFF targets use some of the
71 swapping routines from coffswap.h, and some of the generic COFF
72 routines in coffgen.c, but, unlike the real COFF targets, do not
73 use coffcode.h itself.
75 Get the generic COFF swapping routines, except for the reloc,
76 symbol, and lineno ones. Give them ECOFF names. */
78 #define NO_COFF_RELOCS
79 #define NO_COFF_SYMBOLS
80 #define NO_COFF_LINENOS
81 #define coff_swap_filehdr_in mips_ecoff_swap_filehdr_in
82 #define coff_swap_filehdr_out mips_ecoff_swap_filehdr_out
83 #define coff_swap_aouthdr_in mips_ecoff_swap_aouthdr_in
84 #define coff_swap_aouthdr_out mips_ecoff_swap_aouthdr_out
85 #define coff_swap_scnhdr_in mips_ecoff_swap_scnhdr_in
86 #define coff_swap_scnhdr_out mips_ecoff_swap_scnhdr_out
89 /* Get the ECOFF swapping routines. */
91 #include "ecoffswap.h"
93 /* How to process the various relocs types. */
95 static reloc_howto_type mips_howto_table
[] =
97 /* Reloc type 0 is ignored. The reloc reading code ensures that
98 this is a reference to the .abs section, which will cause
99 bfd_perform_relocation to do nothing. */
100 HOWTO (MIPS_R_IGNORE
, /* type */
102 0, /* size (0 = byte, 1 = short, 2 = long) */
104 FALSE
, /* pc_relative */
106 complain_overflow_dont
, /* complain_on_overflow */
107 0, /* special_function */
109 FALSE
, /* partial_inplace */
112 FALSE
), /* pcrel_offset */
114 /* A 16 bit reference to a symbol, normally from a data section. */
115 HOWTO (MIPS_R_REFHALF
, /* type */
117 1, /* size (0 = byte, 1 = short, 2 = long) */
119 FALSE
, /* pc_relative */
121 complain_overflow_bitfield
, /* complain_on_overflow */
122 mips_generic_reloc
, /* special_function */
123 "REFHALF", /* name */
124 TRUE
, /* partial_inplace */
125 0xffff, /* src_mask */
126 0xffff, /* dst_mask */
127 FALSE
), /* pcrel_offset */
129 /* A 32 bit reference to a symbol, normally from a data section. */
130 HOWTO (MIPS_R_REFWORD
, /* type */
132 2, /* size (0 = byte, 1 = short, 2 = long) */
134 FALSE
, /* pc_relative */
136 complain_overflow_bitfield
, /* complain_on_overflow */
137 mips_generic_reloc
, /* special_function */
138 "REFWORD", /* name */
139 TRUE
, /* partial_inplace */
140 0xffffffff, /* src_mask */
141 0xffffffff, /* dst_mask */
142 FALSE
), /* pcrel_offset */
144 /* A 26 bit absolute jump address. */
145 HOWTO (MIPS_R_JMPADDR
, /* type */
147 2, /* size (0 = byte, 1 = short, 2 = long) */
149 FALSE
, /* pc_relative */
151 complain_overflow_dont
, /* complain_on_overflow */
152 /* This needs complex overflow
153 detection, because the upper four
154 bits must match the PC. */
155 mips_generic_reloc
, /* special_function */
156 "JMPADDR", /* name */
157 TRUE
, /* partial_inplace */
158 0x3ffffff, /* src_mask */
159 0x3ffffff, /* dst_mask */
160 FALSE
), /* pcrel_offset */
162 /* The high 16 bits of a symbol value. Handled by the function
164 HOWTO (MIPS_R_REFHI
, /* type */
166 2, /* size (0 = byte, 1 = short, 2 = long) */
168 FALSE
, /* pc_relative */
170 complain_overflow_bitfield
, /* complain_on_overflow */
171 mips_refhi_reloc
, /* special_function */
173 TRUE
, /* partial_inplace */
174 0xffff, /* src_mask */
175 0xffff, /* dst_mask */
176 FALSE
), /* pcrel_offset */
178 /* The low 16 bits of a symbol value. */
179 HOWTO (MIPS_R_REFLO
, /* type */
181 2, /* size (0 = byte, 1 = short, 2 = long) */
183 FALSE
, /* pc_relative */
185 complain_overflow_dont
, /* complain_on_overflow */
186 mips_reflo_reloc
, /* special_function */
188 TRUE
, /* partial_inplace */
189 0xffff, /* src_mask */
190 0xffff, /* dst_mask */
191 FALSE
), /* pcrel_offset */
193 /* A reference to an offset from the gp register. Handled by the
194 function mips_gprel_reloc. */
195 HOWTO (MIPS_R_GPREL
, /* type */
197 2, /* size (0 = byte, 1 = short, 2 = long) */
199 FALSE
, /* pc_relative */
201 complain_overflow_signed
, /* complain_on_overflow */
202 mips_gprel_reloc
, /* special_function */
204 TRUE
, /* partial_inplace */
205 0xffff, /* src_mask */
206 0xffff, /* dst_mask */
207 FALSE
), /* pcrel_offset */
209 /* A reference to a literal using an offset from the gp register.
210 Handled by the function mips_gprel_reloc. */
211 HOWTO (MIPS_R_LITERAL
, /* type */
213 2, /* size (0 = byte, 1 = short, 2 = long) */
215 FALSE
, /* pc_relative */
217 complain_overflow_signed
, /* complain_on_overflow */
218 mips_gprel_reloc
, /* special_function */
219 "LITERAL", /* name */
220 TRUE
, /* partial_inplace */
221 0xffff, /* src_mask */
222 0xffff, /* dst_mask */
223 FALSE
), /* pcrel_offset */
230 /* FIXME: This relocation is used (internally only) to represent branches
231 when assembling. It should never appear in output files, and
232 be removed. (It used to be used for embedded-PIC support.) */
233 HOWTO (MIPS_R_PCREL16
, /* type */
235 2, /* size (0 = byte, 1 = short, 2 = long) */
237 TRUE
, /* pc_relative */
239 complain_overflow_signed
, /* complain_on_overflow */
240 mips_generic_reloc
, /* special_function */
241 "PCREL16", /* name */
242 TRUE
, /* partial_inplace */
243 0xffff, /* src_mask */
244 0xffff, /* dst_mask */
245 TRUE
), /* pcrel_offset */
248 #define MIPS_HOWTO_COUNT \
249 (sizeof mips_howto_table / sizeof mips_howto_table[0])
251 /* See whether the magic number matches. */
254 mips_ecoff_bad_format_hook (abfd
, filehdr
)
258 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
260 switch (internal_f
->f_magic
)
263 /* I don't know what endianness this implies. */
267 case MIPS_MAGIC_BIG2
:
268 case MIPS_MAGIC_BIG3
:
269 return bfd_big_endian (abfd
);
271 case MIPS_MAGIC_LITTLE
:
272 case MIPS_MAGIC_LITTLE2
:
273 case MIPS_MAGIC_LITTLE3
:
274 return bfd_little_endian (abfd
);
281 /* Reloc handling. MIPS ECOFF relocs are packed into 8 bytes in
282 external form. They use a bit which indicates whether the symbol
285 /* Swap a reloc in. */
288 mips_ecoff_swap_reloc_in (abfd
, ext_ptr
, intern
)
291 struct internal_reloc
*intern
;
293 const RELOC
*ext
= (RELOC
*) ext_ptr
;
295 intern
->r_vaddr
= H_GET_32 (abfd
, ext
->r_vaddr
);
296 if (bfd_header_big_endian (abfd
))
298 intern
->r_symndx
= (((int) ext
->r_bits
[0]
299 << RELOC_BITS0_SYMNDX_SH_LEFT_BIG
)
300 | ((int) ext
->r_bits
[1]
301 << RELOC_BITS1_SYMNDX_SH_LEFT_BIG
)
302 | ((int) ext
->r_bits
[2]
303 << RELOC_BITS2_SYMNDX_SH_LEFT_BIG
));
304 intern
->r_type
= ((ext
->r_bits
[3] & RELOC_BITS3_TYPE_BIG
)
305 >> RELOC_BITS3_TYPE_SH_BIG
);
306 intern
->r_extern
= (ext
->r_bits
[3] & RELOC_BITS3_EXTERN_BIG
) != 0;
310 intern
->r_symndx
= (((int) ext
->r_bits
[0]
311 << RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE
)
312 | ((int) ext
->r_bits
[1]
313 << RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE
)
314 | ((int) ext
->r_bits
[2]
315 << RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE
));
316 intern
->r_type
= (((ext
->r_bits
[3] & RELOC_BITS3_TYPE_LITTLE
)
317 >> RELOC_BITS3_TYPE_SH_LITTLE
)
318 | ((ext
->r_bits
[3] & RELOC_BITS3_TYPEHI_LITTLE
)
319 << RELOC_BITS3_TYPEHI_SH_LITTLE
));
320 intern
->r_extern
= (ext
->r_bits
[3] & RELOC_BITS3_EXTERN_LITTLE
) != 0;
324 /* Swap a reloc out. */
327 mips_ecoff_swap_reloc_out (abfd
, intern
, dst
)
329 const struct internal_reloc
*intern
;
332 RELOC
*ext
= (RELOC
*) dst
;
335 BFD_ASSERT (intern
->r_extern
336 || (intern
->r_symndx
>= 0 && intern
->r_symndx
<= 12));
338 r_symndx
= intern
->r_symndx
;
340 H_PUT_32 (abfd
, intern
->r_vaddr
, ext
->r_vaddr
);
341 if (bfd_header_big_endian (abfd
))
343 ext
->r_bits
[0] = r_symndx
>> RELOC_BITS0_SYMNDX_SH_LEFT_BIG
;
344 ext
->r_bits
[1] = r_symndx
>> RELOC_BITS1_SYMNDX_SH_LEFT_BIG
;
345 ext
->r_bits
[2] = r_symndx
>> RELOC_BITS2_SYMNDX_SH_LEFT_BIG
;
346 ext
->r_bits
[3] = (((intern
->r_type
<< RELOC_BITS3_TYPE_SH_BIG
)
347 & RELOC_BITS3_TYPE_BIG
)
348 | (intern
->r_extern
? RELOC_BITS3_EXTERN_BIG
: 0));
352 ext
->r_bits
[0] = r_symndx
>> RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE
;
353 ext
->r_bits
[1] = r_symndx
>> RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE
;
354 ext
->r_bits
[2] = r_symndx
>> RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE
;
355 ext
->r_bits
[3] = (((intern
->r_type
<< RELOC_BITS3_TYPE_SH_LITTLE
)
356 & RELOC_BITS3_TYPE_LITTLE
)
357 | ((intern
->r_type
>> RELOC_BITS3_TYPEHI_SH_LITTLE
358 & RELOC_BITS3_TYPEHI_LITTLE
))
359 | (intern
->r_extern
? RELOC_BITS3_EXTERN_LITTLE
: 0));
363 /* Finish canonicalizing a reloc. Part of this is generic to all
364 ECOFF targets, and that part is in ecoff.c. The rest is done in
365 this backend routine. It must fill in the howto field. */
368 mips_adjust_reloc_in (abfd
, intern
, rptr
)
370 const struct internal_reloc
*intern
;
373 if (intern
->r_type
> MIPS_R_PCREL16
)
376 if (! intern
->r_extern
377 && (intern
->r_type
== MIPS_R_GPREL
378 || intern
->r_type
== MIPS_R_LITERAL
))
379 rptr
->addend
+= ecoff_data (abfd
)->gp
;
381 /* If the type is MIPS_R_IGNORE, make sure this is a reference to
382 the absolute section so that the reloc is ignored. */
383 if (intern
->r_type
== MIPS_R_IGNORE
)
384 rptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
386 rptr
->howto
= &mips_howto_table
[intern
->r_type
];
389 /* Make any adjustments needed to a reloc before writing it out. None
390 are needed for MIPS. */
393 mips_adjust_reloc_out (abfd
, rel
, intern
)
394 bfd
*abfd ATTRIBUTE_UNUSED
;
395 const arelent
*rel ATTRIBUTE_UNUSED
;
396 struct internal_reloc
*intern ATTRIBUTE_UNUSED
;
400 /* ECOFF relocs are either against external symbols, or against
401 sections. If we are producing relocatable output, and the reloc
402 is against an external symbol, and nothing has given us any
403 additional addend, the resulting reloc will also be against the
404 same symbol. In such a case, we don't want to change anything
405 about the way the reloc is handled, since it will all be done at
406 final link time. Rather than put special case code into
407 bfd_perform_relocation, all the reloc types use this howto
408 function. It just short circuits the reloc if producing
409 relocatable output against an external symbol. */
411 static bfd_reloc_status_type
412 mips_generic_reloc (abfd
,
419 bfd
*abfd ATTRIBUTE_UNUSED
;
420 arelent
*reloc_entry
;
422 PTR data ATTRIBUTE_UNUSED
;
423 asection
*input_section
;
425 char **error_message ATTRIBUTE_UNUSED
;
427 if (output_bfd
!= (bfd
*) NULL
428 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
429 && reloc_entry
->addend
== 0)
431 reloc_entry
->address
+= input_section
->output_offset
;
435 return bfd_reloc_continue
;
438 /* Do a REFHI relocation. This has to be done in combination with a
439 REFLO reloc, because there is a carry from the REFLO to the REFHI.
440 Here we just save the information we need; we do the actual
441 relocation when we see the REFLO. MIPS ECOFF requires that the
442 REFLO immediately follow the REFHI. As a GNU extension, we permit
443 an arbitrary number of HI relocs to be associated with a single LO
444 reloc. This extension permits gcc to output the HI and LO relocs
449 struct mips_hi
*next
;
454 /* FIXME: This should not be a static variable. */
456 static struct mips_hi
*mips_refhi_list
;
458 static bfd_reloc_status_type
459 mips_refhi_reloc (abfd
,
466 bfd
*abfd ATTRIBUTE_UNUSED
;
467 arelent
*reloc_entry
;
470 asection
*input_section
;
472 char **error_message ATTRIBUTE_UNUSED
;
474 bfd_reloc_status_type ret
;
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
;
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
))
497 relocation
= symbol
->value
;
499 relocation
+= symbol
->section
->output_section
->vma
;
500 relocation
+= symbol
->section
->output_offset
;
501 relocation
+= reloc_entry
->addend
;
503 sz
= input_section
->rawsize
? input_section
->rawsize
: input_section
->size
;
504 if (reloc_entry
->address
> sz
)
505 return bfd_reloc_outofrange
;
507 /* Save the information, and let REFLO do the actual relocation. */
508 n
= (struct mips_hi
*) bfd_malloc ((bfd_size_type
) sizeof *n
);
510 return bfd_reloc_outofrange
;
511 n
->addr
= (bfd_byte
*) data
+ reloc_entry
->address
;
512 n
->addend
= relocation
;
513 n
->next
= mips_refhi_list
;
516 if (output_bfd
!= (bfd
*) NULL
)
517 reloc_entry
->address
+= input_section
->output_offset
;
522 /* Do a REFLO relocation. This is a straightforward 16 bit inplace
523 relocation; this function exists in order to do the REFHI
524 relocation described above. */
526 static bfd_reloc_status_type
527 mips_reflo_reloc (abfd
,
535 arelent
*reloc_entry
;
538 asection
*input_section
;
540 char **error_message
;
542 if (mips_refhi_list
!= NULL
)
552 struct mips_hi
*next
;
554 /* Do the REFHI relocation. Note that we actually don't
555 need to know anything about the REFLO itself, except
556 where to find the low 16 bits of the addend needed by the
558 insn
= bfd_get_32 (abfd
, l
->addr
);
559 vallo
= (bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
)
561 val
= ((insn
& 0xffff) << 16) + vallo
;
564 /* The low order 16 bits are always treated as a signed
565 value. Therefore, a negative value in the low order bits
566 requires an adjustment in the high order bits. We need
567 to make this adjustment in two ways: once for the bits we
568 took from the data, and once for the bits we are putting
569 back in to the data. */
570 if ((vallo
& 0x8000) != 0)
572 if ((val
& 0x8000) != 0)
575 insn
= (insn
&~ (unsigned) 0xffff) | ((val
>> 16) & 0xffff);
576 bfd_put_32 (abfd
, (bfd_vma
) insn
, l
->addr
);
583 mips_refhi_list
= NULL
;
586 /* Now do the REFLO reloc in the usual way. */
587 return mips_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
588 input_section
, output_bfd
, error_message
);
591 /* Do a GPREL relocation. This is a 16 bit value which must become
592 the offset from the gp register. */
594 static bfd_reloc_status_type
595 mips_gprel_reloc (abfd
,
603 arelent
*reloc_entry
;
606 asection
*input_section
;
608 char **error_message
;
610 bfd_boolean relocatable
;
617 /* If we're relocating, and this is an external symbol with no
618 addend, we don't want to change anything. We will only have an
619 addend if this is a newly created reloc, not read from an ECOFF
621 if (output_bfd
!= (bfd
*) NULL
622 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
623 && reloc_entry
->addend
== 0)
625 reloc_entry
->address
+= input_section
->output_offset
;
629 if (output_bfd
!= (bfd
*) NULL
)
634 output_bfd
= symbol
->section
->output_section
->owner
;
637 if (bfd_is_und_section (symbol
->section
) && ! relocatable
)
638 return bfd_reloc_undefined
;
640 /* We have to figure out the gp value, so that we can adjust the
641 symbol value correctly. We look up the symbol _gp in the output
642 BFD. If we can't find it, we're stuck. We cache it in the ECOFF
643 target data. We don't need to adjust the symbol value for an
644 external symbol if we are producing relocatable output. */
645 gp
= _bfd_get_gp_value (output_bfd
);
648 || (symbol
->flags
& BSF_SECTION_SYM
) != 0))
652 /* Make up a value. */
653 gp
= symbol
->section
->output_section
->vma
+ 0x4000;
654 _bfd_set_gp_value (output_bfd
, gp
);
662 count
= bfd_get_symcount (output_bfd
);
663 sym
= bfd_get_outsymbols (output_bfd
);
665 if (sym
== (asymbol
**) NULL
)
669 for (i
= 0; i
< count
; i
++, sym
++)
671 register const char *name
;
673 name
= bfd_asymbol_name (*sym
);
674 if (*name
== '_' && strcmp (name
, "_gp") == 0)
676 gp
= bfd_asymbol_value (*sym
);
677 _bfd_set_gp_value (output_bfd
, gp
);
685 /* Only get the error once. */
687 _bfd_set_gp_value (output_bfd
, gp
);
689 (char *) _("GP relative relocation when _gp not defined");
690 return bfd_reloc_dangerous
;
695 if (bfd_is_com_section (symbol
->section
))
698 relocation
= symbol
->value
;
700 relocation
+= symbol
->section
->output_section
->vma
;
701 relocation
+= symbol
->section
->output_offset
;
703 sz
= input_section
->rawsize
? input_section
->rawsize
: input_section
->size
;
704 if (reloc_entry
->address
> sz
)
705 return bfd_reloc_outofrange
;
707 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
709 /* Set val to the offset into the section or symbol. */
710 val
= ((insn
& 0xffff) + reloc_entry
->addend
) & 0xffff;
714 /* Adjust val for the final section location and GP value. If we
715 are producing relocatable output, we don't want to do this for
716 an external symbol. */
718 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
719 val
+= relocation
- gp
;
721 insn
= (insn
&~ (unsigned) 0xffff) | (val
& 0xffff);
722 bfd_put_32 (abfd
, (bfd_vma
) insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
725 reloc_entry
->address
+= input_section
->output_offset
;
727 /* Make sure it fit in 16 bits. */
728 if ((long) val
>= 0x8000 || (long) val
< -0x8000)
729 return bfd_reloc_overflow
;
734 /* Get the howto structure for a generic reloc type. */
736 static reloc_howto_type
*
737 mips_bfd_reloc_type_lookup (abfd
, code
)
738 bfd
*abfd ATTRIBUTE_UNUSED
;
739 bfd_reloc_code_real_type code
;
746 mips_type
= MIPS_R_REFHALF
;
750 mips_type
= MIPS_R_REFWORD
;
752 case BFD_RELOC_MIPS_JMP
:
753 mips_type
= MIPS_R_JMPADDR
;
755 case BFD_RELOC_HI16_S
:
756 mips_type
= MIPS_R_REFHI
;
759 mips_type
= MIPS_R_REFLO
;
761 case BFD_RELOC_GPREL16
:
762 mips_type
= MIPS_R_GPREL
;
764 case BFD_RELOC_MIPS_LITERAL
:
765 mips_type
= MIPS_R_LITERAL
;
767 case BFD_RELOC_16_PCREL_S2
:
768 mips_type
= MIPS_R_PCREL16
;
771 return (reloc_howto_type
*) NULL
;
774 return &mips_howto_table
[mips_type
];
777 /* A helper routine for mips_relocate_section which handles the REFHI
778 relocations. The REFHI relocation must be followed by a REFLO
779 relocation, and the addend used is formed from the addends of both
783 mips_relocate_hi (refhi
, reflo
, input_bfd
, input_section
, contents
,
785 struct internal_reloc
*refhi
;
786 struct internal_reloc
*reflo
;
788 asection
*input_section
;
799 insn
= bfd_get_32 (input_bfd
,
800 contents
+ refhi
->r_vaddr
- input_section
->vma
);
804 vallo
= (bfd_get_32 (input_bfd
,
805 contents
+ reflo
->r_vaddr
- input_section
->vma
)
808 val
= ((insn
& 0xffff) << 16) + vallo
;
811 /* The low order 16 bits are always treated as a signed value.
812 Therefore, a negative value in the low order bits requires an
813 adjustment in the high order bits. We need to make this
814 adjustment in two ways: once for the bits we took from the data,
815 and once for the bits we are putting back in to the data. */
816 if ((vallo
& 0x8000) != 0)
819 if ((val
& 0x8000) != 0)
822 insn
= (insn
&~ (unsigned) 0xffff) | ((val
>> 16) & 0xffff);
823 bfd_put_32 (input_bfd
, (bfd_vma
) insn
,
824 contents
+ refhi
->r_vaddr
- input_section
->vma
);
827 /* Relocate a section while linking a MIPS ECOFF file. */
830 mips_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
831 contents
, external_relocs
)
833 struct bfd_link_info
*info
;
835 asection
*input_section
;
839 asection
**symndx_to_section
;
840 struct ecoff_link_hash_entry
**sym_hashes
;
842 bfd_boolean gp_undefined
;
843 struct external_reloc
*ext_rel
;
844 struct external_reloc
*ext_rel_end
;
847 struct internal_reloc lo_int_rel
;
850 BFD_ASSERT (input_bfd
->xvec
->byteorder
851 == output_bfd
->xvec
->byteorder
);
853 /* We keep a table mapping the symndx found in an internal reloc to
854 the appropriate section. This is faster than looking up the
855 section by name each time. */
856 symndx_to_section
= ecoff_data (input_bfd
)->symndx_to_section
;
857 if (symndx_to_section
== (asection
**) NULL
)
859 amt
= NUM_RELOC_SECTIONS
* sizeof (asection
*);
860 symndx_to_section
= (asection
**) bfd_alloc (input_bfd
, amt
);
861 if (!symndx_to_section
)
864 symndx_to_section
[RELOC_SECTION_NONE
] = NULL
;
865 symndx_to_section
[RELOC_SECTION_TEXT
] =
866 bfd_get_section_by_name (input_bfd
, ".text");
867 symndx_to_section
[RELOC_SECTION_RDATA
] =
868 bfd_get_section_by_name (input_bfd
, ".rdata");
869 symndx_to_section
[RELOC_SECTION_DATA
] =
870 bfd_get_section_by_name (input_bfd
, ".data");
871 symndx_to_section
[RELOC_SECTION_SDATA
] =
872 bfd_get_section_by_name (input_bfd
, ".sdata");
873 symndx_to_section
[RELOC_SECTION_SBSS
] =
874 bfd_get_section_by_name (input_bfd
, ".sbss");
875 symndx_to_section
[RELOC_SECTION_BSS
] =
876 bfd_get_section_by_name (input_bfd
, ".bss");
877 symndx_to_section
[RELOC_SECTION_INIT
] =
878 bfd_get_section_by_name (input_bfd
, ".init");
879 symndx_to_section
[RELOC_SECTION_LIT8
] =
880 bfd_get_section_by_name (input_bfd
, ".lit8");
881 symndx_to_section
[RELOC_SECTION_LIT4
] =
882 bfd_get_section_by_name (input_bfd
, ".lit4");
883 symndx_to_section
[RELOC_SECTION_XDATA
] = NULL
;
884 symndx_to_section
[RELOC_SECTION_PDATA
] = NULL
;
885 symndx_to_section
[RELOC_SECTION_FINI
] =
886 bfd_get_section_by_name (input_bfd
, ".fini");
887 symndx_to_section
[RELOC_SECTION_LITA
] = NULL
;
888 symndx_to_section
[RELOC_SECTION_ABS
] = NULL
;
890 ecoff_data (input_bfd
)->symndx_to_section
= symndx_to_section
;
893 sym_hashes
= ecoff_data (input_bfd
)->sym_hashes
;
895 gp
= _bfd_get_gp_value (output_bfd
);
899 gp_undefined
= FALSE
;
903 ext_rel
= (struct external_reloc
*) external_relocs
;
904 ext_rel_end
= ext_rel
+ input_section
->reloc_count
;
905 for (i
= 0; ext_rel
< ext_rel_end
; ext_rel
++, i
++)
907 struct internal_reloc int_rel
;
908 bfd_boolean use_lo
= FALSE
;
910 reloc_howto_type
*howto
;
911 struct ecoff_link_hash_entry
*h
= NULL
;
914 bfd_reloc_status_type r
;
917 mips_ecoff_swap_reloc_in (input_bfd
, (PTR
) ext_rel
, &int_rel
);
920 int_rel
= lo_int_rel
;
924 BFD_ASSERT (int_rel
.r_type
925 < sizeof mips_howto_table
/ sizeof mips_howto_table
[0]);
927 /* The REFHI reloc requires special handling. It must be followed
928 by a REFLO reloc, and the addend is formed from both relocs. */
929 if (int_rel
.r_type
== MIPS_R_REFHI
)
931 struct external_reloc
*lo_ext_rel
;
933 /* As a GNU extension, permit an arbitrary number of REFHI
934 relocs before the REFLO reloc. This permits gcc to emit
935 the HI and LO relocs itself. */
936 for (lo_ext_rel
= ext_rel
+ 1;
937 lo_ext_rel
< ext_rel_end
;
940 mips_ecoff_swap_reloc_in (input_bfd
, (PTR
) lo_ext_rel
,
942 if (lo_int_rel
.r_type
!= int_rel
.r_type
)
946 if (lo_ext_rel
< ext_rel_end
947 && lo_int_rel
.r_type
== MIPS_R_REFLO
948 && int_rel
.r_extern
== lo_int_rel
.r_extern
949 && int_rel
.r_symndx
== lo_int_rel
.r_symndx
)
952 if (lo_ext_rel
== ext_rel
+ 1)
957 howto
= &mips_howto_table
[int_rel
.r_type
];
959 if (int_rel
.r_extern
)
961 h
= sym_hashes
[int_rel
.r_symndx
];
962 /* If h is NULL, that means that there is a reloc against an
963 external symbol which we thought was just a debugging
964 symbol. This should not happen. */
965 if (h
== (struct ecoff_link_hash_entry
*) NULL
)
970 if (int_rel
.r_symndx
< 0 || int_rel
.r_symndx
>= NUM_RELOC_SECTIONS
)
973 s
= symndx_to_section
[int_rel
.r_symndx
];
975 if (s
== (asection
*) NULL
)
979 /* The GPREL reloc uses an addend: the difference in the GP
981 if (int_rel
.r_type
!= MIPS_R_GPREL
982 && int_rel
.r_type
!= MIPS_R_LITERAL
)
988 if (! ((*info
->callbacks
->reloc_dangerous
)
989 (info
, _("GP relative relocation used when GP not defined"),
990 input_bfd
, input_section
,
991 int_rel
.r_vaddr
- input_section
->vma
)))
993 /* Only give the error once per link. */
995 _bfd_set_gp_value (output_bfd
, gp
);
996 gp_undefined
= FALSE
;
998 if (! int_rel
.r_extern
)
1000 /* This is a relocation against a section. The current
1001 addend in the instruction is the difference between
1002 INPUT_SECTION->vma and the GP value of INPUT_BFD. We
1003 must change this to be the difference between the
1004 final definition (which will end up in RELOCATION)
1005 and the GP value of OUTPUT_BFD (which is in GP). */
1006 addend
= ecoff_data (input_bfd
)->gp
- gp
;
1008 else if (! info
->relocatable
1009 || h
->root
.type
== bfd_link_hash_defined
1010 || h
->root
.type
== bfd_link_hash_defweak
)
1012 /* This is a relocation against a defined symbol. The
1013 current addend in the instruction is simply the
1014 desired offset into the symbol (normally zero). We
1015 are going to change this into a relocation against a
1016 defined symbol, so we want the instruction to hold
1017 the difference between the final definition of the
1018 symbol (which will end up in RELOCATION) and the GP
1019 value of OUTPUT_BFD (which is in GP). */
1024 /* This is a relocation against an undefined or common
1025 symbol. The current addend in the instruction is
1026 simply the desired offset into the symbol (normally
1027 zero). We are generating relocatable output, and we
1028 aren't going to define this symbol, so we just leave
1029 the instruction alone. */
1034 if (info
->relocatable
)
1036 /* We are generating relocatable output, and must convert
1037 the existing reloc. */
1038 if (int_rel
.r_extern
)
1040 if ((h
->root
.type
== bfd_link_hash_defined
1041 || h
->root
.type
== bfd_link_hash_defweak
)
1042 && ! bfd_is_abs_section (h
->root
.u
.def
.section
))
1046 /* This symbol is defined in the output. Convert
1047 the reloc from being against the symbol to being
1048 against the section. */
1050 /* Clear the r_extern bit. */
1051 int_rel
.r_extern
= 0;
1053 /* Compute a new r_symndx value. */
1054 s
= h
->root
.u
.def
.section
;
1055 name
= bfd_get_section_name (output_bfd
,
1058 int_rel
.r_symndx
= -1;
1062 if (strcmp (name
, ".bss") == 0)
1063 int_rel
.r_symndx
= RELOC_SECTION_BSS
;
1066 if (strcmp (name
, ".data") == 0)
1067 int_rel
.r_symndx
= RELOC_SECTION_DATA
;
1070 if (strcmp (name
, ".fini") == 0)
1071 int_rel
.r_symndx
= RELOC_SECTION_FINI
;
1074 if (strcmp (name
, ".init") == 0)
1075 int_rel
.r_symndx
= RELOC_SECTION_INIT
;
1078 if (strcmp (name
, ".lit8") == 0)
1079 int_rel
.r_symndx
= RELOC_SECTION_LIT8
;
1080 else if (strcmp (name
, ".lit4") == 0)
1081 int_rel
.r_symndx
= RELOC_SECTION_LIT4
;
1084 if (strcmp (name
, ".rdata") == 0)
1085 int_rel
.r_symndx
= RELOC_SECTION_RDATA
;
1088 if (strcmp (name
, ".sdata") == 0)
1089 int_rel
.r_symndx
= RELOC_SECTION_SDATA
;
1090 else if (strcmp (name
, ".sbss") == 0)
1091 int_rel
.r_symndx
= RELOC_SECTION_SBSS
;
1094 if (strcmp (name
, ".text") == 0)
1095 int_rel
.r_symndx
= RELOC_SECTION_TEXT
;
1099 if (int_rel
.r_symndx
== -1)
1102 /* Add the section VMA and the symbol value. */
1103 relocation
= (h
->root
.u
.def
.value
1104 + s
->output_section
->vma
1105 + s
->output_offset
);
1107 /* For a PC relative relocation, the object file
1108 currently holds just the addend. We must adjust
1109 by the address to get the right value. */
1110 if (howto
->pc_relative
)
1111 relocation
-= int_rel
.r_vaddr
- input_section
->vma
;
1117 /* Change the symndx value to the right one for the
1119 int_rel
.r_symndx
= h
->indx
;
1120 if (int_rel
.r_symndx
== -1)
1122 /* This symbol is not being written out. */
1123 if (! ((*info
->callbacks
->unattached_reloc
)
1124 (info
, h
->root
.root
.string
, input_bfd
,
1126 int_rel
.r_vaddr
- input_section
->vma
)))
1128 int_rel
.r_symndx
= 0;
1135 /* This is a relocation against a section. Adjust the
1136 value by the amount the section moved. */
1137 relocation
= (s
->output_section
->vma
1142 relocation
+= addend
;
1145 /* Adjust a PC relative relocation by removing the reference
1146 to the original address in the section and including the
1147 reference to the new address. */
1148 if (howto
->pc_relative
)
1149 relocation
-= (input_section
->output_section
->vma
1150 + input_section
->output_offset
1151 - input_section
->vma
);
1153 /* Adjust the contents. */
1154 if (relocation
== 0)
1158 if (int_rel
.r_type
!= MIPS_R_REFHI
)
1159 r
= _bfd_relocate_contents (howto
, input_bfd
, relocation
,
1162 - input_section
->vma
));
1165 mips_relocate_hi (&int_rel
,
1166 use_lo
? &lo_int_rel
: NULL
,
1167 input_bfd
, input_section
, contents
,
1173 /* Adjust the reloc address. */
1174 int_rel
.r_vaddr
+= (input_section
->output_section
->vma
1175 + input_section
->output_offset
1176 - input_section
->vma
);
1178 /* Save the changed reloc information. */
1179 mips_ecoff_swap_reloc_out (input_bfd
, &int_rel
, (PTR
) ext_rel
);
1183 /* We are producing a final executable. */
1184 if (int_rel
.r_extern
)
1186 /* This is a reloc against a symbol. */
1187 if (h
->root
.type
== bfd_link_hash_defined
1188 || h
->root
.type
== bfd_link_hash_defweak
)
1192 hsec
= h
->root
.u
.def
.section
;
1193 relocation
= (h
->root
.u
.def
.value
1194 + hsec
->output_section
->vma
1195 + hsec
->output_offset
);
1199 if (! ((*info
->callbacks
->undefined_symbol
)
1200 (info
, h
->root
.root
.string
, input_bfd
,
1202 int_rel
.r_vaddr
- input_section
->vma
, TRUE
)))
1209 /* This is a reloc against a section. */
1210 relocation
= (s
->output_section
->vma
1214 /* A PC relative reloc is already correct in the object
1215 file. Make it look like a pcrel_offset relocation by
1216 adding in the start address. */
1217 if (howto
->pc_relative
)
1218 relocation
+= int_rel
.r_vaddr
;
1221 if (int_rel
.r_type
!= MIPS_R_REFHI
)
1222 r
= _bfd_final_link_relocate (howto
,
1227 - input_section
->vma
),
1232 mips_relocate_hi (&int_rel
,
1233 use_lo
? &lo_int_rel
: NULL
,
1234 input_bfd
, input_section
, contents
,
1240 /* MIPS_R_JMPADDR requires peculiar overflow detection. The
1241 instruction provides a 28 bit address (the two lower bits are
1242 implicit zeroes) which is combined with the upper four bits
1243 of the instruction address. */
1244 if (r
== bfd_reloc_ok
1245 && int_rel
.r_type
== MIPS_R_JMPADDR
1248 + (int_rel
.r_extern
? 0 : s
->vma
))
1250 != ((input_section
->output_section
->vma
1251 + input_section
->output_offset
1252 + (int_rel
.r_vaddr
- input_section
->vma
))
1254 r
= bfd_reloc_overflow
;
1256 if (r
!= bfd_reloc_ok
)
1261 case bfd_reloc_outofrange
:
1263 case bfd_reloc_overflow
:
1267 if (int_rel
.r_extern
)
1268 name
= h
->root
.root
.string
;
1270 name
= bfd_section_name (input_bfd
, s
);
1271 if (! ((*info
->callbacks
->reloc_overflow
)
1272 (info
, name
, howto
->name
, (bfd_vma
) 0,
1273 input_bfd
, input_section
,
1274 int_rel
.r_vaddr
- input_section
->vma
)))
1285 /* This is the ECOFF backend structure. The backend field of the
1286 target vector points to this. */
1288 static const struct ecoff_backend_data mips_ecoff_backend_data
=
1290 /* COFF backend structure. */
1292 (void (*) PARAMS ((bfd
*,PTR
,int,int,int,int,PTR
))) bfd_void
, /* aux_in */
1293 (void (*) PARAMS ((bfd
*,PTR
,PTR
))) bfd_void
, /* sym_in */
1294 (void (*) PARAMS ((bfd
*,PTR
,PTR
))) bfd_void
, /* lineno_in */
1295 (unsigned (*) PARAMS ((bfd
*,PTR
,int,int,int,int,PTR
)))bfd_void
,/*aux_out*/
1296 (unsigned (*) PARAMS ((bfd
*,PTR
,PTR
))) bfd_void
, /* sym_out */
1297 (unsigned (*) PARAMS ((bfd
*,PTR
,PTR
))) bfd_void
, /* lineno_out */
1298 (unsigned (*) PARAMS ((bfd
*,PTR
,PTR
))) bfd_void
, /* reloc_out */
1299 mips_ecoff_swap_filehdr_out
, mips_ecoff_swap_aouthdr_out
,
1300 mips_ecoff_swap_scnhdr_out
,
1301 FILHSZ
, AOUTSZ
, SCNHSZ
, 0, 0, 0, 0, FILNMLEN
, TRUE
, FALSE
, 4, FALSE
, 2,
1302 mips_ecoff_swap_filehdr_in
, mips_ecoff_swap_aouthdr_in
,
1303 mips_ecoff_swap_scnhdr_in
, NULL
,
1304 mips_ecoff_bad_format_hook
, _bfd_ecoff_set_arch_mach_hook
,
1305 _bfd_ecoff_mkobject_hook
, _bfd_ecoff_styp_to_sec_flags
,
1306 _bfd_ecoff_set_alignment_hook
, _bfd_ecoff_slurp_symbol_table
,
1307 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
1310 /* Supported architecture. */
1312 /* Initial portion of armap string. */
1314 /* The page boundary used to align sections in a demand-paged
1315 executable file. E.g., 0x1000. */
1317 /* TRUE if the .rdata section is part of the text segment, as on the
1318 Alpha. FALSE if .rdata is part of the data segment, as on the
1321 /* Bitsize of constructor entries. */
1323 /* Reloc to use for constructor entries. */
1324 &mips_howto_table
[MIPS_R_REFWORD
],
1326 /* Symbol table magic number. */
1328 /* Alignment of debugging information. E.g., 4. */
1330 /* Sizes of external symbolic information. */
1331 sizeof (struct hdr_ext
),
1332 sizeof (struct dnr_ext
),
1333 sizeof (struct pdr_ext
),
1334 sizeof (struct sym_ext
),
1335 sizeof (struct opt_ext
),
1336 sizeof (struct fdr_ext
),
1337 sizeof (struct rfd_ext
),
1338 sizeof (struct ext_ext
),
1339 /* Functions to swap in external symbolic data. */
1348 _bfd_ecoff_swap_tir_in
,
1349 _bfd_ecoff_swap_rndx_in
,
1350 /* Functions to swap out external symbolic data. */
1359 _bfd_ecoff_swap_tir_out
,
1360 _bfd_ecoff_swap_rndx_out
,
1361 /* Function to read in symbolic data. */
1362 _bfd_ecoff_slurp_symbolic_info
1364 /* External reloc size. */
1366 /* Reloc swapping functions. */
1367 mips_ecoff_swap_reloc_in
,
1368 mips_ecoff_swap_reloc_out
,
1369 /* Backend reloc tweaking. */
1370 mips_adjust_reloc_in
,
1371 mips_adjust_reloc_out
,
1372 /* Relocate section contents while linking. */
1373 mips_relocate_section
,
1374 /* Do final adjustments to filehdr and aouthdr. */
1376 /* Read an element from an archive at a given file position. */
1377 _bfd_get_elt_at_filepos
1380 /* Looking up a reloc type is MIPS specific. */
1381 #define _bfd_ecoff_bfd_reloc_type_lookup mips_bfd_reloc_type_lookup
1383 /* Getting relocated section contents is generic. */
1384 #define _bfd_ecoff_bfd_get_relocated_section_contents \
1385 bfd_generic_get_relocated_section_contents
1387 /* Handling file windows is generic. */
1388 #define _bfd_ecoff_get_section_contents_in_window \
1389 _bfd_generic_get_section_contents_in_window
1391 /* Relaxing sections is MIPS specific. */
1392 #define _bfd_ecoff_bfd_relax_section bfd_generic_relax_section
1394 /* GC of sections is not done. */
1395 #define _bfd_ecoff_bfd_gc_sections bfd_generic_gc_sections
1397 /* Merging of sections is not done. */
1398 #define _bfd_ecoff_bfd_merge_sections bfd_generic_merge_sections
1400 #define _bfd_ecoff_bfd_is_group_section bfd_generic_is_group_section
1401 #define _bfd_ecoff_bfd_discard_group bfd_generic_discard_group
1403 extern const bfd_target ecoff_big_vec
;
1405 const bfd_target ecoff_little_vec
=
1407 "ecoff-littlemips", /* name */
1408 bfd_target_ecoff_flavour
,
1409 BFD_ENDIAN_LITTLE
, /* data byte order is little */
1410 BFD_ENDIAN_LITTLE
, /* header byte order is little */
1412 (HAS_RELOC
| EXEC_P
| /* object flags */
1413 HAS_LINENO
| HAS_DEBUG
|
1414 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
| D_PAGED
),
1416 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_CODE
| SEC_DATA
),
1417 0, /* leading underscore */
1418 ' ', /* ar_pad_char */
1419 15, /* ar_max_namelen */
1420 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
1421 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
1422 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* data */
1423 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
1424 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
1425 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* hdrs */
1427 {_bfd_dummy_target
, coff_object_p
, /* bfd_check_format */
1428 _bfd_ecoff_archive_p
, _bfd_dummy_target
},
1429 {bfd_false
, _bfd_ecoff_mkobject
, /* bfd_set_format */
1430 _bfd_generic_mkarchive
, bfd_false
},
1431 {bfd_false
, _bfd_ecoff_write_object_contents
, /* bfd_write_contents */
1432 _bfd_write_archive_contents
, bfd_false
},
1434 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff
),
1435 BFD_JUMP_TABLE_COPY (_bfd_ecoff
),
1436 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
1437 BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff
),
1438 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff
),
1439 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff
),
1440 BFD_JUMP_TABLE_WRITE (_bfd_ecoff
),
1441 BFD_JUMP_TABLE_LINK (_bfd_ecoff
),
1442 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),
1446 (PTR
) &mips_ecoff_backend_data
1449 const bfd_target ecoff_big_vec
=
1451 "ecoff-bigmips", /* name */
1452 bfd_target_ecoff_flavour
,
1453 BFD_ENDIAN_BIG
, /* data byte order is big */
1454 BFD_ENDIAN_BIG
, /* header byte order is big */
1456 (HAS_RELOC
| EXEC_P
| /* object flags */
1457 HAS_LINENO
| HAS_DEBUG
|
1458 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
| D_PAGED
),
1460 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_CODE
| SEC_DATA
),
1461 0, /* leading underscore */
1462 ' ', /* ar_pad_char */
1463 15, /* ar_max_namelen */
1464 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
1465 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
1466 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
,
1467 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
1468 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
1469 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
,
1470 {_bfd_dummy_target
, coff_object_p
, /* bfd_check_format */
1471 _bfd_ecoff_archive_p
, _bfd_dummy_target
},
1472 {bfd_false
, _bfd_ecoff_mkobject
, /* bfd_set_format */
1473 _bfd_generic_mkarchive
, bfd_false
},
1474 {bfd_false
, _bfd_ecoff_write_object_contents
, /* bfd_write_contents */
1475 _bfd_write_archive_contents
, bfd_false
},
1477 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff
),
1478 BFD_JUMP_TABLE_COPY (_bfd_ecoff
),
1479 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
1480 BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff
),
1481 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff
),
1482 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff
),
1483 BFD_JUMP_TABLE_WRITE (_bfd_ecoff
),
1484 BFD_JUMP_TABLE_LINK (_bfd_ecoff
),
1485 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),
1489 (PTR
) &mips_ecoff_backend_data
1492 const bfd_target ecoff_biglittle_vec
=
1494 "ecoff-biglittlemips", /* name */
1495 bfd_target_ecoff_flavour
,
1496 BFD_ENDIAN_LITTLE
, /* data byte order is little */
1497 BFD_ENDIAN_BIG
, /* header byte order is big */
1499 (HAS_RELOC
| EXEC_P
| /* object flags */
1500 HAS_LINENO
| HAS_DEBUG
|
1501 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
| D_PAGED
),
1503 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_CODE
| SEC_DATA
),
1504 0, /* leading underscore */
1505 ' ', /* ar_pad_char */
1506 15, /* ar_max_namelen */
1507 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
1508 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
1509 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* data */
1510 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
1511 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
1512 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* hdrs */
1514 {_bfd_dummy_target
, coff_object_p
, /* bfd_check_format */
1515 _bfd_ecoff_archive_p
, _bfd_dummy_target
},
1516 {bfd_false
, _bfd_ecoff_mkobject
, /* bfd_set_format */
1517 _bfd_generic_mkarchive
, bfd_false
},
1518 {bfd_false
, _bfd_ecoff_write_object_contents
, /* bfd_write_contents */
1519 _bfd_write_archive_contents
, bfd_false
},
1521 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff
),
1522 BFD_JUMP_TABLE_COPY (_bfd_ecoff
),
1523 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
1524 BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff
),
1525 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff
),
1526 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff
),
1527 BFD_JUMP_TABLE_WRITE (_bfd_ecoff
),
1528 BFD_JUMP_TABLE_LINK (_bfd_ecoff
),
1529 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),
1533 (PTR
) &mips_ecoff_backend_data