1 /* BFD back-end for Hitachi Super-H COFF binaries.
2 Copyright 1993, 1994, 1995 Free Software Foundation, Inc.
3 Contributed by Cygnus Support.
4 Written by Steve Chamberlain, <sac@cygnus.com>.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 #include "coff/internal.h"
31 /* Internal functions. */
32 static bfd_reloc_status_type sh_reloc
33 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
34 static long get_symbol_value
PARAMS ((asymbol
*));
35 static boolean sh_relax_section
36 PARAMS ((bfd
*, asection
*, struct bfd_link_info
*, boolean
*));
37 static boolean sh_relax_delete_bytes
38 PARAMS ((bfd
*, asection
*, bfd_vma
, int));
39 static boolean sh_relocate_section
40 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
41 struct internal_reloc
*, struct internal_syment
*, asection
**));
42 static bfd_byte
*sh_coff_get_relocated_section_contents
43 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*,
44 bfd_byte
*, boolean
, asymbol
**));
46 /* Default section alignment to 2**2. */
47 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
49 /* Generate long file names. */
50 #define COFF_LONG_FILENAMES
52 /* The supported relocations. There are a lot of relocations defined
53 in coff/internal.h which we do not expect to ever see. */
54 static reloc_howto_type sh_coff_howtos
[] =
59 { 3 }, /* R_SH_PCREL8 */
60 { 4 }, /* R_SH_PCREL16 */
61 { 5 }, /* R_SH_HIGH8 */
62 { 6 }, /* R_SH_IMM24 */
63 { 7 }, /* R_SH_LOW16 */
65 { 9 }, /* R_SH_PCDISP8BY4 */
67 HOWTO (R_SH_PCDISP8BY2
, /* type */
69 1, /* size (0 = byte, 1 = short, 2 = long) */
71 true, /* pc_relative */
73 complain_overflow_signed
, /* complain_on_overflow */
74 sh_reloc
, /* special_function */
75 "r_pcdisp8by2", /* name */
76 true, /* partial_inplace */
79 true), /* pcrel_offset */
81 { 11 }, /* R_SH_PCDISP8 */
83 HOWTO (R_SH_PCDISP
, /* type */
85 1, /* size (0 = byte, 1 = short, 2 = long) */
87 true, /* pc_relative */
89 complain_overflow_signed
, /* complain_on_overflow */
90 sh_reloc
, /* special_function */
91 "r_pcdisp12by2", /* name */
92 true, /* partial_inplace */
95 true), /* pcrel_offset */
99 HOWTO (R_SH_IMM32
, /* type */
101 2, /* size (0 = byte, 1 = short, 2 = long) */
103 false, /* pc_relative */
105 complain_overflow_bitfield
, /* complain_on_overflow */
106 sh_reloc
, /* special_function */
107 "r_imm32", /* name */
108 true, /* partial_inplace */
109 0xffffffff, /* src_mask */
110 0xffffffff, /* dst_mask */
111 false), /* pcrel_offset */
114 { 16 }, /* R_SH_IMM8 */
115 { 17 }, /* R_SH_IMM8BY2 */
116 { 18 }, /* R_SH_IMM8BY4 */
117 { 19 }, /* R_SH_IMM4 */
118 { 20 }, /* R_SH_IMM4BY2 */
119 { 21 }, /* R_SH_IMM4BY4 */
121 HOWTO (R_SH_PCRELIMM8BY2
, /* type */
123 1, /* size (0 = byte, 1 = short, 2 = long) */
125 true, /* pc_relative */
127 complain_overflow_unsigned
, /* complain_on_overflow */
128 sh_reloc
, /* special_function */
129 "r_pcrelimm8by2", /* name */
130 true, /* partial_inplace */
133 true), /* pcrel_offset */
135 HOWTO (R_SH_PCRELIMM8BY4
, /* type */
137 1, /* size (0 = byte, 1 = short, 2 = long) */
139 true, /* pc_relative */
141 complain_overflow_unsigned
, /* complain_on_overflow */
142 sh_reloc
, /* special_function */
143 "r_pcrelimm8by4", /* name */
144 true, /* partial_inplace */
147 true), /* pcrel_offset */
149 HOWTO (R_SH_IMM16
, /* type */
151 1, /* size (0 = byte, 1 = short, 2 = long) */
153 false, /* pc_relative */
155 complain_overflow_bitfield
, /* complain_on_overflow */
156 sh_reloc
, /* special_function */
157 "r_imm16", /* name */
158 true, /* partial_inplace */
159 0xffff, /* src_mask */
160 0xffff, /* dst_mask */
161 false), /* pcrel_offset */
163 HOWTO (R_SH_SWITCH16
, /* type */
165 1, /* size (0 = byte, 1 = short, 2 = long) */
167 false, /* pc_relative */
169 complain_overflow_bitfield
, /* complain_on_overflow */
170 sh_reloc
, /* special_function */
171 "r_switch16", /* name */
172 true, /* partial_inplace */
173 0xffff, /* src_mask */
174 0xffff, /* dst_mask */
175 false), /* pcrel_offset */
177 HOWTO (R_SH_SWITCH32
, /* type */
179 2, /* size (0 = byte, 1 = short, 2 = long) */
181 false, /* pc_relative */
183 complain_overflow_bitfield
, /* complain_on_overflow */
184 sh_reloc
, /* special_function */
185 "r_switch32", /* name */
186 true, /* partial_inplace */
187 0xffffffff, /* src_mask */
188 0xffffffff, /* dst_mask */
189 false), /* pcrel_offset */
191 HOWTO (R_SH_USES
, /* type */
193 1, /* size (0 = byte, 1 = short, 2 = long) */
195 false, /* pc_relative */
197 complain_overflow_bitfield
, /* complain_on_overflow */
198 sh_reloc
, /* special_function */
200 true, /* partial_inplace */
201 0xffff, /* src_mask */
202 0xffff, /* dst_mask */
203 false), /* pcrel_offset */
205 HOWTO (R_SH_COUNT
, /* type */
207 2, /* size (0 = byte, 1 = short, 2 = long) */
209 false, /* pc_relative */
211 complain_overflow_bitfield
, /* complain_on_overflow */
212 sh_reloc
, /* special_function */
213 "r_count", /* name */
214 true, /* partial_inplace */
215 0xffffffff, /* src_mask */
216 0xffffffff, /* dst_mask */
217 false), /* pcrel_offset */
219 HOWTO (R_SH_ALIGN
, /* type */
221 2, /* size (0 = byte, 1 = short, 2 = long) */
223 false, /* pc_relative */
225 complain_overflow_bitfield
, /* complain_on_overflow */
226 sh_reloc
, /* special_function */
227 "r_align", /* name */
228 true, /* partial_inplace */
229 0xffffffff, /* src_mask */
230 0xffffffff, /* dst_mask */
231 false) /* pcrel_offset */
234 #define SH_COFF_HOWTO_COUNT (sizeof sh_coff_howtos / sizeof sh_coff_howtos[0])
236 /* Check for a bad magic number. */
237 #define BADMAG(x) SHBADMAG(x)
239 /* Customize coffcode.h (this is not currently used). */
242 /* FIXME: This should not be set here. */
243 #define __A_MAGIC_SET__
245 /* Swap the r_offset field in and out. */
246 #define SWAP_IN_RELOC_OFFSET bfd_h_get_32
247 #define SWAP_OUT_RELOC_OFFSET bfd_h_put_32
249 /* Swap out extra information in the reloc structure. */
250 #define SWAP_OUT_RELOC_EXTRA(abfd, src, dst) \
253 dst->r_stuff[0] = 'S'; \
254 dst->r_stuff[1] = 'C'; \
258 /* Get the value of a symbol, when performing a relocation. */
261 get_symbol_value (symbol
)
266 if (bfd_is_com_section (symbol
->section
))
269 relocation
= (symbol
->value
+
270 symbol
->section
->output_section
->vma
+
271 symbol
->section
->output_offset
);
276 /* This macro is used in coffcode.h to get the howto corresponding to
277 an internal reloc. */
279 #define RTYPE2HOWTO(relent, internal) \
281 ((internal)->r_type < SH_COFF_HOWTO_COUNT \
282 ? &sh_coff_howtos[(internal)->r_type] \
283 : (reloc_howto_type *) NULL))
285 /* This is the same as the macro in coffcode.h, except that it copies
286 r_offset into reloc_entry->addend for some relocs. */
287 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
289 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
290 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
291 coffsym = (obj_symbols (abfd) \
292 + (cache_ptr->sym_ptr_ptr - symbols)); \
294 coffsym = coff_symbol_from (abfd, ptr); \
295 if (coffsym != (coff_symbol_type *) NULL \
296 && coffsym->native->u.syment.n_scnum == 0) \
297 cache_ptr->addend = 0; \
298 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
299 && ptr->section != (asection *) NULL) \
300 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
302 cache_ptr->addend = 0; \
303 if ((reloc).r_type == R_SH_SWITCH16 \
304 || (reloc).r_type == R_SH_SWITCH32 \
305 || (reloc).r_type == R_SH_USES \
306 || (reloc).r_type == R_SH_COUNT \
307 || (reloc).r_type == R_SH_ALIGN) \
308 cache_ptr->addend = (reloc).r_offset; \
311 /* This is the howto function for the SH relocations. */
313 static bfd_reloc_status_type
314 sh_reloc (abfd
, reloc_entry
, symbol_in
, data
, input_section
, output_bfd
,
317 arelent
*reloc_entry
;
320 asection
*input_section
;
322 char **error_message
;
326 unsigned short r_type
;
327 bfd_vma addr
= reloc_entry
->address
;
328 bfd_byte
*hit_data
= addr
+ (bfd_byte
*) data
;
330 r_type
= reloc_entry
->howto
->type
;
332 if (output_bfd
!= NULL
)
334 /* Partial linking--do nothing. */
335 reloc_entry
->address
+= input_section
->output_offset
;
339 /* Almost all relocs have to do with relaxing. If any work must be
340 done for them, it has been done in sh_relax_section. */
341 if (r_type
!= R_SH_IMM32
342 && (r_type
!= R_SH_PCDISP
343 || (symbol_in
->flags
& BSF_LOCAL
) != 0))
346 if (symbol_in
!= NULL
347 && bfd_is_und_section (symbol_in
->section
))
348 return bfd_reloc_undefined
;
350 sym_value
= get_symbol_value (symbol_in
);
355 insn
= bfd_get_32 (abfd
, hit_data
);
356 insn
+= sym_value
+ reloc_entry
->addend
;
357 bfd_put_32 (abfd
, insn
, hit_data
);
360 insn
= bfd_get_16 (abfd
, hit_data
);
361 sym_value
+= reloc_entry
->addend
;
362 sym_value
-= (input_section
->output_section
->vma
363 + input_section
->output_offset
366 sym_value
+= (insn
& 0xfff) << 1;
369 insn
= (insn
& 0xf000) | (sym_value
& 0xfff);
370 bfd_put_16 (abfd
, insn
, hit_data
);
371 if (sym_value
< (bfd_vma
) -0x1000 || sym_value
>= 0x1000)
372 return bfd_reloc_overflow
;
382 /* We can do relaxing. */
383 #define coff_bfd_relax_section sh_relax_section
385 /* We use the special COFF backend linker. */
386 #define coff_relocate_section sh_relocate_section
388 /* When relaxing, we need to use special code to get the relocated
390 #define coff_bfd_get_relocated_section_contents \
391 sh_coff_get_relocated_section_contents
393 #include "coffcode.h"
395 /* This function handles relaxing on the SH.
397 Function calls on the SH look like this:
406 The compiler and assembler will cooperate to create R_SH_USES
407 relocs on the jsr instructions. The r_offset field of the
408 R_SH_USES reloc is the PC relative offset to the instruction which
409 loads the register (the r_offset field is computed as though it
410 were a jump instruction, so the offset value is actually from four
411 bytes past the instruction). The linker can use this reloc to
412 determine just which function is being called, and thus decide
413 whether it is possible to replace the jsr with a bsr.
415 If multiple function calls are all based on a single register load
416 (i.e., the same function is called multiple times), the compiler
417 guarantees that each function call will have an R_SH_USES reloc.
418 Therefore, if the linker is able to convert each R_SH_USES reloc
419 which refers to that address, it can safely eliminate the register
422 When the assembler creates an R_SH_USES reloc, it examines it to
423 determine which address is being loaded (L1 in the above example).
424 It then counts the number of references to that address, and
425 creates an R_SH_COUNT reloc at that address. The r_offset field of
426 the R_SH_COUNT reloc will be the number of references. If the
427 linker is able to eliminate a register load, it can use the
428 R_SH_COUNT reloc to see whether it can also eliminate the function
432 sh_relax_section (abfd
, sec
, link_info
, again
)
435 struct bfd_link_info
*link_info
;
438 struct internal_reloc
*internal_relocs
;
439 struct internal_reloc
*free_relocs
= NULL
;
440 struct internal_reloc
*irel
, *irelend
;
441 bfd_byte
*contents
= NULL
;
442 bfd_byte
*free_contents
= NULL
;
446 if (link_info
->relocateable
447 || (sec
->flags
& SEC_RELOC
) == 0
448 || sec
->reloc_count
== 0)
451 /* If this is the first time we have been called for this section,
452 initialize the cooked size. */
453 if (sec
->_cooked_size
== 0)
454 sec
->_cooked_size
= sec
->_raw_size
;
456 internal_relocs
= (_bfd_coff_read_internal_relocs
457 (abfd
, sec
, link_info
->keep_memory
,
458 (bfd_byte
*) NULL
, false,
459 (struct internal_reloc
*) NULL
));
460 if (internal_relocs
== NULL
)
462 if (! link_info
->keep_memory
)
463 free_relocs
= internal_relocs
;
465 irelend
= internal_relocs
+ sec
->reloc_count
;
466 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
468 bfd_vma laddr
, paddr
, symval
;
470 struct internal_reloc
*irelfn
, *irelscan
, *irelcount
;
471 struct internal_syment sym
;
474 if (irel
->r_type
!= R_SH_USES
)
477 /* Get the section contents. */
478 if (contents
== NULL
)
480 if (coff_section_data (abfd
, sec
) != NULL
481 && coff_section_data (abfd
, sec
)->contents
!= NULL
)
482 contents
= coff_section_data (abfd
, sec
)->contents
;
485 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
486 if (contents
== NULL
)
488 free_contents
= contents
;
490 if (! bfd_get_section_contents (abfd
, sec
, contents
,
491 (file_ptr
) 0, sec
->_raw_size
))
496 /* The r_offset field of the R_SH_USES reloc will point us to
497 the register load. The 4 is because the r_offset field is
498 computed as though it were a jump offset, which are based
499 from 4 bytes after the jump instruction. */
500 laddr
= irel
->r_vaddr
- sec
->vma
+ 4 + irel
->r_offset
;
501 if (laddr
>= sec
->_raw_size
)
503 (*_bfd_error_handler
) ("%s: 0x%lx: warning: bad R_SH_USES offset",
504 bfd_get_filename (abfd
),
505 (unsigned long) irel
->r_vaddr
);
508 insn
= bfd_get_16 (abfd
, contents
+ laddr
);
510 /* If the instruction is not mov.l NN,rN, we don't know what to
512 if ((insn
& 0xf000) != 0xd000)
514 ((*_bfd_error_handler
)
515 ("%s: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x",
516 bfd_get_filename (abfd
), (unsigned long) irel
->r_vaddr
, insn
));
520 /* Get the address from which the register is being loaded. The
521 displacement in the mov.l instruction is quadrupled. It is a
522 displacement from four bytes after the movl instruction, but,
523 before adding in the PC address, two least significant bits
524 of the PC are cleared. We assume that the section is aligned
525 on a four byte boundary. */
528 paddr
+= (laddr
+ 4) &~ 3;
529 if (paddr
>= sec
->_raw_size
)
531 ((*_bfd_error_handler
)
532 ("%s: 0x%lx: warning: bad R_SH_USES load offset",
533 bfd_get_filename (abfd
), (unsigned long) irel
->r_vaddr
));
537 /* Get the reloc for the address from which the register is
538 being loaded. This reloc will tell us which function is
539 actually being called. */
541 for (irelfn
= internal_relocs
; irelfn
< irelend
; irelfn
++)
542 if (irelfn
->r_vaddr
== paddr
543 && irelfn
->r_type
== R_SH_IMM32
)
545 if (irelfn
>= irelend
)
547 ((*_bfd_error_handler
)
548 ("%s: 0x%lx: warning: could not find expected reloc",
549 bfd_get_filename (abfd
), (unsigned long) paddr
));
553 /* Get the value of the symbol referred to by the reloc. */
554 if (! _bfd_coff_get_external_symbols (abfd
))
556 bfd_coff_swap_sym_in (abfd
,
557 ((bfd_byte
*) obj_coff_external_syms (abfd
)
559 * bfd_coff_symesz (abfd
))),
561 if (sym
.n_scnum
!= 0 && sym
.n_scnum
!= sec
->target_index
)
563 ((*_bfd_error_handler
)
564 ("%s: 0x%lx: warning: symbol in unexpected section",
565 bfd_get_filename (abfd
), (unsigned long) paddr
));
569 if (sym
.n_sclass
!= C_EXT
)
571 symval
= (sym
.n_value
573 + sec
->output_section
->vma
574 + sec
->output_offset
);
578 struct coff_link_hash_entry
*h
;
580 h
= obj_coff_sym_hashes (abfd
)[irelfn
->r_symndx
];
581 BFD_ASSERT (h
!= NULL
);
582 if (h
->root
.type
!= bfd_link_hash_defined
583 && h
->root
.type
!= bfd_link_hash_defweak
)
585 /* This appears to be a reference to an undefined
586 symbol. Just ignore it--it will be caught by the
587 regular reloc processing. */
591 symval
= (h
->root
.u
.def
.value
592 + h
->root
.u
.def
.section
->output_section
->vma
593 + h
->root
.u
.def
.section
->output_offset
);
596 symval
+= bfd_get_32 (abfd
, contents
+ paddr
- sec
->vma
);
598 /* See if this function call can be shortened. */
602 + sec
->output_section
->vma
605 if (foff
< -0x1000 || foff
>= 0x1000)
607 /* After all that work, we can't shorten this function call. */
611 /* Shorten the function call. */
613 /* For simplicity of coding, we are going to modify the section
614 contents, the section relocs, and the BFD symbol table. We
615 must tell the rest of the code not to free up this
616 information. It would be possible to instead create a table
617 of changes which have to be made, as is done in coff-mips.c;
618 that would be more work, but would require less memory when
619 the linker is run. */
621 if (coff_section_data (abfd
, sec
) == NULL
)
624 ((PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
)));
625 if (sec
->used_by_bfd
== NULL
)
629 coff_section_data (abfd
, sec
)->relocs
= internal_relocs
;
630 coff_section_data (abfd
, sec
)->keep_relocs
= true;
633 coff_section_data (abfd
, sec
)->contents
= contents
;
634 coff_section_data (abfd
, sec
)->keep_contents
= true;
635 free_contents
= NULL
;
637 obj_coff_keep_syms (abfd
) = true;
639 /* Replace the jsr with a bsr. */
641 /* Change the R_SH_USES reloc into an R_SH_PCDISP reloc, and
642 replace the jsr with a bsr. */
643 irel
->r_type
= R_SH_PCDISP
;
644 irel
->r_symndx
= irelfn
->r_symndx
;
645 if (sym
.n_sclass
!= C_EXT
)
647 /* If this needs to be changed because of future relaxing,
648 it will be handled here like other internal PCDISP
651 0xb000 | ((foff
>> 1) & 0xfff),
652 contents
+ irel
->r_vaddr
- sec
->vma
);
656 /* We can't fully resolve this yet, because the external
657 symbol value may be changed by future relaxing. We let
658 the final link phase handle it. */
659 bfd_put_16 (abfd
, 0xb000, contents
+ irel
->r_vaddr
- sec
->vma
);
662 /* See if there is another R_SH_USES reloc referring to the same
664 for (irelscan
= internal_relocs
; irelscan
< irelend
; irelscan
++)
665 if (irelscan
->r_type
== R_SH_USES
666 && laddr
== irelscan
->r_vaddr
- sec
->vma
+ 4 + irelscan
->r_offset
)
668 if (irelscan
< irelend
)
670 /* Some other function call depends upon this register load,
671 and we have not yet converted that function call.
672 Indeed, we may never be able to convert it. There is
673 nothing else we can do at this point. */
677 /* Look for a R_SH_COUNT reloc on the location where the
678 function address is stored. Do this before deleting any
679 bytes, to avoid confusion about the address. */
680 for (irelcount
= internal_relocs
; irelcount
< irelend
; irelcount
++)
681 if (irelcount
->r_vaddr
== paddr
682 && irelcount
->r_type
== R_SH_COUNT
)
685 /* Delete the register load. */
686 if (! sh_relax_delete_bytes (abfd
, sec
, laddr
, 2))
689 /* That will change things, so, just in case it permits some
690 other function call to come within range, we should relax
691 again. Note that this is not required, and it may be slow. */
694 /* Now check whether we got a COUNT reloc. */
695 if (irelcount
>= irelend
)
697 ((*_bfd_error_handler
)
698 ("%s: 0x%lx: warning: could not find expected COUNT reloc",
699 bfd_get_filename (abfd
), (unsigned long) paddr
));
703 /* The number of uses is stored in the r_offset field. We've
705 if (irelcount
->r_offset
== 0)
707 ((*_bfd_error_handler
) ("%s: 0x%lx: warning: bad count",
708 bfd_get_filename (abfd
),
709 (unsigned long) paddr
));
713 --irelcount
->r_offset
;
715 /* If there are no more uses, we can delete the address. Reload
716 the address from irelfn, in case it was changed by the
717 previous call to sh_relax_delete_bytes. */
718 if (irelcount
->r_offset
== 0)
720 if (! sh_relax_delete_bytes (abfd
, sec
,
721 irelfn
->r_vaddr
- sec
->vma
, 4))
725 /* We've done all we can with that function call. */
728 if (free_relocs
!= NULL
)
734 if (free_contents
!= NULL
)
736 if (! link_info
->keep_memory
)
737 free (free_contents
);
740 /* Cache the section contents for coff_link_input_bfd. */
741 if (coff_section_data (abfd
, sec
) == NULL
)
744 ((PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
)));
745 if (sec
->used_by_bfd
== NULL
)
747 coff_section_data (abfd
, sec
)->relocs
= NULL
;
749 coff_section_data (abfd
, sec
)->contents
= contents
;
756 if (free_relocs
!= NULL
)
758 if (free_contents
!= NULL
)
759 free (free_contents
);
763 /* Delete some bytes from a section while relaxing. */
766 sh_relax_delete_bytes (abfd
, sec
, addr
, count
)
773 struct internal_reloc
*irel
, *irelend
;
774 struct internal_reloc
*irelalign
;
776 bfd_byte
*esym
, *esymend
;
777 bfd_size_type symesz
;
778 struct coff_link_hash_entry
**sym_hash
;
781 contents
= coff_section_data (abfd
, sec
)->contents
;
783 /* The deletion must stop at the next ALIGN reloc for an aligment
784 power larger than the number of bytes we are deleting. */
787 toaddr
= sec
->_cooked_size
;
789 irel
= coff_section_data (abfd
, sec
)->relocs
;
790 irelend
= irel
+ sec
->reloc_count
;
791 for (; irel
< irelend
; irel
++)
793 if (irel
->r_type
== R_SH_ALIGN
794 && irel
->r_vaddr
- sec
->vma
> addr
795 && count
< (1 << irel
->r_offset
))
798 toaddr
= irel
->r_vaddr
- sec
->vma
;
803 /* Actually delete the bytes. */
804 memmove (contents
+ addr
, contents
+ addr
+ count
, toaddr
- addr
- count
);
805 if (irelalign
== NULL
)
806 sec
->_cooked_size
-= count
;
808 memset (contents
+ toaddr
- count
, 0, count
);
810 /* Adjust all the relocs. */
811 for (irel
= coff_section_data (abfd
, sec
)->relocs
; irel
< irelend
; irel
++)
813 bfd_vma nraddr
, start
, stop
;
815 struct internal_syment sym
;
816 int off
, adjust
, oinsn
;
820 /* Get the new reloc address. */
821 nraddr
= irel
->r_vaddr
- sec
->vma
;
822 if ((irel
->r_vaddr
- sec
->vma
> addr
823 && irel
->r_vaddr
- sec
->vma
< toaddr
)
824 || (irel
->r_type
== R_SH_ALIGN
825 && irel
->r_vaddr
- sec
->vma
== toaddr
))
828 /* See if this reloc was for the bytes we have deleted, in which
829 case we no longer care about it. */
830 if (irel
->r_vaddr
- sec
->vma
>= addr
831 && irel
->r_vaddr
- sec
->vma
< addr
+ count
832 && irel
->r_type
!= R_SH_ALIGN
)
833 irel
->r_type
= R_SH_UNUSED
;
835 /* If this is a PC relative reloc, see if the range it covers
836 includes the bytes we have deleted. */
837 switch (irel
->r_type
)
842 case R_SH_PCDISP8BY2
:
844 case R_SH_PCRELIMM8BY2
:
845 case R_SH_PCRELIMM8BY4
:
846 start
= irel
->r_vaddr
- sec
->vma
;
847 insn
= bfd_get_16 (abfd
, contents
+ nraddr
);
851 switch (irel
->r_type
)
858 /* If this reloc is against a symbol defined in this
859 section, and the symbol will not be adjusted below, we
860 must check the addend to see it will put the value in
861 range to be adjusted, and hence must be changed. */
862 bfd_coff_swap_sym_in (abfd
,
863 ((bfd_byte
*) obj_coff_external_syms (abfd
)
865 * bfd_coff_symesz (abfd
))),
867 if (sym
.n_sclass
!= C_EXT
868 && sym
.n_scnum
== sec
->target_index
869 && ((bfd_vma
) sym
.n_value
<= addr
870 || (bfd_vma
) sym
.n_value
>= toaddr
))
874 val
= bfd_get_32 (abfd
, contents
+ nraddr
);
876 if (val
>= addr
&& val
< toaddr
)
877 bfd_put_32 (abfd
, val
- count
, contents
+ nraddr
);
882 case R_SH_PCDISP8BY2
:
886 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ 4 + off
* 2);
890 bfd_coff_swap_sym_in (abfd
,
891 ((bfd_byte
*) obj_coff_external_syms (abfd
)
893 * bfd_coff_symesz (abfd
))),
895 if (sym
.n_sclass
== C_EXT
)
902 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ 4 + off
* 2);
906 case R_SH_PCRELIMM8BY2
:
908 stop
= start
+ 4 + off
* 2;
911 case R_SH_PCRELIMM8BY4
:
913 stop
= (start
&~ (bfd_vma
) 3) + 4 + off
* 4;
918 /* These relocs types represent
920 The r_offset field holds the difference between the reloc
921 address and L1. That is the start of the reloc, and
922 adding in the contents gives us the top. We must adjust
923 both the r_offset field and the section contents. */
925 start
= irel
->r_vaddr
- sec
->vma
;
926 stop
= (bfd_vma
) ((bfd_signed_vma
) start
- (long) irel
->r_offset
);
930 && (stop
<= addr
|| stop
>= toaddr
))
931 irel
->r_offset
+= count
;
934 && (start
<= addr
|| start
>= toaddr
))
935 irel
->r_offset
-= count
;
939 if (irel
->r_type
== R_SH_SWITCH16
)
940 voff
= bfd_get_signed_16 (abfd
, contents
+ nraddr
);
942 voff
= bfd_get_signed_32 (abfd
, contents
+ nraddr
);
943 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ voff
);
948 start
= irel
->r_vaddr
- sec
->vma
;
949 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ (long) irel
->r_offset
);
955 && (stop
<= addr
|| stop
>= toaddr
))
959 && (start
<= addr
|| start
>= toaddr
))
968 switch (irel
->r_type
)
974 case R_SH_PCDISP8BY2
:
975 case R_SH_PCRELIMM8BY2
:
977 if ((oinsn
& 0xff00) != (insn
& 0xff00))
979 bfd_put_16 (abfd
, insn
, contents
+ nraddr
);
984 if ((oinsn
& 0xf000) != (insn
& 0xf000))
986 bfd_put_16 (abfd
, insn
, contents
+ nraddr
);
989 case R_SH_PCRELIMM8BY4
:
990 BFD_ASSERT (adjust
== count
|| count
>= 4);
995 if ((irel
->r_vaddr
& 3) == 0)
998 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1000 bfd_put_16 (abfd
, insn
, contents
+ nraddr
);
1005 if (voff
< - 0x8000 || voff
>= 0x8000)
1007 bfd_put_signed_16 (abfd
, voff
, contents
+ nraddr
);
1012 bfd_put_signed_32 (abfd
, voff
, contents
+ nraddr
);
1016 irel
->r_offset
+= adjust
;
1022 ((*_bfd_error_handler
)
1023 ("%s: 0x%lx: fatal: reloc overflow while relaxing",
1024 bfd_get_filename (abfd
), (unsigned long) irel
->r_vaddr
));
1025 bfd_set_error (bfd_error_bad_value
);
1030 irel
->r_vaddr
= nraddr
+ sec
->vma
;
1033 /* Look through all the other sections. If there contain any IMM32
1034 relocs against internal symbols which we are not going to adjust
1035 below, we may need to adjust the addends. */
1036 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1038 struct internal_reloc
*internal_relocs
;
1039 struct internal_reloc
*irelscan
, *irelscanend
;
1040 bfd_byte
*ocontents
;
1043 || (o
->flags
& SEC_RELOC
) == 0
1044 || o
->reloc_count
== 0)
1047 /* We always cache the relocs. Perhaps, if info->keep_memory is
1048 false, we should free them, if we are permitted to, when we
1049 leave sh_coff_relax_section. */
1050 internal_relocs
= (_bfd_coff_read_internal_relocs
1051 (abfd
, o
, true, (bfd_byte
*) NULL
, false,
1052 (struct internal_reloc
*) NULL
));
1053 if (internal_relocs
== NULL
)
1057 irelscanend
= internal_relocs
+ o
->reloc_count
;
1058 for (irelscan
= internal_relocs
; irelscan
< irelscanend
; irelscan
++)
1060 struct internal_syment sym
;
1062 if (irelscan
->r_type
!= R_SH_IMM32
)
1065 bfd_coff_swap_sym_in (abfd
,
1066 ((bfd_byte
*) obj_coff_external_syms (abfd
)
1067 + (irelscan
->r_symndx
1068 * bfd_coff_symesz (abfd
))),
1070 if (sym
.n_sclass
!= C_EXT
1071 && sym
.n_scnum
== sec
->target_index
1072 && ((bfd_vma
) sym
.n_value
<= addr
1073 || (bfd_vma
) sym
.n_value
>= toaddr
))
1077 if (ocontents
== NULL
)
1079 if (coff_section_data (abfd
, o
)->contents
!= NULL
)
1080 ocontents
= coff_section_data (abfd
, o
)->contents
;
1083 /* We always cache the section contents.
1084 Perhaps, if info->keep_memory is false, we
1085 should free them, if we are permitted to,
1086 when we leave sh_coff_relax_section. */
1087 ocontents
= (bfd_byte
*) bfd_malloc (o
->_raw_size
);
1088 if (ocontents
== NULL
)
1090 if (! bfd_get_section_contents (abfd
, o
, ocontents
,
1094 coff_section_data (abfd
, o
)->contents
= ocontents
;
1098 val
= bfd_get_32 (abfd
, ocontents
+ irelscan
->r_vaddr
- o
->vma
);
1100 if (val
>= addr
&& val
< toaddr
)
1101 bfd_put_32 (abfd
, val
- count
,
1102 ocontents
+ irelscan
->r_vaddr
- o
->vma
);
1104 coff_section_data (abfd
, o
)->keep_contents
= true;
1109 /* Adjusting the internal symbols will not work if something has
1110 already retrieved the generic symbols. It would be possible to
1111 make this work by adjusting the generic symbols at the same time.
1112 However, this case should not arise in normal usage. */
1113 if (obj_symbols (abfd
) != NULL
1114 || obj_raw_syments (abfd
) != NULL
)
1116 ((*_bfd_error_handler
)
1117 ("%s: fatal: generic symbols retrieved before relaxing",
1118 bfd_get_filename (abfd
)));
1119 bfd_set_error (bfd_error_invalid_operation
);
1123 /* Adjust all the symbols. */
1124 sym_hash
= obj_coff_sym_hashes (abfd
);
1125 symesz
= bfd_coff_symesz (abfd
);
1126 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
1127 esymend
= esym
+ obj_raw_syment_count (abfd
) * symesz
;
1128 while (esym
< esymend
)
1130 struct internal_syment isym
;
1132 bfd_coff_swap_sym_in (abfd
, (PTR
) esym
, (PTR
) &isym
);
1134 if (isym
.n_scnum
== sec
->target_index
1135 && (bfd_vma
) isym
.n_value
> addr
1136 && (bfd_vma
) isym
.n_value
< toaddr
)
1138 isym
.n_value
-= count
;
1140 bfd_coff_swap_sym_out (abfd
, (PTR
) &isym
, (PTR
) esym
);
1142 if (*sym_hash
!= NULL
)
1144 BFD_ASSERT ((*sym_hash
)->root
.type
== bfd_link_hash_defined
1145 || (*sym_hash
)->root
.type
== bfd_link_hash_defweak
);
1146 BFD_ASSERT ((*sym_hash
)->root
.u
.def
.value
>= addr
1147 && (*sym_hash
)->root
.u
.def
.value
< toaddr
);
1148 (*sym_hash
)->root
.u
.def
.value
-= count
;
1152 esym
+= (isym
.n_numaux
+ 1) * symesz
;
1153 sym_hash
+= isym
.n_numaux
+ 1;
1156 /* See if we can move the ALIGN reloc forward. We have adjusted
1157 r_vaddr for it already. */
1158 if (irelalign
!= NULL
)
1162 alignaddr
= BFD_ALIGN (irelalign
->r_vaddr
- sec
->vma
,
1163 1 << irelalign
->r_offset
);
1164 if (alignaddr
!= toaddr
)
1166 /* Tail recursion. */
1167 return sh_relax_delete_bytes (abfd
, sec
,
1168 irelalign
->r_vaddr
- sec
->vma
,
1169 1 << irelalign
->r_offset
);
1176 /* This is a modification of _bfd_coff_generic_relocate_section, which
1177 will handle SH relaxing. */
1180 sh_relocate_section (output_bfd
, info
, input_bfd
, input_section
, contents
,
1181 relocs
, syms
, sections
)
1183 struct bfd_link_info
*info
;
1185 asection
*input_section
;
1187 struct internal_reloc
*relocs
;
1188 struct internal_syment
*syms
;
1189 asection
**sections
;
1191 struct internal_reloc
*rel
;
1192 struct internal_reloc
*relend
;
1195 relend
= rel
+ input_section
->reloc_count
;
1196 for (; rel
< relend
; rel
++)
1199 struct coff_link_hash_entry
*h
;
1200 struct internal_syment
*sym
;
1203 reloc_howto_type
*howto
;
1204 bfd_reloc_status_type rstat
;
1206 /* Almost all relocs have to do with relaxing. If any work must
1207 be done for them, it has been done in sh_relax_section. */
1208 if (rel
->r_type
!= R_SH_IMM32
1209 && rel
->r_type
!= R_SH_PCDISP
)
1212 symndx
= rel
->r_symndx
;
1221 h
= obj_coff_sym_hashes (input_bfd
)[symndx
];
1222 sym
= syms
+ symndx
;
1225 if (sym
!= NULL
&& sym
->n_scnum
!= 0)
1226 addend
= - sym
->n_value
;
1230 if (rel
->r_type
== R_SH_PCDISP
)
1233 if (rel
->r_type
>= SH_COFF_HOWTO_COUNT
)
1236 howto
= &sh_coff_howtos
[rel
->r_type
];
1240 bfd_set_error (bfd_error_bad_value
);
1250 /* There is nothing to do for an internal PCDISP reloc. */
1251 if (rel
->r_type
== R_SH_PCDISP
)
1256 sec
= bfd_abs_section_ptr
;
1261 sec
= sections
[symndx
];
1262 val
= (sec
->output_section
->vma
1263 + sec
->output_offset
1270 if (h
->root
.type
== bfd_link_hash_defined
1271 || h
->root
.type
== bfd_link_hash_defweak
)
1275 sec
= h
->root
.u
.def
.section
;
1276 val
= (h
->root
.u
.def
.value
1277 + sec
->output_section
->vma
1278 + sec
->output_offset
);
1280 else if (! info
->relocateable
)
1282 if (! ((*info
->callbacks
->undefined_symbol
)
1283 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1284 rel
->r_vaddr
- input_section
->vma
)))
1289 rstat
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1291 rel
->r_vaddr
- input_section
->vma
,
1300 case bfd_reloc_overflow
:
1303 char buf
[SYMNMLEN
+ 1];
1308 name
= h
->root
.root
.string
;
1309 else if (sym
->_n
._n_n
._n_zeroes
== 0
1310 && sym
->_n
._n_n
._n_offset
!= 0)
1311 name
= obj_coff_strings (input_bfd
) + sym
->_n
._n_n
._n_offset
;
1314 strncpy (buf
, sym
->_n
._n_name
, SYMNMLEN
);
1315 buf
[SYMNMLEN
] = '\0';
1319 if (! ((*info
->callbacks
->reloc_overflow
)
1320 (info
, name
, howto
->name
, (bfd_vma
) 0, input_bfd
,
1321 input_section
, rel
->r_vaddr
- input_section
->vma
)))
1330 /* This is a version of bfd_generic_get_relocated_section_contents
1331 which uses sh_relocate_section. */
1334 sh_coff_get_relocated_section_contents (output_bfd
, link_info
, link_order
,
1335 data
, relocateable
, symbols
)
1337 struct bfd_link_info
*link_info
;
1338 struct bfd_link_order
*link_order
;
1340 boolean relocateable
;
1343 asection
*input_section
= link_order
->u
.indirect
.section
;
1344 bfd
*input_bfd
= input_section
->owner
;
1345 asection
**sections
= NULL
;
1346 struct internal_reloc
*internal_relocs
= NULL
;
1347 struct internal_syment
*internal_syms
= NULL
;
1349 /* We only need to handle the case of relaxing, or of having a
1350 particular set of section contents, specially. */
1352 || coff_section_data (input_bfd
, input_section
) == NULL
1353 || coff_section_data (input_bfd
, input_section
)->contents
== NULL
)
1354 return bfd_generic_get_relocated_section_contents (output_bfd
, link_info
,
1359 memcpy (data
, coff_section_data (input_bfd
, input_section
)->contents
,
1360 input_section
->_raw_size
);
1362 if ((input_section
->flags
& SEC_RELOC
) != 0
1363 && input_section
->reloc_count
> 0)
1365 bfd_size_type symesz
= bfd_coff_symesz (input_bfd
);
1366 bfd_byte
*esym
, *esymend
;
1367 struct internal_syment
*isymp
;
1370 if (! _bfd_coff_get_external_symbols (input_bfd
))
1373 internal_relocs
= (_bfd_coff_read_internal_relocs
1374 (input_bfd
, input_section
, false, (bfd_byte
*) NULL
,
1375 false, (struct internal_reloc
*) NULL
));
1376 if (internal_relocs
== NULL
)
1379 internal_syms
= ((struct internal_syment
*)
1380 bfd_malloc (obj_raw_syment_count (input_bfd
)
1381 * sizeof (struct internal_syment
)));
1382 if (internal_syms
== NULL
)
1385 sections
= (asection
**) bfd_malloc (obj_raw_syment_count (input_bfd
)
1386 * sizeof (asection
*));
1387 if (sections
== NULL
)
1390 isymp
= internal_syms
;
1392 esym
= (bfd_byte
*) obj_coff_external_syms (input_bfd
);
1393 esymend
= esym
+ obj_raw_syment_count (input_bfd
) * symesz
;
1394 while (esym
< esymend
)
1396 bfd_coff_swap_sym_in (input_bfd
, (PTR
) esym
, (PTR
) isymp
);
1398 if (isymp
->n_scnum
!= 0)
1399 *secpp
= coff_section_from_bfd_index (input_bfd
, isymp
->n_scnum
);
1402 if (isymp
->n_value
== 0)
1403 *secpp
= bfd_und_section_ptr
;
1405 *secpp
= bfd_com_section_ptr
;
1408 esym
+= (isymp
->n_numaux
+ 1) * symesz
;
1409 secpp
+= isymp
->n_numaux
+ 1;
1410 isymp
+= isymp
->n_numaux
+ 1;
1413 if (! sh_relocate_section (output_bfd
, link_info
, input_bfd
,
1414 input_section
, data
, internal_relocs
,
1415 internal_syms
, sections
))
1420 free (internal_syms
);
1421 internal_syms
= NULL
;
1422 free (internal_relocs
);
1423 internal_relocs
= NULL
;
1429 if (internal_relocs
!= NULL
)
1430 free (internal_relocs
);
1431 if (internal_syms
!= NULL
)
1432 free (internal_syms
);
1433 if (sections
!= NULL
)
1438 /* The target vectors. */
1440 const bfd_target shcoff_vec
=
1442 "coff-sh", /* name */
1443 bfd_target_coff_flavour
,
1444 true, /* data byte order is big */
1445 true, /* header byte order is big */
1447 (HAS_RELOC
| EXEC_P
| /* object flags */
1448 HAS_LINENO
| HAS_DEBUG
|
1449 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
| BFD_IS_RELAXABLE
),
1451 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
),
1452 '_', /* leading symbol underscore */
1453 '/', /* ar_pad_char */
1454 15, /* ar_max_namelen */
1455 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
1456 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
1457 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* data */
1458 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
1459 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
1460 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* hdrs */
1462 {_bfd_dummy_target
, coff_object_p
, /* bfd_check_format */
1463 bfd_generic_archive_p
, _bfd_dummy_target
},
1464 {bfd_false
, coff_mkobject
, _bfd_generic_mkarchive
, /* bfd_set_format */
1466 {bfd_false
, coff_write_object_contents
, /* bfd_write_contents */
1467 _bfd_write_archive_contents
, bfd_false
},
1469 BFD_JUMP_TABLE_GENERIC (coff
),
1470 BFD_JUMP_TABLE_COPY (coff
),
1471 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
1472 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff
),
1473 BFD_JUMP_TABLE_SYMBOLS (coff
),
1474 BFD_JUMP_TABLE_RELOCS (coff
),
1475 BFD_JUMP_TABLE_WRITE (coff
),
1476 BFD_JUMP_TABLE_LINK (coff
),
1477 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),
1482 const bfd_target shlcoff_vec
=
1484 "coff-shl", /* name */
1485 bfd_target_coff_flavour
,
1486 false, /* data byte order is little */
1487 false, /* header byte order is little endian too*/
1489 (HAS_RELOC
| EXEC_P
| /* object flags */
1490 HAS_LINENO
| HAS_DEBUG
|
1491 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
| BFD_IS_RELAXABLE
),
1493 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
),
1494 '_', /* leading symbol underscore */
1495 '/', /* ar_pad_char */
1496 15, /* ar_max_namelen */
1497 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
1498 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
1499 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* data */
1500 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
1501 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
1502 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* hdrs */
1504 {_bfd_dummy_target
, coff_object_p
, /* bfd_check_format */
1505 bfd_generic_archive_p
, _bfd_dummy_target
},
1506 {bfd_false
, coff_mkobject
, _bfd_generic_mkarchive
, /* bfd_set_format */
1508 {bfd_false
, coff_write_object_contents
, /* bfd_write_contents */
1509 _bfd_write_archive_contents
, bfd_false
},
1511 BFD_JUMP_TABLE_GENERIC (coff
),
1512 BFD_JUMP_TABLE_COPY (coff
),
1513 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
1514 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff
),
1515 BFD_JUMP_TABLE_SYMBOLS (coff
),
1516 BFD_JUMP_TABLE_RELOCS (coff
),
1517 BFD_JUMP_TABLE_WRITE (coff
),
1518 BFD_JUMP_TABLE_LINK (coff
),
1519 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),