1 /* BFD back-end for Intel 960 COFF files.
2 Copyright (C) 1990, 91, 92, 93, 94, 1995 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 #define BADMAG(x) I960BADMAG(x)
28 #include "coff/i960.h"
29 #include "coff/internal.h"
30 #include "libcoff.h" /* to allow easier abstraction-breaking */
32 static bfd_reloc_status_type optcall_callback
33 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
34 static bfd_reloc_status_type coff_i960_relocate
35 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
36 static reloc_howto_type
*coff_i960_reloc_type_lookup
37 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
38 static boolean coff_i960_start_final_link
39 PARAMS ((bfd
*, struct bfd_link_info
*));
40 static boolean coff_i960_relocate_section
41 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
42 struct internal_reloc
*, struct internal_syment
*, asection
**));
43 static boolean coff_i960_adjust_symndx
44 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*,
45 struct internal_reloc
*, boolean
*));
47 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
49 /* The i960 does not support an MMU, so COFF_PAGE_SIZE can be
51 #define COFF_PAGE_SIZE 1
53 #define COFF_LONG_FILENAMES
55 #define CALLS 0x66003800 /* Template for 'calls' instruction */
56 #define BAL 0x0b000000 /* Template for 'bal' instruction */
57 #define BAL_MASK 0x00ffffff
59 static bfd_reloc_status_type
60 optcall_callback (abfd
, reloc_entry
, symbol_in
, data
,
61 input_section
, ignore_bfd
, error_message
)
66 asection
*input_section
;
70 /* This item has already been relocated correctly, but we may be
71 * able to patch in yet better code - done by digging out the
72 * correct info on this symbol */
73 bfd_reloc_status_type result
;
74 coff_symbol_type
*cs
= coffsymbol(symbol_in
);
76 /* Don't do anything with symbols which aren't tied up yet,
77 except move the reloc. */
78 if (bfd_is_und_section (cs
->symbol
.section
)) {
79 reloc_entry
->address
+= input_section
->output_offset
;
83 /* So the target symbol has to be of coff type, and the symbol
84 has to have the correct native information within it */
85 if ((bfd_asymbol_flavour(&cs
->symbol
) != bfd_target_coff_flavour
)
86 || (cs
->native
== (combined_entry_type
*)NULL
))
88 /* This is interesting, consider the case where we're outputting coff
89 from a mix n match input, linking from coff to a symbol defined in a
90 bout file will cause this match to be true. Should I complain? This
91 will only work if the bout symbol is non leaf. */
93 (char *) "uncertain calling convention for non-COFF symbol";
94 result
= bfd_reloc_dangerous
;
98 switch (cs
->native
->u
.syment
.n_sclass
)
102 /* This is a call to a leaf procedure, replace instruction with a bal
103 to the correct location. */
105 union internal_auxent
*aux
= &((cs
->native
+2)->u
.auxent
);
106 int word
= bfd_get_32(abfd
, (bfd_byte
*)data
+ reloc_entry
->address
);
107 int olf
= (aux
->x_bal
.x_balntry
- cs
->native
->u
.syment
.n_value
);
108 BFD_ASSERT(cs
->native
->u
.syment
.n_numaux
==2);
110 /* We replace the original call instruction with a bal to
111 the bal entry point - the offset of which is described in
112 the 2nd auxent of the original symbol. We keep the native
113 sym and auxents untouched, so the delta between the two
114 is the offset of the bal entry point. */
115 word
= ((word
+ olf
) & BAL_MASK
) | BAL
;
116 bfd_put_32(abfd
, word
, (bfd_byte
*) data
+ reloc_entry
->address
);
118 result
= bfd_reloc_ok
;
121 /* This is a call to a system call, replace with a calls to # */
123 result
= bfd_reloc_ok
;
126 result
= bfd_reloc_ok
;
133 /* i960 COFF is used by VxWorks 5.1. However, VxWorks 5.1 does not
134 appear to correctly handle a reloc against a symbol defined in the
135 same object file. It appears to simply discard such relocs, rather
136 than adding their values into the object file. We handle this here
137 by converting all relocs against defined symbols into relocs
138 against the section symbol, when generating a relocateable output
141 Note that this function is only called if we are not using the COFF
142 specific backend linker. It only does something when doing a
143 relocateable link, which will almost certainly fail when not
144 generating COFF i960 output, so this function is actually no longer
145 useful. It was used before this target was converted to use the
146 COFF specific backend linker. */
148 static bfd_reloc_status_type
149 coff_i960_relocate (abfd
, reloc_entry
, symbol
, data
, input_section
,
150 output_bfd
, error_message
)
152 arelent
*reloc_entry
;
155 asection
*input_section
;
157 char **error_message
;
161 if (output_bfd
== NULL
)
163 /* Not generating relocateable output file. */
164 return bfd_reloc_continue
;
167 if (bfd_is_und_section (bfd_get_section (symbol
)))
169 /* Symbol is not defined, so no need to worry about it. */
170 return bfd_reloc_continue
;
173 if (bfd_is_com_section (bfd_get_section (symbol
)))
175 /* I don't really know what the right action is for a common
177 return bfd_reloc_continue
;
180 /* Convert the reloc to use the section symbol. FIXME: This method
182 osec
= bfd_get_section (symbol
)->output_section
;
183 if (coff_section_data (output_bfd
, osec
) != NULL
184 && coff_section_data (output_bfd
, osec
)->tdata
!= NULL
)
185 reloc_entry
->sym_ptr_ptr
=
186 (asymbol
**) coff_section_data (output_bfd
, osec
)->tdata
;
189 const char *sec_name
;
190 asymbol
**syms
, **sym_end
;
192 sec_name
= bfd_get_section_name (output_bfd
, osec
);
193 syms
= bfd_get_outsymbols (output_bfd
);
194 sym_end
= syms
+ bfd_get_symcount (output_bfd
);
195 for (; syms
< sym_end
; syms
++)
197 if (bfd_asymbol_name (*syms
) != NULL
198 && (*syms
)->value
== 0
199 && strcmp ((*syms
)->section
->output_section
->name
,
207 reloc_entry
->sym_ptr_ptr
= syms
;
209 if (coff_section_data (output_bfd
, osec
) == NULL
)
212 ((PTR
) bfd_zalloc (abfd
,
213 sizeof (struct coff_section_tdata
)));
214 if (osec
->used_by_bfd
== NULL
)
215 return bfd_reloc_overflow
;
217 coff_section_data (output_bfd
, osec
)->tdata
= (PTR
) syms
;
220 /* Let bfd_perform_relocation do its thing, which will include
221 stuffing the symbol addend into the object file. */
222 return bfd_reloc_continue
;
225 static reloc_howto_type howto_rellong
=
226 HOWTO ((unsigned int) R_RELLONG
, 0, 2, 32,false, 0,
227 complain_overflow_bitfield
, coff_i960_relocate
,"rellong", true,
228 0xffffffff, 0xffffffff, 0);
229 static reloc_howto_type howto_iprmed
=
230 HOWTO (R_IPRMED
, 0, 2, 24,true,0, complain_overflow_signed
,
231 coff_i960_relocate
, "iprmed ", true, 0x00ffffff, 0x00ffffff, 0);
232 static reloc_howto_type howto_optcall
=
233 HOWTO (R_OPTCALL
, 0,2,24,true,0, complain_overflow_signed
,
234 optcall_callback
, "optcall", true, 0x00ffffff, 0x00ffffff, 0);
236 static reloc_howto_type
*
237 coff_i960_reloc_type_lookup (abfd
, code
)
239 bfd_reloc_code_real_type code
;
245 case BFD_RELOC_I960_CALLJ
:
246 return &howto_optcall
;
249 return &howto_rellong
;
250 case BFD_RELOC_24_PCREL
:
251 return &howto_iprmed
;
255 /* The real code is in coffcode.h */
257 #define RTYPE2HOWTO(cache_ptr, dst) \
259 reloc_howto_type *howto_ptr; \
260 switch ((dst)->r_type) { \
261 case 17: howto_ptr = &howto_rellong; break; \
262 case 25: howto_ptr = &howto_iprmed; break; \
263 case 27: howto_ptr = &howto_optcall; break; \
264 default: howto_ptr = 0; break; \
266 (cache_ptr)->howto = howto_ptr; \
269 /* i960 COFF is used by VxWorks 5.1. However, VxWorks 5.1 does not
270 appear to correctly handle a reloc against a symbol defined in the
271 same object file. It appears to simply discard such relocs, rather
272 than adding their values into the object file. We handle this by
273 converting all relocs against global symbols into relocs against
274 internal symbols at the start of the section. This routine is
275 called at the start of the linking process, and it creates the
276 necessary symbols. */
279 coff_i960_start_final_link (abfd
, info
)
281 struct bfd_link_info
*info
;
283 bfd_size_type symesz
= bfd_coff_symesz (abfd
);
287 if (! info
->relocateable
)
290 esym
= (bfd_byte
*) malloc (symesz
);
293 bfd_set_error (bfd_error_no_memory
);
297 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
300 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
302 struct internal_syment isym
;
304 strncpy (isym
._n
._n_name
, o
->name
, SYMNMLEN
);
306 isym
.n_scnum
= o
->target_index
;
307 isym
.n_type
= T_NULL
;
308 isym
.n_sclass
= C_STAT
;
311 bfd_coff_swap_sym_out (abfd
, (PTR
) &isym
, (PTR
) esym
);
313 if (bfd_write (esym
, symesz
, 1, abfd
) != symesz
)
319 obj_raw_syment_count (abfd
) += 1;
327 /* The reloc processing routine for the optimized COFF linker. */
330 coff_i960_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
331 contents
, relocs
, syms
, sections
)
333 struct bfd_link_info
*info
;
335 asection
*input_section
;
337 struct internal_reloc
*relocs
;
338 struct internal_syment
*syms
;
341 struct internal_reloc
*rel
;
342 struct internal_reloc
*relend
;
345 relend
= rel
+ input_section
->reloc_count
;
346 for (; rel
< relend
; rel
++)
349 struct coff_link_hash_entry
*h
;
350 struct internal_syment
*sym
;
353 reloc_howto_type
*howto
;
354 bfd_reloc_status_type rstat
= bfd_reloc_ok
;
357 symndx
= rel
->r_symndx
;
366 h
= obj_coff_sym_hashes (input_bfd
)[symndx
];
370 if (sym
!= NULL
&& sym
->n_scnum
!= 0)
371 addend
= - sym
->n_value
;
377 case 17: howto
= &howto_rellong
; break;
378 case 25: howto
= &howto_iprmed
; break;
379 case 27: howto
= &howto_optcall
; break;
381 bfd_set_error (bfd_error_bad_value
);
393 sec
= bfd_abs_section_ptr
;
398 sec
= sections
[symndx
];
399 val
= (sec
->output_section
->vma
407 if (h
->root
.type
== bfd_link_hash_defined
408 || h
->root
.type
== bfd_link_hash_defweak
)
412 sec
= h
->root
.u
.def
.section
;
413 val
= (h
->root
.u
.def
.value
414 + sec
->output_section
->vma
415 + sec
->output_offset
);
417 else if (! info
->relocateable
)
419 if (! ((*info
->callbacks
->undefined_symbol
)
420 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
421 rel
->r_vaddr
- input_section
->vma
)))
428 if (howto
->type
== R_OPTCALL
&& ! info
->relocateable
&& symndx
!= -1)
435 class = sym
->n_sclass
;
440 /* This symbol is apparently not from a COFF input file.
441 We warn, and then assume that it is not a leaf
443 if (! ((*info
->callbacks
->reloc_dangerous
)
445 "uncertain calling convention for non-COFF symbol",
446 input_bfd
, input_section
,
447 rel
->r_vaddr
- input_section
->vma
)))
452 /* This is a call to a leaf procedure; use the bal
460 BFD_ASSERT (h
->numaux
== 2);
461 olf
= h
->aux
[1].x_bal
.x_balntry
;
466 union internal_auxent aux
;
468 BFD_ASSERT (sym
->n_numaux
== 2);
469 esyms
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
470 esyms
+= (symndx
+ 2) * bfd_coff_symesz (input_bfd
);
471 bfd_coff_swap_aux_in (input_bfd
, (PTR
) esyms
, sym
->n_type
,
472 sym
->n_sclass
, 1, sym
->n_numaux
,
474 olf
= aux
.x_bal
.x_balntry
;
477 word
= bfd_get_32 (input_bfd
,
479 + (rel
->r_vaddr
- input_section
->vma
)));
480 word
= ((word
+ olf
- val
) & BAL_MASK
) | BAL
;
481 bfd_put_32 (input_bfd
,
484 + (rel
->r_vaddr
- input_section
->vma
)));
495 rstat
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
497 rel
->r_vaddr
- input_section
->vma
,
506 case bfd_reloc_overflow
:
509 char buf
[SYMNMLEN
+ 1];
514 name
= h
->root
.root
.string
;
517 name
= _bfd_coff_internal_syment_name (input_bfd
, sym
, buf
);
522 if (! ((*info
->callbacks
->reloc_overflow
)
523 (info
, name
, howto
->name
, (bfd_vma
) 0, input_bfd
,
524 input_section
, rel
->r_vaddr
- input_section
->vma
)))
533 /* Adjust the symbol index of any reloc against a global symbol to
534 instead be a reloc against the internal symbol we created specially
539 coff_i960_adjust_symndx (obfd
, info
, ibfd
, sec
, irel
, adjustedp
)
541 struct bfd_link_info
*info
;
544 struct internal_reloc
*irel
;
547 struct coff_link_hash_entry
*h
;
551 h
= obj_coff_sym_hashes (ibfd
)[irel
->r_symndx
];
553 || (h
->root
.type
!= bfd_link_hash_defined
554 && h
->root
.type
!= bfd_link_hash_defweak
))
557 irel
->r_symndx
= h
->root
.u
.def
.section
->output_section
->target_index
- 1;
563 #define coff_start_final_link coff_i960_start_final_link
565 #define coff_relocate_section coff_i960_relocate_section
567 #define coff_adjust_symndx coff_i960_adjust_symndx
569 #define coff_bfd_reloc_type_lookup coff_i960_reloc_type_lookup
571 #include "coffcode.h"
573 const bfd_target icoff_little_vec
=
575 "coff-Intel-little", /* name */
576 bfd_target_coff_flavour
,
577 false, /* data byte order is little */
578 false, /* header byte order is little */
580 (HAS_RELOC
| EXEC_P
| /* object flags */
581 HAS_LINENO
| HAS_DEBUG
|
582 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
),
584 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
), /* section flags */
585 '_', /* leading underscore */
586 '/', /* ar_pad_char */
587 15, /* ar_max_namelen */
589 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
590 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
591 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* data */
592 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
593 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
594 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* hdrs */
596 {_bfd_dummy_target
, coff_object_p
, /* bfd_check_format */
597 bfd_generic_archive_p
, _bfd_dummy_target
},
598 {bfd_false
, coff_mkobject
, /* bfd_set_format */
599 _bfd_generic_mkarchive
, bfd_false
},
600 {bfd_false
, coff_write_object_contents
, /* bfd_write_contents */
601 _bfd_write_archive_contents
, bfd_false
},
603 BFD_JUMP_TABLE_GENERIC (coff
),
604 BFD_JUMP_TABLE_COPY (coff
),
605 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
606 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff
),
607 BFD_JUMP_TABLE_SYMBOLS (coff
),
608 BFD_JUMP_TABLE_RELOCS (coff
),
609 BFD_JUMP_TABLE_WRITE (coff
),
610 BFD_JUMP_TABLE_LINK (coff
),
611 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),
617 const bfd_target icoff_big_vec
=
619 "coff-Intel-big", /* name */
620 bfd_target_coff_flavour
,
621 false, /* data byte order is little */
622 true, /* header byte order is big */
624 (HAS_RELOC
| EXEC_P
| /* object flags */
625 HAS_LINENO
| HAS_DEBUG
|
626 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
),
628 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
), /* section flags */
629 '_', /* leading underscore */
630 '/', /* ar_pad_char */
631 15, /* ar_max_namelen */
633 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
634 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
635 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* data */
636 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
637 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
638 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* hdrs */
640 {_bfd_dummy_target
, coff_object_p
, /* bfd_check_format */
641 bfd_generic_archive_p
, _bfd_dummy_target
},
642 {bfd_false
, coff_mkobject
, /* bfd_set_format */
643 _bfd_generic_mkarchive
, bfd_false
},
644 {bfd_false
, coff_write_object_contents
, /* bfd_write_contents */
645 _bfd_write_archive_contents
, bfd_false
},
647 BFD_JUMP_TABLE_GENERIC (coff
),
648 BFD_JUMP_TABLE_COPY (coff
),
649 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
650 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff
),
651 BFD_JUMP_TABLE_SYMBOLS (coff
),
652 BFD_JUMP_TABLE_RELOCS (coff
),
653 BFD_JUMP_TABLE_WRITE (coff
),
654 BFD_JUMP_TABLE_LINK (coff
),
655 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),