1 /* Hitachi SH specific support for 32-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4 Contributed by Ian Lance Taylor, Cygnus Support.
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. */
29 static bfd_reloc_status_type sh_elf_reloc
30 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
31 static bfd_reloc_status_type sh_elf_ignore_reloc
32 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
33 static reloc_howto_type
*sh_elf_reloc_type_lookup
34 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
35 static void sh_elf_info_to_howto
36 PARAMS ((bfd
*, arelent
*, Elf_Internal_Rela
*));
37 static boolean sh_elf_set_private_flags
38 PARAMS ((bfd
*, flagword
));
39 static boolean sh_elf_copy_private_data
40 PARAMS ((bfd
*, bfd
*));
41 static boolean sh_elf_merge_private_data
42 PARAMS ((bfd
*, bfd
*));
43 static boolean sh_elf_set_mach_from_flags
45 static boolean sh_elf_relax_section
46 PARAMS ((bfd
*, asection
*, struct bfd_link_info
*, boolean
*));
47 static boolean sh_elf_relax_delete_bytes
48 PARAMS ((bfd
*, asection
*, bfd_vma
, int));
49 static boolean sh_elf_align_loads
50 PARAMS ((bfd
*, asection
*, Elf_Internal_Rela
*, bfd_byte
*, boolean
*));
51 static boolean sh_elf_swap_insns
52 PARAMS ((bfd
*, asection
*, PTR
, bfd_byte
*, bfd_vma
));
53 static boolean sh_elf_relocate_section
54 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
55 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
56 static bfd_byte
*sh_elf_get_relocated_section_contents
57 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*,
58 bfd_byte
*, boolean
, asymbol
**));
59 static boolean sh_elf_check_relocs
60 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
61 const Elf_Internal_Rela
*));
62 static struct bfd_hash_entry
*sh_elf_link_hash_newfunc
63 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
64 static struct bfd_link_hash_table
*sh_elf_link_hash_table_create
66 static boolean sh_elf_adjust_dynamic_symbol
67 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
68 static boolean sh_elf_size_dynamic_sections
69 PARAMS ((bfd
*, struct bfd_link_info
*));
70 static boolean sh_elf_finish_dynamic_symbol
71 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
73 static boolean sh_elf_finish_dynamic_sections
74 PARAMS ((bfd
*, struct bfd_link_info
*));
76 /* The name of the dynamic interpreter. This is put in the .interp
79 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
81 static reloc_howto_type sh_elf_howto_table
[] =
84 HOWTO (R_SH_NONE
, /* type */
86 0, /* size (0 = byte, 1 = short, 2 = long) */
88 false, /* pc_relative */
90 complain_overflow_dont
, /* complain_on_overflow */
91 sh_elf_ignore_reloc
, /* special_function */
92 "R_SH_NONE", /* name */
93 false, /* partial_inplace */
96 false), /* pcrel_offset */
98 /* 32 bit absolute relocation. Setting partial_inplace to true and
99 src_mask to a non-zero value is similar to the COFF toolchain. */
100 HOWTO (R_SH_DIR32
, /* type */
102 2, /* size (0 = byte, 1 = short, 2 = long) */
104 false, /* pc_relative */
106 complain_overflow_bitfield
, /* complain_on_overflow */
107 sh_elf_reloc
, /* special_function */
108 "R_SH_DIR32", /* name */
109 true, /* partial_inplace */
110 0xffffffff, /* src_mask */
111 0xffffffff, /* dst_mask */
112 false), /* pcrel_offset */
114 /* 32 bit PC relative relocation. */
115 HOWTO (R_SH_REL32
, /* type */
117 2, /* size (0 = byte, 1 = short, 2 = long) */
119 true, /* pc_relative */
121 complain_overflow_signed
, /* complain_on_overflow */
122 sh_elf_ignore_reloc
, /* special_function */
123 "R_SH_REL32", /* name */
124 false, /* partial_inplace */
126 0xffffffff, /* dst_mask */
127 true), /* pcrel_offset */
129 /* 8 bit PC relative branch divided by 2. */
130 HOWTO (R_SH_DIR8WPN
, /* type */
132 1, /* size (0 = byte, 1 = short, 2 = long) */
134 true, /* pc_relative */
136 complain_overflow_signed
, /* complain_on_overflow */
137 sh_elf_ignore_reloc
, /* special_function */
138 "R_SH_DIR8WPN", /* name */
139 true, /* partial_inplace */
142 true), /* pcrel_offset */
144 /* 12 bit PC relative branch divided by 2. */
145 HOWTO (R_SH_IND12W
, /* type */
147 1, /* size (0 = byte, 1 = short, 2 = long) */
149 true, /* pc_relative */
151 complain_overflow_signed
, /* complain_on_overflow */
152 sh_elf_reloc
, /* special_function */
153 "R_SH_IND12W", /* name */
154 true, /* partial_inplace */
155 0xfff, /* src_mask */
156 0xfff, /* dst_mask */
157 true), /* pcrel_offset */
159 /* 8 bit unsigned PC relative divided by 4. */
160 HOWTO (R_SH_DIR8WPL
, /* type */
162 1, /* size (0 = byte, 1 = short, 2 = long) */
164 true, /* pc_relative */
166 complain_overflow_unsigned
, /* complain_on_overflow */
167 sh_elf_ignore_reloc
, /* special_function */
168 "R_SH_DIR8WPL", /* name */
169 true, /* partial_inplace */
172 true), /* pcrel_offset */
174 /* 8 bit unsigned PC relative divided by 2. */
175 HOWTO (R_SH_DIR8WPZ
, /* type */
177 1, /* size (0 = byte, 1 = short, 2 = long) */
179 true, /* pc_relative */
181 complain_overflow_unsigned
, /* complain_on_overflow */
182 sh_elf_ignore_reloc
, /* special_function */
183 "R_SH_DIR8WPZ", /* name */
184 true, /* partial_inplace */
187 true), /* pcrel_offset */
189 /* 8 bit GBR relative. FIXME: This only makes sense if we have some
190 special symbol for the GBR relative area, and that is not
192 HOWTO (R_SH_DIR8BP
, /* type */
194 1, /* size (0 = byte, 1 = short, 2 = long) */
196 false, /* pc_relative */
198 complain_overflow_unsigned
, /* complain_on_overflow */
199 sh_elf_ignore_reloc
, /* special_function */
200 "R_SH_DIR8BP", /* name */
201 false, /* partial_inplace */
204 true), /* pcrel_offset */
206 /* 8 bit GBR relative divided by 2. FIXME: This only makes sense if
207 we have some special symbol for the GBR relative area, and that
208 is not implemented. */
209 HOWTO (R_SH_DIR8W
, /* type */
211 1, /* size (0 = byte, 1 = short, 2 = long) */
213 false, /* pc_relative */
215 complain_overflow_unsigned
, /* complain_on_overflow */
216 sh_elf_ignore_reloc
, /* special_function */
217 "R_SH_DIR8W", /* name */
218 false, /* partial_inplace */
221 true), /* pcrel_offset */
223 /* 8 bit GBR relative divided by 4. FIXME: This only makes sense if
224 we have some special symbol for the GBR relative area, and that
225 is not implemented. */
226 HOWTO (R_SH_DIR8L
, /* type */
228 1, /* size (0 = byte, 1 = short, 2 = long) */
230 false, /* pc_relative */
232 complain_overflow_unsigned
, /* complain_on_overflow */
233 sh_elf_ignore_reloc
, /* special_function */
234 "R_SH_DIR8L", /* name */
235 false, /* partial_inplace */
238 true), /* pcrel_offset */
256 /* The remaining relocs are a GNU extension used for relaxing. The
257 final pass of the linker never needs to do anything with any of
258 these relocs. Any required operations are handled by the
261 /* A 16 bit switch table entry. This is generated for an expression
262 such as ``.word L1 - L2''. The offset holds the difference
263 between the reloc address and L2. */
264 HOWTO (R_SH_SWITCH16
, /* type */
266 1, /* size (0 = byte, 1 = short, 2 = long) */
268 false, /* pc_relative */
270 complain_overflow_unsigned
, /* complain_on_overflow */
271 sh_elf_ignore_reloc
, /* special_function */
272 "R_SH_SWITCH16", /* name */
273 false, /* partial_inplace */
276 true), /* pcrel_offset */
278 /* A 32 bit switch table entry. This is generated for an expression
279 such as ``.long L1 - L2''. The offset holds the difference
280 between the reloc address and L2. */
281 HOWTO (R_SH_SWITCH32
, /* type */
283 2, /* size (0 = byte, 1 = short, 2 = long) */
285 false, /* pc_relative */
287 complain_overflow_unsigned
, /* complain_on_overflow */
288 sh_elf_ignore_reloc
, /* special_function */
289 "R_SH_SWITCH32", /* name */
290 false, /* partial_inplace */
293 true), /* pcrel_offset */
295 /* Indicates a .uses pseudo-op. The compiler will generate .uses
296 pseudo-ops when it finds a function call which can be relaxed.
297 The offset field holds the PC relative offset to the instruction
298 which loads the register used in the function call. */
299 HOWTO (R_SH_USES
, /* type */
301 1, /* size (0 = byte, 1 = short, 2 = long) */
303 false, /* pc_relative */
305 complain_overflow_unsigned
, /* complain_on_overflow */
306 sh_elf_ignore_reloc
, /* special_function */
307 "R_SH_USES", /* name */
308 false, /* partial_inplace */
311 true), /* pcrel_offset */
313 /* The assembler will generate this reloc for addresses referred to
314 by the register loads associated with USES relocs. The offset
315 field holds the number of times the address is referenced in the
317 HOWTO (R_SH_COUNT
, /* type */
319 1, /* size (0 = byte, 1 = short, 2 = long) */
321 false, /* pc_relative */
323 complain_overflow_unsigned
, /* complain_on_overflow */
324 sh_elf_ignore_reloc
, /* special_function */
325 "R_SH_COUNT", /* name */
326 false, /* partial_inplace */
329 true), /* pcrel_offset */
331 /* Indicates an alignment statement. The offset field is the power
332 of 2 to which subsequent portions of the object file must be
334 HOWTO (R_SH_ALIGN
, /* type */
336 1, /* size (0 = byte, 1 = short, 2 = long) */
338 false, /* pc_relative */
340 complain_overflow_unsigned
, /* complain_on_overflow */
341 sh_elf_ignore_reloc
, /* special_function */
342 "R_SH_ALIGN", /* name */
343 false, /* partial_inplace */
346 true), /* pcrel_offset */
348 /* The assembler will generate this reloc before a block of
349 instructions. A section should be processed as assumining it
350 contains data, unless this reloc is seen. */
351 HOWTO (R_SH_CODE
, /* type */
353 1, /* size (0 = byte, 1 = short, 2 = long) */
355 false, /* pc_relative */
357 complain_overflow_unsigned
, /* complain_on_overflow */
358 sh_elf_ignore_reloc
, /* special_function */
359 "R_SH_CODE", /* name */
360 false, /* partial_inplace */
363 true), /* pcrel_offset */
365 /* The assembler will generate this reloc after a block of
366 instructions when it sees data that is not instructions. */
367 HOWTO (R_SH_DATA
, /* type */
369 1, /* size (0 = byte, 1 = short, 2 = long) */
371 false, /* pc_relative */
373 complain_overflow_unsigned
, /* complain_on_overflow */
374 sh_elf_ignore_reloc
, /* special_function */
375 "R_SH_DATA", /* name */
376 false, /* partial_inplace */
379 true), /* pcrel_offset */
381 /* The assembler generates this reloc for each label within a block
382 of instructions. This permits the linker to avoid swapping
383 instructions which are the targets of branches. */
384 HOWTO (R_SH_LABEL
, /* type */
386 1, /* size (0 = byte, 1 = short, 2 = long) */
388 false, /* pc_relative */
390 complain_overflow_unsigned
, /* complain_on_overflow */
391 sh_elf_ignore_reloc
, /* special_function */
392 "R_SH_LABEL", /* name */
393 false, /* partial_inplace */
396 true), /* pcrel_offset */
398 /* An 8 bit switch table entry. This is generated for an expression
399 such as ``.word L1 - L2''. The offset holds the difference
400 between the reloc address and L2. */
401 HOWTO (R_SH_SWITCH8
, /* type */
403 0, /* size (0 = byte, 1 = short, 2 = long) */
405 false, /* pc_relative */
407 complain_overflow_unsigned
, /* complain_on_overflow */
408 sh_elf_ignore_reloc
, /* special_function */
409 "R_SH_SWITCH8", /* name */
410 false, /* partial_inplace */
413 true), /* pcrel_offset */
415 /* GNU extension to record C++ vtable hierarchy */
416 HOWTO (R_SH_GNU_VTINHERIT
, /* type */
418 2, /* size (0 = byte, 1 = short, 2 = long) */
420 false, /* pc_relative */
422 complain_overflow_dont
, /* complain_on_overflow */
423 NULL
, /* special_function */
424 "R_SH_GNU_VTINHERIT", /* name */
425 false, /* partial_inplace */
428 false), /* pcrel_offset */
430 /* GNU extension to record C++ vtable member usage */
431 HOWTO (R_SH_GNU_VTENTRY
, /* type */
433 2, /* size (0 = byte, 1 = short, 2 = long) */
435 false, /* pc_relative */
437 complain_overflow_dont
, /* complain_on_overflow */
438 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
439 "R_SH_GNU_VTENTRY", /* name */
440 false, /* partial_inplace */
443 false), /* pcrel_offset */
445 /* 8 bit PC relative divided by 2 - but specified in a very odd way. */
446 HOWTO (R_SH_LOOP_START
, /* type */
448 1, /* size (0 = byte, 1 = short, 2 = long) */
450 false, /* pc_relative */
452 complain_overflow_signed
, /* complain_on_overflow */
453 sh_elf_ignore_reloc
, /* special_function */
454 "R_SH_LOOP_START", /* name */
455 true, /* partial_inplace */
458 true), /* pcrel_offset */
460 /* 8 bit PC relative divided by 2 - but specified in a very odd way. */
461 HOWTO (R_SH_LOOP_END
, /* type */
463 1, /* size (0 = byte, 1 = short, 2 = long) */
465 false, /* pc_relative */
467 complain_overflow_signed
, /* complain_on_overflow */
468 sh_elf_ignore_reloc
, /* special_function */
469 "R_SH_LOOP_END", /* name */
470 true, /* partial_inplace */
473 true), /* pcrel_offset */
598 HOWTO (R_SH_GOT32
, /* type */
600 2, /* size (0 = byte, 1 = short, 2 = long) */
602 false, /* pc_relative */
604 complain_overflow_bitfield
, /* complain_on_overflow */
605 bfd_elf_generic_reloc
, /* */
606 "R_SH_GOT32", /* name */
607 true, /* partial_inplace */
608 0xffffffff, /* src_mask */
609 0xffffffff, /* dst_mask */
610 false), /* pcrel_offset */
612 HOWTO (R_SH_PLT32
, /* type */
614 2, /* size (0 = byte, 1 = short, 2 = long) */
616 true, /* pc_relative */
618 complain_overflow_bitfield
, /* complain_on_overflow */
619 bfd_elf_generic_reloc
, /* */
620 "R_SH_PLT32", /* name */
621 true, /* partial_inplace */
622 0xffffffff, /* src_mask */
623 0xffffffff, /* dst_mask */
624 true), /* pcrel_offset */
626 HOWTO (R_SH_COPY
, /* type */
628 2, /* size (0 = byte, 1 = short, 2 = long) */
630 false, /* pc_relative */
632 complain_overflow_bitfield
, /* complain_on_overflow */
633 bfd_elf_generic_reloc
, /* */
634 "R_SH_COPY", /* name */
635 true, /* partial_inplace */
636 0xffffffff, /* src_mask */
637 0xffffffff, /* dst_mask */
638 false), /* pcrel_offset */
640 HOWTO (R_SH_GLOB_DAT
, /* type */
642 2, /* size (0 = byte, 1 = short, 2 = long) */
644 false, /* pc_relative */
646 complain_overflow_bitfield
, /* complain_on_overflow */
647 bfd_elf_generic_reloc
, /* */
648 "R_SH_GLOB_DAT", /* name */
649 true, /* partial_inplace */
650 0xffffffff, /* src_mask */
651 0xffffffff, /* dst_mask */
652 false), /* pcrel_offset */
654 HOWTO (R_SH_JMP_SLOT
, /* type */
656 2, /* size (0 = byte, 1 = short, 2 = long) */
658 false, /* pc_relative */
660 complain_overflow_bitfield
, /* complain_on_overflow */
661 bfd_elf_generic_reloc
, /* */
662 "R_SH_JMP_SLOT", /* name */
663 true, /* partial_inplace */
664 0xffffffff, /* src_mask */
665 0xffffffff, /* dst_mask */
666 false), /* pcrel_offset */
668 HOWTO (R_SH_RELATIVE
, /* type */
670 2, /* size (0 = byte, 1 = short, 2 = long) */
672 false, /* pc_relative */
674 complain_overflow_bitfield
, /* complain_on_overflow */
675 bfd_elf_generic_reloc
, /* */
676 "R_SH_RELATIVE", /* name */
677 true, /* partial_inplace */
678 0xffffffff, /* src_mask */
679 0xffffffff, /* dst_mask */
680 false), /* pcrel_offset */
682 HOWTO (R_SH_GOTOFF
, /* type */
684 2, /* size (0 = byte, 1 = short, 2 = long) */
686 false, /* pc_relative */
688 complain_overflow_bitfield
, /* complain_on_overflow */
689 bfd_elf_generic_reloc
, /* */
690 "R_SH_GOTOFF", /* name */
691 true, /* partial_inplace */
692 0xffffffff, /* src_mask */
693 0xffffffff, /* dst_mask */
694 false), /* pcrel_offset */
696 HOWTO (R_SH_GOTPC
, /* type */
698 2, /* size (0 = byte, 1 = short, 2 = long) */
700 true, /* pc_relative */
702 complain_overflow_bitfield
, /* complain_on_overflow */
703 bfd_elf_generic_reloc
, /* */
704 "R_SH_GOTPC", /* name */
705 true, /* partial_inplace */
706 0xffffffff, /* src_mask */
707 0xffffffff, /* dst_mask */
708 true), /* pcrel_offset */
712 static bfd_reloc_status_type
713 sh_elf_reloc_loop (r_type
, input_bfd
, input_section
, contents
, addr
,
714 symbol_section
, start
, end
)
715 int r_type ATTRIBUTE_UNUSED
;
717 asection
*input_section
;
720 asection
*symbol_section
;
723 static bfd_vma last_addr
;
724 static asection
*last_symbol_section
;
725 bfd_byte
*free_contents
= NULL
;
726 bfd_byte
*start_ptr
, *ptr
, *last_ptr
;
731 /* Sanity check the address. */
732 if (addr
> input_section
->_raw_size
)
733 return bfd_reloc_outofrange
;
735 /* We require the start and end relocations to be processed consecutively -
736 although we allow then to be processed forwards or backwards. */
740 last_symbol_section
= symbol_section
;
743 if (last_addr
!= addr
)
747 if (! symbol_section
|| last_symbol_section
!= symbol_section
|| end
< start
)
748 return bfd_reloc_outofrange
;
750 /* Get the symbol_section contents. */
751 if (symbol_section
!= input_section
)
753 if (elf_section_data (symbol_section
)->this_hdr
.contents
!= NULL
)
754 contents
= elf_section_data (symbol_section
)->this_hdr
.contents
;
757 free_contents
= contents
758 = (bfd_byte
*) bfd_malloc (symbol_section
->_raw_size
);
759 if (contents
== NULL
)
760 return bfd_reloc_outofrange
;
761 if (! bfd_get_section_contents (input_bfd
, symbol_section
, contents
,
763 symbol_section
->_raw_size
))
766 return bfd_reloc_outofrange
;
770 #define IS_PPI(PTR) ((bfd_get_16 (input_bfd, (PTR)) & 0xfc00) == 0xf800)
771 start_ptr
= contents
+ start
;
772 for (cum_diff
= -6, ptr
= contents
+ end
; cum_diff
< 0 && ptr
> start_ptr
;)
774 for (last_ptr
= ptr
, ptr
-= 4; ptr
>= start_ptr
&& IS_PPI (ptr
);)
777 diff
= (last_ptr
- ptr
) >> 1;
778 cum_diff
+= diff
& 1;
781 /* Calculate the start / end values to load into rs / re minus four -
782 so that will cancel out the four we would otherwise have to add to
783 addr to get the value to subtract in order to get relative addressing. */
787 end
= (ptr
+ cum_diff
* 2) - contents
;
791 bfd_vma start0
= start
- 4;
793 while (start0
&& IS_PPI (contents
+ start0
))
795 start0
= start
- 2 - ((start
- start0
) & 2);
796 start
= start0
- cum_diff
- 2;
801 free (free_contents
);
803 insn
= bfd_get_16 (input_bfd
, contents
+ addr
);
805 x
= (insn
& 0x200 ? end
: start
) - addr
;
806 if (input_section
!= symbol_section
)
807 x
+= ((symbol_section
->output_section
->vma
+ symbol_section
->output_offset
)
808 - (input_section
->output_section
->vma
809 + input_section
->output_offset
));
811 if (x
< -128 || x
> 127)
812 return bfd_reloc_overflow
;
814 x
= (insn
& ~0xff) | (x
& 0xff);
815 bfd_put_16 (input_bfd
, x
, contents
+ addr
);
820 /* This function is used for normal relocs. This used to be like the COFF
821 function, and is almost certainly incorrect for other ELF targets. */
823 static bfd_reloc_status_type
824 sh_elf_reloc (abfd
, reloc_entry
, symbol_in
, data
, input_section
, output_bfd
,
827 arelent
*reloc_entry
;
830 asection
*input_section
;
832 char **error_message ATTRIBUTE_UNUSED
;
836 enum elf_sh_reloc_type r_type
;
837 bfd_vma addr
= reloc_entry
->address
;
838 bfd_byte
*hit_data
= addr
+ (bfd_byte
*) data
;
840 r_type
= (enum elf_sh_reloc_type
) reloc_entry
->howto
->type
;
842 if (output_bfd
!= NULL
)
844 /* Partial linking--do nothing. */
845 reloc_entry
->address
+= input_section
->output_offset
;
849 /* Almost all relocs have to do with relaxing. If any work must be
850 done for them, it has been done in sh_relax_section. */
851 if (r_type
== R_SH_IND12W
&& (symbol_in
->flags
& BSF_LOCAL
) != 0)
854 if (symbol_in
!= NULL
855 && bfd_is_und_section (symbol_in
->section
))
856 return bfd_reloc_undefined
;
858 if (bfd_is_com_section (symbol_in
->section
))
861 sym_value
= (symbol_in
->value
+
862 symbol_in
->section
->output_section
->vma
+
863 symbol_in
->section
->output_offset
);
868 insn
= bfd_get_32 (abfd
, hit_data
);
869 insn
+= sym_value
+ reloc_entry
->addend
;
870 bfd_put_32 (abfd
, insn
, hit_data
);
873 insn
= bfd_get_16 (abfd
, hit_data
);
874 sym_value
+= reloc_entry
->addend
;
875 sym_value
-= (input_section
->output_section
->vma
876 + input_section
->output_offset
879 sym_value
+= (insn
& 0xfff) << 1;
882 insn
= (insn
& 0xf000) | (sym_value
& 0xfff);
883 bfd_put_16 (abfd
, insn
, hit_data
);
884 if (sym_value
< (bfd_vma
) -0x1000 || sym_value
>= 0x1000)
885 return bfd_reloc_overflow
;
895 /* This function is used for relocs which are only used for relaxing,
896 which the linker should otherwise ignore. */
898 static bfd_reloc_status_type
899 sh_elf_ignore_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
,
900 output_bfd
, error_message
)
901 bfd
*abfd ATTRIBUTE_UNUSED
;
902 arelent
*reloc_entry
;
903 asymbol
*symbol ATTRIBUTE_UNUSED
;
904 PTR data ATTRIBUTE_UNUSED
;
905 asection
*input_section
;
907 char **error_message ATTRIBUTE_UNUSED
;
909 if (output_bfd
!= NULL
)
910 reloc_entry
->address
+= input_section
->output_offset
;
914 /* This structure is used to map BFD reloc codes to SH ELF relocs. */
918 bfd_reloc_code_real_type bfd_reloc_val
;
919 unsigned char elf_reloc_val
;
922 /* An array mapping BFD reloc codes to SH ELF relocs. */
924 static const struct elf_reloc_map sh_reloc_map
[] =
926 { BFD_RELOC_NONE
, R_SH_NONE
},
927 { BFD_RELOC_32
, R_SH_DIR32
},
928 { BFD_RELOC_CTOR
, R_SH_DIR32
},
929 { BFD_RELOC_32_PCREL
, R_SH_REL32
},
930 { BFD_RELOC_SH_PCDISP8BY2
, R_SH_DIR8WPN
},
931 { BFD_RELOC_SH_PCDISP12BY2
, R_SH_IND12W
},
932 { BFD_RELOC_SH_PCRELIMM8BY2
, R_SH_DIR8WPZ
},
933 { BFD_RELOC_SH_PCRELIMM8BY4
, R_SH_DIR8WPL
},
934 { BFD_RELOC_8_PCREL
, R_SH_SWITCH8
},
935 { BFD_RELOC_SH_SWITCH16
, R_SH_SWITCH16
},
936 { BFD_RELOC_SH_SWITCH32
, R_SH_SWITCH32
},
937 { BFD_RELOC_SH_USES
, R_SH_USES
},
938 { BFD_RELOC_SH_COUNT
, R_SH_COUNT
},
939 { BFD_RELOC_SH_ALIGN
, R_SH_ALIGN
},
940 { BFD_RELOC_SH_CODE
, R_SH_CODE
},
941 { BFD_RELOC_SH_DATA
, R_SH_DATA
},
942 { BFD_RELOC_SH_LABEL
, R_SH_LABEL
},
943 { BFD_RELOC_VTABLE_INHERIT
, R_SH_GNU_VTINHERIT
},
944 { BFD_RELOC_VTABLE_ENTRY
, R_SH_GNU_VTENTRY
},
945 { BFD_RELOC_SH_LOOP_START
, R_SH_LOOP_START
},
946 { BFD_RELOC_SH_LOOP_END
, R_SH_LOOP_END
},
947 { BFD_RELOC_32_GOT_PCREL
, R_SH_GOT32
},
948 { BFD_RELOC_32_PLT_PCREL
, R_SH_PLT32
},
949 { BFD_RELOC_SH_COPY
, R_SH_COPY
},
950 { BFD_RELOC_SH_GLOB_DAT
, R_SH_GLOB_DAT
},
951 { BFD_RELOC_SH_JMP_SLOT
, R_SH_JMP_SLOT
},
952 { BFD_RELOC_SH_RELATIVE
, R_SH_RELATIVE
},
953 { BFD_RELOC_32_GOTOFF
, R_SH_GOTOFF
},
954 { BFD_RELOC_SH_GOTPC
, R_SH_GOTPC
},
957 /* Given a BFD reloc code, return the howto structure for the
958 corresponding SH ELf reloc. */
960 static reloc_howto_type
*
961 sh_elf_reloc_type_lookup (abfd
, code
)
962 bfd
*abfd ATTRIBUTE_UNUSED
;
963 bfd_reloc_code_real_type code
;
967 for (i
= 0; i
< sizeof (sh_reloc_map
) / sizeof (struct elf_reloc_map
); i
++)
969 if (sh_reloc_map
[i
].bfd_reloc_val
== code
)
970 return &sh_elf_howto_table
[(int) sh_reloc_map
[i
].elf_reloc_val
];
976 /* Given an ELF reloc, fill in the howto field of a relent. */
979 sh_elf_info_to_howto (abfd
, cache_ptr
, dst
)
980 bfd
*abfd ATTRIBUTE_UNUSED
;
982 Elf_Internal_Rela
*dst
;
986 r
= ELF32_R_TYPE (dst
->r_info
);
988 BFD_ASSERT (r
< (unsigned int) R_SH_max
);
989 BFD_ASSERT (r
< R_SH_FIRST_INVALID_RELOC
|| r
> R_SH_LAST_INVALID_RELOC
);
990 BFD_ASSERT (r
< R_SH_FIRST_INVALID_RELOC_2
|| r
> R_SH_LAST_INVALID_RELOC_2
);
992 cache_ptr
->howto
= &sh_elf_howto_table
[r
];
995 /* This function handles relaxing for SH ELF. See the corresponding
996 function in coff-sh.c for a description of what this does. FIXME:
997 There is a lot of duplication here between this code and the COFF
998 specific code. The format of relocs and symbols is wound deeply
999 into this code, but it would still be better if the duplication
1000 could be eliminated somehow. Note in particular that although both
1001 functions use symbols like R_SH_CODE, those symbols have different
1002 values; in coff-sh.c they come from include/coff/sh.h, whereas here
1003 they come from enum elf_sh_reloc_type in include/elf/sh.h. */
1006 sh_elf_relax_section (abfd
, sec
, link_info
, again
)
1009 struct bfd_link_info
*link_info
;
1012 Elf_Internal_Shdr
*symtab_hdr
;
1013 Elf_Internal_Rela
*internal_relocs
;
1014 Elf_Internal_Rela
*free_relocs
= NULL
;
1016 Elf_Internal_Rela
*irel
, *irelend
;
1017 bfd_byte
*contents
= NULL
;
1018 bfd_byte
*free_contents
= NULL
;
1019 Elf32_External_Sym
*extsyms
= NULL
;
1020 Elf32_External_Sym
*free_extsyms
= NULL
;
1024 if (link_info
->relocateable
1025 || (sec
->flags
& SEC_RELOC
) == 0
1026 || sec
->reloc_count
== 0)
1029 /* If this is the first time we have been called for this section,
1030 initialize the cooked size. */
1031 if (sec
->_cooked_size
== 0)
1032 sec
->_cooked_size
= sec
->_raw_size
;
1034 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1036 internal_relocs
= (_bfd_elf32_link_read_relocs
1037 (abfd
, sec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
1038 link_info
->keep_memory
));
1039 if (internal_relocs
== NULL
)
1041 if (! link_info
->keep_memory
)
1042 free_relocs
= internal_relocs
;
1046 irelend
= internal_relocs
+ sec
->reloc_count
;
1047 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1049 bfd_vma laddr
, paddr
, symval
;
1050 unsigned short insn
;
1051 Elf_Internal_Rela
*irelfn
, *irelscan
, *irelcount
;
1052 bfd_signed_vma foff
;
1054 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_CODE
)
1057 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_USES
)
1060 /* Get the section contents. */
1061 if (contents
== NULL
)
1063 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1064 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1067 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
1068 if (contents
== NULL
)
1070 free_contents
= contents
;
1072 if (! bfd_get_section_contents (abfd
, sec
, contents
,
1073 (file_ptr
) 0, sec
->_raw_size
))
1078 /* The r_addend field of the R_SH_USES reloc will point us to
1079 the register load. The 4 is because the r_addend field is
1080 computed as though it were a jump offset, which are based
1081 from 4 bytes after the jump instruction. */
1082 laddr
= irel
->r_offset
+ 4 + irel
->r_addend
;
1083 if (laddr
>= sec
->_raw_size
)
1085 (*_bfd_error_handler
) (_("%s: 0x%lx: warning: bad R_SH_USES offset"),
1086 bfd_get_filename (abfd
),
1087 (unsigned long) irel
->r_offset
);
1090 insn
= bfd_get_16 (abfd
, contents
+ laddr
);
1092 /* If the instruction is not mov.l NN,rN, we don't know what to
1094 if ((insn
& 0xf000) != 0xd000)
1096 ((*_bfd_error_handler
)
1097 (_("%s: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
1098 bfd_get_filename (abfd
), (unsigned long) irel
->r_offset
, insn
));
1102 /* Get the address from which the register is being loaded. The
1103 displacement in the mov.l instruction is quadrupled. It is a
1104 displacement from four bytes after the movl instruction, but,
1105 before adding in the PC address, two least significant bits
1106 of the PC are cleared. We assume that the section is aligned
1107 on a four byte boundary. */
1108 paddr
= insn
& 0xff;
1110 paddr
+= (laddr
+ 4) & ~3;
1111 if (paddr
>= sec
->_raw_size
)
1113 ((*_bfd_error_handler
)
1114 (_("%s: 0x%lx: warning: bad R_SH_USES load offset"),
1115 bfd_get_filename (abfd
), (unsigned long) irel
->r_offset
));
1119 /* Get the reloc for the address from which the register is
1120 being loaded. This reloc will tell us which function is
1121 actually being called. */
1122 for (irelfn
= internal_relocs
; irelfn
< irelend
; irelfn
++)
1123 if (irelfn
->r_offset
== paddr
1124 && ELF32_R_TYPE (irelfn
->r_info
) == (int) R_SH_DIR32
)
1126 if (irelfn
>= irelend
)
1128 ((*_bfd_error_handler
)
1129 (_("%s: 0x%lx: warning: could not find expected reloc"),
1130 bfd_get_filename (abfd
), (unsigned long) paddr
));
1134 /* Read this BFD's symbols if we haven't done so already. */
1135 if (extsyms
== NULL
)
1137 if (symtab_hdr
->contents
!= NULL
)
1138 extsyms
= (Elf32_External_Sym
*) symtab_hdr
->contents
;
1141 extsyms
= ((Elf32_External_Sym
*)
1142 bfd_malloc (symtab_hdr
->sh_size
));
1143 if (extsyms
== NULL
)
1145 free_extsyms
= extsyms
;
1146 if (bfd_seek (abfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
1147 || (bfd_read (extsyms
, 1, symtab_hdr
->sh_size
, abfd
)
1148 != symtab_hdr
->sh_size
))
1153 /* Get the value of the symbol referred to by the reloc. */
1154 if (ELF32_R_SYM (irelfn
->r_info
) < symtab_hdr
->sh_info
)
1156 Elf_Internal_Sym isym
;
1158 /* A local symbol. */
1159 bfd_elf32_swap_symbol_in (abfd
,
1160 extsyms
+ ELF32_R_SYM (irelfn
->r_info
),
1163 if (isym
.st_shndx
!= _bfd_elf_section_from_bfd_section (abfd
, sec
))
1165 ((*_bfd_error_handler
)
1166 (_("%s: 0x%lx: warning: symbol in unexpected section"),
1167 bfd_get_filename (abfd
), (unsigned long) paddr
));
1171 symval
= (isym
.st_value
1172 + sec
->output_section
->vma
1173 + sec
->output_offset
);
1178 struct elf_link_hash_entry
*h
;
1180 indx
= ELF32_R_SYM (irelfn
->r_info
) - symtab_hdr
->sh_info
;
1181 h
= elf_sym_hashes (abfd
)[indx
];
1182 BFD_ASSERT (h
!= NULL
);
1183 if (h
->root
.type
!= bfd_link_hash_defined
1184 && h
->root
.type
!= bfd_link_hash_defweak
)
1186 /* This appears to be a reference to an undefined
1187 symbol. Just ignore it--it will be caught by the
1188 regular reloc processing. */
1192 symval
= (h
->root
.u
.def
.value
1193 + h
->root
.u
.def
.section
->output_section
->vma
1194 + h
->root
.u
.def
.section
->output_offset
);
1197 symval
+= bfd_get_32 (abfd
, contents
+ paddr
);
1199 /* See if this function call can be shortened. */
1202 + sec
->output_section
->vma
1203 + sec
->output_offset
1205 if (foff
< -0x1000 || foff
>= 0x1000)
1207 /* After all that work, we can't shorten this function call. */
1211 /* Shorten the function call. */
1213 /* For simplicity of coding, we are going to modify the section
1214 contents, the section relocs, and the BFD symbol table. We
1215 must tell the rest of the code not to free up this
1216 information. It would be possible to instead create a table
1217 of changes which have to be made, as is done in coff-mips.c;
1218 that would be more work, but would require less memory when
1219 the linker is run. */
1221 elf_section_data (sec
)->relocs
= internal_relocs
;
1224 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1225 free_contents
= NULL
;
1227 symtab_hdr
->contents
= (bfd_byte
*) extsyms
;
1228 free_extsyms
= NULL
;
1230 /* Replace the jsr with a bsr. */
1232 /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
1233 replace the jsr with a bsr. */
1234 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irelfn
->r_info
), R_SH_IND12W
);
1235 if (ELF32_R_SYM (irelfn
->r_info
) < symtab_hdr
->sh_info
)
1237 /* If this needs to be changed because of future relaxing,
1238 it will be handled here like other internal IND12W
1241 0xb000 | ((foff
>> 1) & 0xfff),
1242 contents
+ irel
->r_offset
);
1246 /* We can't fully resolve this yet, because the external
1247 symbol value may be changed by future relaxing. We let
1248 the final link phase handle it. */
1249 bfd_put_16 (abfd
, 0xb000, contents
+ irel
->r_offset
);
1252 /* See if there is another R_SH_USES reloc referring to the same
1254 for (irelscan
= internal_relocs
; irelscan
< irelend
; irelscan
++)
1255 if (ELF32_R_TYPE (irelscan
->r_info
) == (int) R_SH_USES
1256 && laddr
== irelscan
->r_offset
+ 4 + irelscan
->r_addend
)
1258 if (irelscan
< irelend
)
1260 /* Some other function call depends upon this register load,
1261 and we have not yet converted that function call.
1262 Indeed, we may never be able to convert it. There is
1263 nothing else we can do at this point. */
1267 /* Look for a R_SH_COUNT reloc on the location where the
1268 function address is stored. Do this before deleting any
1269 bytes, to avoid confusion about the address. */
1270 for (irelcount
= internal_relocs
; irelcount
< irelend
; irelcount
++)
1271 if (irelcount
->r_offset
== paddr
1272 && ELF32_R_TYPE (irelcount
->r_info
) == (int) R_SH_COUNT
)
1275 /* Delete the register load. */
1276 if (! sh_elf_relax_delete_bytes (abfd
, sec
, laddr
, 2))
1279 /* That will change things, so, just in case it permits some
1280 other function call to come within range, we should relax
1281 again. Note that this is not required, and it may be slow. */
1284 /* Now check whether we got a COUNT reloc. */
1285 if (irelcount
>= irelend
)
1287 ((*_bfd_error_handler
)
1288 (_("%s: 0x%lx: warning: could not find expected COUNT reloc"),
1289 bfd_get_filename (abfd
), (unsigned long) paddr
));
1293 /* The number of uses is stored in the r_addend field. We've
1294 just deleted one. */
1295 if (irelcount
->r_addend
== 0)
1297 ((*_bfd_error_handler
) (_("%s: 0x%lx: warning: bad count"),
1298 bfd_get_filename (abfd
),
1299 (unsigned long) paddr
));
1303 --irelcount
->r_addend
;
1305 /* If there are no more uses, we can delete the address. Reload
1306 the address from irelfn, in case it was changed by the
1307 previous call to sh_elf_relax_delete_bytes. */
1308 if (irelcount
->r_addend
== 0)
1310 if (! sh_elf_relax_delete_bytes (abfd
, sec
, irelfn
->r_offset
, 4))
1314 /* We've done all we can with that function call. */
1317 /* Look for load and store instructions that we can align on four
1323 /* Get the section contents. */
1324 if (contents
== NULL
)
1326 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1327 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1330 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
1331 if (contents
== NULL
)
1333 free_contents
= contents
;
1335 if (! bfd_get_section_contents (abfd
, sec
, contents
,
1336 (file_ptr
) 0, sec
->_raw_size
))
1341 if (! sh_elf_align_loads (abfd
, sec
, internal_relocs
, contents
,
1347 elf_section_data (sec
)->relocs
= internal_relocs
;
1350 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1351 free_contents
= NULL
;
1353 symtab_hdr
->contents
= (bfd_byte
*) extsyms
;
1354 free_extsyms
= NULL
;
1358 if (free_relocs
!= NULL
)
1364 if (free_contents
!= NULL
)
1366 if (! link_info
->keep_memory
)
1367 free (free_contents
);
1370 /* Cache the section contents for elf_link_input_bfd. */
1371 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1373 free_contents
= NULL
;
1376 if (free_extsyms
!= NULL
)
1378 if (! link_info
->keep_memory
)
1379 free (free_extsyms
);
1382 /* Cache the symbols for elf_link_input_bfd. */
1383 symtab_hdr
->contents
= extsyms
;
1385 free_extsyms
= NULL
;
1391 if (free_relocs
!= NULL
)
1393 if (free_contents
!= NULL
)
1394 free (free_contents
);
1395 if (free_extsyms
!= NULL
)
1396 free (free_extsyms
);
1400 /* Delete some bytes from a section while relaxing. FIXME: There is a
1401 lot of duplication between this function and sh_relax_delete_bytes
1405 sh_elf_relax_delete_bytes (abfd
, sec
, addr
, count
)
1411 Elf_Internal_Shdr
*symtab_hdr
;
1412 Elf32_External_Sym
*extsyms
;
1415 Elf_Internal_Rela
*irel
, *irelend
;
1416 Elf_Internal_Rela
*irelalign
;
1418 Elf32_External_Sym
*esym
, *esymend
;
1419 struct elf_link_hash_entry
*sym_hash
;
1422 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1423 extsyms
= (Elf32_External_Sym
*) symtab_hdr
->contents
;
1425 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
1427 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1429 /* The deletion must stop at the next ALIGN reloc for an aligment
1430 power larger than the number of bytes we are deleting. */
1433 toaddr
= sec
->_cooked_size
;
1435 irel
= elf_section_data (sec
)->relocs
;
1436 irelend
= irel
+ sec
->reloc_count
;
1437 for (; irel
< irelend
; irel
++)
1439 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_ALIGN
1440 && irel
->r_offset
> addr
1441 && count
< (1 << irel
->r_addend
))
1444 toaddr
= irel
->r_offset
;
1449 /* Actually delete the bytes. */
1450 memmove (contents
+ addr
, contents
+ addr
+ count
, toaddr
- addr
- count
);
1451 if (irelalign
== NULL
)
1452 sec
->_cooked_size
-= count
;
1457 #define NOP_OPCODE (0x0009)
1459 BFD_ASSERT ((count
& 1) == 0);
1460 for (i
= 0; i
< count
; i
+= 2)
1461 bfd_put_16 (abfd
, NOP_OPCODE
, contents
+ toaddr
- count
+ i
);
1464 /* Adjust all the relocs. */
1465 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1467 bfd_vma nraddr
, stop
;
1470 Elf_Internal_Sym sym
;
1471 int off
, adjust
, oinsn
;
1472 bfd_signed_vma voff
= 0;
1475 /* Get the new reloc address. */
1476 nraddr
= irel
->r_offset
;
1477 if ((irel
->r_offset
> addr
1478 && irel
->r_offset
< toaddr
)
1479 || (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_ALIGN
1480 && irel
->r_offset
== toaddr
))
1483 /* See if this reloc was for the bytes we have deleted, in which
1484 case we no longer care about it. Don't delete relocs which
1485 represent addresses, though. */
1486 if (irel
->r_offset
>= addr
1487 && irel
->r_offset
< addr
+ count
1488 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_ALIGN
1489 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_CODE
1490 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_DATA
1491 && ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_LABEL
)
1492 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1495 /* If this is a PC relative reloc, see if the range it covers
1496 includes the bytes we have deleted. */
1497 switch ((enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
))
1506 start
= irel
->r_offset
;
1507 insn
= bfd_get_16 (abfd
, contents
+ nraddr
);
1511 switch ((enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
))
1514 start
= stop
= addr
;
1518 /* If this reloc is against a symbol defined in this
1519 section, and the symbol will not be adjusted below, we
1520 must check the addend to see it will put the value in
1521 range to be adjusted, and hence must be changed. */
1522 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
1524 bfd_elf32_swap_symbol_in (abfd
,
1525 extsyms
+ ELF32_R_SYM (irel
->r_info
),
1527 if (sym
.st_shndx
== shndx
1528 && (sym
.st_value
<= addr
1529 || sym
.st_value
>= toaddr
))
1533 val
= bfd_get_32 (abfd
, contents
+ nraddr
);
1534 val
+= sym
.st_value
;
1535 if (val
> addr
&& val
< toaddr
)
1536 bfd_put_32 (abfd
, val
- count
, contents
+ nraddr
);
1539 start
= stop
= addr
;
1546 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ 4 + off
* 2);
1550 if (ELF32_R_SYM (irel
->r_info
) >= symtab_hdr
->sh_info
)
1551 start
= stop
= addr
;
1557 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ 4 + off
* 2);
1563 stop
= start
+ 4 + off
* 2;
1568 stop
= (start
& ~(bfd_vma
) 3) + 4 + off
* 4;
1574 /* These relocs types represent
1576 The r_addend field holds the difference between the reloc
1577 address and L1. That is the start of the reloc, and
1578 adding in the contents gives us the top. We must adjust
1579 both the r_offset field and the section contents.
1580 N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset,
1581 and the elf bfd r_offset is called r_vaddr. */
1583 stop
= irel
->r_offset
;
1584 start
= (bfd_vma
) ((bfd_signed_vma
) stop
- (long) irel
->r_addend
);
1588 && (stop
<= addr
|| stop
>= toaddr
))
1589 irel
->r_addend
+= count
;
1590 else if (stop
> addr
1592 && (start
<= addr
|| start
>= toaddr
))
1593 irel
->r_addend
-= count
;
1595 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_SWITCH16
)
1596 voff
= bfd_get_signed_16 (abfd
, contents
+ nraddr
);
1597 else if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_SWITCH8
)
1598 voff
= bfd_get_8 (abfd
, contents
+ nraddr
);
1600 voff
= bfd_get_signed_32 (abfd
, contents
+ nraddr
);
1601 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ voff
);
1606 start
= irel
->r_offset
;
1607 stop
= (bfd_vma
) ((bfd_signed_vma
) start
1608 + (long) irel
->r_addend
1615 && (stop
<= addr
|| stop
>= toaddr
))
1617 else if (stop
> addr
1619 && (start
<= addr
|| start
>= toaddr
))
1628 switch ((enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
))
1637 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1639 bfd_put_16 (abfd
, insn
, contents
+ nraddr
);
1644 if ((oinsn
& 0xf000) != (insn
& 0xf000))
1646 bfd_put_16 (abfd
, insn
, contents
+ nraddr
);
1650 BFD_ASSERT (adjust
== count
|| count
>= 4);
1655 if ((irel
->r_offset
& 3) == 0)
1658 if ((oinsn
& 0xff00) != (insn
& 0xff00))
1660 bfd_put_16 (abfd
, insn
, contents
+ nraddr
);
1665 if (voff
< 0 || voff
>= 0xff)
1667 bfd_put_8 (abfd
, voff
, contents
+ nraddr
);
1672 if (voff
< - 0x8000 || voff
>= 0x8000)
1674 bfd_put_signed_16 (abfd
, voff
, contents
+ nraddr
);
1679 bfd_put_signed_32 (abfd
, voff
, contents
+ nraddr
);
1683 irel
->r_addend
+= adjust
;
1689 ((*_bfd_error_handler
)
1690 (_("%s: 0x%lx: fatal: reloc overflow while relaxing"),
1691 bfd_get_filename (abfd
), (unsigned long) irel
->r_offset
));
1692 bfd_set_error (bfd_error_bad_value
);
1697 irel
->r_offset
= nraddr
;
1700 /* Look through all the other sections. If there contain any IMM32
1701 relocs against internal symbols which we are not going to adjust
1702 below, we may need to adjust the addends. */
1703 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1705 Elf_Internal_Rela
*internal_relocs
;
1706 Elf_Internal_Rela
*irelscan
, *irelscanend
;
1707 bfd_byte
*ocontents
;
1710 || (o
->flags
& SEC_RELOC
) == 0
1711 || o
->reloc_count
== 0)
1714 /* We always cache the relocs. Perhaps, if info->keep_memory is
1715 false, we should free them, if we are permitted to, when we
1716 leave sh_coff_relax_section. */
1717 internal_relocs
= (_bfd_elf32_link_read_relocs
1718 (abfd
, o
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
1720 if (internal_relocs
== NULL
)
1724 irelscanend
= internal_relocs
+ o
->reloc_count
;
1725 for (irelscan
= internal_relocs
; irelscan
< irelscanend
; irelscan
++)
1727 Elf_Internal_Sym sym
;
1729 /* Dwarf line numbers use R_SH_SWITCH32 relocs. */
1730 if (ELF32_R_TYPE (irelscan
->r_info
) == (int) R_SH_SWITCH32
)
1732 bfd_vma start
, stop
;
1733 bfd_signed_vma voff
;
1735 if (ocontents
== NULL
)
1737 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
1738 ocontents
= elf_section_data (o
)->this_hdr
.contents
;
1741 /* We always cache the section contents.
1742 Perhaps, if info->keep_memory is false, we
1743 should free them, if we are permitted to,
1744 when we leave sh_coff_relax_section. */
1745 ocontents
= (bfd_byte
*) bfd_malloc (o
->_raw_size
);
1746 if (ocontents
== NULL
)
1748 if (! bfd_get_section_contents (abfd
, o
, ocontents
,
1752 elf_section_data (o
)->this_hdr
.contents
= ocontents
;
1756 stop
= irelscan
->r_offset
;
1758 = (bfd_vma
) ((bfd_signed_vma
) stop
- (long) irelscan
->r_addend
);
1760 /* STOP is in a different section, so it won't change. */
1761 if (start
> addr
&& start
< toaddr
)
1762 irelscan
->r_addend
+= count
;
1764 voff
= bfd_get_signed_32 (abfd
, ocontents
+ irelscan
->r_offset
);
1765 stop
= (bfd_vma
) ((bfd_signed_vma
) start
+ voff
);
1769 && (stop
<= addr
|| stop
>= toaddr
))
1770 bfd_put_signed_32 (abfd
, voff
+ count
,
1771 ocontents
+ irelscan
->r_offset
);
1772 else if (stop
> addr
1774 && (start
<= addr
|| start
>= toaddr
))
1775 bfd_put_signed_32 (abfd
, voff
- count
,
1776 ocontents
+ irelscan
->r_offset
);
1779 if (ELF32_R_TYPE (irelscan
->r_info
) != (int) R_SH_DIR32
)
1782 if (ELF32_R_SYM (irelscan
->r_info
) >= symtab_hdr
->sh_info
)
1785 bfd_elf32_swap_symbol_in (abfd
,
1786 extsyms
+ ELF32_R_SYM (irelscan
->r_info
),
1789 if (sym
.st_shndx
== shndx
1790 && (sym
.st_value
<= addr
1791 || sym
.st_value
>= toaddr
))
1795 if (ocontents
== NULL
)
1797 if (elf_section_data (o
)->this_hdr
.contents
!= NULL
)
1798 ocontents
= elf_section_data (o
)->this_hdr
.contents
;
1801 /* We always cache the section contents.
1802 Perhaps, if info->keep_memory is false, we
1803 should free them, if we are permitted to,
1804 when we leave sh_coff_relax_section. */
1805 ocontents
= (bfd_byte
*) bfd_malloc (o
->_raw_size
);
1806 if (ocontents
== NULL
)
1808 if (! bfd_get_section_contents (abfd
, o
, ocontents
,
1812 elf_section_data (o
)->this_hdr
.contents
= ocontents
;
1816 val
= bfd_get_32 (abfd
, ocontents
+ irelscan
->r_offset
);
1817 val
+= sym
.st_value
;
1818 if (val
> addr
&& val
< toaddr
)
1819 bfd_put_32 (abfd
, val
- count
,
1820 ocontents
+ irelscan
->r_offset
);
1825 /* Adjust the local symbols defined in this section. */
1827 esymend
= esym
+ symtab_hdr
->sh_info
;
1828 for (; esym
< esymend
; esym
++)
1830 Elf_Internal_Sym isym
;
1832 bfd_elf32_swap_symbol_in (abfd
, esym
, &isym
);
1834 if (isym
.st_shndx
== shndx
1835 && isym
.st_value
> addr
1836 && isym
.st_value
< toaddr
)
1838 isym
.st_value
-= count
;
1839 bfd_elf32_swap_symbol_out (abfd
, &isym
, esym
);
1843 /* Now adjust the global symbols defined in this section. */
1844 esym
= extsyms
+ symtab_hdr
->sh_info
;
1845 esymend
= extsyms
+ (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
));
1846 for (index
= 0; esym
< esymend
; esym
++, index
++)
1848 Elf_Internal_Sym isym
;
1850 bfd_elf32_swap_symbol_in (abfd
, esym
, &isym
);
1851 sym_hash
= elf_sym_hashes (abfd
)[index
];
1852 if (isym
.st_shndx
== shndx
1853 && ((sym_hash
)->root
.type
== bfd_link_hash_defined
1854 || (sym_hash
)->root
.type
== bfd_link_hash_defweak
)
1855 && (sym_hash
)->root
.u
.def
.section
== sec
1856 && (sym_hash
)->root
.u
.def
.value
> addr
1857 && (sym_hash
)->root
.u
.def
.value
< toaddr
)
1859 (sym_hash
)->root
.u
.def
.value
-= count
;
1863 /* See if we can move the ALIGN reloc forward. We have adjusted
1864 r_offset for it already. */
1865 if (irelalign
!= NULL
)
1867 bfd_vma alignto
, alignaddr
;
1869 alignto
= BFD_ALIGN (toaddr
, 1 << irelalign
->r_addend
);
1870 alignaddr
= BFD_ALIGN (irelalign
->r_offset
,
1871 1 << irelalign
->r_addend
);
1872 if (alignto
!= alignaddr
)
1874 /* Tail recursion. */
1875 return sh_elf_relax_delete_bytes (abfd
, sec
, alignaddr
,
1876 alignto
- alignaddr
);
1883 /* Look for loads and stores which we can align to four byte
1884 boundaries. This is like sh_align_loads in coff-sh.c. */
1887 sh_elf_align_loads (abfd
, sec
, internal_relocs
, contents
, pswapped
)
1890 Elf_Internal_Rela
*internal_relocs
;
1894 Elf_Internal_Rela
*irel
, *irelend
;
1895 bfd_vma
*labels
= NULL
;
1896 bfd_vma
*label
, *label_end
;
1900 irelend
= internal_relocs
+ sec
->reloc_count
;
1902 /* Get all the addresses with labels on them. */
1903 labels
= (bfd_vma
*) bfd_malloc (sec
->reloc_count
* sizeof (bfd_vma
));
1907 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1909 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_LABEL
)
1911 *label_end
= irel
->r_offset
;
1916 /* Note that the assembler currently always outputs relocs in
1917 address order. If that ever changes, this code will need to sort
1918 the label values and the relocs. */
1922 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1924 bfd_vma start
, stop
;
1926 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_SH_CODE
)
1929 start
= irel
->r_offset
;
1931 for (irel
++; irel
< irelend
; irel
++)
1932 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_SH_DATA
)
1935 stop
= irel
->r_offset
;
1937 stop
= sec
->_cooked_size
;
1939 if (! _bfd_sh_align_load_span (abfd
, sec
, contents
, sh_elf_swap_insns
,
1940 (PTR
) internal_relocs
, &label
,
1941 label_end
, start
, stop
, pswapped
))
1955 /* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */
1958 sh_elf_swap_insns (abfd
, sec
, relocs
, contents
, addr
)
1965 Elf_Internal_Rela
*internal_relocs
= (Elf_Internal_Rela
*) relocs
;
1966 unsigned short i1
, i2
;
1967 Elf_Internal_Rela
*irel
, *irelend
;
1969 /* Swap the instructions themselves. */
1970 i1
= bfd_get_16 (abfd
, contents
+ addr
);
1971 i2
= bfd_get_16 (abfd
, contents
+ addr
+ 2);
1972 bfd_put_16 (abfd
, i2
, contents
+ addr
);
1973 bfd_put_16 (abfd
, i1
, contents
+ addr
+ 2);
1975 /* Adjust all reloc addresses. */
1976 irelend
= internal_relocs
+ sec
->reloc_count
;
1977 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1979 enum elf_sh_reloc_type type
;
1982 /* There are a few special types of relocs that we don't want to
1983 adjust. These relocs do not apply to the instruction itself,
1984 but are only associated with the address. */
1985 type
= (enum elf_sh_reloc_type
) ELF32_R_TYPE (irel
->r_info
);
1986 if (type
== R_SH_ALIGN
1987 || type
== R_SH_CODE
1988 || type
== R_SH_DATA
1989 || type
== R_SH_LABEL
)
1992 /* If an R_SH_USES reloc points to one of the addresses being
1993 swapped, we must adjust it. It would be incorrect to do this
1994 for a jump, though, since we want to execute both
1995 instructions after the jump. (We have avoided swapping
1996 around a label, so the jump will not wind up executing an
1997 instruction it shouldn't). */
1998 if (type
== R_SH_USES
)
2002 off
= irel
->r_offset
+ 4 + irel
->r_addend
;
2004 irel
->r_offset
+= 2;
2005 else if (off
== addr
+ 2)
2006 irel
->r_offset
-= 2;
2009 if (irel
->r_offset
== addr
)
2011 irel
->r_offset
+= 2;
2014 else if (irel
->r_offset
== addr
+ 2)
2016 irel
->r_offset
-= 2;
2025 unsigned short insn
, oinsn
;
2028 loc
= contents
+ irel
->r_offset
;
2037 insn
= bfd_get_16 (abfd
, loc
);
2040 if ((oinsn
& 0xff00) != (insn
& 0xff00))
2042 bfd_put_16 (abfd
, insn
, loc
);
2046 insn
= bfd_get_16 (abfd
, loc
);
2049 if ((oinsn
& 0xf000) != (insn
& 0xf000))
2051 bfd_put_16 (abfd
, insn
, loc
);
2055 /* This reloc ignores the least significant 3 bits of
2056 the program counter before adding in the offset.
2057 This means that if ADDR is at an even address, the
2058 swap will not affect the offset. If ADDR is an at an
2059 odd address, then the instruction will be crossing a
2060 four byte boundary, and must be adjusted. */
2061 if ((addr
& 3) != 0)
2063 insn
= bfd_get_16 (abfd
, loc
);
2066 if ((oinsn
& 0xff00) != (insn
& 0xff00))
2068 bfd_put_16 (abfd
, insn
, loc
);
2076 ((*_bfd_error_handler
)
2077 (_("%s: 0x%lx: fatal: reloc overflow while relaxing"),
2078 bfd_get_filename (abfd
), (unsigned long) irel
->r_offset
));
2079 bfd_set_error (bfd_error_bad_value
);
2088 /* The size in bytes of an entry in the procedure linkage table. */
2090 #define PLT_ENTRY_SIZE 28
2092 /* First entry in an absolute procedure linkage table look like this. */
2095 /* Note - this code has been "optimised" not to use r2. r2 is used by
2096 GCC to return the address of large strutcures, so it should not be
2097 corrupted here. This does mean however, that this PLT does not conform
2098 to the SH PIC ABI. That spec says that r0 contains the type of the PLT
2099 and r2 contains the GOT id. This version stores the GOT id in r0 and
2100 ignores the type. Loaders can easily detect this difference however,
2101 since the type will always be 0 or 8, and the GOT ids will always be
2102 greater than or equal to 12. */
2103 static const bfd_byte elf_sh_plt0_entry_be
[PLT_ENTRY_SIZE
] =
2105 0xd0, 0x05, /* mov.l 2f,r0 */
2106 0x60, 0x02, /* mov.l @r0,r0 */
2107 0x2f, 0x06, /* mov.l r0,@-r15 */
2108 0xd0, 0x03, /* mov.l 1f,r0 */
2109 0x60, 0x02, /* mov.l @r0,r0 */
2110 0x40, 0x2b, /* jmp @r0 */
2111 0x60, 0xf6, /* mov.l @r15+,r0 */
2112 0x00, 0x09, /* nop */
2113 0x00, 0x09, /* nop */
2114 0x00, 0x09, /* nop */
2115 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
2116 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
2119 static const bfd_byte elf_sh_plt0_entry_le
[PLT_ENTRY_SIZE
] =
2121 0x05, 0xd0, /* mov.l 2f,r0 */
2122 0x02, 0x60, /* mov.l @r0,r0 */
2123 0x06, 0x2f, /* mov.l r0,@-r15 */
2124 0x03, 0xd0, /* mov.l 1f,r0 */
2125 0x02, 0x60, /* mov.l @r0,r0 */
2126 0x2b, 0x40, /* jmp @r0 */
2127 0xf6, 0x60, /* mov.l @r15+,r0 */
2128 0x09, 0x00, /* nop */
2129 0x09, 0x00, /* nop */
2130 0x09, 0x00, /* nop */
2131 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
2132 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
2135 /* Sebsequent entries in an absolute procedure linkage table look like
2138 static const bfd_byte elf_sh_plt_entry_be
[PLT_ENTRY_SIZE
] =
2140 0xd0, 0x04, /* mov.l 1f,r0 */
2141 0x60, 0x02, /* mov.l @r0,r0 */
2142 0xd1, 0x02, /* mov.l 0f,r1 */
2143 0x40, 0x2b, /* jmp @r0 */
2144 0x60, 0x13, /* mov r1,r0 */
2145 0xd1, 0x03, /* mov.l 2f,r1 */
2146 0x40, 0x2b, /* jmp @r0 */
2147 0x00, 0x09, /* nop */
2148 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
2149 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
2150 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
2153 static const bfd_byte elf_sh_plt_entry_le
[PLT_ENTRY_SIZE
] =
2155 0x04, 0xd0, /* mov.l 1f,r0 */
2156 0x02, 0x60, /* mov.l @r0,r0 */
2157 0x02, 0xd1, /* mov.l 0f,r1 */
2158 0x2b, 0x40, /* jmp @r0 */
2159 0x13, 0x60, /* mov r1,r0 */
2160 0x03, 0xd1, /* mov.l 2f,r1 */
2161 0x2b, 0x40, /* jmp @r0 */
2162 0x09, 0x00, /* nop */
2163 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
2164 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
2165 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
2168 /* Entries in a PIC procedure linkage table look like this. */
2170 static const bfd_byte elf_sh_pic_plt_entry_be
[PLT_ENTRY_SIZE
] =
2172 0xd0, 0x04, /* mov.l 1f,r0 */
2173 0x00, 0xce, /* mov.l @(r0,r12),r0 */
2174 0x40, 0x2b, /* jmp @r0 */
2175 0x00, 0x09, /* nop */
2176 0x50, 0xc2, /* mov.l @(8,r12),r0 */
2177 0xd1, 0x03, /* mov.l 2f,r1 */
2178 0x40, 0x2b, /* jmp @r0 */
2179 0x50, 0xc1, /* mov.l @(4,r12),r0 */
2180 0x00, 0x09, /* nop */
2181 0x00, 0x09, /* nop */
2182 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
2183 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
2186 static const bfd_byte elf_sh_pic_plt_entry_le
[PLT_ENTRY_SIZE
] =
2188 0x04, 0xd0, /* mov.l 1f,r0 */
2189 0xce, 0x00, /* mov.l @(r0,r12),r0 */
2190 0x2b, 0x40, /* jmp @r0 */
2191 0x09, 0x00, /* nop */
2192 0xc2, 0x50, /* mov.l @(8,r12),r0 */
2193 0x03, 0xd1, /* mov.l 2f,r1 */
2194 0x2b, 0x40, /* jmp @r0 */
2195 0xc1, 0x50, /* mov.l @(4,r12),r0 */
2196 0x09, 0x00, /* nop */
2197 0x09, 0x00, /* nop */
2198 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
2199 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
2202 #else /* These are the old style PLT entries. */
2203 static const bfd_byte elf_sh_plt0_entry_be
[PLT_ENTRY_SIZE
] =
2205 0xd0, 0x04, /* mov.l 1f,r0 */
2206 0xd2, 0x05, /* mov.l 2f,r2 */
2207 0x60, 0x02, /* mov.l @r0,r0 */
2208 0x62, 0x22, /* mov.l @r2,r2 */
2209 0x40, 0x2b, /* jmp @r0 */
2210 0xe0, 0x00, /* mov #0,r0 */
2211 0x00, 0x09, /* nop */
2212 0x00, 0x09, /* nop */
2213 0x00, 0x09, /* nop */
2214 0x00, 0x09, /* nop */
2215 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
2216 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
2219 static const bfd_byte elf_sh_plt0_entry_le
[PLT_ENTRY_SIZE
] =
2221 0x04, 0xd0, /* mov.l 1f,r0 */
2222 0x05, 0xd2, /* mov.l 2f,r2 */
2223 0x02, 0x60, /* mov.l @r0,r0 */
2224 0x22, 0x62, /* mov.l @r2,r2 */
2225 0x2b, 0x40, /* jmp @r0 */
2226 0x00, 0xe0, /* mov #0,r0 */
2227 0x09, 0x00, /* nop */
2228 0x09, 0x00, /* nop */
2229 0x09, 0x00, /* nop */
2230 0x09, 0x00, /* nop */
2231 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
2232 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
2235 /* Sebsequent entries in an absolute procedure linkage table look like
2238 static const bfd_byte elf_sh_plt_entry_be
[PLT_ENTRY_SIZE
] =
2240 0xd0, 0x04, /* mov.l 1f,r0 */
2241 0x60, 0x02, /* mov.l @r0,r0 */
2242 0xd2, 0x02, /* mov.l 0f,r2 */
2243 0x40, 0x2b, /* jmp @r0 */
2244 0x60, 0x23, /* mov r2,r0 */
2245 0xd1, 0x03, /* mov.l 2f,r1 */
2246 0x40, 0x2b, /* jmp @r0 */
2247 0x00, 0x09, /* nop */
2248 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
2249 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
2250 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
2253 static const bfd_byte elf_sh_plt_entry_le
[PLT_ENTRY_SIZE
] =
2255 0x04, 0xd0, /* mov.l 1f,r0 */
2256 0x02, 0x60, /* mov.l @r0,r0 */
2257 0x02, 0xd2, /* mov.l 0f,r2 */
2258 0x2b, 0x40, /* jmp @r0 */
2259 0x23, 0x60, /* mov r2,r0 */
2260 0x03, 0xd1, /* mov.l 2f,r1 */
2261 0x2b, 0x40, /* jmp @r0 */
2262 0x09, 0x00, /* nop */
2263 0, 0, 0, 0, /* 0: replaced with address of .PLT. */
2264 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
2265 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
2268 /* Entries in a PIC procedure linkage table look like this. */
2270 static const bfd_byte elf_sh_pic_plt_entry_be
[PLT_ENTRY_SIZE
] =
2272 0xd0, 0x04, /* mov.l 1f,r0 */
2273 0x00, 0xce, /* mov.l @(r0,r12),r0 */
2274 0x40, 0x2b, /* jmp @r0 */
2275 0x00, 0x09, /* nop */
2276 0x50, 0xc2, /* 0: mov.l @(8,r12),r0 */
2277 0x52, 0xc1, /* 1: mov.l @(4,r12),r2 */
2278 0xd1, 0x02, /* mov.l 2f,r1 */
2279 0x40, 0x2b, /* jmp @r0 */
2280 0xe0, 0x00, /* mov #0,r0 ! shows the type of PLT. */
2281 0x00, 0x09, /* nop */
2282 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
2283 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
2286 static const bfd_byte elf_sh_pic_plt_entry_le
[PLT_ENTRY_SIZE
] =
2288 0x04, 0xd0, /* mov.l 1f,r0 */
2289 0xce, 0x00, /* mov.l @(r0,r12),r0 */
2290 0x2b, 0x40, /* jmp @r0 */
2291 0x09, 0x00, /* nop */
2292 0xc2, 0x50, /* 0: mov.l @(8,r12),r0 */
2293 0xc1, 0x52, /* 1: mov.l @(4,r12),r2 */
2294 0x02, 0xd1, /* mov.l 2f,r1 */
2295 0x2b, 0x40, /* jmp @r0 */
2296 0x00, 0xe0, /* mov #0,r0 ! shows the type of PLT. */
2297 0x09, 0x00, /* nop */
2298 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
2299 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
2301 #endif /* old style PLT entries. */
2303 static const bfd_byte
*elf_sh_plt0_entry
;
2304 static const bfd_byte
*elf_sh_plt_entry
;
2305 static const bfd_byte
*elf_sh_pic_plt_entry
;
2307 /* Return size of a PLT entry. */
2308 #define elf_sh_sizeof_plt(info) PLT_ENTRY_SIZE
2310 /* Return offset of the PLT0 address in an absolute PLT entry. */
2311 #define elf_sh_plt_plt0_offset(info) 16
2313 /* Return offset of the linker in PLT0 entry. */
2314 #define elf_sh_plt0_linker_offset(info) 20
2316 /* Return offset of the GOT id in PLT0 entry. */
2317 #define elf_sh_plt0_gotid_offset(info) 24
2319 /* Return offset of the tempoline in PLT entry */
2320 #define elf_sh_plt_temp_offset(info) 8
2322 /* Return offset of the symbol in PLT entry. */
2323 #define elf_sh_plt_symbol_offset(info) 20
2325 /* Return offset of the relocation in PLT entry. */
2326 #define elf_sh_plt_reloc_offset(info) 24
2328 /* The sh linker needs to keep track of the number of relocs that it
2329 decides to copy in check_relocs for each symbol. This is so that
2330 it can discard PC relative relocs if it doesn't need them when
2331 linking with -Bsymbolic. We store the information in a field
2332 extending the regular ELF linker hash table. */
2334 /* This structure keeps track of the number of PC relative relocs we
2335 have copied for a given symbol. */
2337 struct elf_sh_pcrel_relocs_copied
2340 struct elf_sh_pcrel_relocs_copied
*next
;
2341 /* A section in dynobj. */
2343 /* Number of relocs copied in this section. */
2344 bfd_size_type count
;
2347 /* sh ELF linker hash entry. */
2349 struct elf_sh_link_hash_entry
2351 struct elf_link_hash_entry root
;
2353 /* Number of PC relative relocs copied for this symbol. */
2354 struct elf_sh_pcrel_relocs_copied
*pcrel_relocs_copied
;
2357 /* sh ELF linker hash table. */
2359 struct elf_sh_link_hash_table
2361 struct elf_link_hash_table root
;
2364 /* Declare this now that the above structures are defined. */
2366 static boolean sh_elf_discard_copies
2367 PARAMS ((struct elf_sh_link_hash_entry
*, PTR
));
2369 /* Traverse an sh ELF linker hash table. */
2371 #define sh_elf_link_hash_traverse(table, func, info) \
2372 (elf_link_hash_traverse \
2374 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
2377 /* Get the sh ELF linker hash table from a link_info structure. */
2379 #define sh_elf_hash_table(p) \
2380 ((struct elf_sh_link_hash_table *) ((p)->hash))
2382 /* Create an entry in an sh ELF linker hash table. */
2384 static struct bfd_hash_entry
*
2385 sh_elf_link_hash_newfunc (entry
, table
, string
)
2386 struct bfd_hash_entry
*entry
;
2387 struct bfd_hash_table
*table
;
2390 struct elf_sh_link_hash_entry
*ret
=
2391 (struct elf_sh_link_hash_entry
*) entry
;
2393 /* Allocate the structure if it has not already been allocated by a
2395 if (ret
== (struct elf_sh_link_hash_entry
*) NULL
)
2396 ret
= ((struct elf_sh_link_hash_entry
*)
2397 bfd_hash_allocate (table
,
2398 sizeof (struct elf_sh_link_hash_entry
)));
2399 if (ret
== (struct elf_sh_link_hash_entry
*) NULL
)
2400 return (struct bfd_hash_entry
*) ret
;
2402 /* Call the allocation method of the superclass. */
2403 ret
= ((struct elf_sh_link_hash_entry
*)
2404 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
2406 if (ret
!= (struct elf_sh_link_hash_entry
*) NULL
)
2408 ret
->pcrel_relocs_copied
= NULL
;
2411 return (struct bfd_hash_entry
*) ret
;
2414 /* Create an sh ELF linker hash table. */
2416 static struct bfd_link_hash_table
*
2417 sh_elf_link_hash_table_create (abfd
)
2420 struct elf_sh_link_hash_table
*ret
;
2422 ret
= ((struct elf_sh_link_hash_table
*)
2423 bfd_alloc (abfd
, sizeof (struct elf_sh_link_hash_table
)));
2424 if (ret
== (struct elf_sh_link_hash_table
*) NULL
)
2427 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
2428 sh_elf_link_hash_newfunc
))
2430 bfd_release (abfd
, ret
);
2434 return &ret
->root
.root
;
2437 /* Create dynamic sections when linking against a dynamic object. */
2440 sh_elf_create_dynamic_sections (abfd
, info
)
2442 struct bfd_link_info
*info
;
2444 flagword flags
, pltflags
;
2445 register asection
*s
;
2446 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2449 switch (bed
->s
->arch_size
)
2460 bfd_set_error (bfd_error_bad_value
);
2464 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2465 .rel[a].bss sections. */
2467 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2468 | SEC_LINKER_CREATED
);
2471 pltflags
|= SEC_CODE
;
2472 if (bed
->plt_not_loaded
)
2473 pltflags
&= ~ (SEC_LOAD
| SEC_HAS_CONTENTS
);
2474 if (bed
->plt_readonly
)
2475 pltflags
|= SEC_READONLY
;
2477 s
= bfd_make_section (abfd
, ".plt");
2479 || ! bfd_set_section_flags (abfd
, s
, pltflags
)
2480 || ! bfd_set_section_alignment (abfd
, s
, bed
->plt_alignment
))
2483 if (bed
->want_plt_sym
)
2485 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2487 struct elf_link_hash_entry
*h
= NULL
;
2488 if (! (_bfd_generic_link_add_one_symbol
2489 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
,
2490 (bfd_vma
) 0, (const char *) NULL
, false,
2491 get_elf_backend_data (abfd
)->collect
,
2492 (struct bfd_link_hash_entry
**) &h
)))
2494 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2495 h
->type
= STT_OBJECT
;
2498 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
2502 s
= bfd_make_section (abfd
,
2503 bed
->default_use_rela_p
? ".rela.plt" : ".rel.plt");
2505 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
2506 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
2509 if (! _bfd_elf_create_got_section (abfd
, info
))
2513 const char *secname
;
2518 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2520 secflags
= bfd_get_section_flags (abfd
, sec
);
2521 if ((secflags
& (SEC_DATA
| SEC_LINKER_CREATED
))
2522 || ((secflags
& SEC_HAS_CONTENTS
) != SEC_HAS_CONTENTS
))
2524 secname
= bfd_get_section_name (abfd
, sec
);
2525 relname
= (char *) bfd_malloc (strlen (secname
) + 6);
2526 strcpy (relname
, ".rela");
2527 strcat (relname
, secname
);
2528 s
= bfd_make_section (abfd
, relname
);
2530 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
2531 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
2536 if (bed
->want_dynbss
)
2538 /* The .dynbss section is a place to put symbols which are defined
2539 by dynamic objects, are referenced by regular objects, and are
2540 not functions. We must allocate space for them in the process
2541 image and use a R_*_COPY reloc to tell the dynamic linker to
2542 initialize them at run time. The linker script puts the .dynbss
2543 section into the .bss section of the final image. */
2544 s
= bfd_make_section (abfd
, ".dynbss");
2546 || ! bfd_set_section_flags (abfd
, s
, SEC_ALLOC
))
2549 /* The .rel[a].bss section holds copy relocs. This section is not
2550 normally needed. We need to create it here, though, so that the
2551 linker will map it to an output section. We can't just create it
2552 only if we need it, because we will not know whether we need it
2553 until we have seen all the input files, and the first time the
2554 main linker code calls BFD after examining all the input files
2555 (size_dynamic_sections) the input sections have already been
2556 mapped to the output sections. If the section turns out not to
2557 be needed, we can discard it later. We will never need this
2558 section when generating a shared object, since they do not use
2562 s
= bfd_make_section (abfd
,
2563 (bed
->default_use_rela_p
2564 ? ".rela.bss" : ".rel.bss"));
2566 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
2567 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
2575 /* Adjust a symbol defined by a dynamic object and referenced by a
2576 regular object. The current definition is in some section of the
2577 dynamic object, but we're not including those sections. We have to
2578 change the definition to something the rest of the link can
2582 sh_elf_adjust_dynamic_symbol (info
, h
)
2583 struct bfd_link_info
*info
;
2584 struct elf_link_hash_entry
*h
;
2588 unsigned int power_of_two
;
2590 dynobj
= elf_hash_table (info
)->dynobj
;
2592 /* Make sure we know what is going on here. */
2593 BFD_ASSERT (dynobj
!= NULL
2594 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
2595 || h
->weakdef
!= NULL
2596 || ((h
->elf_link_hash_flags
2597 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2598 && (h
->elf_link_hash_flags
2599 & ELF_LINK_HASH_REF_REGULAR
) != 0
2600 && (h
->elf_link_hash_flags
2601 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
2603 /* If this is a function, put it in the procedure linkage table. We
2604 will fill in the contents of the procedure linkage table later,
2605 when we know the address of the .got section. */
2606 if (h
->type
== STT_FUNC
2607 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
2610 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
2611 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0)
2613 /* This case can occur if we saw a PLT reloc in an input
2614 file, but the symbol was never referred to by a dynamic
2615 object. In such a case, we don't actually need to build
2616 a procedure linkage table, and we can just do a REL32
2618 BFD_ASSERT ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0);
2622 /* Make sure this symbol is output as a dynamic symbol. */
2623 if (h
->dynindx
== -1)
2625 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2629 s
= bfd_get_section_by_name (dynobj
, ".plt");
2630 BFD_ASSERT (s
!= NULL
);
2632 /* If this is the first .plt entry, make room for the special
2634 if (s
->_raw_size
== 0)
2635 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2637 /* If this symbol is not defined in a regular file, and we are
2638 not generating a shared library, then set the symbol to this
2639 location in the .plt. This is required to make function
2640 pointers compare as equal between the normal executable and
2641 the shared library. */
2643 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2645 h
->root
.u
.def
.section
= s
;
2646 h
->root
.u
.def
.value
= s
->_raw_size
;
2649 h
->plt
.offset
= s
->_raw_size
;
2651 /* Make room for this entry. */
2652 s
->_raw_size
+= elf_sh_sizeof_plt (info
);
2654 /* We also need to make an entry in the .got.plt section, which
2655 will be placed in the .got section by the linker script. */
2657 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
2658 BFD_ASSERT (s
!= NULL
);
2661 /* We also need to make an entry in the .rela.plt section. */
2663 s
= bfd_get_section_by_name (dynobj
, ".rela.plt");
2664 BFD_ASSERT (s
!= NULL
);
2665 s
->_raw_size
+= sizeof (Elf32_External_Rela
);
2670 /* If this is a weak symbol, and there is a real definition, the
2671 processor independent code will have arranged for us to see the
2672 real definition first, and we can just use the same value. */
2673 if (h
->weakdef
!= NULL
)
2675 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
2676 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
2677 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
2678 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
2682 /* This is a reference to a symbol defined by a dynamic object which
2683 is not a function. */
2685 /* If we are creating a shared library, we must presume that the
2686 only references to the symbol are via the global offset table.
2687 For such cases we need not do anything here; the relocations will
2688 be handled correctly by relocate_section. */
2692 /* If there are no references to this symbol that do not use the
2693 GOT, we don't need to generate a copy reloc. */
2694 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
2697 /* We must allocate the symbol in our .dynbss section, which will
2698 become part of the .bss section of the executable. There will be
2699 an entry for this symbol in the .dynsym section. The dynamic
2700 object will contain position independent code, so all references
2701 from the dynamic object to this symbol will go through the global
2702 offset table. The dynamic linker will use the .dynsym entry to
2703 determine the address it must put in the global offset table, so
2704 both the dynamic object and the regular object will refer to the
2705 same memory location for the variable. */
2707 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2708 BFD_ASSERT (s
!= NULL
);
2710 /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
2711 copy the initial value out of the dynamic object and into the
2712 runtime process image. We need to remember the offset into the
2713 .rela.bss section we are going to use. */
2714 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2718 srel
= bfd_get_section_by_name (dynobj
, ".rela.bss");
2719 BFD_ASSERT (srel
!= NULL
);
2720 srel
->_raw_size
+= sizeof (Elf32_External_Rela
);
2721 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
2724 /* We need to figure out the alignment required for this symbol. I
2725 have no idea how ELF linkers handle this. */
2726 power_of_two
= bfd_log2 (h
->size
);
2727 if (power_of_two
> 3)
2730 /* Apply the required alignment. */
2731 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
2732 (bfd_size_type
) (1 << power_of_two
));
2733 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
2735 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
2739 /* Define the symbol as being at this point in the section. */
2740 h
->root
.u
.def
.section
= s
;
2741 h
->root
.u
.def
.value
= s
->_raw_size
;
2743 /* Increment the section size to make room for the symbol. */
2744 s
->_raw_size
+= h
->size
;
2749 /* Set the sizes of the dynamic sections. */
2752 sh_elf_size_dynamic_sections (output_bfd
, info
)
2754 struct bfd_link_info
*info
;
2762 dynobj
= elf_hash_table (info
)->dynobj
;
2763 BFD_ASSERT (dynobj
!= NULL
);
2765 if (elf_hash_table (info
)->dynamic_sections_created
)
2767 /* Set the contents of the .interp section to the interpreter. */
2770 s
= bfd_get_section_by_name (dynobj
, ".interp");
2771 BFD_ASSERT (s
!= NULL
);
2772 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2773 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2778 /* We may have created entries in the .rela.got section.
2779 However, if we are not creating the dynamic sections, we will
2780 not actually use these entries. Reset the size of .rela.got,
2781 which will cause it to get stripped from the output file
2783 s
= bfd_get_section_by_name (dynobj
, ".rela.got");
2788 /* If this is a -Bsymbolic shared link, then we need to discard all
2789 PC relative relocs against symbols defined in a regular object.
2790 We allocated space for them in the check_relocs routine, but we
2791 will not fill them in in the relocate_section routine. */
2792 if (info
->shared
&& info
->symbolic
)
2793 sh_elf_link_hash_traverse (sh_elf_hash_table (info
),
2794 sh_elf_discard_copies
,
2797 /* The check_relocs and adjust_dynamic_symbol entry points have
2798 determined the sizes of the various dynamic sections. Allocate
2803 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2808 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2811 /* It's OK to base decisions on the section name, because none
2812 of the dynobj section names depend upon the input files. */
2813 name
= bfd_get_section_name (dynobj
, s
);
2817 if (strcmp (name
, ".plt") == 0)
2819 if (s
->_raw_size
== 0)
2821 /* Strip this section if we don't need it; see the
2827 /* Remember whether there is a PLT. */
2831 else if (strncmp (name
, ".rela", 5) == 0)
2833 if (s
->_raw_size
== 0)
2835 /* If we don't need this section, strip it from the
2836 output file. This is mostly to handle .rela.bss and
2837 .rela.plt. We must create both sections in
2838 create_dynamic_sections, because they must be created
2839 before the linker maps input sections to output
2840 sections. The linker does that before
2841 adjust_dynamic_symbol is called, and it is that
2842 function which decides whether anything needs to go
2843 into these sections. */
2850 /* Remember whether there are any reloc sections other
2852 if (strcmp (name
, ".rela.plt") != 0)
2854 const char *outname
;
2858 /* If this relocation section applies to a read only
2859 section, then we probably need a DT_TEXTREL
2860 entry. The entries in the .rela.plt section
2861 really apply to the .got section, which we
2862 created ourselves and so know is not readonly. */
2863 outname
= bfd_get_section_name (output_bfd
,
2865 target
= bfd_get_section_by_name (output_bfd
, outname
+ 5);
2867 && (target
->flags
& SEC_READONLY
) != 0
2868 && (target
->flags
& SEC_ALLOC
) != 0)
2872 /* We use the reloc_count field as a counter if we need
2873 to copy relocs into the output file. */
2877 else if (strncmp (name
, ".got", 4) != 0)
2879 /* It's not one of our sections, so don't allocate space. */
2885 _bfd_strip_section_from_output (info
, s
);
2889 /* Allocate memory for the section contents. */
2890 s
->contents
= (bfd_byte
*) bfd_alloc (dynobj
, s
->_raw_size
);
2891 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
2895 if (elf_hash_table (info
)->dynamic_sections_created
)
2897 /* Add some entries to the .dynamic section. We fill in the
2898 values later, in sh_elf_finish_dynamic_sections, but we
2899 must add the entries now so that we get the correct size for
2900 the .dynamic section. The DT_DEBUG entry is filled in by the
2901 dynamic linker and used by the debugger. */
2904 if (! bfd_elf32_add_dynamic_entry (info
, DT_DEBUG
, 0))
2910 if (! bfd_elf32_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2911 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2912 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
2913 || ! bfd_elf32_add_dynamic_entry (info
, DT_JMPREL
, 0))
2919 if (! bfd_elf32_add_dynamic_entry (info
, DT_RELA
, 0)
2920 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELASZ
, 0)
2921 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELAENT
,
2922 sizeof (Elf32_External_Rela
)))
2928 if (! bfd_elf32_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2936 /* This function is called via sh_elf_link_hash_traverse if we are
2937 creating a shared object with -Bsymbolic. It discards the space
2938 allocated to copy PC relative relocs against symbols which are
2939 defined in regular objects. We allocated space for them in the
2940 check_relocs routine, but we won't fill them in in the
2941 relocate_section routine. */
2944 sh_elf_discard_copies (h
, ignore
)
2945 struct elf_sh_link_hash_entry
*h
;
2946 PTR ignore ATTRIBUTE_UNUSED
;
2948 struct elf_sh_pcrel_relocs_copied
*s
;
2950 /* We only discard relocs for symbols defined in a regular object. */
2951 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2954 for (s
= h
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
2955 s
->section
->_raw_size
-= s
->count
* sizeof (Elf32_External_Rela
);
2960 /* Relocate an SH ELF section. */
2963 sh_elf_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
2964 contents
, relocs
, local_syms
, local_sections
)
2965 bfd
*output_bfd ATTRIBUTE_UNUSED
;
2966 struct bfd_link_info
*info
;
2968 asection
*input_section
;
2970 Elf_Internal_Rela
*relocs
;
2971 Elf_Internal_Sym
*local_syms
;
2972 asection
**local_sections
;
2974 Elf_Internal_Shdr
*symtab_hdr
;
2975 struct elf_link_hash_entry
**sym_hashes
;
2976 Elf_Internal_Rela
*rel
, *relend
;
2978 bfd_vma
*local_got_offsets
;
2983 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2984 sym_hashes
= elf_sym_hashes (input_bfd
);
2985 dynobj
= elf_hash_table (info
)->dynobj
;
2986 local_got_offsets
= elf_local_got_offsets (input_bfd
);
2993 relend
= relocs
+ input_section
->reloc_count
;
2994 for (; rel
< relend
; rel
++)
2997 reloc_howto_type
*howto
;
2998 unsigned long r_symndx
;
2999 Elf_Internal_Sym
*sym
;
3001 struct elf_link_hash_entry
*h
;
3003 bfd_vma addend
= (bfd_vma
) 0;
3004 bfd_reloc_status_type r
;
3006 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3008 r_type
= ELF32_R_TYPE (rel
->r_info
);
3010 /* Many of the relocs are only used for relaxing, and are
3011 handled entirely by the relaxation code. */
3012 if (r_type
> (int) R_SH_LAST_INVALID_RELOC
3013 && r_type
< (int) R_SH_LOOP_START
)
3015 if (r_type
== (int) R_SH_NONE
)
3019 || r_type
>= R_SH_max
3020 || (r_type
>= (int) R_SH_FIRST_INVALID_RELOC
3021 && r_type
<= (int) R_SH_LAST_INVALID_RELOC
)
3022 || (r_type
>= (int) R_SH_FIRST_INVALID_RELOC_2
3023 && r_type
<= (int) R_SH_LAST_INVALID_RELOC_2
))
3025 bfd_set_error (bfd_error_bad_value
);
3029 howto
= sh_elf_howto_table
+ r_type
;
3031 /* This is a final link. */
3035 if (r_symndx
< symtab_hdr
->sh_info
)
3037 sym
= local_syms
+ r_symndx
;
3038 sec
= local_sections
[r_symndx
];
3039 relocation
= (sec
->output_section
->vma
3040 + sec
->output_offset
3043 if (info
->relocateable
)
3045 /* This is a relocateable link. We don't have to change
3046 anything, unless the reloc is against a section symbol,
3047 in which case we have to adjust according to where the
3048 section symbol winds up in the output section. */
3049 sym
= local_syms
+ r_symndx
;
3050 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3051 goto final_link_relocate
;
3058 /* Section symbol are never (?) placed in the hash table, so
3059 we can just ignore hash relocations when creating a
3060 relocateable object file. */
3061 if (info
->relocateable
)
3064 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
3065 while (h
->root
.type
== bfd_link_hash_indirect
3066 || h
->root
.type
== bfd_link_hash_warning
)
3067 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3068 if (h
->root
.type
== bfd_link_hash_defined
3069 || h
->root
.type
== bfd_link_hash_defweak
)
3071 sec
= h
->root
.u
.def
.section
;
3072 /* In these cases, we don't need the relocation value.
3073 We check specially because in some obscure cases
3074 sec->output_section will be NULL. */
3075 if (r_type
== R_SH_GOTPC
3076 || (r_type
== R_SH_PLT32
3077 && h
->plt
.offset
!= (bfd_vma
) -1)
3078 || (r_type
== R_SH_GOT32
3079 && elf_hash_table (info
)->dynamic_sections_created
3081 || (! info
->symbolic
&& h
->dynindx
!= -1)
3082 || (h
->elf_link_hash_flags
3083 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
3084 /* The cases above are those in which relocation is
3085 overwritten in the switch block below. The cases
3086 below are those in which we must defer relocation
3087 to run-time, because we can't resolve absolute
3088 addresses when creating a shared library. */
3090 && ((! info
->symbolic
&& h
->dynindx
!= -1)
3091 || (h
->elf_link_hash_flags
3092 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
3093 && ((r_type
== R_SH_DIR32
3094 && !(ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
3095 || ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
))
3096 || r_type
== R_SH_REL32
)
3097 && ((input_section
->flags
& SEC_ALLOC
) != 0
3098 /* DWARF will emit R_SH_DIR32 relocations in its
3099 sections against symbols defined externally
3100 in shared libraries. We can't do anything
3102 || (input_section
->flags
& SEC_DEBUGGING
) != 0)))
3104 else if (sec
->output_section
== NULL
)
3106 (*_bfd_error_handler
)
3107 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
3108 bfd_get_filename (input_bfd
), h
->root
.root
.string
,
3109 bfd_get_section_name (input_bfd
, input_section
));
3113 relocation
= (h
->root
.u
.def
.value
3114 + sec
->output_section
->vma
3115 + sec
->output_offset
);
3117 else if (h
->root
.type
== bfd_link_hash_undefweak
)
3119 else if (info
->shared
&& !info
->symbolic
&& !info
->no_undefined
)
3123 if (! ((*info
->callbacks
->undefined_symbol
)
3124 (info
, h
->root
.root
.string
, input_bfd
,
3125 input_section
, rel
->r_offset
, true)))
3131 switch ((int) r_type
)
3133 final_link_relocate
:
3134 /* COFF relocs don't use the addend. The addend is used for
3135 R_SH_DIR32 to be compatible with other compilers. */
3136 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
3137 contents
, rel
->r_offset
,
3138 relocation
, addend
);
3143 goto final_link_relocate
;
3148 /* If the reloc is against the start of this section, then
3149 the assembler has already taken care of it and the reloc
3150 is here only to assist in relaxing. If the reloc is not
3151 against the start of this section, then it's against an
3152 external symbol and we must deal with it ourselves. */
3153 if (input_section
->output_section
->vma
+ input_section
->output_offset
3156 int disp
= (relocation
3157 - input_section
->output_section
->vma
3158 - input_section
->output_offset
3164 case R_SH_DIR8WPZ
: mask
= 1; break;
3165 case R_SH_DIR8WPL
: mask
= 3; break;
3166 default: mask
= 0; break;
3170 ((*_bfd_error_handler
)
3171 (_("%s: 0x%lx: fatal: unaligned branch target for relax-support relocation"),
3172 bfd_get_filename (input_section
->owner
),
3173 (unsigned long) rel
->r_offset
));
3174 bfd_set_error (bfd_error_bad_value
);
3178 goto final_link_relocate
;
3184 bfd_set_error (bfd_error_bad_value
);
3190 && (input_section
->flags
& SEC_ALLOC
) != 0
3191 && (r_type
!= R_SH_REL32
3194 && (! info
->symbolic
3195 || (h
->elf_link_hash_flags
3196 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
3198 Elf_Internal_Rela outrel
;
3199 boolean skip
, relocate
;
3201 /* When generating a shared object, these relocations
3202 are copied into the output file to be resolved at run
3209 name
= (bfd_elf_string_from_elf_section
3211 elf_elfheader (input_bfd
)->e_shstrndx
,
3212 elf_section_data (input_section
)->rel_hdr
.sh_name
));
3216 BFD_ASSERT (strncmp (name
, ".rela", 5) == 0
3217 && strcmp (bfd_get_section_name (input_bfd
,
3221 sreloc
= bfd_get_section_by_name (dynobj
, name
);
3222 BFD_ASSERT (sreloc
!= NULL
);
3227 if (elf_section_data (input_section
)->stab_info
== NULL
)
3228 outrel
.r_offset
= rel
->r_offset
;
3233 off
= (_bfd_stab_section_offset
3234 (output_bfd
, &elf_hash_table (info
)->stab_info
,
3236 &elf_section_data (input_section
)->stab_info
,
3238 if (off
== (bfd_vma
) -1)
3240 outrel
.r_offset
= off
;
3243 outrel
.r_offset
+= (input_section
->output_section
->vma
3244 + input_section
->output_offset
);
3248 memset (&outrel
, 0, sizeof outrel
);
3251 else if (r_type
== R_SH_REL32
)
3253 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
3255 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_REL32
);
3256 outrel
.r_addend
= rel
->r_addend
;
3260 /* h->dynindx may be -1 if this symbol was marked to
3263 || ((info
->symbolic
|| h
->dynindx
== -1)
3264 && (h
->elf_link_hash_flags
3265 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
3268 outrel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
3269 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3273 BFD_ASSERT (h
->dynindx
!= -1);
3275 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_DIR32
);
3276 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3280 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
3281 (((Elf32_External_Rela
*)
3283 + sreloc
->reloc_count
));
3284 ++sreloc
->reloc_count
;
3286 /* If this reloc is against an external symbol, we do
3287 not want to fiddle with the addend. Otherwise, we
3288 need to include the symbol value so that it becomes
3289 an addend for the dynamic reloc. */
3293 else if (r_type
== R_SH_DIR32
)
3294 addend
= rel
->r_addend
;
3295 goto final_link_relocate
;
3298 /* Relocation is to the entry for this symbol in the global
3302 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3303 BFD_ASSERT (sgot
!= NULL
);
3310 off
= h
->got
.offset
;
3311 BFD_ASSERT (off
!= (bfd_vma
) -1);
3313 if (! elf_hash_table (info
)->dynamic_sections_created
3315 && (info
->symbolic
|| h
->dynindx
== -1
3316 || ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
3317 || ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
)
3318 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
3320 /* This is actually a static link, or it is a
3321 -Bsymbolic link and the symbol is defined
3322 locally, or the symbol was forced to be local
3323 because of a version file. We must initialize
3324 this entry in the global offset table. Since the
3325 offset must always be a multiple of 4, we use the
3326 least significant bit to record whether we have
3327 initialized it already.
3329 When doing a dynamic link, we create a .rela.got
3330 relocation entry to initialize the value. This
3331 is done in the finish_dynamic_symbol routine. */
3336 bfd_put_32 (output_bfd
, relocation
,
3337 sgot
->contents
+ off
);
3342 relocation
= sgot
->output_offset
+ off
;
3348 BFD_ASSERT (local_got_offsets
!= NULL
3349 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
3351 off
= local_got_offsets
[r_symndx
];
3353 /* The offset must always be a multiple of 4. We use
3354 the least significant bit to record whether we have
3355 already generated the necessary reloc. */
3360 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
3365 Elf_Internal_Rela outrel
;
3367 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
3368 BFD_ASSERT (srelgot
!= NULL
);
3370 outrel
.r_offset
= (sgot
->output_section
->vma
3371 + sgot
->output_offset
3373 outrel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
3374 outrel
.r_addend
= relocation
;
3375 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
3376 (((Elf32_External_Rela
*)
3378 + srelgot
->reloc_count
));
3379 ++srelgot
->reloc_count
;
3382 local_got_offsets
[r_symndx
] |= 1;
3385 relocation
= sgot
->output_offset
+ off
;
3388 goto final_link_relocate
;
3391 /* Relocation is relative to the start of the global offset
3396 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3397 BFD_ASSERT (sgot
!= NULL
);
3400 /* Note that sgot->output_offset is not involved in this
3401 calculation. We always want the start of .got. If we
3402 defined _GLOBAL_OFFSET_TABLE in a different way, as is
3403 permitted by the ABI, we might have to change this
3405 relocation
-= sgot
->output_section
->vma
;
3407 goto final_link_relocate
;
3410 /* Use global offset table as symbol value. */
3414 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3415 BFD_ASSERT (sgot
!= NULL
);
3418 relocation
= sgot
->output_section
->vma
;
3420 goto final_link_relocate
;
3423 /* Relocation is to the entry for this symbol in the
3424 procedure linkage table. */
3426 /* Resolve a PLT reloc against a local symbol directly,
3427 without using the procedure linkage table. */
3429 goto final_link_relocate
;
3431 if (ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
3432 || ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
)
3433 goto final_link_relocate
;
3435 if (h
->plt
.offset
== (bfd_vma
) -1)
3437 /* We didn't make a PLT entry for this symbol. This
3438 happens when statically linking PIC code, or when
3439 using -Bsymbolic. */
3440 goto final_link_relocate
;
3445 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3446 BFD_ASSERT (splt
!= NULL
);
3449 relocation
= (splt
->output_section
->vma
3450 + splt
->output_offset
3453 goto final_link_relocate
;
3455 case R_SH_LOOP_START
:
3457 static bfd_vma start
, end
;
3459 start
= (relocation
+ rel
->r_addend
3460 - (sec
->output_section
->vma
+ sec
->output_offset
));
3461 r
= sh_elf_reloc_loop (r_type
, input_bfd
, input_section
, contents
,
3462 rel
->r_offset
, sec
, start
, end
);
3466 end
= (relocation
+ rel
->r_addend
3467 - (sec
->output_section
->vma
+ sec
->output_offset
));
3468 r
= sh_elf_reloc_loop (r_type
, input_bfd
, input_section
, contents
,
3469 rel
->r_offset
, sec
, start
, end
);
3474 if (r
!= bfd_reloc_ok
)
3479 case bfd_reloc_outofrange
:
3481 case bfd_reloc_overflow
:
3486 name
= h
->root
.root
.string
;
3489 name
= (bfd_elf_string_from_elf_section
3490 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
3494 name
= bfd_section_name (input_bfd
, sec
);
3496 if (! ((*info
->callbacks
->reloc_overflow
)
3497 (info
, name
, howto
->name
, (bfd_vma
) 0,
3498 input_bfd
, input_section
, rel
->r_offset
)))
3509 /* This is a version of bfd_generic_get_relocated_section_contents
3510 which uses sh_elf_relocate_section. */
3513 sh_elf_get_relocated_section_contents (output_bfd
, link_info
, link_order
,
3514 data
, relocateable
, symbols
)
3516 struct bfd_link_info
*link_info
;
3517 struct bfd_link_order
*link_order
;
3519 boolean relocateable
;
3522 Elf_Internal_Shdr
*symtab_hdr
;
3523 asection
*input_section
= link_order
->u
.indirect
.section
;
3524 bfd
*input_bfd
= input_section
->owner
;
3525 asection
**sections
= NULL
;
3526 Elf_Internal_Rela
*internal_relocs
= NULL
;
3527 Elf32_External_Sym
*external_syms
= NULL
;
3528 Elf_Internal_Sym
*internal_syms
= NULL
;
3530 /* We only need to handle the case of relaxing, or of having a
3531 particular set of section contents, specially. */
3533 || elf_section_data (input_section
)->this_hdr
.contents
== NULL
)
3534 return bfd_generic_get_relocated_section_contents (output_bfd
, link_info
,
3539 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3541 memcpy (data
, elf_section_data (input_section
)->this_hdr
.contents
,
3542 input_section
->_raw_size
);
3544 if ((input_section
->flags
& SEC_RELOC
) != 0
3545 && input_section
->reloc_count
> 0)
3547 Elf_Internal_Sym
*isymp
;
3549 Elf32_External_Sym
*esym
, *esymend
;
3551 if (symtab_hdr
->contents
!= NULL
)
3552 external_syms
= (Elf32_External_Sym
*) symtab_hdr
->contents
;
3555 external_syms
= ((Elf32_External_Sym
*)
3556 bfd_malloc (symtab_hdr
->sh_info
3557 * sizeof (Elf32_External_Sym
)));
3558 if (external_syms
== NULL
&& symtab_hdr
->sh_info
> 0)
3560 if (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
3561 || (bfd_read (external_syms
, sizeof (Elf32_External_Sym
),
3562 symtab_hdr
->sh_info
, input_bfd
)
3563 != (symtab_hdr
->sh_info
* sizeof (Elf32_External_Sym
))))
3567 internal_relocs
= (_bfd_elf32_link_read_relocs
3568 (input_bfd
, input_section
, (PTR
) NULL
,
3569 (Elf_Internal_Rela
*) NULL
, false));
3570 if (internal_relocs
== NULL
)
3573 internal_syms
= ((Elf_Internal_Sym
*)
3574 bfd_malloc (symtab_hdr
->sh_info
3575 * sizeof (Elf_Internal_Sym
)));
3576 if (internal_syms
== NULL
&& symtab_hdr
->sh_info
> 0)
3579 sections
= (asection
**) bfd_malloc (symtab_hdr
->sh_info
3580 * sizeof (asection
*));
3581 if (sections
== NULL
&& symtab_hdr
->sh_info
> 0)
3584 isymp
= internal_syms
;
3586 esym
= external_syms
;
3587 esymend
= esym
+ symtab_hdr
->sh_info
;
3588 for (; esym
< esymend
; ++esym
, ++isymp
, ++secpp
)
3592 bfd_elf32_swap_symbol_in (input_bfd
, esym
, isymp
);
3594 if (isymp
->st_shndx
== SHN_UNDEF
)
3595 isec
= bfd_und_section_ptr
;
3596 else if (isymp
->st_shndx
> 0 && isymp
->st_shndx
< SHN_LORESERVE
)
3597 isec
= bfd_section_from_elf_index (input_bfd
, isymp
->st_shndx
);
3598 else if (isymp
->st_shndx
== SHN_ABS
)
3599 isec
= bfd_abs_section_ptr
;
3600 else if (isymp
->st_shndx
== SHN_COMMON
)
3601 isec
= bfd_com_section_ptr
;
3611 if (! sh_elf_relocate_section (output_bfd
, link_info
, input_bfd
,
3612 input_section
, data
, internal_relocs
,
3613 internal_syms
, sections
))
3616 if (sections
!= NULL
)
3619 if (internal_syms
!= NULL
)
3620 free (internal_syms
);
3621 internal_syms
= NULL
;
3622 if (external_syms
!= NULL
&& symtab_hdr
->contents
== NULL
)
3623 free (external_syms
);
3624 external_syms
= NULL
;
3625 if (internal_relocs
!= elf_section_data (input_section
)->relocs
)
3626 free (internal_relocs
);
3627 internal_relocs
= NULL
;
3633 if (internal_relocs
!= NULL
3634 && internal_relocs
!= elf_section_data (input_section
)->relocs
)
3635 free (internal_relocs
);
3636 if (external_syms
!= NULL
&& symtab_hdr
->contents
== NULL
)
3637 free (external_syms
);
3638 if (internal_syms
!= NULL
)
3639 free (internal_syms
);
3640 if (sections
!= NULL
)
3645 sh_elf_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
3647 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
3648 Elf_Internal_Rela
*rel
;
3649 struct elf_link_hash_entry
*h
;
3650 Elf_Internal_Sym
*sym
;
3654 switch (ELF32_R_TYPE (rel
->r_info
))
3656 case R_SH_GNU_VTINHERIT
:
3657 case R_SH_GNU_VTENTRY
:
3661 switch (h
->root
.type
)
3663 case bfd_link_hash_defined
:
3664 case bfd_link_hash_defweak
:
3665 return h
->root
.u
.def
.section
;
3667 case bfd_link_hash_common
:
3668 return h
->root
.u
.c
.p
->section
;
3677 if (!(elf_bad_symtab (abfd
)
3678 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
3679 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
3680 && sym
->st_shndx
!= SHN_COMMON
))
3681 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
3686 /* Update the got entry reference counts for the section being removed. */
3689 sh_elf_gc_sweep_hook (abfd
, info
, sec
, relocs
)
3690 bfd
*abfd ATTRIBUTE_UNUSED
;
3691 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
3692 asection
*sec ATTRIBUTE_UNUSED
;
3693 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
3695 /* We use got and plt entries for sh, but it would seem that the
3696 existing SH code does no sort of reference counting or whatnot on
3697 its GOT and PLT entries, so it is not possible to garbage collect
3698 them at this time. */
3702 /* Look through the relocs for a section during the first phase.
3703 Since we don't do .gots or .plts, we just need to consider the
3704 virtual table relocs for gc. */
3707 sh_elf_check_relocs (abfd
, info
, sec
, relocs
)
3709 struct bfd_link_info
*info
;
3711 const Elf_Internal_Rela
*relocs
;
3713 Elf_Internal_Shdr
*symtab_hdr
;
3714 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
3715 const Elf_Internal_Rela
*rel
;
3716 const Elf_Internal_Rela
*rel_end
;
3718 bfd_vma
*local_got_offsets
;
3727 if (info
->relocateable
)
3730 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3731 sym_hashes
= elf_sym_hashes (abfd
);
3732 sym_hashes_end
= sym_hashes
+ symtab_hdr
->sh_size
/sizeof (Elf32_External_Sym
);
3733 if (!elf_bad_symtab (abfd
))
3734 sym_hashes_end
-= symtab_hdr
->sh_info
;
3736 dynobj
= elf_hash_table (info
)->dynobj
;
3737 local_got_offsets
= elf_local_got_offsets (abfd
);
3739 rel_end
= relocs
+ sec
->reloc_count
;
3740 for (rel
= relocs
; rel
< rel_end
; rel
++)
3742 struct elf_link_hash_entry
*h
;
3743 unsigned long r_symndx
;
3745 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3746 if (r_symndx
< symtab_hdr
->sh_info
)
3749 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
3751 /* Some relocs require a global offset table. */
3754 switch (ELF32_R_TYPE (rel
->r_info
))
3759 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
3760 if (! _bfd_elf_create_got_section (dynobj
, info
))
3769 switch (ELF32_R_TYPE (rel
->r_info
))
3771 /* This relocation describes the C++ object vtable hierarchy.
3772 Reconstruct it for later use during GC. */
3773 case R_SH_GNU_VTINHERIT
:
3774 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
3778 /* This relocation describes which C++ vtable entries are actually
3779 used. Record for later use during GC. */
3780 case R_SH_GNU_VTENTRY
:
3781 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
3786 /* This symbol requires a global offset table entry. */
3790 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3791 BFD_ASSERT (sgot
!= NULL
);
3795 && (h
!= NULL
|| info
->shared
))
3797 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
3798 if (srelgot
== NULL
)
3800 srelgot
= bfd_make_section (dynobj
, ".rela.got");
3802 || ! bfd_set_section_flags (dynobj
, srelgot
,
3807 | SEC_LINKER_CREATED
3809 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
3816 if (h
->got
.offset
!= (bfd_vma
) -1)
3818 /* We have already allocated space in the .got. */
3821 h
->got
.offset
= sgot
->_raw_size
;
3823 /* Make sure this symbol is output as a dynamic symbol. */
3824 if (h
->dynindx
== -1)
3826 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
3830 srelgot
->_raw_size
+= sizeof (Elf32_External_Rela
);
3834 /* This is a global offset table entry for a local
3836 if (local_got_offsets
== NULL
)
3839 register unsigned int i
;
3841 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
3842 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
3843 if (local_got_offsets
== NULL
)
3845 elf_local_got_offsets (abfd
) = local_got_offsets
;
3846 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
3847 local_got_offsets
[i
] = (bfd_vma
) -1;
3849 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
3851 /* We have already allocated space in the .got. */
3854 local_got_offsets
[r_symndx
] = sgot
->_raw_size
;
3858 /* If we are generating a shared object, we need to
3859 output a R_SH_RELATIVE reloc so that the dynamic
3860 linker can adjust this GOT entry. */
3861 srelgot
->_raw_size
+= sizeof (Elf32_External_Rela
);
3865 sgot
->_raw_size
+= 4;
3870 /* This symbol requires a procedure linkage table entry. We
3871 actually build the entry in adjust_dynamic_symbol,
3872 because this might be a case of linking PIC code which is
3873 never referenced by a dynamic object, in which case we
3874 don't need to generate a procedure linkage table entry
3877 /* If this is a local symbol, we resolve it directly without
3878 creating a procedure linkage table entry. */
3882 if (ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
3883 || ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
)
3886 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
3893 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
3895 /* If we are creating a shared library, and this is a reloc
3896 against a global symbol, or a non PC relative reloc
3897 against a local symbol, then we need to copy the reloc
3898 into the shared library. However, if we are linking with
3899 -Bsymbolic, we do not need to copy a reloc against a
3900 global symbol which is defined in an object we are
3901 including in the link (i.e., DEF_REGULAR is set). At
3902 this point we have not seen all the input files, so it is
3903 possible that DEF_REGULAR is not set now but will be set
3904 later (it is never cleared). We account for that
3905 possibility below by storing information in the
3906 pcrel_relocs_copied field of the hash table entry. */
3908 && (sec
->flags
& SEC_ALLOC
) != 0
3909 && (ELF32_R_TYPE (rel
->r_info
) != R_SH_REL32
3911 && (! info
->symbolic
3912 || (h
->elf_link_hash_flags
3913 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
3915 /* When creating a shared object, we must copy these
3916 reloc types into the output file. We create a reloc
3917 section in dynobj and make room for this reloc. */
3922 name
= (bfd_elf_string_from_elf_section
3924 elf_elfheader (abfd
)->e_shstrndx
,
3925 elf_section_data (sec
)->rel_hdr
.sh_name
));
3929 BFD_ASSERT (strncmp (name
, ".rela", 5) == 0
3930 && strcmp (bfd_get_section_name (abfd
, sec
),
3933 sreloc
= bfd_get_section_by_name (dynobj
, name
);
3938 sreloc
= bfd_make_section (dynobj
, name
);
3939 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
3940 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3941 if ((sec
->flags
& SEC_ALLOC
) != 0)
3942 flags
|= SEC_ALLOC
| SEC_LOAD
;
3944 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
3945 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
3950 sreloc
->_raw_size
+= sizeof (Elf32_External_Rela
);
3952 /* If we are linking with -Bsymbolic, and this is a
3953 global symbol, we count the number of PC relative
3954 relocations we have entered for this symbol, so that
3955 we can discard them again if the symbol is later
3956 defined by a regular object. Note that this function
3957 is only called if we are using an elf_sh linker
3958 hash table, which means that h is really a pointer to
3959 an elf_sh_link_hash_entry. */
3960 if (h
!= NULL
&& info
->symbolic
3961 && ELF32_R_TYPE (rel
->r_info
) == R_SH_REL32
)
3963 struct elf_sh_link_hash_entry
*eh
;
3964 struct elf_sh_pcrel_relocs_copied
*p
;
3966 eh
= (struct elf_sh_link_hash_entry
*) h
;
3968 for (p
= eh
->pcrel_relocs_copied
; p
!= NULL
; p
= p
->next
)
3969 if (p
->section
== sreloc
)
3974 p
= ((struct elf_sh_pcrel_relocs_copied
*)
3975 bfd_alloc (dynobj
, sizeof *p
));
3978 p
->next
= eh
->pcrel_relocs_copied
;
3979 eh
->pcrel_relocs_copied
= p
;
3980 p
->section
= sreloc
;
3996 sh_elf_set_mach_from_flags (abfd
)
3999 flagword flags
= elf_elfheader (abfd
)->e_flags
;
4001 switch (flags
& EF_SH_MACH_MASK
)
4004 bfd_default_set_arch_mach (abfd
, bfd_arch_sh
, bfd_mach_sh
);
4007 bfd_default_set_arch_mach (abfd
, bfd_arch_sh
, bfd_mach_sh2
);
4010 bfd_default_set_arch_mach (abfd
, bfd_arch_sh
, bfd_mach_sh_dsp
);
4013 bfd_default_set_arch_mach (abfd
, bfd_arch_sh
, bfd_mach_sh3
);
4016 bfd_default_set_arch_mach (abfd
, bfd_arch_sh
, bfd_mach_sh3_dsp
);
4019 bfd_default_set_arch_mach (abfd
, bfd_arch_sh
, bfd_mach_sh3e
);
4023 bfd_default_set_arch_mach (abfd
, bfd_arch_sh
, bfd_mach_sh4
);
4031 /* Function to keep SH specific file flags. */
4034 sh_elf_set_private_flags (abfd
, flags
)
4038 BFD_ASSERT (! elf_flags_init (abfd
)
4039 || elf_elfheader (abfd
)->e_flags
== flags
);
4041 elf_elfheader (abfd
)->e_flags
= flags
;
4042 elf_flags_init (abfd
) = true;
4043 return sh_elf_set_mach_from_flags (abfd
);
4046 /* Copy backend specific data from one object module to another */
4049 sh_elf_copy_private_data (ibfd
, obfd
)
4053 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4054 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4057 return sh_elf_set_private_flags (obfd
, elf_elfheader (ibfd
)->e_flags
);
4060 /* This routine checks for linking big and little endian objects
4061 together, and for linking sh-dsp with sh3e / sh4 objects. */
4064 sh_elf_merge_private_data (ibfd
, obfd
)
4068 flagword old_flags
, new_flags
;
4070 if (_bfd_generic_verify_endian_match (ibfd
, obfd
) == false)
4073 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4074 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4077 if (! elf_flags_init (obfd
))
4079 /* This happens when ld starts out with a 'blank' output file. */
4080 elf_flags_init (obfd
) = true;
4081 elf_elfheader (obfd
)->e_flags
= EF_SH1
;
4083 old_flags
= elf_elfheader (obfd
)->e_flags
;
4084 new_flags
= elf_elfheader (ibfd
)->e_flags
;
4085 if ((EF_SH_HAS_DSP (old_flags
) && EF_SH_HAS_FP (new_flags
))
4086 || (EF_SH_HAS_DSP (new_flags
) && EF_SH_HAS_FP (old_flags
)))
4088 (*_bfd_error_handler
)
4089 ("%s: uses %s instructions while previous modules use %s instructions",
4090 bfd_get_filename (ibfd
),
4091 EF_SH_HAS_DSP (new_flags
) ? "dsp" : "floating point",
4092 EF_SH_HAS_DSP (new_flags
) ? "floating point" : "dsp");
4093 bfd_set_error (bfd_error_bad_value
);
4096 elf_elfheader (obfd
)->e_flags
= EF_SH_MERGE_MACH (old_flags
, new_flags
);
4098 return sh_elf_set_mach_from_flags (obfd
);
4101 /* Finish up dynamic symbol handling. We set the contents of various
4102 dynamic sections here. */
4105 sh_elf_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
4107 struct bfd_link_info
*info
;
4108 struct elf_link_hash_entry
*h
;
4109 Elf_Internal_Sym
*sym
;
4113 dynobj
= elf_hash_table (info
)->dynobj
;
4115 if (h
->plt
.offset
!= (bfd_vma
) -1)
4123 Elf_Internal_Rela rel
;
4125 /* This symbol has an entry in the procedure linkage table. Set
4128 BFD_ASSERT (h
->dynindx
!= -1);
4130 splt
= bfd_get_section_by_name (dynobj
, ".plt");
4131 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
4132 srel
= bfd_get_section_by_name (dynobj
, ".rela.plt");
4133 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
4135 /* Get the index in the procedure linkage table which
4136 corresponds to this symbol. This is the index of this symbol
4137 in all the symbols for which we are making plt entries. The
4138 first entry in the procedure linkage table is reserved. */
4139 plt_index
= h
->plt
.offset
/ elf_sh_sizeof_plt (info
) - 1;
4141 /* Get the offset into the .got table of the entry that
4142 corresponds to this function. Each .got entry is 4 bytes.
4143 The first three are reserved. */
4144 got_offset
= (plt_index
+ 3) * 4;
4146 /* Fill in the entry in the procedure linkage table. */
4149 if (elf_sh_plt_entry
== NULL
)
4151 elf_sh_plt_entry
= (bfd_big_endian (output_bfd
) ?
4152 elf_sh_plt_entry_be
: elf_sh_plt_entry_le
);
4154 memcpy (splt
->contents
+ h
->plt
.offset
, elf_sh_plt_entry
,
4155 elf_sh_sizeof_plt (info
));
4156 bfd_put_32 (output_bfd
,
4157 (sgot
->output_section
->vma
4158 + sgot
->output_offset
4160 (splt
->contents
+ h
->plt
.offset
4161 + elf_sh_plt_symbol_offset (info
)));
4163 bfd_put_32 (output_bfd
,
4164 (splt
->output_section
->vma
+ splt
->output_offset
),
4165 (splt
->contents
+ h
->plt
.offset
4166 + elf_sh_plt_plt0_offset (info
)));
4170 if (elf_sh_pic_plt_entry
== NULL
)
4172 elf_sh_pic_plt_entry
= (bfd_big_endian (output_bfd
) ?
4173 elf_sh_pic_plt_entry_be
:
4174 elf_sh_pic_plt_entry_le
);
4176 memcpy (splt
->contents
+ h
->plt
.offset
, elf_sh_pic_plt_entry
,
4177 elf_sh_sizeof_plt (info
));
4178 bfd_put_32 (output_bfd
, got_offset
,
4179 (splt
->contents
+ h
->plt
.offset
4180 + elf_sh_plt_symbol_offset (info
)));
4183 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rela
),
4184 (splt
->contents
+ h
->plt
.offset
4185 + elf_sh_plt_reloc_offset (info
)));
4187 /* Fill in the entry in the global offset table. */
4188 bfd_put_32 (output_bfd
,
4189 (splt
->output_section
->vma
4190 + splt
->output_offset
4192 + elf_sh_plt_temp_offset (info
)),
4193 sgot
->contents
+ got_offset
);
4195 /* Fill in the entry in the .rela.plt section. */
4196 rel
.r_offset
= (sgot
->output_section
->vma
4197 + sgot
->output_offset
4199 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_JMP_SLOT
);
4201 bfd_elf32_swap_reloca_out (output_bfd
, &rel
,
4202 ((Elf32_External_Rela
*) srel
->contents
4205 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
4207 /* Mark the symbol as undefined, rather than as defined in
4208 the .plt section. Leave the value alone. */
4209 sym
->st_shndx
= SHN_UNDEF
;
4213 if (h
->got
.offset
!= (bfd_vma
) -1)
4217 Elf_Internal_Rela rel
;
4219 /* This symbol has an entry in the global offset table. Set it
4222 sgot
= bfd_get_section_by_name (dynobj
, ".got");
4223 srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
4224 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
4226 rel
.r_offset
= (sgot
->output_section
->vma
4227 + sgot
->output_offset
4228 + (h
->got
.offset
&~ 1));
4230 /* If this is a -Bsymbolic link, and the symbol is defined
4231 locally, we just want to emit a RELATIVE reloc. Likewise if
4232 the symbol was forced to be local because of a version file.
4233 The entry in the global offset table will already have been
4234 initialized in the relocate_section function. */
4236 && (info
->symbolic
|| h
->dynindx
== -1)
4237 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
4239 rel
.r_info
= ELF32_R_INFO (0, R_SH_RELATIVE
);
4240 rel
.r_addend
= (h
->root
.u
.def
.value
4241 + h
->root
.u
.def
.section
->output_section
->vma
4242 + h
->root
.u
.def
.section
->output_offset
);
4246 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
4247 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_GLOB_DAT
);
4251 bfd_elf32_swap_reloca_out (output_bfd
, &rel
,
4252 ((Elf32_External_Rela
*) srel
->contents
4253 + srel
->reloc_count
));
4254 ++srel
->reloc_count
;
4257 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
4260 Elf_Internal_Rela rel
;
4262 /* This symbol needs a copy reloc. Set it up. */
4264 BFD_ASSERT (h
->dynindx
!= -1
4265 && (h
->root
.type
== bfd_link_hash_defined
4266 || h
->root
.type
== bfd_link_hash_defweak
));
4268 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
4270 BFD_ASSERT (s
!= NULL
);
4272 rel
.r_offset
= (h
->root
.u
.def
.value
4273 + h
->root
.u
.def
.section
->output_section
->vma
4274 + h
->root
.u
.def
.section
->output_offset
);
4275 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SH_COPY
);
4277 bfd_elf32_swap_reloca_out (output_bfd
, &rel
,
4278 ((Elf32_External_Rela
*) s
->contents
4283 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
4284 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
4285 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
4286 sym
->st_shndx
= SHN_ABS
;
4291 /* Finish up the dynamic sections. */
4294 sh_elf_finish_dynamic_sections (output_bfd
, info
)
4296 struct bfd_link_info
*info
;
4302 dynobj
= elf_hash_table (info
)->dynobj
;
4304 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
4305 BFD_ASSERT (sgot
!= NULL
);
4306 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
4308 if (elf_hash_table (info
)->dynamic_sections_created
)
4311 Elf32_External_Dyn
*dyncon
, *dynconend
;
4313 BFD_ASSERT (sdyn
!= NULL
);
4315 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
4316 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
4317 for (; dyncon
< dynconend
; dyncon
++)
4319 Elf_Internal_Dyn dyn
;
4323 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4337 s
= bfd_get_section_by_name (output_bfd
, name
);
4338 BFD_ASSERT (s
!= NULL
);
4339 dyn
.d_un
.d_ptr
= s
->vma
;
4340 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4344 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
4345 BFD_ASSERT (s
!= NULL
);
4346 if (s
->_cooked_size
!= 0)
4347 dyn
.d_un
.d_val
= s
->_cooked_size
;
4349 dyn
.d_un
.d_val
= s
->_raw_size
;
4350 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4354 /* My reading of the SVR4 ABI indicates that the
4355 procedure linkage table relocs (DT_JMPREL) should be
4356 included in the overall relocs (DT_RELA). This is
4357 what Solaris does. However, UnixWare can not handle
4358 that case. Therefore, we override the DT_RELASZ entry
4359 here to make it not include the JMPREL relocs. Since
4360 the linker script arranges for .rela.plt to follow all
4361 other relocation sections, we don't have to worry
4362 about changing the DT_RELA entry. */
4363 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
4366 if (s
->_cooked_size
!= 0)
4367 dyn
.d_un
.d_val
-= s
->_cooked_size
;
4369 dyn
.d_un
.d_val
-= s
->_raw_size
;
4371 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4376 /* Fill in the first entry in the procedure linkage table. */
4377 splt
= bfd_get_section_by_name (dynobj
, ".plt");
4378 if (splt
&& splt
->_raw_size
> 0)
4382 if (elf_sh_pic_plt_entry
== NULL
)
4384 elf_sh_pic_plt_entry
= (bfd_big_endian (output_bfd
) ?
4385 elf_sh_pic_plt_entry_be
:
4386 elf_sh_pic_plt_entry_le
);
4388 memcpy (splt
->contents
, elf_sh_pic_plt_entry
,
4389 elf_sh_sizeof_plt (info
));
4393 if (elf_sh_plt0_entry
== NULL
)
4395 elf_sh_plt0_entry
= (bfd_big_endian (output_bfd
) ?
4396 elf_sh_plt0_entry_be
:
4397 elf_sh_plt0_entry_le
);
4399 memcpy (splt
->contents
, elf_sh_plt0_entry
, PLT_ENTRY_SIZE
);
4400 bfd_put_32 (output_bfd
,
4401 sgot
->output_section
->vma
+ sgot
->output_offset
+ 4,
4402 splt
->contents
+ elf_sh_plt0_gotid_offset (info
));
4403 bfd_put_32 (output_bfd
,
4404 sgot
->output_section
->vma
+ sgot
->output_offset
+ 8,
4405 splt
->contents
+ elf_sh_plt0_linker_offset (info
));
4408 /* UnixWare sets the entsize of .plt to 4, although that doesn't
4409 really seem like the right value. */
4410 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
4414 /* Fill in the first three entries in the global offset table. */
4415 if (sgot
->_raw_size
> 0)
4418 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
4420 bfd_put_32 (output_bfd
,
4421 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
4423 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
4424 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
4427 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
4433 #define TARGET_BIG_SYM bfd_elf32_sh_vec
4434 #define TARGET_BIG_NAME "elf32-sh"
4435 #define TARGET_LITTLE_SYM bfd_elf32_shl_vec
4436 #define TARGET_LITTLE_NAME "elf32-shl"
4437 #define ELF_ARCH bfd_arch_sh
4438 #define ELF_MACHINE_CODE EM_SH
4439 #define ELF_MAXPAGESIZE 128
4441 #define elf_symbol_leading_char '_'
4442 #endif /* ELF_ARCH */
4444 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
4445 #define elf_info_to_howto sh_elf_info_to_howto
4446 #define bfd_elf32_bfd_relax_section sh_elf_relax_section
4447 #define elf_backend_relocate_section sh_elf_relocate_section
4448 #define bfd_elf32_bfd_get_relocated_section_contents \
4449 sh_elf_get_relocated_section_contents
4450 #define elf_backend_object_p sh_elf_set_mach_from_flags
4451 #define bfd_elf32_bfd_set_private_bfd_flags \
4452 sh_elf_set_private_flags
4453 #define bfd_elf32_bfd_copy_private_bfd_data \
4454 sh_elf_copy_private_data
4455 #define bfd_elf32_bfd_merge_private_bfd_data \
4456 sh_elf_merge_private_data
4458 #define elf_backend_gc_mark_hook sh_elf_gc_mark_hook
4459 #define elf_backend_gc_sweep_hook sh_elf_gc_sweep_hook
4460 #define elf_backend_check_relocs sh_elf_check_relocs
4462 #define elf_backend_can_gc_sections 1
4463 #define elf_backend_create_dynamic_sections \
4464 sh_elf_create_dynamic_sections
4465 #define bfd_elf32_bfd_link_hash_table_create \
4466 sh_elf_link_hash_table_create
4467 #define elf_backend_adjust_dynamic_symbol \
4468 sh_elf_adjust_dynamic_symbol
4469 #define elf_backend_size_dynamic_sections \
4470 sh_elf_size_dynamic_sections
4471 #define elf_backend_finish_dynamic_symbol \
4472 sh_elf_finish_dynamic_symbol
4473 #define elf_backend_finish_dynamic_sections \
4474 sh_elf_finish_dynamic_sections
4476 #define elf_backend_want_got_plt 1
4477 #define elf_backend_plt_readonly 1
4478 #define elf_backend_want_plt_sym 0
4479 #define elf_backend_got_header_size 12
4480 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
4481 #include "elf32-target.h"