1 |
578 |
markom |
/* 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.
|
5 |
|
|
|
6 |
|
|
This file is part of BFD, the Binary File Descriptor library.
|
7 |
|
|
|
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.
|
12 |
|
|
|
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.
|
17 |
|
|
|
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. */
|
21 |
|
|
|
22 |
|
|
#include "bfd.h"
|
23 |
|
|
#include "sysdep.h"
|
24 |
|
|
#include "bfdlink.h"
|
25 |
|
|
#include "libbfd.h"
|
26 |
|
|
#include "elf-bfd.h"
|
27 |
|
|
#include "elf/sh.h"
|
28 |
|
|
|
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
|
44 |
|
|
PARAMS ((bfd *));
|
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
|
65 |
|
|
PARAMS ((bfd *));
|
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 *,
|
72 |
|
|
Elf_Internal_Sym *));
|
73 |
|
|
static boolean sh_elf_finish_dynamic_sections
|
74 |
|
|
PARAMS ((bfd *, struct bfd_link_info *));
|
75 |
|
|
|
76 |
|
|
/* The name of the dynamic interpreter. This is put in the .interp
|
77 |
|
|
section. */
|
78 |
|
|
|
79 |
|
|
#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
|
80 |
|
|
|
81 |
|
|
static reloc_howto_type sh_elf_howto_table[] =
|
82 |
|
|
{
|
83 |
|
|
/* No relocation. */
|
84 |
|
|
HOWTO (R_SH_NONE, /* type */
|
85 |
|
|
0, /* rightshift */
|
86 |
|
|
0, /* size (0 = byte, 1 = short, 2 = long) */
|
87 |
|
|
0, /* bitsize */
|
88 |
|
|
false, /* pc_relative */
|
89 |
|
|
0, /* bitpos */
|
90 |
|
|
complain_overflow_dont, /* complain_on_overflow */
|
91 |
|
|
sh_elf_ignore_reloc, /* special_function */
|
92 |
|
|
"R_SH_NONE", /* name */
|
93 |
|
|
false, /* partial_inplace */
|
94 |
|
|
0, /* src_mask */
|
95 |
|
|
0, /* dst_mask */
|
96 |
|
|
false), /* pcrel_offset */
|
97 |
|
|
|
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 */
|
101 |
|
|
0, /* rightshift */
|
102 |
|
|
2, /* size (0 = byte, 1 = short, 2 = long) */
|
103 |
|
|
32, /* bitsize */
|
104 |
|
|
false, /* pc_relative */
|
105 |
|
|
0, /* bitpos */
|
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 */
|
113 |
|
|
|
114 |
|
|
/* 32 bit PC relative relocation. */
|
115 |
|
|
HOWTO (R_SH_REL32, /* type */
|
116 |
|
|
0, /* rightshift */
|
117 |
|
|
2, /* size (0 = byte, 1 = short, 2 = long) */
|
118 |
|
|
32, /* bitsize */
|
119 |
|
|
true, /* pc_relative */
|
120 |
|
|
0, /* bitpos */
|
121 |
|
|
complain_overflow_signed, /* complain_on_overflow */
|
122 |
|
|
sh_elf_ignore_reloc, /* special_function */
|
123 |
|
|
"R_SH_REL32", /* name */
|
124 |
|
|
false, /* partial_inplace */
|
125 |
|
|
0, /* src_mask */
|
126 |
|
|
0xffffffff, /* dst_mask */
|
127 |
|
|
true), /* pcrel_offset */
|
128 |
|
|
|
129 |
|
|
/* 8 bit PC relative branch divided by 2. */
|
130 |
|
|
HOWTO (R_SH_DIR8WPN, /* type */
|
131 |
|
|
1, /* rightshift */
|
132 |
|
|
1, /* size (0 = byte, 1 = short, 2 = long) */
|
133 |
|
|
8, /* bitsize */
|
134 |
|
|
true, /* pc_relative */
|
135 |
|
|
0, /* bitpos */
|
136 |
|
|
complain_overflow_signed, /* complain_on_overflow */
|
137 |
|
|
sh_elf_ignore_reloc, /* special_function */
|
138 |
|
|
"R_SH_DIR8WPN", /* name */
|
139 |
|
|
true, /* partial_inplace */
|
140 |
|
|
0xff, /* src_mask */
|
141 |
|
|
0xff, /* dst_mask */
|
142 |
|
|
true), /* pcrel_offset */
|
143 |
|
|
|
144 |
|
|
/* 12 bit PC relative branch divided by 2. */
|
145 |
|
|
HOWTO (R_SH_IND12W, /* type */
|
146 |
|
|
1, /* rightshift */
|
147 |
|
|
1, /* size (0 = byte, 1 = short, 2 = long) */
|
148 |
|
|
12, /* bitsize */
|
149 |
|
|
true, /* pc_relative */
|
150 |
|
|
0, /* bitpos */
|
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 */
|
158 |
|
|
|
159 |
|
|
/* 8 bit unsigned PC relative divided by 4. */
|
160 |
|
|
HOWTO (R_SH_DIR8WPL, /* type */
|
161 |
|
|
2, /* rightshift */
|
162 |
|
|
1, /* size (0 = byte, 1 = short, 2 = long) */
|
163 |
|
|
8, /* bitsize */
|
164 |
|
|
true, /* pc_relative */
|
165 |
|
|
0, /* bitpos */
|
166 |
|
|
complain_overflow_unsigned, /* complain_on_overflow */
|
167 |
|
|
sh_elf_ignore_reloc, /* special_function */
|
168 |
|
|
"R_SH_DIR8WPL", /* name */
|
169 |
|
|
true, /* partial_inplace */
|
170 |
|
|
0xff, /* src_mask */
|
171 |
|
|
0xff, /* dst_mask */
|
172 |
|
|
true), /* pcrel_offset */
|
173 |
|
|
|
174 |
|
|
/* 8 bit unsigned PC relative divided by 2. */
|
175 |
|
|
HOWTO (R_SH_DIR8WPZ, /* type */
|
176 |
|
|
1, /* rightshift */
|
177 |
|
|
1, /* size (0 = byte, 1 = short, 2 = long) */
|
178 |
|
|
8, /* bitsize */
|
179 |
|
|
true, /* pc_relative */
|
180 |
|
|
0, /* bitpos */
|
181 |
|
|
complain_overflow_unsigned, /* complain_on_overflow */
|
182 |
|
|
sh_elf_ignore_reloc, /* special_function */
|
183 |
|
|
"R_SH_DIR8WPZ", /* name */
|
184 |
|
|
true, /* partial_inplace */
|
185 |
|
|
0xff, /* src_mask */
|
186 |
|
|
0xff, /* dst_mask */
|
187 |
|
|
true), /* pcrel_offset */
|
188 |
|
|
|
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
|
191 |
|
|
implemented. */
|
192 |
|
|
HOWTO (R_SH_DIR8BP, /* type */
|
193 |
|
|
0, /* rightshift */
|
194 |
|
|
1, /* size (0 = byte, 1 = short, 2 = long) */
|
195 |
|
|
8, /* bitsize */
|
196 |
|
|
false, /* pc_relative */
|
197 |
|
|
0, /* bitpos */
|
198 |
|
|
complain_overflow_unsigned, /* complain_on_overflow */
|
199 |
|
|
sh_elf_ignore_reloc, /* special_function */
|
200 |
|
|
"R_SH_DIR8BP", /* name */
|
201 |
|
|
false, /* partial_inplace */
|
202 |
|
|
0, /* src_mask */
|
203 |
|
|
0xff, /* dst_mask */
|
204 |
|
|
true), /* pcrel_offset */
|
205 |
|
|
|
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 */
|
210 |
|
|
1, /* rightshift */
|
211 |
|
|
1, /* size (0 = byte, 1 = short, 2 = long) */
|
212 |
|
|
8, /* bitsize */
|
213 |
|
|
false, /* pc_relative */
|
214 |
|
|
0, /* bitpos */
|
215 |
|
|
complain_overflow_unsigned, /* complain_on_overflow */
|
216 |
|
|
sh_elf_ignore_reloc, /* special_function */
|
217 |
|
|
"R_SH_DIR8W", /* name */
|
218 |
|
|
false, /* partial_inplace */
|
219 |
|
|
0, /* src_mask */
|
220 |
|
|
0xff, /* dst_mask */
|
221 |
|
|
true), /* pcrel_offset */
|
222 |
|
|
|
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 */
|
227 |
|
|
2, /* rightshift */
|
228 |
|
|
1, /* size (0 = byte, 1 = short, 2 = long) */
|
229 |
|
|
8, /* bitsize */
|
230 |
|
|
false, /* pc_relative */
|
231 |
|
|
0, /* bitpos */
|
232 |
|
|
complain_overflow_unsigned, /* complain_on_overflow */
|
233 |
|
|
sh_elf_ignore_reloc, /* special_function */
|
234 |
|
|
"R_SH_DIR8L", /* name */
|
235 |
|
|
false, /* partial_inplace */
|
236 |
|
|
0, /* src_mask */
|
237 |
|
|
0xff, /* dst_mask */
|
238 |
|
|
true), /* pcrel_offset */
|
239 |
|
|
|
240 |
|
|
EMPTY_HOWTO (10),
|
241 |
|
|
EMPTY_HOWTO (11),
|
242 |
|
|
EMPTY_HOWTO (12),
|
243 |
|
|
EMPTY_HOWTO (13),
|
244 |
|
|
EMPTY_HOWTO (14),
|
245 |
|
|
EMPTY_HOWTO (15),
|
246 |
|
|
EMPTY_HOWTO (16),
|
247 |
|
|
EMPTY_HOWTO (17),
|
248 |
|
|
EMPTY_HOWTO (18),
|
249 |
|
|
EMPTY_HOWTO (19),
|
250 |
|
|
EMPTY_HOWTO (20),
|
251 |
|
|
EMPTY_HOWTO (21),
|
252 |
|
|
EMPTY_HOWTO (22),
|
253 |
|
|
EMPTY_HOWTO (23),
|
254 |
|
|
EMPTY_HOWTO (24),
|
255 |
|
|
|
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
|
259 |
|
|
relaxation code. */
|
260 |
|
|
|
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 */
|
265 |
|
|
0, /* rightshift */
|
266 |
|
|
1, /* size (0 = byte, 1 = short, 2 = long) */
|
267 |
|
|
16, /* bitsize */
|
268 |
|
|
false, /* pc_relative */
|
269 |
|
|
0, /* bitpos */
|
270 |
|
|
complain_overflow_unsigned, /* complain_on_overflow */
|
271 |
|
|
sh_elf_ignore_reloc, /* special_function */
|
272 |
|
|
"R_SH_SWITCH16", /* name */
|
273 |
|
|
false, /* partial_inplace */
|
274 |
|
|
0, /* src_mask */
|
275 |
|
|
0, /* dst_mask */
|
276 |
|
|
true), /* pcrel_offset */
|
277 |
|
|
|
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 */
|
282 |
|
|
0, /* rightshift */
|
283 |
|
|
2, /* size (0 = byte, 1 = short, 2 = long) */
|
284 |
|
|
32, /* bitsize */
|
285 |
|
|
false, /* pc_relative */
|
286 |
|
|
0, /* bitpos */
|
287 |
|
|
complain_overflow_unsigned, /* complain_on_overflow */
|
288 |
|
|
sh_elf_ignore_reloc, /* special_function */
|
289 |
|
|
"R_SH_SWITCH32", /* name */
|
290 |
|
|
false, /* partial_inplace */
|
291 |
|
|
0, /* src_mask */
|
292 |
|
|
0, /* dst_mask */
|
293 |
|
|
true), /* pcrel_offset */
|
294 |
|
|
|
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 */
|
300 |
|
|
0, /* rightshift */
|
301 |
|
|
1, /* size (0 = byte, 1 = short, 2 = long) */
|
302 |
|
|
0, /* bitsize */
|
303 |
|
|
false, /* pc_relative */
|
304 |
|
|
0, /* bitpos */
|
305 |
|
|
complain_overflow_unsigned, /* complain_on_overflow */
|
306 |
|
|
sh_elf_ignore_reloc, /* special_function */
|
307 |
|
|
"R_SH_USES", /* name */
|
308 |
|
|
false, /* partial_inplace */
|
309 |
|
|
0, /* src_mask */
|
310 |
|
|
0, /* dst_mask */
|
311 |
|
|
true), /* pcrel_offset */
|
312 |
|
|
|
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
|
316 |
|
|
object file. */
|
317 |
|
|
HOWTO (R_SH_COUNT, /* type */
|
318 |
|
|
0, /* rightshift */
|
319 |
|
|
1, /* size (0 = byte, 1 = short, 2 = long) */
|
320 |
|
|
0, /* bitsize */
|
321 |
|
|
false, /* pc_relative */
|
322 |
|
|
0, /* bitpos */
|
323 |
|
|
complain_overflow_unsigned, /* complain_on_overflow */
|
324 |
|
|
sh_elf_ignore_reloc, /* special_function */
|
325 |
|
|
"R_SH_COUNT", /* name */
|
326 |
|
|
false, /* partial_inplace */
|
327 |
|
|
0, /* src_mask */
|
328 |
|
|
0, /* dst_mask */
|
329 |
|
|
true), /* pcrel_offset */
|
330 |
|
|
|
331 |
|
|
/* Indicates an alignment statement. The offset field is the power
|
332 |
|
|
of 2 to which subsequent portions of the object file must be
|
333 |
|
|
aligned. */
|
334 |
|
|
HOWTO (R_SH_ALIGN, /* type */
|
335 |
|
|
0, /* rightshift */
|
336 |
|
|
1, /* size (0 = byte, 1 = short, 2 = long) */
|
337 |
|
|
0, /* bitsize */
|
338 |
|
|
false, /* pc_relative */
|
339 |
|
|
0, /* bitpos */
|
340 |
|
|
complain_overflow_unsigned, /* complain_on_overflow */
|
341 |
|
|
sh_elf_ignore_reloc, /* special_function */
|
342 |
|
|
"R_SH_ALIGN", /* name */
|
343 |
|
|
false, /* partial_inplace */
|
344 |
|
|
0, /* src_mask */
|
345 |
|
|
0, /* dst_mask */
|
346 |
|
|
true), /* pcrel_offset */
|
347 |
|
|
|
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 */
|
352 |
|
|
0, /* rightshift */
|
353 |
|
|
1, /* size (0 = byte, 1 = short, 2 = long) */
|
354 |
|
|
0, /* bitsize */
|
355 |
|
|
false, /* pc_relative */
|
356 |
|
|
0, /* bitpos */
|
357 |
|
|
complain_overflow_unsigned, /* complain_on_overflow */
|
358 |
|
|
sh_elf_ignore_reloc, /* special_function */
|
359 |
|
|
"R_SH_CODE", /* name */
|
360 |
|
|
false, /* partial_inplace */
|
361 |
|
|
0, /* src_mask */
|
362 |
|
|
0, /* dst_mask */
|
363 |
|
|
true), /* pcrel_offset */
|
364 |
|
|
|
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 */
|
368 |
|
|
0, /* rightshift */
|
369 |
|
|
1, /* size (0 = byte, 1 = short, 2 = long) */
|
370 |
|
|
0, /* bitsize */
|
371 |
|
|
false, /* pc_relative */
|
372 |
|
|
0, /* bitpos */
|
373 |
|
|
complain_overflow_unsigned, /* complain_on_overflow */
|
374 |
|
|
sh_elf_ignore_reloc, /* special_function */
|
375 |
|
|
"R_SH_DATA", /* name */
|
376 |
|
|
false, /* partial_inplace */
|
377 |
|
|
0, /* src_mask */
|
378 |
|
|
0, /* dst_mask */
|
379 |
|
|
true), /* pcrel_offset */
|
380 |
|
|
|
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 */
|
385 |
|
|
0, /* rightshift */
|
386 |
|
|
1, /* size (0 = byte, 1 = short, 2 = long) */
|
387 |
|
|
0, /* bitsize */
|
388 |
|
|
false, /* pc_relative */
|
389 |
|
|
0, /* bitpos */
|
390 |
|
|
complain_overflow_unsigned, /* complain_on_overflow */
|
391 |
|
|
sh_elf_ignore_reloc, /* special_function */
|
392 |
|
|
"R_SH_LABEL", /* name */
|
393 |
|
|
false, /* partial_inplace */
|
394 |
|
|
0, /* src_mask */
|
395 |
|
|
0, /* dst_mask */
|
396 |
|
|
true), /* pcrel_offset */
|
397 |
|
|
|
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 */
|
402 |
|
|
0, /* rightshift */
|
403 |
|
|
0, /* size (0 = byte, 1 = short, 2 = long) */
|
404 |
|
|
8, /* bitsize */
|
405 |
|
|
false, /* pc_relative */
|
406 |
|
|
0, /* bitpos */
|
407 |
|
|
complain_overflow_unsigned, /* complain_on_overflow */
|
408 |
|
|
sh_elf_ignore_reloc, /* special_function */
|
409 |
|
|
"R_SH_SWITCH8", /* name */
|
410 |
|
|
false, /* partial_inplace */
|
411 |
|
|
0, /* src_mask */
|
412 |
|
|
0, /* dst_mask */
|
413 |
|
|
true), /* pcrel_offset */
|
414 |
|
|
|
415 |
|
|
/* GNU extension to record C++ vtable hierarchy */
|
416 |
|
|
HOWTO (R_SH_GNU_VTINHERIT, /* type */
|
417 |
|
|
0, /* rightshift */
|
418 |
|
|
2, /* size (0 = byte, 1 = short, 2 = long) */
|
419 |
|
|
0, /* bitsize */
|
420 |
|
|
false, /* pc_relative */
|
421 |
|
|
0, /* bitpos */
|
422 |
|
|
complain_overflow_dont, /* complain_on_overflow */
|
423 |
|
|
NULL, /* special_function */
|
424 |
|
|
"R_SH_GNU_VTINHERIT", /* name */
|
425 |
|
|
false, /* partial_inplace */
|
426 |
|
|
0, /* src_mask */
|
427 |
|
|
0, /* dst_mask */
|
428 |
|
|
false), /* pcrel_offset */
|
429 |
|
|
|
430 |
|
|
/* GNU extension to record C++ vtable member usage */
|
431 |
|
|
HOWTO (R_SH_GNU_VTENTRY, /* type */
|
432 |
|
|
0, /* rightshift */
|
433 |
|
|
2, /* size (0 = byte, 1 = short, 2 = long) */
|
434 |
|
|
0, /* bitsize */
|
435 |
|
|
false, /* pc_relative */
|
436 |
|
|
0, /* bitpos */
|
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 */
|
441 |
|
|
0, /* src_mask */
|
442 |
|
|
0, /* dst_mask */
|
443 |
|
|
false), /* pcrel_offset */
|
444 |
|
|
|
445 |
|
|
/* 8 bit PC relative divided by 2 - but specified in a very odd way. */
|
446 |
|
|
HOWTO (R_SH_LOOP_START, /* type */
|
447 |
|
|
1, /* rightshift */
|
448 |
|
|
1, /* size (0 = byte, 1 = short, 2 = long) */
|
449 |
|
|
8, /* bitsize */
|
450 |
|
|
false, /* pc_relative */
|
451 |
|
|
0, /* bitpos */
|
452 |
|
|
complain_overflow_signed, /* complain_on_overflow */
|
453 |
|
|
sh_elf_ignore_reloc, /* special_function */
|
454 |
|
|
"R_SH_LOOP_START", /* name */
|
455 |
|
|
true, /* partial_inplace */
|
456 |
|
|
0xff, /* src_mask */
|
457 |
|
|
0xff, /* dst_mask */
|
458 |
|
|
true), /* pcrel_offset */
|
459 |
|
|
|
460 |
|
|
/* 8 bit PC relative divided by 2 - but specified in a very odd way. */
|
461 |
|
|
HOWTO (R_SH_LOOP_END, /* type */
|
462 |
|
|
1, /* rightshift */
|
463 |
|
|
1, /* size (0 = byte, 1 = short, 2 = long) */
|
464 |
|
|
8, /* bitsize */
|
465 |
|
|
false, /* pc_relative */
|
466 |
|
|
0, /* bitpos */
|
467 |
|
|
complain_overflow_signed, /* complain_on_overflow */
|
468 |
|
|
sh_elf_ignore_reloc, /* special_function */
|
469 |
|
|
"R_SH_LOOP_END", /* name */
|
470 |
|
|
true, /* partial_inplace */
|
471 |
|
|
0xff, /* src_mask */
|
472 |
|
|
0xff, /* dst_mask */
|
473 |
|
|
true), /* pcrel_offset */
|
474 |
|
|
|
475 |
|
|
EMPTY_HOWTO (38),
|
476 |
|
|
EMPTY_HOWTO (39),
|
477 |
|
|
EMPTY_HOWTO (40),
|
478 |
|
|
EMPTY_HOWTO (41),
|
479 |
|
|
EMPTY_HOWTO (42),
|
480 |
|
|
EMPTY_HOWTO (43),
|
481 |
|
|
EMPTY_HOWTO (44),
|
482 |
|
|
EMPTY_HOWTO (45),
|
483 |
|
|
EMPTY_HOWTO (46),
|
484 |
|
|
EMPTY_HOWTO (47),
|
485 |
|
|
EMPTY_HOWTO (48),
|
486 |
|
|
EMPTY_HOWTO (49),
|
487 |
|
|
EMPTY_HOWTO (50),
|
488 |
|
|
EMPTY_HOWTO (51),
|
489 |
|
|
EMPTY_HOWTO (52),
|
490 |
|
|
EMPTY_HOWTO (53),
|
491 |
|
|
EMPTY_HOWTO (54),
|
492 |
|
|
EMPTY_HOWTO (55),
|
493 |
|
|
EMPTY_HOWTO (56),
|
494 |
|
|
EMPTY_HOWTO (57),
|
495 |
|
|
EMPTY_HOWTO (58),
|
496 |
|
|
EMPTY_HOWTO (59),
|
497 |
|
|
EMPTY_HOWTO (60),
|
498 |
|
|
EMPTY_HOWTO (61),
|
499 |
|
|
EMPTY_HOWTO (62),
|
500 |
|
|
EMPTY_HOWTO (63),
|
501 |
|
|
EMPTY_HOWTO (64),
|
502 |
|
|
EMPTY_HOWTO (65),
|
503 |
|
|
EMPTY_HOWTO (66),
|
504 |
|
|
EMPTY_HOWTO (67),
|
505 |
|
|
EMPTY_HOWTO (68),
|
506 |
|
|
EMPTY_HOWTO (69),
|
507 |
|
|
EMPTY_HOWTO (70),
|
508 |
|
|
EMPTY_HOWTO (71),
|
509 |
|
|
EMPTY_HOWTO (72),
|
510 |
|
|
EMPTY_HOWTO (73),
|
511 |
|
|
EMPTY_HOWTO (74),
|
512 |
|
|
EMPTY_HOWTO (75),
|
513 |
|
|
EMPTY_HOWTO (76),
|
514 |
|
|
EMPTY_HOWTO (77),
|
515 |
|
|
EMPTY_HOWTO (78),
|
516 |
|
|
EMPTY_HOWTO (79),
|
517 |
|
|
EMPTY_HOWTO (80),
|
518 |
|
|
EMPTY_HOWTO (81),
|
519 |
|
|
EMPTY_HOWTO (82),
|
520 |
|
|
EMPTY_HOWTO (83),
|
521 |
|
|
EMPTY_HOWTO (84),
|
522 |
|
|
EMPTY_HOWTO (85),
|
523 |
|
|
EMPTY_HOWTO (86),
|
524 |
|
|
EMPTY_HOWTO (87),
|
525 |
|
|
EMPTY_HOWTO (88),
|
526 |
|
|
EMPTY_HOWTO (89),
|
527 |
|
|
EMPTY_HOWTO (90),
|
528 |
|
|
EMPTY_HOWTO (91),
|
529 |
|
|
EMPTY_HOWTO (92),
|
530 |
|
|
EMPTY_HOWTO (93),
|
531 |
|
|
EMPTY_HOWTO (94),
|
532 |
|
|
EMPTY_HOWTO (95),
|
533 |
|
|
EMPTY_HOWTO (96),
|
534 |
|
|
EMPTY_HOWTO (97),
|
535 |
|
|
EMPTY_HOWTO (98),
|
536 |
|
|
EMPTY_HOWTO (99),
|
537 |
|
|
EMPTY_HOWTO (100),
|
538 |
|
|
EMPTY_HOWTO (101),
|
539 |
|
|
EMPTY_HOWTO (102),
|
540 |
|
|
EMPTY_HOWTO (103),
|
541 |
|
|
EMPTY_HOWTO (104),
|
542 |
|
|
EMPTY_HOWTO (105),
|
543 |
|
|
EMPTY_HOWTO (106),
|
544 |
|
|
EMPTY_HOWTO (107),
|
545 |
|
|
EMPTY_HOWTO (108),
|
546 |
|
|
EMPTY_HOWTO (109),
|
547 |
|
|
EMPTY_HOWTO (110),
|
548 |
|
|
EMPTY_HOWTO (111),
|
549 |
|
|
EMPTY_HOWTO (112),
|
550 |
|
|
EMPTY_HOWTO (113),
|
551 |
|
|
EMPTY_HOWTO (114),
|
552 |
|
|
EMPTY_HOWTO (115),
|
553 |
|
|
EMPTY_HOWTO (116),
|
554 |
|
|
EMPTY_HOWTO (117),
|
555 |
|
|
EMPTY_HOWTO (118),
|
556 |
|
|
EMPTY_HOWTO (119),
|
557 |
|
|
EMPTY_HOWTO (120),
|
558 |
|
|
EMPTY_HOWTO (121),
|
559 |
|
|
EMPTY_HOWTO (122),
|
560 |
|
|
EMPTY_HOWTO (123),
|
561 |
|
|
EMPTY_HOWTO (124),
|
562 |
|
|
EMPTY_HOWTO (125),
|
563 |
|
|
EMPTY_HOWTO (126),
|
564 |
|
|
EMPTY_HOWTO (127),
|
565 |
|
|
EMPTY_HOWTO (128),
|
566 |
|
|
EMPTY_HOWTO (129),
|
567 |
|
|
EMPTY_HOWTO (130),
|
568 |
|
|
EMPTY_HOWTO (131),
|
569 |
|
|
EMPTY_HOWTO (132),
|
570 |
|
|
EMPTY_HOWTO (133),
|
571 |
|
|
EMPTY_HOWTO (134),
|
572 |
|
|
EMPTY_HOWTO (135),
|
573 |
|
|
EMPTY_HOWTO (136),
|
574 |
|
|
EMPTY_HOWTO (137),
|
575 |
|
|
EMPTY_HOWTO (138),
|
576 |
|
|
EMPTY_HOWTO (139),
|
577 |
|
|
EMPTY_HOWTO (140),
|
578 |
|
|
EMPTY_HOWTO (141),
|
579 |
|
|
EMPTY_HOWTO (142),
|
580 |
|
|
EMPTY_HOWTO (143),
|
581 |
|
|
EMPTY_HOWTO (144),
|
582 |
|
|
EMPTY_HOWTO (145),
|
583 |
|
|
EMPTY_HOWTO (146),
|
584 |
|
|
EMPTY_HOWTO (147),
|
585 |
|
|
EMPTY_HOWTO (148),
|
586 |
|
|
EMPTY_HOWTO (149),
|
587 |
|
|
EMPTY_HOWTO (150),
|
588 |
|
|
EMPTY_HOWTO (151),
|
589 |
|
|
EMPTY_HOWTO (152),
|
590 |
|
|
EMPTY_HOWTO (153),
|
591 |
|
|
EMPTY_HOWTO (154),
|
592 |
|
|
EMPTY_HOWTO (155),
|
593 |
|
|
EMPTY_HOWTO (156),
|
594 |
|
|
EMPTY_HOWTO (157),
|
595 |
|
|
EMPTY_HOWTO (158),
|
596 |
|
|
EMPTY_HOWTO (159),
|
597 |
|
|
|
598 |
|
|
HOWTO (R_SH_GOT32, /* type */
|
599 |
|
|
0, /* rightshift */
|
600 |
|
|
2, /* size (0 = byte, 1 = short, 2 = long) */
|
601 |
|
|
32, /* bitsize */
|
602 |
|
|
false, /* pc_relative */
|
603 |
|
|
0, /* bitpos */
|
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 */
|
611 |
|
|
|
612 |
|
|
HOWTO (R_SH_PLT32, /* type */
|
613 |
|
|
0, /* rightshift */
|
614 |
|
|
2, /* size (0 = byte, 1 = short, 2 = long) */
|
615 |
|
|
32, /* bitsize */
|
616 |
|
|
true, /* pc_relative */
|
617 |
|
|
0, /* bitpos */
|
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 */
|
625 |
|
|
|
626 |
|
|
HOWTO (R_SH_COPY, /* type */
|
627 |
|
|
0, /* rightshift */
|
628 |
|
|
2, /* size (0 = byte, 1 = short, 2 = long) */
|
629 |
|
|
32, /* bitsize */
|
630 |
|
|
false, /* pc_relative */
|
631 |
|
|
0, /* bitpos */
|
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 */
|
639 |
|
|
|
640 |
|
|
HOWTO (R_SH_GLOB_DAT, /* type */
|
641 |
|
|
0, /* rightshift */
|
642 |
|
|
2, /* size (0 = byte, 1 = short, 2 = long) */
|
643 |
|
|
32, /* bitsize */
|
644 |
|
|
false, /* pc_relative */
|
645 |
|
|
0, /* bitpos */
|
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 */
|
653 |
|
|
|
654 |
|
|
HOWTO (R_SH_JMP_SLOT, /* type */
|
655 |
|
|
0, /* rightshift */
|
656 |
|
|
2, /* size (0 = byte, 1 = short, 2 = long) */
|
657 |
|
|
32, /* bitsize */
|
658 |
|
|
false, /* pc_relative */
|
659 |
|
|
0, /* bitpos */
|
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 */
|
667 |
|
|
|
668 |
|
|
HOWTO (R_SH_RELATIVE, /* type */
|
669 |
|
|
0, /* rightshift */
|
670 |
|
|
2, /* size (0 = byte, 1 = short, 2 = long) */
|
671 |
|
|
32, /* bitsize */
|
672 |
|
|
false, /* pc_relative */
|
673 |
|
|
0, /* bitpos */
|
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 */
|
681 |
|
|
|
682 |
|
|
HOWTO (R_SH_GOTOFF, /* type */
|
683 |
|
|
0, /* rightshift */
|
684 |
|
|
2, /* size (0 = byte, 1 = short, 2 = long) */
|
685 |
|
|
32, /* bitsize */
|
686 |
|
|
false, /* pc_relative */
|
687 |
|
|
0, /* bitpos */
|
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 */
|
695 |
|
|
|
696 |
|
|
HOWTO (R_SH_GOTPC, /* type */
|
697 |
|
|
0, /* rightshift */
|
698 |
|
|
2, /* size (0 = byte, 1 = short, 2 = long) */
|
699 |
|
|
32, /* bitsize */
|
700 |
|
|
true, /* pc_relative */
|
701 |
|
|
0, /* bitpos */
|
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 */
|
709 |
|
|
|
710 |
|
|
};
|
711 |
|
|
|
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;
|
716 |
|
|
bfd *input_bfd;
|
717 |
|
|
asection *input_section;
|
718 |
|
|
bfd_byte *contents;
|
719 |
|
|
bfd_vma addr;
|
720 |
|
|
asection *symbol_section;
|
721 |
|
|
bfd_vma start, end;
|
722 |
|
|
{
|
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;
|
727 |
|
|
int diff, cum_diff;
|
728 |
|
|
bfd_signed_vma x;
|
729 |
|
|
int insn;
|
730 |
|
|
|
731 |
|
|
/* Sanity check the address. */
|
732 |
|
|
if (addr > input_section->_raw_size)
|
733 |
|
|
return bfd_reloc_outofrange;
|
734 |
|
|
|
735 |
|
|
/* We require the start and end relocations to be processed consecutively -
|
736 |
|
|
although we allow then to be processed forwards or backwards. */
|
737 |
|
|
if (! last_addr)
|
738 |
|
|
{
|
739 |
|
|
last_addr = addr;
|
740 |
|
|
last_symbol_section = symbol_section;
|
741 |
|
|
return bfd_reloc_ok;
|
742 |
|
|
}
|
743 |
|
|
if (last_addr != addr)
|
744 |
|
|
abort ();
|
745 |
|
|
last_addr = 0;
|
746 |
|
|
|
747 |
|
|
if (! symbol_section || last_symbol_section != symbol_section || end < start)
|
748 |
|
|
return bfd_reloc_outofrange;
|
749 |
|
|
|
750 |
|
|
/* Get the symbol_section contents. */
|
751 |
|
|
if (symbol_section != input_section)
|
752 |
|
|
{
|
753 |
|
|
if (elf_section_data (symbol_section)->this_hdr.contents != NULL)
|
754 |
|
|
contents = elf_section_data (symbol_section)->this_hdr.contents;
|
755 |
|
|
else
|
756 |
|
|
{
|
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,
|
762 |
|
|
(file_ptr) 0,
|
763 |
|
|
symbol_section->_raw_size))
|
764 |
|
|
{
|
765 |
|
|
free (contents);
|
766 |
|
|
return bfd_reloc_outofrange;
|
767 |
|
|
}
|
768 |
|
|
}
|
769 |
|
|
}
|
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;)
|
773 |
|
|
{
|
774 |
|
|
for (last_ptr = ptr, ptr -= 4; ptr >= start_ptr && IS_PPI (ptr);)
|
775 |
|
|
ptr -= 2;
|
776 |
|
|
ptr += 2;
|
777 |
|
|
diff = (last_ptr - ptr) >> 1;
|
778 |
|
|
cum_diff += diff & 1;
|
779 |
|
|
cum_diff += diff;
|
780 |
|
|
}
|
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. */
|
784 |
|
|
if (cum_diff >= 0)
|
785 |
|
|
{
|
786 |
|
|
start -= 4;
|
787 |
|
|
end = (ptr + cum_diff * 2) - contents;
|
788 |
|
|
}
|
789 |
|
|
else
|
790 |
|
|
{
|
791 |
|
|
bfd_vma start0 = start - 4;
|
792 |
|
|
|
793 |
|
|
while (start0 && IS_PPI (contents + start0))
|
794 |
|
|
start0 -= 2;
|
795 |
|
|
start0 = start - 2 - ((start - start0) & 2);
|
796 |
|
|
start = start0 - cum_diff - 2;
|
797 |
|
|
end = start0;
|
798 |
|
|
}
|
799 |
|
|
|
800 |
|
|
if (free_contents)
|
801 |
|
|
free (free_contents);
|
802 |
|
|
|
803 |
|
|
insn = bfd_get_16 (input_bfd, contents + addr);
|
804 |
|
|
|
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));
|
810 |
|
|
x >>= 1;
|
811 |
|
|
if (x < -128 || x > 127)
|
812 |
|
|
return bfd_reloc_overflow;
|
813 |
|
|
|
814 |
|
|
x = (insn & ~0xff) | (x & 0xff);
|
815 |
|
|
bfd_put_16 (input_bfd, x, contents + addr);
|
816 |
|
|
|
817 |
|
|
return bfd_reloc_ok;
|
818 |
|
|
}
|
819 |
|
|
|
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. */
|
822 |
|
|
|
823 |
|
|
static bfd_reloc_status_type
|
824 |
|
|
sh_elf_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
|
825 |
|
|
error_message)
|
826 |
|
|
bfd *abfd;
|
827 |
|
|
arelent *reloc_entry;
|
828 |
|
|
asymbol *symbol_in;
|
829 |
|
|
PTR data;
|
830 |
|
|
asection *input_section;
|
831 |
|
|
bfd *output_bfd;
|
832 |
|
|
char **error_message ATTRIBUTE_UNUSED;
|
833 |
|
|
{
|
834 |
|
|
unsigned long insn;
|
835 |
|
|
bfd_vma sym_value;
|
836 |
|
|
enum elf_sh_reloc_type r_type;
|
837 |
|
|
bfd_vma addr = reloc_entry->address;
|
838 |
|
|
bfd_byte *hit_data = addr + (bfd_byte *) data;
|
839 |
|
|
|
840 |
|
|
r_type = (enum elf_sh_reloc_type) reloc_entry->howto->type;
|
841 |
|
|
|
842 |
|
|
if (output_bfd != NULL)
|
843 |
|
|
{
|
844 |
|
|
/* Partial linking--do nothing. */
|
845 |
|
|
reloc_entry->address += input_section->output_offset;
|
846 |
|
|
return bfd_reloc_ok;
|
847 |
|
|
}
|
848 |
|
|
|
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)
|
852 |
|
|
return bfd_reloc_ok;
|
853 |
|
|
|
854 |
|
|
if (symbol_in != NULL
|
855 |
|
|
&& bfd_is_und_section (symbol_in->section))
|
856 |
|
|
return bfd_reloc_undefined;
|
857 |
|
|
|
858 |
|
|
if (bfd_is_com_section (symbol_in->section))
|
859 |
|
|
sym_value = 0;
|
860 |
|
|
else
|
861 |
|
|
sym_value = (symbol_in->value +
|
862 |
|
|
symbol_in->section->output_section->vma +
|
863 |
|
|
symbol_in->section->output_offset);
|
864 |
|
|
|
865 |
|
|
switch (r_type)
|
866 |
|
|
{
|
867 |
|
|
case R_SH_DIR32:
|
868 |
|
|
insn = bfd_get_32 (abfd, hit_data);
|
869 |
|
|
insn += sym_value + reloc_entry->addend;
|
870 |
|
|
bfd_put_32 (abfd, insn, hit_data);
|
871 |
|
|
break;
|
872 |
|
|
case R_SH_IND12W:
|
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
|
877 |
|
|
+ addr
|
878 |
|
|
+ 4);
|
879 |
|
|
sym_value += (insn & 0xfff) << 1;
|
880 |
|
|
if (insn & 0x800)
|
881 |
|
|
sym_value -= 0x1000;
|
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;
|
886 |
|
|
break;
|
887 |
|
|
default:
|
888 |
|
|
abort ();
|
889 |
|
|
break;
|
890 |
|
|
}
|
891 |
|
|
|
892 |
|
|
return bfd_reloc_ok;
|
893 |
|
|
}
|
894 |
|
|
|
895 |
|
|
/* This function is used for relocs which are only used for relaxing,
|
896 |
|
|
which the linker should otherwise ignore. */
|
897 |
|
|
|
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;
|
906 |
|
|
bfd *output_bfd;
|
907 |
|
|
char **error_message ATTRIBUTE_UNUSED;
|
908 |
|
|
{
|
909 |
|
|
if (output_bfd != NULL)
|
910 |
|
|
reloc_entry->address += input_section->output_offset;
|
911 |
|
|
return bfd_reloc_ok;
|
912 |
|
|
}
|
913 |
|
|
|
914 |
|
|
/* This structure is used to map BFD reloc codes to SH ELF relocs. */
|
915 |
|
|
|
916 |
|
|
struct elf_reloc_map
|
917 |
|
|
{
|
918 |
|
|
bfd_reloc_code_real_type bfd_reloc_val;
|
919 |
|
|
unsigned char elf_reloc_val;
|
920 |
|
|
};
|
921 |
|
|
|
922 |
|
|
/* An array mapping BFD reloc codes to SH ELF relocs. */
|
923 |
|
|
|
924 |
|
|
static const struct elf_reloc_map sh_reloc_map[] =
|
925 |
|
|
{
|
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 },
|
955 |
|
|
};
|
956 |
|
|
|
957 |
|
|
/* Given a BFD reloc code, return the howto structure for the
|
958 |
|
|
corresponding SH ELf reloc. */
|
959 |
|
|
|
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;
|
964 |
|
|
{
|
965 |
|
|
unsigned int i;
|
966 |
|
|
|
967 |
|
|
for (i = 0; i < sizeof (sh_reloc_map) / sizeof (struct elf_reloc_map); i++)
|
968 |
|
|
{
|
969 |
|
|
if (sh_reloc_map[i].bfd_reloc_val == code)
|
970 |
|
|
return &sh_elf_howto_table[(int) sh_reloc_map[i].elf_reloc_val];
|
971 |
|
|
}
|
972 |
|
|
|
973 |
|
|
return NULL;
|
974 |
|
|
}
|
975 |
|
|
|
976 |
|
|
/* Given an ELF reloc, fill in the howto field of a relent. */
|
977 |
|
|
|
978 |
|
|
static void
|
979 |
|
|
sh_elf_info_to_howto (abfd, cache_ptr, dst)
|
980 |
|
|
bfd *abfd ATTRIBUTE_UNUSED;
|
981 |
|
|
arelent *cache_ptr;
|
982 |
|
|
Elf_Internal_Rela *dst;
|
983 |
|
|
{
|
984 |
|
|
unsigned int r;
|
985 |
|
|
|
986 |
|
|
r = ELF32_R_TYPE (dst->r_info);
|
987 |
|
|
|
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);
|
991 |
|
|
|
992 |
|
|
cache_ptr->howto = &sh_elf_howto_table[r];
|
993 |
|
|
}
|
994 |
|
|
|
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. */
|
1004 |
|
|
|
1005 |
|
|
static boolean
|
1006 |
|
|
sh_elf_relax_section (abfd, sec, link_info, again)
|
1007 |
|
|
bfd *abfd;
|
1008 |
|
|
asection *sec;
|
1009 |
|
|
struct bfd_link_info *link_info;
|
1010 |
|
|
boolean *again;
|
1011 |
|
|
{
|
1012 |
|
|
Elf_Internal_Shdr *symtab_hdr;
|
1013 |
|
|
Elf_Internal_Rela *internal_relocs;
|
1014 |
|
|
Elf_Internal_Rela *free_relocs = NULL;
|
1015 |
|
|
boolean have_code;
|
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;
|
1021 |
|
|
|
1022 |
|
|
*again = false;
|
1023 |
|
|
|
1024 |
|
|
if (link_info->relocateable
|
1025 |
|
|
|| (sec->flags & SEC_RELOC) == 0
|
1026 |
|
|
|| sec->reloc_count == 0)
|
1027 |
|
|
return true;
|
1028 |
|
|
|
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;
|
1033 |
|
|
|
1034 |
|
|
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
|
1035 |
|
|
|
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)
|
1040 |
|
|
goto error_return;
|
1041 |
|
|
if (! link_info->keep_memory)
|
1042 |
|
|
free_relocs = internal_relocs;
|
1043 |
|
|
|
1044 |
|
|
have_code = false;
|
1045 |
|
|
|
1046 |
|
|
irelend = internal_relocs + sec->reloc_count;
|
1047 |
|
|
for (irel = internal_relocs; irel < irelend; irel++)
|
1048 |
|
|
{
|
1049 |
|
|
bfd_vma laddr, paddr, symval;
|
1050 |
|
|
unsigned short insn;
|
1051 |
|
|
Elf_Internal_Rela *irelfn, *irelscan, *irelcount;
|
1052 |
|
|
bfd_signed_vma foff;
|
1053 |
|
|
|
1054 |
|
|
if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_CODE)
|
1055 |
|
|
have_code = true;
|
1056 |
|
|
|
1057 |
|
|
if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_USES)
|
1058 |
|
|
continue;
|
1059 |
|
|
|
1060 |
|
|
/* Get the section contents. */
|
1061 |
|
|
if (contents == NULL)
|
1062 |
|
|
{
|
1063 |
|
|
if (elf_section_data (sec)->this_hdr.contents != NULL)
|
1064 |
|
|
contents = elf_section_data (sec)->this_hdr.contents;
|
1065 |
|
|
else
|
1066 |
|
|
{
|
1067 |
|
|
contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
|
1068 |
|
|
if (contents == NULL)
|
1069 |
|
|
goto error_return;
|
1070 |
|
|
free_contents = contents;
|
1071 |
|
|
|
1072 |
|
|
if (! bfd_get_section_contents (abfd, sec, contents,
|
1073 |
|
|
(file_ptr) 0, sec->_raw_size))
|
1074 |
|
|
goto error_return;
|
1075 |
|
|
}
|
1076 |
|
|
}
|
1077 |
|
|
|
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)
|
1084 |
|
|
{
|
1085 |
|
|
(*_bfd_error_handler) (_("%s: 0x%lx: warning: bad R_SH_USES offset"),
|
1086 |
|
|
bfd_get_filename (abfd),
|
1087 |
|
|
(unsigned long) irel->r_offset);
|
1088 |
|
|
continue;
|
1089 |
|
|
}
|
1090 |
|
|
insn = bfd_get_16 (abfd, contents + laddr);
|
1091 |
|
|
|
1092 |
|
|
/* If the instruction is not mov.l NN,rN, we don't know what to
|
1093 |
|
|
do. */
|
1094 |
|
|
if ((insn & 0xf000) != 0xd000)
|
1095 |
|
|
{
|
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));
|
1099 |
|
|
continue;
|
1100 |
|
|
}
|
1101 |
|
|
|
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;
|
1109 |
|
|
paddr *= 4;
|
1110 |
|
|
paddr += (laddr + 4) & ~3;
|
1111 |
|
|
if (paddr >= sec->_raw_size)
|
1112 |
|
|
{
|
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));
|
1116 |
|
|
continue;
|
1117 |
|
|
}
|
1118 |
|
|
|
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)
|
1125 |
|
|
break;
|
1126 |
|
|
if (irelfn >= irelend)
|
1127 |
|
|
{
|
1128 |
|
|
((*_bfd_error_handler)
|
1129 |
|
|
(_("%s: 0x%lx: warning: could not find expected reloc"),
|
1130 |
|
|
bfd_get_filename (abfd), (unsigned long) paddr));
|
1131 |
|
|
continue;
|
1132 |
|
|
}
|
1133 |
|
|
|
1134 |
|
|
/* Read this BFD's symbols if we haven't done so already. */
|
1135 |
|
|
if (extsyms == NULL)
|
1136 |
|
|
{
|
1137 |
|
|
if (symtab_hdr->contents != NULL)
|
1138 |
|
|
extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
|
1139 |
|
|
else
|
1140 |
|
|
{
|
1141 |
|
|
extsyms = ((Elf32_External_Sym *)
|
1142 |
|
|
bfd_malloc (symtab_hdr->sh_size));
|
1143 |
|
|
if (extsyms == NULL)
|
1144 |
|
|
goto error_return;
|
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))
|
1149 |
|
|
goto error_return;
|
1150 |
|
|
}
|
1151 |
|
|
}
|
1152 |
|
|
|
1153 |
|
|
/* Get the value of the symbol referred to by the reloc. */
|
1154 |
|
|
if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
|
1155 |
|
|
{
|
1156 |
|
|
Elf_Internal_Sym isym;
|
1157 |
|
|
|
1158 |
|
|
/* A local symbol. */
|
1159 |
|
|
bfd_elf32_swap_symbol_in (abfd,
|
1160 |
|
|
extsyms + ELF32_R_SYM (irelfn->r_info),
|
1161 |
|
|
&isym);
|
1162 |
|
|
|
1163 |
|
|
if (isym.st_shndx != _bfd_elf_section_from_bfd_section (abfd, sec))
|
1164 |
|
|
{
|
1165 |
|
|
((*_bfd_error_handler)
|
1166 |
|
|
(_("%s: 0x%lx: warning: symbol in unexpected section"),
|
1167 |
|
|
bfd_get_filename (abfd), (unsigned long) paddr));
|
1168 |
|
|
continue;
|
1169 |
|
|
}
|
1170 |
|
|
|
1171 |
|
|
symval = (isym.st_value
|
1172 |
|
|
+ sec->output_section->vma
|
1173 |
|
|
+ sec->output_offset);
|
1174 |
|
|
}
|
1175 |
|
|
else
|
1176 |
|
|
{
|
1177 |
|
|
unsigned long indx;
|
1178 |
|
|
struct elf_link_hash_entry *h;
|
1179 |
|
|
|
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)
|
1185 |
|
|
{
|
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. */
|
1189 |
|
|
continue;
|
1190 |
|
|
}
|
1191 |
|
|
|
1192 |
|
|
symval = (h->root.u.def.value
|
1193 |
|
|
+ h->root.u.def.section->output_section->vma
|
1194 |
|
|
+ h->root.u.def.section->output_offset);
|
1195 |
|
|
}
|
1196 |
|
|
|
1197 |
|
|
symval += bfd_get_32 (abfd, contents + paddr);
|
1198 |
|
|
|
1199 |
|
|
/* See if this function call can be shortened. */
|
1200 |
|
|
foff = (symval
|
1201 |
|
|
- (irel->r_offset
|
1202 |
|
|
+ sec->output_section->vma
|
1203 |
|
|
+ sec->output_offset
|
1204 |
|
|
+ 4));
|
1205 |
|
|
if (foff < -0x1000 || foff >= 0x1000)
|
1206 |
|
|
{
|
1207 |
|
|
/* After all that work, we can't shorten this function call. */
|
1208 |
|
|
continue;
|
1209 |
|
|
}
|
1210 |
|
|
|
1211 |
|
|
/* Shorten the function call. */
|
1212 |
|
|
|
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. */
|
1220 |
|
|
|
1221 |
|
|
elf_section_data (sec)->relocs = internal_relocs;
|
1222 |
|
|
free_relocs = NULL;
|
1223 |
|
|
|
1224 |
|
|
elf_section_data (sec)->this_hdr.contents = contents;
|
1225 |
|
|
free_contents = NULL;
|
1226 |
|
|
|
1227 |
|
|
symtab_hdr->contents = (bfd_byte *) extsyms;
|
1228 |
|
|
free_extsyms = NULL;
|
1229 |
|
|
|
1230 |
|
|
/* Replace the jsr with a bsr. */
|
1231 |
|
|
|
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)
|
1236 |
|
|
{
|
1237 |
|
|
/* If this needs to be changed because of future relaxing,
|
1238 |
|
|
it will be handled here like other internal IND12W
|
1239 |
|
|
relocs. */
|
1240 |
|
|
bfd_put_16 (abfd,
|
1241 |
|
|
0xb000 | ((foff >> 1) & 0xfff),
|
1242 |
|
|
contents + irel->r_offset);
|
1243 |
|
|
}
|
1244 |
|
|
else
|
1245 |
|
|
{
|
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);
|
1250 |
|
|
}
|
1251 |
|
|
|
1252 |
|
|
/* See if there is another R_SH_USES reloc referring to the same
|
1253 |
|
|
register load. */
|
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)
|
1257 |
|
|
break;
|
1258 |
|
|
if (irelscan < irelend)
|
1259 |
|
|
{
|
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. */
|
1264 |
|
|
continue;
|
1265 |
|
|
}
|
1266 |
|
|
|
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)
|
1273 |
|
|
break;
|
1274 |
|
|
|
1275 |
|
|
/* Delete the register load. */
|
1276 |
|
|
if (! sh_elf_relax_delete_bytes (abfd, sec, laddr, 2))
|
1277 |
|
|
goto error_return;
|
1278 |
|
|
|
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. */
|
1282 |
|
|
*again = true;
|
1283 |
|
|
|
1284 |
|
|
/* Now check whether we got a COUNT reloc. */
|
1285 |
|
|
if (irelcount >= irelend)
|
1286 |
|
|
{
|
1287 |
|
|
((*_bfd_error_handler)
|
1288 |
|
|
(_("%s: 0x%lx: warning: could not find expected COUNT reloc"),
|
1289 |
|
|
bfd_get_filename (abfd), (unsigned long) paddr));
|
1290 |
|
|
continue;
|
1291 |
|
|
}
|
1292 |
|
|
|
1293 |
|
|
/* The number of uses is stored in the r_addend field. We've
|
1294 |
|
|
just deleted one. */
|
1295 |
|
|
if (irelcount->r_addend == 0)
|
1296 |
|
|
{
|
1297 |
|
|
((*_bfd_error_handler) (_("%s: 0x%lx: warning: bad count"),
|
1298 |
|
|
bfd_get_filename (abfd),
|
1299 |
|
|
(unsigned long) paddr));
|
1300 |
|
|
continue;
|
1301 |
|
|
}
|
1302 |
|
|
|
1303 |
|
|
--irelcount->r_addend;
|
1304 |
|
|
|
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)
|
1309 |
|
|
{
|
1310 |
|
|
if (! sh_elf_relax_delete_bytes (abfd, sec, irelfn->r_offset, 4))
|
1311 |
|
|
goto error_return;
|
1312 |
|
|
}
|
1313 |
|
|
|
1314 |
|
|
/* We've done all we can with that function call. */
|
1315 |
|
|
}
|
1316 |
|
|
|
1317 |
|
|
/* Look for load and store instructions that we can align on four
|
1318 |
|
|
byte boundaries. */
|
1319 |
|
|
if (have_code)
|
1320 |
|
|
{
|
1321 |
|
|
boolean swapped;
|
1322 |
|
|
|
1323 |
|
|
/* Get the section contents. */
|
1324 |
|
|
if (contents == NULL)
|
1325 |
|
|
{
|
1326 |
|
|
if (elf_section_data (sec)->this_hdr.contents != NULL)
|
1327 |
|
|
contents = elf_section_data (sec)->this_hdr.contents;
|
1328 |
|
|
else
|
1329 |
|
|
{
|
1330 |
|
|
contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
|
1331 |
|
|
if (contents == NULL)
|
1332 |
|
|
goto error_return;
|
1333 |
|
|
free_contents = contents;
|
1334 |
|
|
|
1335 |
|
|
if (! bfd_get_section_contents (abfd, sec, contents,
|
1336 |
|
|
(file_ptr) 0, sec->_raw_size))
|
1337 |
|
|
goto error_return;
|
1338 |
|
|
}
|
1339 |
|
|
}
|
1340 |
|
|
|
1341 |
|
|
if (! sh_elf_align_loads (abfd, sec, internal_relocs, contents,
|
1342 |
|
|
&swapped))
|
1343 |
|
|
goto error_return;
|
1344 |
|
|
|
1345 |
|
|
if (swapped)
|
1346 |
|
|
{
|
1347 |
|
|
elf_section_data (sec)->relocs = internal_relocs;
|
1348 |
|
|
free_relocs = NULL;
|
1349 |
|
|
|
1350 |
|
|
elf_section_data (sec)->this_hdr.contents = contents;
|
1351 |
|
|
free_contents = NULL;
|
1352 |
|
|
|
1353 |
|
|
symtab_hdr->contents = (bfd_byte *) extsyms;
|
1354 |
|
|
free_extsyms = NULL;
|
1355 |
|
|
}
|
1356 |
|
|
}
|
1357 |
|
|
|
1358 |
|
|
if (free_relocs != NULL)
|
1359 |
|
|
{
|
1360 |
|
|
free (free_relocs);
|
1361 |
|
|
free_relocs = NULL;
|
1362 |
|
|
}
|
1363 |
|
|
|
1364 |
|
|
if (free_contents != NULL)
|
1365 |
|
|
{
|
1366 |
|
|
if (! link_info->keep_memory)
|
1367 |
|
|
free (free_contents);
|
1368 |
|
|
else
|
1369 |
|
|
{
|
1370 |
|
|
/* Cache the section contents for elf_link_input_bfd. */
|
1371 |
|
|
elf_section_data (sec)->this_hdr.contents = contents;
|
1372 |
|
|
}
|
1373 |
|
|
free_contents = NULL;
|
1374 |
|
|
}
|
1375 |
|
|
|
1376 |
|
|
if (free_extsyms != NULL)
|
1377 |
|
|
{
|
1378 |
|
|
if (! link_info->keep_memory)
|
1379 |
|
|
free (free_extsyms);
|
1380 |
|
|
else
|
1381 |
|
|
{
|
1382 |
|
|
/* Cache the symbols for elf_link_input_bfd. */
|
1383 |
|
|
symtab_hdr->contents = extsyms;
|
1384 |
|
|
}
|
1385 |
|
|
free_extsyms = NULL;
|
1386 |
|
|
}
|
1387 |
|
|
|
1388 |
|
|
return true;
|
1389 |
|
|
|
1390 |
|
|
error_return:
|
1391 |
|
|
if (free_relocs != NULL)
|
1392 |
|
|
free (free_relocs);
|
1393 |
|
|
if (free_contents != NULL)
|
1394 |
|
|
free (free_contents);
|
1395 |
|
|
if (free_extsyms != NULL)
|
1396 |
|
|
free (free_extsyms);
|
1397 |
|
|
return false;
|
1398 |
|
|
}
|
1399 |
|
|
|
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
|
1402 |
|
|
in coff-sh.c. */
|
1403 |
|
|
|
1404 |
|
|
static boolean
|
1405 |
|
|
sh_elf_relax_delete_bytes (abfd, sec, addr, count)
|
1406 |
|
|
bfd *abfd;
|
1407 |
|
|
asection *sec;
|
1408 |
|
|
bfd_vma addr;
|
1409 |
|
|
int count;
|
1410 |
|
|
{
|
1411 |
|
|
Elf_Internal_Shdr *symtab_hdr;
|
1412 |
|
|
Elf32_External_Sym *extsyms;
|
1413 |
|
|
int shndx, index;
|
1414 |
|
|
bfd_byte *contents;
|
1415 |
|
|
Elf_Internal_Rela *irel, *irelend;
|
1416 |
|
|
Elf_Internal_Rela *irelalign;
|
1417 |
|
|
bfd_vma toaddr;
|
1418 |
|
|
Elf32_External_Sym *esym, *esymend;
|
1419 |
|
|
struct elf_link_hash_entry *sym_hash;
|
1420 |
|
|
asection *o;
|
1421 |
|
|
|
1422 |
|
|
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
|
1423 |
|
|
extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
|
1424 |
|
|
|
1425 |
|
|
shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
|
1426 |
|
|
|
1427 |
|
|
contents = elf_section_data (sec)->this_hdr.contents;
|
1428 |
|
|
|
1429 |
|
|
/* The deletion must stop at the next ALIGN reloc for an aligment
|
1430 |
|
|
power larger than the number of bytes we are deleting. */
|
1431 |
|
|
|
1432 |
|
|
irelalign = NULL;
|
1433 |
|
|
toaddr = sec->_cooked_size;
|
1434 |
|
|
|
1435 |
|
|
irel = elf_section_data (sec)->relocs;
|
1436 |
|
|
irelend = irel + sec->reloc_count;
|
1437 |
|
|
for (; irel < irelend; irel++)
|
1438 |
|
|
{
|
1439 |
|
|
if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
|
1440 |
|
|
&& irel->r_offset > addr
|
1441 |
|
|
&& count < (1 << irel->r_addend))
|
1442 |
|
|
{
|
1443 |
|
|
irelalign = irel;
|
1444 |
|
|
toaddr = irel->r_offset;
|
1445 |
|
|
break;
|
1446 |
|
|
}
|
1447 |
|
|
}
|
1448 |
|
|
|
1449 |
|
|
/* Actually delete the bytes. */
|
1450 |
|
|
memmove (contents + addr, contents + addr + count, toaddr - addr - count);
|
1451 |
|
|
if (irelalign == NULL)
|
1452 |
|
|
sec->_cooked_size -= count;
|
1453 |
|
|
else
|
1454 |
|
|
{
|
1455 |
|
|
int i;
|
1456 |
|
|
|
1457 |
|
|
#define NOP_OPCODE (0x0009)
|
1458 |
|
|
|
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);
|
1462 |
|
|
}
|
1463 |
|
|
|
1464 |
|
|
/* Adjust all the relocs. */
|
1465 |
|
|
for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
|
1466 |
|
|
{
|
1467 |
|
|
bfd_vma nraddr, stop;
|
1468 |
|
|
bfd_vma start = 0;
|
1469 |
|
|
int insn = 0;
|
1470 |
|
|
Elf_Internal_Sym sym;
|
1471 |
|
|
int off, adjust, oinsn;
|
1472 |
|
|
bfd_signed_vma voff = 0;
|
1473 |
|
|
boolean overflow;
|
1474 |
|
|
|
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))
|
1481 |
|
|
nraddr -= count;
|
1482 |
|
|
|
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),
|
1493 |
|
|
(int) R_SH_NONE);
|
1494 |
|
|
|
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))
|
1498 |
|
|
{
|
1499 |
|
|
default:
|
1500 |
|
|
break;
|
1501 |
|
|
|
1502 |
|
|
case R_SH_DIR8WPN:
|
1503 |
|
|
case R_SH_IND12W:
|
1504 |
|
|
case R_SH_DIR8WPZ:
|
1505 |
|
|
case R_SH_DIR8WPL:
|
1506 |
|
|
start = irel->r_offset;
|
1507 |
|
|
insn = bfd_get_16 (abfd, contents + nraddr);
|
1508 |
|
|
break;
|
1509 |
|
|
}
|
1510 |
|
|
|
1511 |
|
|
switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
|
1512 |
|
|
{
|
1513 |
|
|
default:
|
1514 |
|
|
start = stop = addr;
|
1515 |
|
|
break;
|
1516 |
|
|
|
1517 |
|
|
case R_SH_DIR32:
|
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)
|
1523 |
|
|
{
|
1524 |
|
|
bfd_elf32_swap_symbol_in (abfd,
|
1525 |
|
|
extsyms + ELF32_R_SYM (irel->r_info),
|
1526 |
|
|
&sym);
|
1527 |
|
|
if (sym.st_shndx == shndx
|
1528 |
|
|
&& (sym.st_value <= addr
|
1529 |
|
|
|| sym.st_value >= toaddr))
|
1530 |
|
|
{
|
1531 |
|
|
bfd_vma val;
|
1532 |
|
|
|
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);
|
1537 |
|
|
}
|
1538 |
|
|
}
|
1539 |
|
|
start = stop = addr;
|
1540 |
|
|
break;
|
1541 |
|
|
|
1542 |
|
|
case R_SH_DIR8WPN:
|
1543 |
|
|
off = insn & 0xff;
|
1544 |
|
|
if (off & 0x80)
|
1545 |
|
|
off -= 0x100;
|
1546 |
|
|
stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
|
1547 |
|
|
break;
|
1548 |
|
|
|
1549 |
|
|
case R_SH_IND12W:
|
1550 |
|
|
if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info)
|
1551 |
|
|
start = stop = addr;
|
1552 |
|
|
else
|
1553 |
|
|
{
|
1554 |
|
|
off = insn & 0xfff;
|
1555 |
|
|
if (off & 0x800)
|
1556 |
|
|
off -= 0x1000;
|
1557 |
|
|
stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
|
1558 |
|
|
}
|
1559 |
|
|
break;
|
1560 |
|
|
|
1561 |
|
|
case R_SH_DIR8WPZ:
|
1562 |
|
|
off = insn & 0xff;
|
1563 |
|
|
stop = start + 4 + off * 2;
|
1564 |
|
|
break;
|
1565 |
|
|
|
1566 |
|
|
case R_SH_DIR8WPL:
|
1567 |
|
|
off = insn & 0xff;
|
1568 |
|
|
stop = (start & ~(bfd_vma) 3) + 4 + off * 4;
|
1569 |
|
|
break;
|
1570 |
|
|
|
1571 |
|
|
case R_SH_SWITCH8:
|
1572 |
|
|
case R_SH_SWITCH16:
|
1573 |
|
|
case R_SH_SWITCH32:
|
1574 |
|
|
/* These relocs types represent
|
1575 |
|
|
.word L2-L1
|
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. */
|
1582 |
|
|
|
1583 |
|
|
stop = irel->r_offset;
|
1584 |
|
|
start = (bfd_vma) ((bfd_signed_vma) stop - (long) irel->r_addend);
|
1585 |
|
|
|
1586 |
|
|
if (start > addr
|
1587 |
|
|
&& start < toaddr
|
1588 |
|
|
&& (stop <= addr || stop >= toaddr))
|
1589 |
|
|
irel->r_addend += count;
|
1590 |
|
|
else if (stop > addr
|
1591 |
|
|
&& stop < toaddr
|
1592 |
|
|
&& (start <= addr || start >= toaddr))
|
1593 |
|
|
irel->r_addend -= count;
|
1594 |
|
|
|
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);
|
1599 |
|
|
else
|
1600 |
|
|
voff = bfd_get_signed_32 (abfd, contents + nraddr);
|
1601 |
|
|
stop = (bfd_vma) ((bfd_signed_vma) start + voff);
|
1602 |
|
|
|
1603 |
|
|
break;
|
1604 |
|
|
|
1605 |
|
|
case R_SH_USES:
|
1606 |
|
|
start = irel->r_offset;
|
1607 |
|
|
stop = (bfd_vma) ((bfd_signed_vma) start
|
1608 |
|
|
+ (long) irel->r_addend
|
1609 |
|
|
+ 4);
|
1610 |
|
|
break;
|
1611 |
|
|
}
|
1612 |
|
|
|
1613 |
|
|
if (start > addr
|
1614 |
|
|
&& start < toaddr
|
1615 |
|
|
&& (stop <= addr || stop >= toaddr))
|
1616 |
|
|
adjust = count;
|
1617 |
|
|
else if (stop > addr
|
1618 |
|
|
&& stop < toaddr
|
1619 |
|
|
&& (start <= addr || start >= toaddr))
|
1620 |
|
|
adjust = - count;
|
1621 |
|
|
else
|
1622 |
|
|
adjust = 0;
|
1623 |
|
|
|
1624 |
|
|
if (adjust != 0)
|
1625 |
|
|
{
|
1626 |
|
|
oinsn = insn;
|
1627 |
|
|
overflow = false;
|
1628 |
|
|
switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
|
1629 |
|
|
{
|
1630 |
|
|
default:
|
1631 |
|
|
abort ();
|
1632 |
|
|
break;
|
1633 |
|
|
|
1634 |
|
|
case R_SH_DIR8WPN:
|
1635 |
|
|
case R_SH_DIR8WPZ:
|
1636 |
|
|
insn += adjust / 2;
|
1637 |
|
|
if ((oinsn & 0xff00) != (insn & 0xff00))
|
1638 |
|
|
overflow = true;
|
1639 |
|
|
bfd_put_16 (abfd, insn, contents + nraddr);
|
1640 |
|
|
break;
|
1641 |
|
|
|
1642 |
|
|
case R_SH_IND12W:
|
1643 |
|
|
insn += adjust / 2;
|
1644 |
|
|
if ((oinsn & 0xf000) != (insn & 0xf000))
|
1645 |
|
|
overflow = true;
|
1646 |
|
|
bfd_put_16 (abfd, insn, contents + nraddr);
|
1647 |
|
|
break;
|
1648 |
|
|
|
1649 |
|
|
case R_SH_DIR8WPL:
|
1650 |
|
|
BFD_ASSERT (adjust == count || count >= 4);
|
1651 |
|
|
if (count >= 4)
|
1652 |
|
|
insn += adjust / 4;
|
1653 |
|
|
else
|
1654 |
|
|
{
|
1655 |
|
|
if ((irel->r_offset & 3) == 0)
|
1656 |
|
|
++insn;
|
1657 |
|
|
}
|
1658 |
|
|
if ((oinsn & 0xff00) != (insn & 0xff00))
|
1659 |
|
|
overflow = true;
|
1660 |
|
|
bfd_put_16 (abfd, insn, contents + nraddr);
|
1661 |
|
|
break;
|
1662 |
|
|
|
1663 |
|
|
case R_SH_SWITCH8:
|
1664 |
|
|
voff += adjust;
|
1665 |
|
|
if (voff < 0 || voff >= 0xff)
|
1666 |
|
|
overflow = true;
|
1667 |
|
|
bfd_put_8 (abfd, voff, contents + nraddr);
|
1668 |
|
|
break;
|
1669 |
|
|
|
1670 |
|
|
case R_SH_SWITCH16:
|
1671 |
|
|
voff += adjust;
|
1672 |
|
|
if (voff < - 0x8000 || voff >= 0x8000)
|
1673 |
|
|
overflow = true;
|
1674 |
|
|
bfd_put_signed_16 (abfd, voff, contents + nraddr);
|
1675 |
|
|
break;
|
1676 |
|
|
|
1677 |
|
|
case R_SH_SWITCH32:
|
1678 |
|
|
voff += adjust;
|
1679 |
|
|
bfd_put_signed_32 (abfd, voff, contents + nraddr);
|
1680 |
|
|
break;
|
1681 |
|
|
|
1682 |
|
|
case R_SH_USES:
|
1683 |
|
|
irel->r_addend += adjust;
|
1684 |
|
|
break;
|
1685 |
|
|
}
|
1686 |
|
|
|
1687 |
|
|
if (overflow)
|
1688 |
|
|
{
|
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);
|
1693 |
|
|
return false;
|
1694 |
|
|
}
|
1695 |
|
|
}
|
1696 |
|
|
|
1697 |
|
|
irel->r_offset = nraddr;
|
1698 |
|
|
}
|
1699 |
|
|
|
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)
|
1704 |
|
|
{
|
1705 |
|
|
Elf_Internal_Rela *internal_relocs;
|
1706 |
|
|
Elf_Internal_Rela *irelscan, *irelscanend;
|
1707 |
|
|
bfd_byte *ocontents;
|
1708 |
|
|
|
1709 |
|
|
if (o == sec
|
1710 |
|
|
|| (o->flags & SEC_RELOC) == 0
|
1711 |
|
|
|| o->reloc_count == 0)
|
1712 |
|
|
continue;
|
1713 |
|
|
|
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,
|
1719 |
|
|
true));
|
1720 |
|
|
if (internal_relocs == NULL)
|
1721 |
|
|
return false;
|
1722 |
|
|
|
1723 |
|
|
ocontents = NULL;
|
1724 |
|
|
irelscanend = internal_relocs + o->reloc_count;
|
1725 |
|
|
for (irelscan = internal_relocs; irelscan < irelscanend; irelscan++)
|
1726 |
|
|
{
|
1727 |
|
|
Elf_Internal_Sym sym;
|
1728 |
|
|
|
1729 |
|
|
/* Dwarf line numbers use R_SH_SWITCH32 relocs. */
|
1730 |
|
|
if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_SWITCH32)
|
1731 |
|
|
{
|
1732 |
|
|
bfd_vma start, stop;
|
1733 |
|
|
bfd_signed_vma voff;
|
1734 |
|
|
|
1735 |
|
|
if (ocontents == NULL)
|
1736 |
|
|
{
|
1737 |
|
|
if (elf_section_data (o)->this_hdr.contents != NULL)
|
1738 |
|
|
ocontents = elf_section_data (o)->this_hdr.contents;
|
1739 |
|
|
else
|
1740 |
|
|
{
|
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)
|
1747 |
|
|
return false;
|
1748 |
|
|
if (! bfd_get_section_contents (abfd, o, ocontents,
|
1749 |
|
|
(file_ptr) 0,
|
1750 |
|
|
o->_raw_size))
|
1751 |
|
|
return false;
|
1752 |
|
|
elf_section_data (o)->this_hdr.contents = ocontents;
|
1753 |
|
|
}
|
1754 |
|
|
}
|
1755 |
|
|
|
1756 |
|
|
stop = irelscan->r_offset;
|
1757 |
|
|
start
|
1758 |
|
|
= (bfd_vma) ((bfd_signed_vma) stop - (long) irelscan->r_addend);
|
1759 |
|
|
|
1760 |
|
|
/* STOP is in a different section, so it won't change. */
|
1761 |
|
|
if (start > addr && start < toaddr)
|
1762 |
|
|
irelscan->r_addend += count;
|
1763 |
|
|
|
1764 |
|
|
voff = bfd_get_signed_32 (abfd, ocontents + irelscan->r_offset);
|
1765 |
|
|
stop = (bfd_vma) ((bfd_signed_vma) start + voff);
|
1766 |
|
|
|
1767 |
|
|
if (start > addr
|
1768 |
|
|
&& start < toaddr
|
1769 |
|
|
&& (stop <= addr || stop >= toaddr))
|
1770 |
|
|
bfd_put_signed_32 (abfd, voff + count,
|
1771 |
|
|
ocontents + irelscan->r_offset);
|
1772 |
|
|
else if (stop > addr
|
1773 |
|
|
&& stop < toaddr
|
1774 |
|
|
&& (start <= addr || start >= toaddr))
|
1775 |
|
|
bfd_put_signed_32 (abfd, voff - count,
|
1776 |
|
|
ocontents + irelscan->r_offset);
|
1777 |
|
|
}
|
1778 |
|
|
|
1779 |
|
|
if (ELF32_R_TYPE (irelscan->r_info) != (int) R_SH_DIR32)
|
1780 |
|
|
continue;
|
1781 |
|
|
|
1782 |
|
|
if (ELF32_R_SYM (irelscan->r_info) >= symtab_hdr->sh_info)
|
1783 |
|
|
continue;
|
1784 |
|
|
|
1785 |
|
|
bfd_elf32_swap_symbol_in (abfd,
|
1786 |
|
|
extsyms + ELF32_R_SYM (irelscan->r_info),
|
1787 |
|
|
&sym);
|
1788 |
|
|
|
1789 |
|
|
if (sym.st_shndx == shndx
|
1790 |
|
|
&& (sym.st_value <= addr
|
1791 |
|
|
|| sym.st_value >= toaddr))
|
1792 |
|
|
{
|
1793 |
|
|
bfd_vma val;
|
1794 |
|
|
|
1795 |
|
|
if (ocontents == NULL)
|
1796 |
|
|
{
|
1797 |
|
|
if (elf_section_data (o)->this_hdr.contents != NULL)
|
1798 |
|
|
ocontents = elf_section_data (o)->this_hdr.contents;
|
1799 |
|
|
else
|
1800 |
|
|
{
|
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)
|
1807 |
|
|
return false;
|
1808 |
|
|
if (! bfd_get_section_contents (abfd, o, ocontents,
|
1809 |
|
|
(file_ptr) 0,
|
1810 |
|
|
o->_raw_size))
|
1811 |
|
|
return false;
|
1812 |
|
|
elf_section_data (o)->this_hdr.contents = ocontents;
|
1813 |
|
|
}
|
1814 |
|
|
}
|
1815 |
|
|
|
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);
|
1821 |
|
|
}
|
1822 |
|
|
}
|
1823 |
|
|
}
|
1824 |
|
|
|
1825 |
|
|
/* Adjust the local symbols defined in this section. */
|
1826 |
|
|
esym = extsyms;
|
1827 |
|
|
esymend = esym + symtab_hdr->sh_info;
|
1828 |
|
|
for (; esym < esymend; esym++)
|
1829 |
|
|
{
|
1830 |
|
|
Elf_Internal_Sym isym;
|
1831 |
|
|
|
1832 |
|
|
bfd_elf32_swap_symbol_in (abfd, esym, &isym);
|
1833 |
|
|
|
1834 |
|
|
if (isym.st_shndx == shndx
|
1835 |
|
|
&& isym.st_value > addr
|
1836 |
|
|
&& isym.st_value < toaddr)
|
1837 |
|
|
{
|
1838 |
|
|
isym.st_value -= count;
|
1839 |
|
|
bfd_elf32_swap_symbol_out (abfd, &isym, esym);
|
1840 |
|
|
}
|
1841 |
|
|
}
|
1842 |
|
|
|
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++)
|
1847 |
|
|
{
|
1848 |
|
|
Elf_Internal_Sym isym;
|
1849 |
|
|
|
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)
|
1858 |
|
|
{
|
1859 |
|
|
(sym_hash)->root.u.def.value -= count;
|
1860 |
|
|
}
|
1861 |
|
|
}
|
1862 |
|
|
|
1863 |
|
|
/* See if we can move the ALIGN reloc forward. We have adjusted
|
1864 |
|
|
r_offset for it already. */
|
1865 |
|
|
if (irelalign != NULL)
|
1866 |
|
|
{
|
1867 |
|
|
bfd_vma alignto, alignaddr;
|
1868 |
|
|
|
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)
|
1873 |
|
|
{
|
1874 |
|
|
/* Tail recursion. */
|
1875 |
|
|
return sh_elf_relax_delete_bytes (abfd, sec, alignaddr,
|
1876 |
|
|
alignto - alignaddr);
|
1877 |
|
|
}
|
1878 |
|
|
}
|
1879 |
|
|
|
1880 |
|
|
return true;
|
1881 |
|
|
}
|
1882 |
|
|
|
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. */
|
1885 |
|
|
|
1886 |
|
|
static boolean
|
1887 |
|
|
sh_elf_align_loads (abfd, sec, internal_relocs, contents, pswapped)
|
1888 |
|
|
bfd *abfd;
|
1889 |
|
|
asection *sec;
|
1890 |
|
|
Elf_Internal_Rela *internal_relocs;
|
1891 |
|
|
bfd_byte *contents;
|
1892 |
|
|
boolean *pswapped;
|
1893 |
|
|
{
|
1894 |
|
|
Elf_Internal_Rela *irel, *irelend;
|
1895 |
|
|
bfd_vma *labels = NULL;
|
1896 |
|
|
bfd_vma *label, *label_end;
|
1897 |
|
|
|
1898 |
|
|
*pswapped = false;
|
1899 |
|
|
|
1900 |
|
|
irelend = internal_relocs + sec->reloc_count;
|
1901 |
|
|
|
1902 |
|
|
/* Get all the addresses with labels on them. */
|
1903 |
|
|
labels = (bfd_vma *) bfd_malloc (sec->reloc_count * sizeof (bfd_vma));
|
1904 |
|
|
if (labels == NULL)
|
1905 |
|
|
goto error_return;
|
1906 |
|
|
label_end = labels;
|
1907 |
|
|
for (irel = internal_relocs; irel < irelend; irel++)
|
1908 |
|
|
{
|
1909 |
|
|
if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_LABEL)
|
1910 |
|
|
{
|
1911 |
|
|
*label_end = irel->r_offset;
|
1912 |
|
|
++label_end;
|
1913 |
|
|
}
|
1914 |
|
|
}
|
1915 |
|
|
|
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. */
|
1919 |
|
|
|
1920 |
|
|
label = labels;
|
1921 |
|
|
|
1922 |
|
|
for (irel = internal_relocs; irel < irelend; irel++)
|
1923 |
|
|
{
|
1924 |
|
|
bfd_vma start, stop;
|
1925 |
|
|
|
1926 |
|
|
if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE)
|
1927 |
|
|
continue;
|
1928 |
|
|
|
1929 |
|
|
start = irel->r_offset;
|
1930 |
|
|
|
1931 |
|
|
for (irel++; irel < irelend; irel++)
|
1932 |
|
|
if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_DATA)
|
1933 |
|
|
break;
|
1934 |
|
|
if (irel < irelend)
|
1935 |
|
|
stop = irel->r_offset;
|
1936 |
|
|
else
|
1937 |
|
|
stop = sec->_cooked_size;
|
1938 |
|
|
|
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))
|
1942 |
|
|
goto error_return;
|
1943 |
|
|
}
|
1944 |
|
|
|
1945 |
|
|
free (labels);
|
1946 |
|
|
|
1947 |
|
|
return true;
|
1948 |
|
|
|
1949 |
|
|
error_return:
|
1950 |
|
|
if (labels != NULL)
|
1951 |
|
|
free (labels);
|
1952 |
|
|
return false;
|
1953 |
|
|
}
|
1954 |
|
|
|
1955 |
|
|
/* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */
|
1956 |
|
|
|
1957 |
|
|
static boolean
|
1958 |
|
|
sh_elf_swap_insns (abfd, sec, relocs, contents, addr)
|
1959 |
|
|
bfd *abfd;
|
1960 |
|
|
asection *sec;
|
1961 |
|
|
PTR relocs;
|
1962 |
|
|
bfd_byte *contents;
|
1963 |
|
|
bfd_vma addr;
|
1964 |
|
|
{
|
1965 |
|
|
Elf_Internal_Rela *internal_relocs = (Elf_Internal_Rela *) relocs;
|
1966 |
|
|
unsigned short i1, i2;
|
1967 |
|
|
Elf_Internal_Rela *irel, *irelend;
|
1968 |
|
|
|
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);
|
1974 |
|
|
|
1975 |
|
|
/* Adjust all reloc addresses. */
|
1976 |
|
|
irelend = internal_relocs + sec->reloc_count;
|
1977 |
|
|
for (irel = internal_relocs; irel < irelend; irel++)
|
1978 |
|
|
{
|
1979 |
|
|
enum elf_sh_reloc_type type;
|
1980 |
|
|
int add;
|
1981 |
|
|
|
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)
|
1990 |
|
|
continue;
|
1991 |
|
|
|
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)
|
1999 |
|
|
{
|
2000 |
|
|
bfd_vma off;
|
2001 |
|
|
|
2002 |
|
|
off = irel->r_offset + 4 + irel->r_addend;
|
2003 |
|
|
if (off == addr)
|
2004 |
|
|
irel->r_offset += 2;
|
2005 |
|
|
else if (off == addr + 2)
|
2006 |
|
|
irel->r_offset -= 2;
|
2007 |
|
|
}
|
2008 |
|
|
|
2009 |
|
|
if (irel->r_offset == addr)
|
2010 |
|
|
{
|
2011 |
|
|
irel->r_offset += 2;
|
2012 |
|
|
add = -2;
|
2013 |
|
|
}
|
2014 |
|
|
else if (irel->r_offset == addr + 2)
|
2015 |
|
|
{
|
2016 |
|
|
irel->r_offset -= 2;
|
2017 |
|
|
add = 2;
|
2018 |
|
|
}
|
2019 |
|
|
else
|
2020 |
|
|
add = 0;
|
2021 |
|
|
|
2022 |
|
|
if (add != 0)
|
2023 |
|
|
{
|
2024 |
|
|
bfd_byte *loc;
|
2025 |
|
|
unsigned short insn, oinsn;
|
2026 |
|
|
boolean overflow;
|
2027 |
|
|
|
2028 |
|
|
loc = contents + irel->r_offset;
|
2029 |
|
|
overflow = false;
|
2030 |
|
|
switch (type)
|
2031 |
|
|
{
|
2032 |
|
|
default:
|
2033 |
|
|
break;
|
2034 |
|
|
|
2035 |
|
|
case R_SH_DIR8WPN:
|
2036 |
|
|
case R_SH_DIR8WPZ:
|
2037 |
|
|
insn = bfd_get_16 (abfd, loc);
|
2038 |
|
|
oinsn = insn;
|
2039 |
|
|
insn += add / 2;
|
2040 |
|
|
if ((oinsn & 0xff00) != (insn & 0xff00))
|
2041 |
|
|
overflow = true;
|
2042 |
|
|
bfd_put_16 (abfd, insn, loc);
|
2043 |
|
|
break;
|
2044 |
|
|
|
2045 |
|
|
case R_SH_IND12W:
|
2046 |
|
|
insn = bfd_get_16 (abfd, loc);
|
2047 |
|
|
oinsn = insn;
|
2048 |
|
|
insn += add / 2;
|
2049 |
|
|
if ((oinsn & 0xf000) != (insn & 0xf000))
|
2050 |
|
|
overflow = true;
|
2051 |
|
|
bfd_put_16 (abfd, insn, loc);
|
2052 |
|
|
break;
|
2053 |
|
|
|
2054 |
|
|
case R_SH_DIR8WPL:
|
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)
|
2062 |
|
|
{
|
2063 |
|
|
insn = bfd_get_16 (abfd, loc);
|
2064 |
|
|
oinsn = insn;
|
2065 |
|
|
insn += add / 2;
|
2066 |
|
|
if ((oinsn & 0xff00) != (insn & 0xff00))
|
2067 |
|
|
overflow = true;
|
2068 |
|
|
bfd_put_16 (abfd, insn, loc);
|
2069 |
|
|
}
|
2070 |
|
|
|
2071 |
|
|
break;
|
2072 |
|
|
}
|
2073 |
|
|
|
2074 |
|
|
if (overflow)
|
2075 |
|
|
{
|
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);
|
2080 |
|
|
return false;
|
2081 |
|
|
}
|
2082 |
|
|
}
|
2083 |
|
|
}
|
2084 |
|
|
|
2085 |
|
|
return true;
|
2086 |
|
|
}
|
2087 |
|
|
|
2088 |
|
|
/* The size in bytes of an entry in the procedure linkage table. */
|
2089 |
|
|
|
2090 |
|
|
#define PLT_ENTRY_SIZE 28
|
2091 |
|
|
|
2092 |
|
|
/* First entry in an absolute procedure linkage table look like this. */
|
2093 |
|
|
|
2094 |
|
|
#if 1
|
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] =
|
2104 |
|
|
{
|
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. */
|
2117 |
|
|
};
|
2118 |
|
|
|
2119 |
|
|
static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] =
|
2120 |
|
|
{
|
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. */
|
2133 |
|
|
};
|
2134 |
|
|
|
2135 |
|
|
/* Sebsequent entries in an absolute procedure linkage table look like
|
2136 |
|
|
this. */
|
2137 |
|
|
|
2138 |
|
|
static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] =
|
2139 |
|
|
{
|
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. */
|
2151 |
|
|
};
|
2152 |
|
|
|
2153 |
|
|
static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] =
|
2154 |
|
|
{
|
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. */
|
2166 |
|
|
};
|
2167 |
|
|
|
2168 |
|
|
/* Entries in a PIC procedure linkage table look like this. */
|
2169 |
|
|
|
2170 |
|
|
static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] =
|
2171 |
|
|
{
|
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. */
|
2184 |
|
|
};
|
2185 |
|
|
|
2186 |
|
|
static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] =
|
2187 |
|
|
{
|
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. */
|
2200 |
|
|
};
|
2201 |
|
|
|
2202 |
|
|
#else /* These are the old style PLT entries. */
|
2203 |
|
|
static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] =
|
2204 |
|
|
{
|
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. */
|
2217 |
|
|
};
|
2218 |
|
|
|
2219 |
|
|
static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] =
|
2220 |
|
|
{
|
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. */
|
2233 |
|
|
};
|
2234 |
|
|
|
2235 |
|
|
/* Sebsequent entries in an absolute procedure linkage table look like
|
2236 |
|
|
this. */
|
2237 |
|
|
|
2238 |
|
|
static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] =
|
2239 |
|
|
{
|
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. */
|
2251 |
|
|
};
|
2252 |
|
|
|
2253 |
|
|
static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] =
|
2254 |
|
|
{
|
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. */
|
2266 |
|
|
};
|
2267 |
|
|
|
2268 |
|
|
/* Entries in a PIC procedure linkage table look like this. */
|
2269 |
|
|
|
2270 |
|
|
static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] =
|
2271 |
|
|
{
|
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. */
|
2284 |
|
|
};
|
2285 |
|
|
|
2286 |
|
|
static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] =
|
2287 |
|
|
{
|
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. */
|
2300 |
|
|
};
|
2301 |
|
|
#endif /* old style PLT entries. */
|
2302 |
|
|
|
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;
|
2306 |
|
|
|
2307 |
|
|
/* Return size of a PLT entry. */
|
2308 |
|
|
#define elf_sh_sizeof_plt(info) PLT_ENTRY_SIZE
|
2309 |
|
|
|
2310 |
|
|
/* Return offset of the PLT0 address in an absolute PLT entry. */
|
2311 |
|
|
#define elf_sh_plt_plt0_offset(info) 16
|
2312 |
|
|
|
2313 |
|
|
/* Return offset of the linker in PLT0 entry. */
|
2314 |
|
|
#define elf_sh_plt0_linker_offset(info) 20
|
2315 |
|
|
|
2316 |
|
|
/* Return offset of the GOT id in PLT0 entry. */
|
2317 |
|
|
#define elf_sh_plt0_gotid_offset(info) 24
|
2318 |
|
|
|
2319 |
|
|
/* Return offset of the tempoline in PLT entry */
|
2320 |
|
|
#define elf_sh_plt_temp_offset(info) 8
|
2321 |
|
|
|
2322 |
|
|
/* Return offset of the symbol in PLT entry. */
|
2323 |
|
|
#define elf_sh_plt_symbol_offset(info) 20
|
2324 |
|
|
|
2325 |
|
|
/* Return offset of the relocation in PLT entry. */
|
2326 |
|
|
#define elf_sh_plt_reloc_offset(info) 24
|
2327 |
|
|
|
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. */
|
2333 |
|
|
|
2334 |
|
|
/* This structure keeps track of the number of PC relative relocs we
|
2335 |
|
|
have copied for a given symbol. */
|
2336 |
|
|
|
2337 |
|
|
struct elf_sh_pcrel_relocs_copied
|
2338 |
|
|
{
|
2339 |
|
|
/* Next section. */
|
2340 |
|
|
struct elf_sh_pcrel_relocs_copied *next;
|
2341 |
|
|
/* A section in dynobj. */
|
2342 |
|
|
asection *section;
|
2343 |
|
|
/* Number of relocs copied in this section. */
|
2344 |
|
|
bfd_size_type count;
|
2345 |
|
|
};
|
2346 |
|
|
|
2347 |
|
|
/* sh ELF linker hash entry. */
|
2348 |
|
|
|
2349 |
|
|
struct elf_sh_link_hash_entry
|
2350 |
|
|
{
|
2351 |
|
|
struct elf_link_hash_entry root;
|
2352 |
|
|
|
2353 |
|
|
/* Number of PC relative relocs copied for this symbol. */
|
2354 |
|
|
struct elf_sh_pcrel_relocs_copied *pcrel_relocs_copied;
|
2355 |
|
|
};
|
2356 |
|
|
|
2357 |
|
|
/* sh ELF linker hash table. */
|
2358 |
|
|
|
2359 |
|
|
struct elf_sh_link_hash_table
|
2360 |
|
|
{
|
2361 |
|
|
struct elf_link_hash_table root;
|
2362 |
|
|
};
|
2363 |
|
|
|
2364 |
|
|
/* Declare this now that the above structures are defined. */
|
2365 |
|
|
|
2366 |
|
|
static boolean sh_elf_discard_copies
|
2367 |
|
|
PARAMS ((struct elf_sh_link_hash_entry *, PTR));
|
2368 |
|
|
|
2369 |
|
|
/* Traverse an sh ELF linker hash table. */
|
2370 |
|
|
|
2371 |
|
|
#define sh_elf_link_hash_traverse(table, func, info) \
|
2372 |
|
|
(elf_link_hash_traverse \
|
2373 |
|
|
(&(table)->root, \
|
2374 |
|
|
(boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
|
2375 |
|
|
(info)))
|
2376 |
|
|
|
2377 |
|
|
/* Get the sh ELF linker hash table from a link_info structure. */
|
2378 |
|
|
|
2379 |
|
|
#define sh_elf_hash_table(p) \
|
2380 |
|
|
((struct elf_sh_link_hash_table *) ((p)->hash))
|
2381 |
|
|
|
2382 |
|
|
/* Create an entry in an sh ELF linker hash table. */
|
2383 |
|
|
|
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;
|
2388 |
|
|
const char *string;
|
2389 |
|
|
{
|
2390 |
|
|
struct elf_sh_link_hash_entry *ret =
|
2391 |
|
|
(struct elf_sh_link_hash_entry *) entry;
|
2392 |
|
|
|
2393 |
|
|
/* Allocate the structure if it has not already been allocated by a
|
2394 |
|
|
subclass. */
|
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;
|
2401 |
|
|
|
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,
|
2405 |
|
|
table, string));
|
2406 |
|
|
if (ret != (struct elf_sh_link_hash_entry *) NULL)
|
2407 |
|
|
{
|
2408 |
|
|
ret->pcrel_relocs_copied = NULL;
|
2409 |
|
|
}
|
2410 |
|
|
|
2411 |
|
|
return (struct bfd_hash_entry *) ret;
|
2412 |
|
|
}
|
2413 |
|
|
|
2414 |
|
|
/* Create an sh ELF linker hash table. */
|
2415 |
|
|
|
2416 |
|
|
static struct bfd_link_hash_table *
|
2417 |
|
|
sh_elf_link_hash_table_create (abfd)
|
2418 |
|
|
bfd *abfd;
|
2419 |
|
|
{
|
2420 |
|
|
struct elf_sh_link_hash_table *ret;
|
2421 |
|
|
|
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)
|
2425 |
|
|
return NULL;
|
2426 |
|
|
|
2427 |
|
|
if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
|
2428 |
|
|
sh_elf_link_hash_newfunc))
|
2429 |
|
|
{
|
2430 |
|
|
bfd_release (abfd, ret);
|
2431 |
|
|
return NULL;
|
2432 |
|
|
}
|
2433 |
|
|
|
2434 |
|
|
return &ret->root.root;
|
2435 |
|
|
}
|
2436 |
|
|
|
2437 |
|
|
/* Create dynamic sections when linking against a dynamic object. */
|
2438 |
|
|
|
2439 |
|
|
static boolean
|
2440 |
|
|
sh_elf_create_dynamic_sections (abfd, info)
|
2441 |
|
|
bfd *abfd;
|
2442 |
|
|
struct bfd_link_info *info;
|
2443 |
|
|
{
|
2444 |
|
|
flagword flags, pltflags;
|
2445 |
|
|
register asection *s;
|
2446 |
|
|
struct elf_backend_data *bed = get_elf_backend_data (abfd);
|
2447 |
|
|
int ptralign = 0;
|
2448 |
|
|
|
2449 |
|
|
switch (bed->s->arch_size)
|
2450 |
|
|
{
|
2451 |
|
|
case 32:
|
2452 |
|
|
ptralign = 2;
|
2453 |
|
|
break;
|
2454 |
|
|
|
2455 |
|
|
case 64:
|
2456 |
|
|
ptralign = 3;
|
2457 |
|
|
break;
|
2458 |
|
|
|
2459 |
|
|
default:
|
2460 |
|
|
bfd_set_error (bfd_error_bad_value);
|
2461 |
|
|
return false;
|
2462 |
|
|
}
|
2463 |
|
|
|
2464 |
|
|
/* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
|
2465 |
|
|
.rel[a].bss sections. */
|
2466 |
|
|
|
2467 |
|
|
flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
|
2468 |
|
|
| SEC_LINKER_CREATED);
|
2469 |
|
|
|
2470 |
|
|
pltflags = flags;
|
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;
|
2476 |
|
|
|
2477 |
|
|
s = bfd_make_section (abfd, ".plt");
|
2478 |
|
|
if (s == NULL
|
2479 |
|
|
|| ! bfd_set_section_flags (abfd, s, pltflags)
|
2480 |
|
|
|| ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
|
2481 |
|
|
return false;
|
2482 |
|
|
|
2483 |
|
|
if (bed->want_plt_sym)
|
2484 |
|
|
{
|
2485 |
|
|
/* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
|
2486 |
|
|
.plt section. */
|
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)))
|
2493 |
|
|
return false;
|
2494 |
|
|
h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
|
2495 |
|
|
h->type = STT_OBJECT;
|
2496 |
|
|
|
2497 |
|
|
if (info->shared
|
2498 |
|
|
&& ! _bfd_elf_link_record_dynamic_symbol (info, h))
|
2499 |
|
|
return false;
|
2500 |
|
|
}
|
2501 |
|
|
|
2502 |
|
|
s = bfd_make_section (abfd,
|
2503 |
|
|
bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
|
2504 |
|
|
if (s == NULL
|
2505 |
|
|
|| ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
|
2506 |
|
|
|| ! bfd_set_section_alignment (abfd, s, ptralign))
|
2507 |
|
|
return false;
|
2508 |
|
|
|
2509 |
|
|
if (! _bfd_elf_create_got_section (abfd, info))
|
2510 |
|
|
return false;
|
2511 |
|
|
|
2512 |
|
|
{
|
2513 |
|
|
const char *secname;
|
2514 |
|
|
char *relname;
|
2515 |
|
|
flagword secflags;
|
2516 |
|
|
asection *sec;
|
2517 |
|
|
|
2518 |
|
|
for (sec = abfd->sections; sec; sec = sec->next)
|
2519 |
|
|
{
|
2520 |
|
|
secflags = bfd_get_section_flags (abfd, sec);
|
2521 |
|
|
if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
|
2522 |
|
|
|| ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
|
2523 |
|
|
continue;
|
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);
|
2529 |
|
|
if (s == NULL
|
2530 |
|
|
|| ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
|
2531 |
|
|
|| ! bfd_set_section_alignment (abfd, s, ptralign))
|
2532 |
|
|
return false;
|
2533 |
|
|
}
|
2534 |
|
|
}
|
2535 |
|
|
|
2536 |
|
|
if (bed->want_dynbss)
|
2537 |
|
|
{
|
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");
|
2545 |
|
|
if (s == NULL
|
2546 |
|
|
|| ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
|
2547 |
|
|
return false;
|
2548 |
|
|
|
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
|
2559 |
|
|
copy relocs. */
|
2560 |
|
|
if (! info->shared)
|
2561 |
|
|
{
|
2562 |
|
|
s = bfd_make_section (abfd,
|
2563 |
|
|
(bed->default_use_rela_p
|
2564 |
|
|
? ".rela.bss" : ".rel.bss"));
|
2565 |
|
|
if (s == NULL
|
2566 |
|
|
|| ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
|
2567 |
|
|
|| ! bfd_set_section_alignment (abfd, s, ptralign))
|
2568 |
|
|
return false;
|
2569 |
|
|
}
|
2570 |
|
|
}
|
2571 |
|
|
|
2572 |
|
|
return true;
|
2573 |
|
|
}
|
2574 |
|
|
|
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
|
2579 |
|
|
understand. */
|
2580 |
|
|
|
2581 |
|
|
static boolean
|
2582 |
|
|
sh_elf_adjust_dynamic_symbol (info, h)
|
2583 |
|
|
struct bfd_link_info *info;
|
2584 |
|
|
struct elf_link_hash_entry *h;
|
2585 |
|
|
{
|
2586 |
|
|
bfd *dynobj;
|
2587 |
|
|
asection *s;
|
2588 |
|
|
unsigned int power_of_two;
|
2589 |
|
|
|
2590 |
|
|
dynobj = elf_hash_table (info)->dynobj;
|
2591 |
|
|
|
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)));
|
2602 |
|
|
|
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)
|
2608 |
|
|
{
|
2609 |
|
|
if (! info->shared
|
2610 |
|
|
&& (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
|
2611 |
|
|
&& (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
|
2612 |
|
|
{
|
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
|
2617 |
|
|
reloc instead. */
|
2618 |
|
|
BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
|
2619 |
|
|
return true;
|
2620 |
|
|
}
|
2621 |
|
|
|
2622 |
|
|
/* Make sure this symbol is output as a dynamic symbol. */
|
2623 |
|
|
if (h->dynindx == -1)
|
2624 |
|
|
{
|
2625 |
|
|
if (! bfd_elf32_link_record_dynamic_symbol (info, h))
|
2626 |
|
|
return false;
|
2627 |
|
|
}
|
2628 |
|
|
|
2629 |
|
|
s = bfd_get_section_by_name (dynobj, ".plt");
|
2630 |
|
|
BFD_ASSERT (s != NULL);
|
2631 |
|
|
|
2632 |
|
|
/* If this is the first .plt entry, make room for the special
|
2633 |
|
|
first entry. */
|
2634 |
|
|
if (s->_raw_size == 0)
|
2635 |
|
|
s->_raw_size += PLT_ENTRY_SIZE;
|
2636 |
|
|
|
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. */
|
2642 |
|
|
if (! info->shared
|
2643 |
|
|
&& (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
|
2644 |
|
|
{
|
2645 |
|
|
h->root.u.def.section = s;
|
2646 |
|
|
h->root.u.def.value = s->_raw_size;
|
2647 |
|
|
}
|
2648 |
|
|
|
2649 |
|
|
h->plt.offset = s->_raw_size;
|
2650 |
|
|
|
2651 |
|
|
/* Make room for this entry. */
|
2652 |
|
|
s->_raw_size += elf_sh_sizeof_plt (info);
|
2653 |
|
|
|
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. */
|
2656 |
|
|
|
2657 |
|
|
s = bfd_get_section_by_name (dynobj, ".got.plt");
|
2658 |
|
|
BFD_ASSERT (s != NULL);
|
2659 |
|
|
s->_raw_size += 4;
|
2660 |
|
|
|
2661 |
|
|
/* We also need to make an entry in the .rela.plt section. */
|
2662 |
|
|
|
2663 |
|
|
s = bfd_get_section_by_name (dynobj, ".rela.plt");
|
2664 |
|
|
BFD_ASSERT (s != NULL);
|
2665 |
|
|
s->_raw_size += sizeof (Elf32_External_Rela);
|
2666 |
|
|
|
2667 |
|
|
return true;
|
2668 |
|
|
}
|
2669 |
|
|
|
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)
|
2674 |
|
|
{
|
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;
|
2679 |
|
|
return true;
|
2680 |
|
|
}
|
2681 |
|
|
|
2682 |
|
|
/* This is a reference to a symbol defined by a dynamic object which
|
2683 |
|
|
is not a function. */
|
2684 |
|
|
|
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. */
|
2689 |
|
|
if (info->shared)
|
2690 |
|
|
return true;
|
2691 |
|
|
|
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)
|
2695 |
|
|
return true;
|
2696 |
|
|
|
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. */
|
2706 |
|
|
|
2707 |
|
|
s = bfd_get_section_by_name (dynobj, ".dynbss");
|
2708 |
|
|
BFD_ASSERT (s != NULL);
|
2709 |
|
|
|
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)
|
2715 |
|
|
{
|
2716 |
|
|
asection *srel;
|
2717 |
|
|
|
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;
|
2722 |
|
|
}
|
2723 |
|
|
|
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)
|
2728 |
|
|
power_of_two = 3;
|
2729 |
|
|
|
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))
|
2734 |
|
|
{
|
2735 |
|
|
if (! bfd_set_section_alignment (dynobj, s, power_of_two))
|
2736 |
|
|
return false;
|
2737 |
|
|
}
|
2738 |
|
|
|
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;
|
2742 |
|
|
|
2743 |
|
|
/* Increment the section size to make room for the symbol. */
|
2744 |
|
|
s->_raw_size += h->size;
|
2745 |
|
|
|
2746 |
|
|
return true;
|
2747 |
|
|
}
|
2748 |
|
|
|
2749 |
|
|
/* Set the sizes of the dynamic sections. */
|
2750 |
|
|
|
2751 |
|
|
static boolean
|
2752 |
|
|
sh_elf_size_dynamic_sections (output_bfd, info)
|
2753 |
|
|
bfd *output_bfd;
|
2754 |
|
|
struct bfd_link_info *info;
|
2755 |
|
|
{
|
2756 |
|
|
bfd *dynobj;
|
2757 |
|
|
asection *s;
|
2758 |
|
|
boolean plt;
|
2759 |
|
|
boolean relocs;
|
2760 |
|
|
boolean reltext;
|
2761 |
|
|
|
2762 |
|
|
dynobj = elf_hash_table (info)->dynobj;
|
2763 |
|
|
BFD_ASSERT (dynobj != NULL);
|
2764 |
|
|
|
2765 |
|
|
if (elf_hash_table (info)->dynamic_sections_created)
|
2766 |
|
|
{
|
2767 |
|
|
/* Set the contents of the .interp section to the interpreter. */
|
2768 |
|
|
if (! info->shared)
|
2769 |
|
|
{
|
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;
|
2774 |
|
|
}
|
2775 |
|
|
}
|
2776 |
|
|
else
|
2777 |
|
|
{
|
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
|
2782 |
|
|
below. */
|
2783 |
|
|
s = bfd_get_section_by_name (dynobj, ".rela.got");
|
2784 |
|
|
if (s != NULL)
|
2785 |
|
|
s->_raw_size = 0;
|
2786 |
|
|
}
|
2787 |
|
|
|
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,
|
2795 |
|
|
(PTR) NULL);
|
2796 |
|
|
|
2797 |
|
|
/* The check_relocs and adjust_dynamic_symbol entry points have
|
2798 |
|
|
determined the sizes of the various dynamic sections. Allocate
|
2799 |
|
|
memory for them. */
|
2800 |
|
|
plt = false;
|
2801 |
|
|
relocs = false;
|
2802 |
|
|
reltext = false;
|
2803 |
|
|
for (s = dynobj->sections; s != NULL; s = s->next)
|
2804 |
|
|
{
|
2805 |
|
|
const char *name;
|
2806 |
|
|
boolean strip;
|
2807 |
|
|
|
2808 |
|
|
if ((s->flags & SEC_LINKER_CREATED) == 0)
|
2809 |
|
|
continue;
|
2810 |
|
|
|
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);
|
2814 |
|
|
|
2815 |
|
|
strip = false;
|
2816 |
|
|
|
2817 |
|
|
if (strcmp (name, ".plt") == 0)
|
2818 |
|
|
{
|
2819 |
|
|
if (s->_raw_size == 0)
|
2820 |
|
|
{
|
2821 |
|
|
/* Strip this section if we don't need it; see the
|
2822 |
|
|
comment below. */
|
2823 |
|
|
strip = true;
|
2824 |
|
|
}
|
2825 |
|
|
else
|
2826 |
|
|
{
|
2827 |
|
|
/* Remember whether there is a PLT. */
|
2828 |
|
|
plt = true;
|
2829 |
|
|
}
|
2830 |
|
|
}
|
2831 |
|
|
else if (strncmp (name, ".rela", 5) == 0)
|
2832 |
|
|
{
|
2833 |
|
|
if (s->_raw_size == 0)
|
2834 |
|
|
{
|
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. */
|
2844 |
|
|
strip = true;
|
2845 |
|
|
}
|
2846 |
|
|
else
|
2847 |
|
|
{
|
2848 |
|
|
asection *target;
|
2849 |
|
|
|
2850 |
|
|
/* Remember whether there are any reloc sections other
|
2851 |
|
|
than .rela.plt. */
|
2852 |
|
|
if (strcmp (name, ".rela.plt") != 0)
|
2853 |
|
|
{
|
2854 |
|
|
const char *outname;
|
2855 |
|
|
|
2856 |
|
|
relocs = true;
|
2857 |
|
|
|
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,
|
2864 |
|
|
s->output_section);
|
2865 |
|
|
target = bfd_get_section_by_name (output_bfd, outname + 5);
|
2866 |
|
|
if (target != NULL
|
2867 |
|
|
&& (target->flags & SEC_READONLY) != 0
|
2868 |
|
|
&& (target->flags & SEC_ALLOC) != 0)
|
2869 |
|
|
reltext = true;
|
2870 |
|
|
}
|
2871 |
|
|
|
2872 |
|
|
/* We use the reloc_count field as a counter if we need
|
2873 |
|
|
to copy relocs into the output file. */
|
2874 |
|
|
s->reloc_count = 0;
|
2875 |
|
|
}
|
2876 |
|
|
}
|
2877 |
|
|
else if (strncmp (name, ".got", 4) != 0)
|
2878 |
|
|
{
|
2879 |
|
|
/* It's not one of our sections, so don't allocate space. */
|
2880 |
|
|
continue;
|
2881 |
|
|
}
|
2882 |
|
|
|
2883 |
|
|
if (strip)
|
2884 |
|
|
{
|
2885 |
|
|
_bfd_strip_section_from_output (info, s);
|
2886 |
|
|
continue;
|
2887 |
|
|
}
|
2888 |
|
|
|
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)
|
2892 |
|
|
return false;
|
2893 |
|
|
}
|
2894 |
|
|
|
2895 |
|
|
if (elf_hash_table (info)->dynamic_sections_created)
|
2896 |
|
|
{
|
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. */
|
2902 |
|
|
if (! info->shared)
|
2903 |
|
|
{
|
2904 |
|
|
if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
|
2905 |
|
|
return false;
|
2906 |
|
|
}
|
2907 |
|
|
|
2908 |
|
|
if (plt)
|
2909 |
|
|
{
|
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))
|
2914 |
|
|
return false;
|
2915 |
|
|
}
|
2916 |
|
|
|
2917 |
|
|
if (relocs)
|
2918 |
|
|
{
|
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)))
|
2923 |
|
|
return false;
|
2924 |
|
|
}
|
2925 |
|
|
|
2926 |
|
|
if (reltext)
|
2927 |
|
|
{
|
2928 |
|
|
if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
|
2929 |
|
|
return false;
|
2930 |
|
|
}
|
2931 |
|
|
}
|
2932 |
|
|
|
2933 |
|
|
return true;
|
2934 |
|
|
}
|
2935 |
|
|
|
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. */
|
2942 |
|
|
|
2943 |
|
|
static boolean
|
2944 |
|
|
sh_elf_discard_copies (h, ignore)
|
2945 |
|
|
struct elf_sh_link_hash_entry *h;
|
2946 |
|
|
PTR ignore ATTRIBUTE_UNUSED;
|
2947 |
|
|
{
|
2948 |
|
|
struct elf_sh_pcrel_relocs_copied *s;
|
2949 |
|
|
|
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)
|
2952 |
|
|
return true;
|
2953 |
|
|
|
2954 |
|
|
for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
|
2955 |
|
|
s->section->_raw_size -= s->count * sizeof (Elf32_External_Rela);
|
2956 |
|
|
|
2957 |
|
|
return true;
|
2958 |
|
|
}
|
2959 |
|
|
|
2960 |
|
|
/* Relocate an SH ELF section. */
|
2961 |
|
|
|
2962 |
|
|
static boolean
|
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;
|
2967 |
|
|
bfd *input_bfd;
|
2968 |
|
|
asection *input_section;
|
2969 |
|
|
bfd_byte *contents;
|
2970 |
|
|
Elf_Internal_Rela *relocs;
|
2971 |
|
|
Elf_Internal_Sym *local_syms;
|
2972 |
|
|
asection **local_sections;
|
2973 |
|
|
{
|
2974 |
|
|
Elf_Internal_Shdr *symtab_hdr;
|
2975 |
|
|
struct elf_link_hash_entry **sym_hashes;
|
2976 |
|
|
Elf_Internal_Rela *rel, *relend;
|
2977 |
|
|
bfd *dynobj;
|
2978 |
|
|
bfd_vma *local_got_offsets;
|
2979 |
|
|
asection *sgot;
|
2980 |
|
|
asection *splt;
|
2981 |
|
|
asection *sreloc;
|
2982 |
|
|
|
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);
|
2987 |
|
|
|
2988 |
|
|
sgot = NULL;
|
2989 |
|
|
splt = NULL;
|
2990 |
|
|
sreloc = NULL;
|
2991 |
|
|
|
2992 |
|
|
rel = relocs;
|
2993 |
|
|
relend = relocs + input_section->reloc_count;
|
2994 |
|
|
for (; rel < relend; rel++)
|
2995 |
|
|
{
|
2996 |
|
|
int r_type;
|
2997 |
|
|
reloc_howto_type *howto;
|
2998 |
|
|
unsigned long r_symndx;
|
2999 |
|
|
Elf_Internal_Sym *sym;
|
3000 |
|
|
asection *sec;
|
3001 |
|
|
struct elf_link_hash_entry *h;
|
3002 |
|
|
bfd_vma relocation;
|
3003 |
|
|
bfd_vma addend = (bfd_vma) 0;
|
3004 |
|
|
bfd_reloc_status_type r;
|
3005 |
|
|
|
3006 |
|
|
r_symndx = ELF32_R_SYM (rel->r_info);
|
3007 |
|
|
|
3008 |
|
|
r_type = ELF32_R_TYPE (rel->r_info);
|
3009 |
|
|
|
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)
|
3014 |
|
|
continue;
|
3015 |
|
|
if (r_type == (int) R_SH_NONE)
|
3016 |
|
|
continue;
|
3017 |
|
|
|
3018 |
|
|
if (r_type < 0
|
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))
|
3024 |
|
|
{
|
3025 |
|
|
bfd_set_error (bfd_error_bad_value);
|
3026 |
|
|
return false;
|
3027 |
|
|
}
|
3028 |
|
|
|
3029 |
|
|
howto = sh_elf_howto_table + r_type;
|
3030 |
|
|
|
3031 |
|
|
/* This is a final link. */
|
3032 |
|
|
h = NULL;
|
3033 |
|
|
sym = NULL;
|
3034 |
|
|
sec = NULL;
|
3035 |
|
|
if (r_symndx < symtab_hdr->sh_info)
|
3036 |
|
|
{
|
3037 |
|
|
sym = local_syms + r_symndx;
|
3038 |
|
|
sec = local_sections[r_symndx];
|
3039 |
|
|
relocation = (sec->output_section->vma
|
3040 |
|
|
+ sec->output_offset
|
3041 |
|
|
+ sym->st_value);
|
3042 |
|
|
|
3043 |
|
|
if (info->relocateable)
|
3044 |
|
|
{
|
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;
|
3052 |
|
|
|
3053 |
|
|
continue;
|
3054 |
|
|
}
|
3055 |
|
|
}
|
3056 |
|
|
else
|
3057 |
|
|
{
|
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)
|
3062 |
|
|
continue;
|
3063 |
|
|
|
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)
|
3070 |
|
|
{
|
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
|
3080 |
|
|
&& (! info->shared
|
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. */
|
3089 |
|
|
|| (info->shared
|
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
|
3101 |
|
|
with them here. */
|
3102 |
|
|
|| (input_section->flags & SEC_DEBUGGING) != 0)))
|
3103 |
|
|
relocation = 0;
|
3104 |
|
|
else if (sec->output_section == NULL)
|
3105 |
|
|
{
|
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));
|
3110 |
|
|
relocation = 0;
|
3111 |
|
|
}
|
3112 |
|
|
else
|
3113 |
|
|
relocation = (h->root.u.def.value
|
3114 |
|
|
+ sec->output_section->vma
|
3115 |
|
|
+ sec->output_offset);
|
3116 |
|
|
}
|
3117 |
|
|
else if (h->root.type == bfd_link_hash_undefweak)
|
3118 |
|
|
relocation = 0;
|
3119 |
|
|
else if (info->shared && !info->symbolic && !info->no_undefined)
|
3120 |
|
|
relocation = 0;
|
3121 |
|
|
else
|
3122 |
|
|
{
|
3123 |
|
|
if (! ((*info->callbacks->undefined_symbol)
|
3124 |
|
|
(info, h->root.root.string, input_bfd,
|
3125 |
|
|
input_section, rel->r_offset, true)))
|
3126 |
|
|
return false;
|
3127 |
|
|
relocation = 0;
|
3128 |
|
|
}
|
3129 |
|
|
}
|
3130 |
|
|
|
3131 |
|
|
switch ((int) r_type)
|
3132 |
|
|
{
|
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);
|
3139 |
|
|
break;
|
3140 |
|
|
|
3141 |
|
|
case R_SH_IND12W:
|
3142 |
|
|
relocation -= 4;
|
3143 |
|
|
goto final_link_relocate;
|
3144 |
|
|
|
3145 |
|
|
case R_SH_DIR8WPN:
|
3146 |
|
|
case R_SH_DIR8WPZ:
|
3147 |
|
|
case R_SH_DIR8WPL:
|
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
|
3154 |
|
|
!= relocation)
|
3155 |
|
|
{
|
3156 |
|
|
int disp = (relocation
|
3157 |
|
|
- input_section->output_section->vma
|
3158 |
|
|
- input_section->output_offset
|
3159 |
|
|
- rel->r_offset);
|
3160 |
|
|
int mask = 0;
|
3161 |
|
|
switch (r_type)
|
3162 |
|
|
{
|
3163 |
|
|
case R_SH_DIR8WPN:
|
3164 |
|
|
case R_SH_DIR8WPZ: mask = 1; break;
|
3165 |
|
|
case R_SH_DIR8WPL: mask = 3; break;
|
3166 |
|
|
default: mask = 0; break;
|
3167 |
|
|
}
|
3168 |
|
|
if (disp & mask)
|
3169 |
|
|
{
|
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);
|
3175 |
|
|
return false;
|
3176 |
|
|
}
|
3177 |
|
|
relocation -= 4;
|
3178 |
|
|
goto final_link_relocate;
|
3179 |
|
|
}
|
3180 |
|
|
r = bfd_reloc_ok;
|
3181 |
|
|
break;
|
3182 |
|
|
|
3183 |
|
|
default:
|
3184 |
|
|
bfd_set_error (bfd_error_bad_value);
|
3185 |
|
|
return false;
|
3186 |
|
|
|
3187 |
|
|
case R_SH_DIR32:
|
3188 |
|
|
case R_SH_REL32:
|
3189 |
|
|
if (info->shared
|
3190 |
|
|
&& (input_section->flags & SEC_ALLOC) != 0
|
3191 |
|
|
&& (r_type != R_SH_REL32
|
3192 |
|
|
|| (h != NULL
|
3193 |
|
|
&& h->dynindx != -1
|
3194 |
|
|
&& (! info->symbolic
|
3195 |
|
|
|| (h->elf_link_hash_flags
|
3196 |
|
|
& ELF_LINK_HASH_DEF_REGULAR) == 0))))
|
3197 |
|
|
{
|
3198 |
|
|
Elf_Internal_Rela outrel;
|
3199 |
|
|
boolean skip, relocate;
|
3200 |
|
|
|
3201 |
|
|
/* When generating a shared object, these relocations
|
3202 |
|
|
are copied into the output file to be resolved at run
|
3203 |
|
|
time. */
|
3204 |
|
|
|
3205 |
|
|
if (sreloc == NULL)
|
3206 |
|
|
{
|
3207 |
|
|
const char *name;
|
3208 |
|
|
|
3209 |
|
|
name = (bfd_elf_string_from_elf_section
|
3210 |
|
|
(input_bfd,
|
3211 |
|
|
elf_elfheader (input_bfd)->e_shstrndx,
|
3212 |
|
|
elf_section_data (input_section)->rel_hdr.sh_name));
|
3213 |
|
|
if (name == NULL)
|
3214 |
|
|
return false;
|
3215 |
|
|
|
3216 |
|
|
BFD_ASSERT (strncmp (name, ".rela", 5) == 0
|
3217 |
|
|
&& strcmp (bfd_get_section_name (input_bfd,
|
3218 |
|
|
input_section),
|
3219 |
|
|
name + 5) == 0);
|
3220 |
|
|
|
3221 |
|
|
sreloc = bfd_get_section_by_name (dynobj, name);
|
3222 |
|
|
BFD_ASSERT (sreloc != NULL);
|
3223 |
|
|
}
|
3224 |
|
|
|
3225 |
|
|
skip = false;
|
3226 |
|
|
|
3227 |
|
|
if (elf_section_data (input_section)->stab_info == NULL)
|
3228 |
|
|
outrel.r_offset = rel->r_offset;
|
3229 |
|
|
else
|
3230 |
|
|
{
|
3231 |
|
|
bfd_vma off;
|
3232 |
|
|
|
3233 |
|
|
off = (_bfd_stab_section_offset
|
3234 |
|
|
(output_bfd, &elf_hash_table (info)->stab_info,
|
3235 |
|
|
input_section,
|
3236 |
|
|
&elf_section_data (input_section)->stab_info,
|
3237 |
|
|
rel->r_offset));
|
3238 |
|
|
if (off == (bfd_vma) -1)
|
3239 |
|
|
skip = true;
|
3240 |
|
|
outrel.r_offset = off;
|
3241 |
|
|
}
|
3242 |
|
|
|
3243 |
|
|
outrel.r_offset += (input_section->output_section->vma
|
3244 |
|
|
+ input_section->output_offset);
|
3245 |
|
|
|
3246 |
|
|
if (skip)
|
3247 |
|
|
{
|
3248 |
|
|
memset (&outrel, 0, sizeof outrel);
|
3249 |
|
|
relocate = false;
|
3250 |
|
|
}
|
3251 |
|
|
else if (r_type == R_SH_REL32)
|
3252 |
|
|
{
|
3253 |
|
|
BFD_ASSERT (h != NULL && h->dynindx != -1);
|
3254 |
|
|
relocate = false;
|
3255 |
|
|
outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_REL32);
|
3256 |
|
|
outrel.r_addend = rel->r_addend;
|
3257 |
|
|
}
|
3258 |
|
|
else
|
3259 |
|
|
{
|
3260 |
|
|
/* h->dynindx may be -1 if this symbol was marked to
|
3261 |
|
|
become local. */
|
3262 |
|
|
if (h == NULL
|
3263 |
|
|
|| ((info->symbolic || h->dynindx == -1)
|
3264 |
|
|
&& (h->elf_link_hash_flags
|
3265 |
|
|
& ELF_LINK_HASH_DEF_REGULAR) != 0))
|
3266 |
|
|
{
|
3267 |
|
|
relocate = true;
|
3268 |
|
|
outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
|
3269 |
|
|
outrel.r_addend = relocation + rel->r_addend;
|
3270 |
|
|
}
|
3271 |
|
|
else
|
3272 |
|
|
{
|
3273 |
|
|
BFD_ASSERT (h->dynindx != -1);
|
3274 |
|
|
relocate = false;
|
3275 |
|
|
outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_DIR32);
|
3276 |
|
|
outrel.r_addend = relocation + rel->r_addend;
|
3277 |
|
|
}
|
3278 |
|
|
}
|
3279 |
|
|
|
3280 |
|
|
bfd_elf32_swap_reloca_out (output_bfd, &outrel,
|
3281 |
|
|
(((Elf32_External_Rela *)
|
3282 |
|
|
sreloc->contents)
|
3283 |
|
|
+ sreloc->reloc_count));
|
3284 |
|
|
++sreloc->reloc_count;
|
3285 |
|
|
|
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. */
|
3290 |
|
|
if (! relocate)
|
3291 |
|
|
continue;
|
3292 |
|
|
}
|
3293 |
|
|
else if (r_type == R_SH_DIR32)
|
3294 |
|
|
addend = rel->r_addend;
|
3295 |
|
|
goto final_link_relocate;
|
3296 |
|
|
|
3297 |
|
|
case R_SH_GOT32:
|
3298 |
|
|
/* Relocation is to the entry for this symbol in the global
|
3299 |
|
|
offset table. */
|
3300 |
|
|
if (sgot == NULL)
|
3301 |
|
|
{
|
3302 |
|
|
sgot = bfd_get_section_by_name (dynobj, ".got");
|
3303 |
|
|
BFD_ASSERT (sgot != NULL);
|
3304 |
|
|
}
|
3305 |
|
|
|
3306 |
|
|
if (h != NULL)
|
3307 |
|
|
{
|
3308 |
|
|
bfd_vma off;
|
3309 |
|
|
|
3310 |
|
|
off = h->got.offset;
|
3311 |
|
|
BFD_ASSERT (off != (bfd_vma) -1);
|
3312 |
|
|
|
3313 |
|
|
if (! elf_hash_table (info)->dynamic_sections_created
|
3314 |
|
|
|| (info->shared
|
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)))
|
3319 |
|
|
{
|
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.
|
3328 |
|
|
|
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. */
|
3332 |
|
|
if ((off & 1) != 0)
|
3333 |
|
|
off &= ~1;
|
3334 |
|
|
else
|
3335 |
|
|
{
|
3336 |
|
|
bfd_put_32 (output_bfd, relocation,
|
3337 |
|
|
sgot->contents + off);
|
3338 |
|
|
h->got.offset |= 1;
|
3339 |
|
|
}
|
3340 |
|
|
}
|
3341 |
|
|
|
3342 |
|
|
relocation = sgot->output_offset + off;
|
3343 |
|
|
}
|
3344 |
|
|
else
|
3345 |
|
|
{
|
3346 |
|
|
bfd_vma off;
|
3347 |
|
|
|
3348 |
|
|
BFD_ASSERT (local_got_offsets != NULL
|
3349 |
|
|
&& local_got_offsets[r_symndx] != (bfd_vma) -1);
|
3350 |
|
|
|
3351 |
|
|
off = local_got_offsets[r_symndx];
|
3352 |
|
|
|
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. */
|
3356 |
|
|
if ((off & 1) != 0)
|
3357 |
|
|
off &= ~1;
|
3358 |
|
|
else
|
3359 |
|
|
{
|
3360 |
|
|
bfd_put_32 (output_bfd, relocation, sgot->contents + off);
|
3361 |
|
|
|
3362 |
|
|
if (info->shared)
|
3363 |
|
|
{
|
3364 |
|
|
asection *srelgot;
|
3365 |
|
|
Elf_Internal_Rela outrel;
|
3366 |
|
|
|
3367 |
|
|
srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
|
3368 |
|
|
BFD_ASSERT (srelgot != NULL);
|
3369 |
|
|
|
3370 |
|
|
outrel.r_offset = (sgot->output_section->vma
|
3371 |
|
|
+ sgot->output_offset
|
3372 |
|
|
+ off);
|
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 *)
|
3377 |
|
|
srelgot->contents)
|
3378 |
|
|
+ srelgot->reloc_count));
|
3379 |
|
|
++srelgot->reloc_count;
|
3380 |
|
|
}
|
3381 |
|
|
|
3382 |
|
|
local_got_offsets[r_symndx] |= 1;
|
3383 |
|
|
}
|
3384 |
|
|
|
3385 |
|
|
relocation = sgot->output_offset + off;
|
3386 |
|
|
}
|
3387 |
|
|
|
3388 |
|
|
goto final_link_relocate;
|
3389 |
|
|
|
3390 |
|
|
case R_SH_GOTOFF:
|
3391 |
|
|
/* Relocation is relative to the start of the global offset
|
3392 |
|
|
table. */
|
3393 |
|
|
|
3394 |
|
|
if (sgot == NULL)
|
3395 |
|
|
{
|
3396 |
|
|
sgot = bfd_get_section_by_name (dynobj, ".got");
|
3397 |
|
|
BFD_ASSERT (sgot != NULL);
|
3398 |
|
|
}
|
3399 |
|
|
|
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
|
3404 |
|
|
calculation. */
|
3405 |
|
|
relocation -= sgot->output_section->vma;
|
3406 |
|
|
|
3407 |
|
|
goto final_link_relocate;
|
3408 |
|
|
|
3409 |
|
|
case R_SH_GOTPC:
|
3410 |
|
|
/* Use global offset table as symbol value. */
|
3411 |
|
|
|
3412 |
|
|
if (sgot == NULL)
|
3413 |
|
|
{
|
3414 |
|
|
sgot = bfd_get_section_by_name (dynobj, ".got");
|
3415 |
|
|
BFD_ASSERT (sgot != NULL);
|
3416 |
|
|
}
|
3417 |
|
|
|
3418 |
|
|
relocation = sgot->output_section->vma;
|
3419 |
|
|
|
3420 |
|
|
goto final_link_relocate;
|
3421 |
|
|
|
3422 |
|
|
case R_SH_PLT32:
|
3423 |
|
|
/* Relocation is to the entry for this symbol in the
|
3424 |
|
|
procedure linkage table. */
|
3425 |
|
|
|
3426 |
|
|
/* Resolve a PLT reloc against a local symbol directly,
|
3427 |
|
|
without using the procedure linkage table. */
|
3428 |
|
|
if (h == NULL)
|
3429 |
|
|
goto final_link_relocate;
|
3430 |
|
|
|
3431 |
|
|
if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
|
3432 |
|
|
|| ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
|
3433 |
|
|
goto final_link_relocate;
|
3434 |
|
|
|
3435 |
|
|
if (h->plt.offset == (bfd_vma) -1)
|
3436 |
|
|
{
|
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;
|
3441 |
|
|
}
|
3442 |
|
|
|
3443 |
|
|
if (splt == NULL)
|
3444 |
|
|
{
|
3445 |
|
|
splt = bfd_get_section_by_name (dynobj, ".plt");
|
3446 |
|
|
BFD_ASSERT (splt != NULL);
|
3447 |
|
|
}
|
3448 |
|
|
|
3449 |
|
|
relocation = (splt->output_section->vma
|
3450 |
|
|
+ splt->output_offset
|
3451 |
|
|
+ h->plt.offset);
|
3452 |
|
|
|
3453 |
|
|
goto final_link_relocate;
|
3454 |
|
|
|
3455 |
|
|
case R_SH_LOOP_START:
|
3456 |
|
|
{
|
3457 |
|
|
static bfd_vma start, end;
|
3458 |
|
|
|
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);
|
3463 |
|
|
break;
|
3464 |
|
|
|
3465 |
|
|
case R_SH_LOOP_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);
|
3470 |
|
|
break;
|
3471 |
|
|
}
|
3472 |
|
|
}
|
3473 |
|
|
|
3474 |
|
|
if (r != bfd_reloc_ok)
|
3475 |
|
|
{
|
3476 |
|
|
switch (r)
|
3477 |
|
|
{
|
3478 |
|
|
default:
|
3479 |
|
|
case bfd_reloc_outofrange:
|
3480 |
|
|
abort ();
|
3481 |
|
|
case bfd_reloc_overflow:
|
3482 |
|
|
{
|
3483 |
|
|
const char *name;
|
3484 |
|
|
|
3485 |
|
|
if (h != NULL)
|
3486 |
|
|
name = h->root.root.string;
|
3487 |
|
|
else
|
3488 |
|
|
{
|
3489 |
|
|
name = (bfd_elf_string_from_elf_section
|
3490 |
|
|
(input_bfd, symtab_hdr->sh_link, sym->st_name));
|
3491 |
|
|
if (name == NULL)
|
3492 |
|
|
return false;
|
3493 |
|
|
if (*name == '\0')
|
3494 |
|
|
name = bfd_section_name (input_bfd, sec);
|
3495 |
|
|
}
|
3496 |
|
|
if (! ((*info->callbacks->reloc_overflow)
|
3497 |
|
|
(info, name, howto->name, (bfd_vma) 0,
|
3498 |
|
|
input_bfd, input_section, rel->r_offset)))
|
3499 |
|
|
return false;
|
3500 |
|
|
}
|
3501 |
|
|
break;
|
3502 |
|
|
}
|
3503 |
|
|
}
|
3504 |
|
|
}
|
3505 |
|
|
|
3506 |
|
|
return true;
|
3507 |
|
|
}
|
3508 |
|
|
|
3509 |
|
|
/* This is a version of bfd_generic_get_relocated_section_contents
|
3510 |
|
|
which uses sh_elf_relocate_section. */
|
3511 |
|
|
|
3512 |
|
|
static bfd_byte *
|
3513 |
|
|
sh_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
|
3514 |
|
|
data, relocateable, symbols)
|
3515 |
|
|
bfd *output_bfd;
|
3516 |
|
|
struct bfd_link_info *link_info;
|
3517 |
|
|
struct bfd_link_order *link_order;
|
3518 |
|
|
bfd_byte *data;
|
3519 |
|
|
boolean relocateable;
|
3520 |
|
|
asymbol **symbols;
|
3521 |
|
|
{
|
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;
|
3529 |
|
|
|
3530 |
|
|
/* We only need to handle the case of relaxing, or of having a
|
3531 |
|
|
particular set of section contents, specially. */
|
3532 |
|
|
if (relocateable
|
3533 |
|
|
|| elf_section_data (input_section)->this_hdr.contents == NULL)
|
3534 |
|
|
return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
|
3535 |
|
|
link_order, data,
|
3536 |
|
|
relocateable,
|
3537 |
|
|
symbols);
|
3538 |
|
|
|
3539 |
|
|
symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
|
3540 |
|
|
|
3541 |
|
|
memcpy (data, elf_section_data (input_section)->this_hdr.contents,
|
3542 |
|
|
input_section->_raw_size);
|
3543 |
|
|
|
3544 |
|
|
if ((input_section->flags & SEC_RELOC) != 0
|
3545 |
|
|
&& input_section->reloc_count > 0)
|
3546 |
|
|
{
|
3547 |
|
|
Elf_Internal_Sym *isymp;
|
3548 |
|
|
asection **secpp;
|
3549 |
|
|
Elf32_External_Sym *esym, *esymend;
|
3550 |
|
|
|
3551 |
|
|
if (symtab_hdr->contents != NULL)
|
3552 |
|
|
external_syms = (Elf32_External_Sym *) symtab_hdr->contents;
|
3553 |
|
|
else
|
3554 |
|
|
{
|
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)
|
3559 |
|
|
goto error_return;
|
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))))
|
3564 |
|
|
goto error_return;
|
3565 |
|
|
}
|
3566 |
|
|
|
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)
|
3571 |
|
|
goto error_return;
|
3572 |
|
|
|
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)
|
3577 |
|
|
goto error_return;
|
3578 |
|
|
|
3579 |
|
|
sections = (asection **) bfd_malloc (symtab_hdr->sh_info
|
3580 |
|
|
* sizeof (asection *));
|
3581 |
|
|
if (sections == NULL && symtab_hdr->sh_info > 0)
|
3582 |
|
|
goto error_return;
|
3583 |
|
|
|
3584 |
|
|
isymp = internal_syms;
|
3585 |
|
|
secpp = sections;
|
3586 |
|
|
esym = external_syms;
|
3587 |
|
|
esymend = esym + symtab_hdr->sh_info;
|
3588 |
|
|
for (; esym < esymend; ++esym, ++isymp, ++secpp)
|
3589 |
|
|
{
|
3590 |
|
|
asection *isec;
|
3591 |
|
|
|
3592 |
|
|
bfd_elf32_swap_symbol_in (input_bfd, esym, isymp);
|
3593 |
|
|
|
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;
|
3602 |
|
|
else
|
3603 |
|
|
{
|
3604 |
|
|
/* Who knows? */
|
3605 |
|
|
isec = NULL;
|
3606 |
|
|
}
|
3607 |
|
|
|
3608 |
|
|
*secpp = isec;
|
3609 |
|
|
}
|
3610 |
|
|
|
3611 |
|
|
if (! sh_elf_relocate_section (output_bfd, link_info, input_bfd,
|
3612 |
|
|
input_section, data, internal_relocs,
|
3613 |
|
|
internal_syms, sections))
|
3614 |
|
|
goto error_return;
|
3615 |
|
|
|
3616 |
|
|
if (sections != NULL)
|
3617 |
|
|
free (sections);
|
3618 |
|
|
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;
|
3628 |
|
|
}
|
3629 |
|
|
|
3630 |
|
|
return data;
|
3631 |
|
|
|
3632 |
|
|
error_return:
|
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)
|
3641 |
|
|
free (sections);
|
3642 |
|
|
return NULL;
|
3643 |
|
|
}
|
3644 |
|
|
static asection *
|
3645 |
|
|
sh_elf_gc_mark_hook (abfd, info, rel, h, sym)
|
3646 |
|
|
bfd *abfd;
|
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;
|
3651 |
|
|
{
|
3652 |
|
|
if (h != NULL)
|
3653 |
|
|
{
|
3654 |
|
|
switch (ELF32_R_TYPE (rel->r_info))
|
3655 |
|
|
{
|
3656 |
|
|
case R_SH_GNU_VTINHERIT:
|
3657 |
|
|
case R_SH_GNU_VTENTRY:
|
3658 |
|
|
break;
|
3659 |
|
|
|
3660 |
|
|
default:
|
3661 |
|
|
switch (h->root.type)
|
3662 |
|
|
{
|
3663 |
|
|
case bfd_link_hash_defined:
|
3664 |
|
|
case bfd_link_hash_defweak:
|
3665 |
|
|
return h->root.u.def.section;
|
3666 |
|
|
|
3667 |
|
|
case bfd_link_hash_common:
|
3668 |
|
|
return h->root.u.c.p->section;
|
3669 |
|
|
|
3670 |
|
|
default:
|
3671 |
|
|
break;
|
3672 |
|
|
}
|
3673 |
|
|
}
|
3674 |
|
|
}
|
3675 |
|
|
else
|
3676 |
|
|
{
|
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);
|
3682 |
|
|
}
|
3683 |
|
|
return NULL;
|
3684 |
|
|
}
|
3685 |
|
|
|
3686 |
|
|
/* Update the got entry reference counts for the section being removed. */
|
3687 |
|
|
|
3688 |
|
|
static boolean
|
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;
|
3694 |
|
|
{
|
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. */
|
3699 |
|
|
return true;
|
3700 |
|
|
}
|
3701 |
|
|
|
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. */
|
3705 |
|
|
|
3706 |
|
|
static boolean
|
3707 |
|
|
sh_elf_check_relocs (abfd, info, sec, relocs)
|
3708 |
|
|
bfd *abfd;
|
3709 |
|
|
struct bfd_link_info *info;
|
3710 |
|
|
asection *sec;
|
3711 |
|
|
const Elf_Internal_Rela *relocs;
|
3712 |
|
|
{
|
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;
|
3717 |
|
|
bfd *dynobj;
|
3718 |
|
|
bfd_vma *local_got_offsets;
|
3719 |
|
|
asection *sgot;
|
3720 |
|
|
asection *srelgot;
|
3721 |
|
|
asection *sreloc;
|
3722 |
|
|
|
3723 |
|
|
sgot = NULL;
|
3724 |
|
|
srelgot = NULL;
|
3725 |
|
|
sreloc = NULL;
|
3726 |
|
|
|
3727 |
|
|
if (info->relocateable)
|
3728 |
|
|
return true;
|
3729 |
|
|
|
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;
|
3735 |
|
|
|
3736 |
|
|
dynobj = elf_hash_table (info)->dynobj;
|
3737 |
|
|
local_got_offsets = elf_local_got_offsets (abfd);
|
3738 |
|
|
|
3739 |
|
|
rel_end = relocs + sec->reloc_count;
|
3740 |
|
|
for (rel = relocs; rel < rel_end; rel++)
|
3741 |
|
|
{
|
3742 |
|
|
struct elf_link_hash_entry *h;
|
3743 |
|
|
unsigned long r_symndx;
|
3744 |
|
|
|
3745 |
|
|
r_symndx = ELF32_R_SYM (rel->r_info);
|
3746 |
|
|
if (r_symndx < symtab_hdr->sh_info)
|
3747 |
|
|
h = NULL;
|
3748 |
|
|
else
|
3749 |
|
|
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
|
3750 |
|
|
|
3751 |
|
|
/* Some relocs require a global offset table. */
|
3752 |
|
|
if (dynobj == NULL)
|
3753 |
|
|
{
|
3754 |
|
|
switch (ELF32_R_TYPE (rel->r_info))
|
3755 |
|
|
{
|
3756 |
|
|
case R_SH_GOT32:
|
3757 |
|
|
case R_SH_GOTOFF:
|
3758 |
|
|
case R_SH_GOTPC:
|
3759 |
|
|
elf_hash_table (info)->dynobj = dynobj = abfd;
|
3760 |
|
|
if (! _bfd_elf_create_got_section (dynobj, info))
|
3761 |
|
|
return false;
|
3762 |
|
|
break;
|
3763 |
|
|
|
3764 |
|
|
default:
|
3765 |
|
|
break;
|
3766 |
|
|
}
|
3767 |
|
|
}
|
3768 |
|
|
|
3769 |
|
|
switch (ELF32_R_TYPE (rel->r_info))
|
3770 |
|
|
{
|
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))
|
3775 |
|
|
return false;
|
3776 |
|
|
break;
|
3777 |
|
|
|
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))
|
3782 |
|
|
return false;
|
3783 |
|
|
break;
|
3784 |
|
|
|
3785 |
|
|
case R_SH_GOT32:
|
3786 |
|
|
/* This symbol requires a global offset table entry. */
|
3787 |
|
|
|
3788 |
|
|
if (sgot == NULL)
|
3789 |
|
|
{
|
3790 |
|
|
sgot = bfd_get_section_by_name (dynobj, ".got");
|
3791 |
|
|
BFD_ASSERT (sgot != NULL);
|
3792 |
|
|
}
|
3793 |
|
|
|
3794 |
|
|
if (srelgot == NULL
|
3795 |
|
|
&& (h != NULL || info->shared))
|
3796 |
|
|
{
|
3797 |
|
|
srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
|
3798 |
|
|
if (srelgot == NULL)
|
3799 |
|
|
{
|
3800 |
|
|
srelgot = bfd_make_section (dynobj, ".rela.got");
|
3801 |
|
|
if (srelgot == NULL
|
3802 |
|
|
|| ! bfd_set_section_flags (dynobj, srelgot,
|
3803 |
|
|
(SEC_ALLOC
|
3804 |
|
|
| SEC_LOAD
|
3805 |
|
|
| SEC_HAS_CONTENTS
|
3806 |
|
|
| SEC_IN_MEMORY
|
3807 |
|
|
| SEC_LINKER_CREATED
|
3808 |
|
|
| SEC_READONLY))
|
3809 |
|
|
|| ! bfd_set_section_alignment (dynobj, srelgot, 2))
|
3810 |
|
|
return false;
|
3811 |
|
|
}
|
3812 |
|
|
}
|
3813 |
|
|
|
3814 |
|
|
if (h != NULL)
|
3815 |
|
|
{
|
3816 |
|
|
if (h->got.offset != (bfd_vma) -1)
|
3817 |
|
|
{
|
3818 |
|
|
/* We have already allocated space in the .got. */
|
3819 |
|
|
break;
|
3820 |
|
|
}
|
3821 |
|
|
h->got.offset = sgot->_raw_size;
|
3822 |
|
|
|
3823 |
|
|
/* Make sure this symbol is output as a dynamic symbol. */
|
3824 |
|
|
if (h->dynindx == -1)
|
3825 |
|
|
{
|
3826 |
|
|
if (! bfd_elf32_link_record_dynamic_symbol (info, h))
|
3827 |
|
|
return false;
|
3828 |
|
|
}
|
3829 |
|
|
|
3830 |
|
|
srelgot->_raw_size += sizeof (Elf32_External_Rela);
|
3831 |
|
|
}
|
3832 |
|
|
else
|
3833 |
|
|
{
|
3834 |
|
|
/* This is a global offset table entry for a local
|
3835 |
|
|
symbol. */
|
3836 |
|
|
if (local_got_offsets == NULL)
|
3837 |
|
|
{
|
3838 |
|
|
size_t size;
|
3839 |
|
|
register unsigned int i;
|
3840 |
|
|
|
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)
|
3844 |
|
|
return false;
|
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;
|
3848 |
|
|
}
|
3849 |
|
|
if (local_got_offsets[r_symndx] != (bfd_vma) -1)
|
3850 |
|
|
{
|
3851 |
|
|
/* We have already allocated space in the .got. */
|
3852 |
|
|
break;
|
3853 |
|
|
}
|
3854 |
|
|
local_got_offsets[r_symndx] = sgot->_raw_size;
|
3855 |
|
|
|
3856 |
|
|
if (info->shared)
|
3857 |
|
|
{
|
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);
|
3862 |
|
|
}
|
3863 |
|
|
}
|
3864 |
|
|
|
3865 |
|
|
sgot->_raw_size += 4;
|
3866 |
|
|
|
3867 |
|
|
break;
|
3868 |
|
|
|
3869 |
|
|
case R_SH_PLT32:
|
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
|
3875 |
|
|
after all. */
|
3876 |
|
|
|
3877 |
|
|
/* If this is a local symbol, we resolve it directly without
|
3878 |
|
|
creating a procedure linkage table entry. */
|
3879 |
|
|
if (h == NULL)
|
3880 |
|
|
continue;
|
3881 |
|
|
|
3882 |
|
|
if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
|
3883 |
|
|
|| ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
|
3884 |
|
|
break;
|
3885 |
|
|
|
3886 |
|
|
h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
|
3887 |
|
|
|
3888 |
|
|
break;
|
3889 |
|
|
|
3890 |
|
|
case R_SH_DIR32:
|
3891 |
|
|
case R_SH_REL32:
|
3892 |
|
|
if (h != NULL)
|
3893 |
|
|
h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
|
3894 |
|
|
|
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. */
|
3907 |
|
|
if (info->shared
|
3908 |
|
|
&& (sec->flags & SEC_ALLOC) != 0
|
3909 |
|
|
&& (ELF32_R_TYPE (rel->r_info) != R_SH_REL32
|
3910 |
|
|
|| (h != NULL
|
3911 |
|
|
&& (! info->symbolic
|
3912 |
|
|
|| (h->elf_link_hash_flags
|
3913 |
|
|
& ELF_LINK_HASH_DEF_REGULAR) == 0))))
|
3914 |
|
|
{
|
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. */
|
3918 |
|
|
if (sreloc == NULL)
|
3919 |
|
|
{
|
3920 |
|
|
const char *name;
|
3921 |
|
|
|
3922 |
|
|
name = (bfd_elf_string_from_elf_section
|
3923 |
|
|
(abfd,
|
3924 |
|
|
elf_elfheader (abfd)->e_shstrndx,
|
3925 |
|
|
elf_section_data (sec)->rel_hdr.sh_name));
|
3926 |
|
|
if (name == NULL)
|
3927 |
|
|
return false;
|
3928 |
|
|
|
3929 |
|
|
BFD_ASSERT (strncmp (name, ".rela", 5) == 0
|
3930 |
|
|
&& strcmp (bfd_get_section_name (abfd, sec),
|
3931 |
|
|
name + 5) == 0);
|
3932 |
|
|
|
3933 |
|
|
sreloc = bfd_get_section_by_name (dynobj, name);
|
3934 |
|
|
if (sreloc == NULL)
|
3935 |
|
|
{
|
3936 |
|
|
flagword flags;
|
3937 |
|
|
|
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;
|
3943 |
|
|
if (sreloc == NULL
|
3944 |
|
|
|| ! bfd_set_section_flags (dynobj, sreloc, flags)
|
3945 |
|
|
|| ! bfd_set_section_alignment (dynobj, sreloc, 2))
|
3946 |
|
|
return false;
|
3947 |
|
|
}
|
3948 |
|
|
}
|
3949 |
|
|
|
3950 |
|
|
sreloc->_raw_size += sizeof (Elf32_External_Rela);
|
3951 |
|
|
|
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)
|
3962 |
|
|
{
|
3963 |
|
|
struct elf_sh_link_hash_entry *eh;
|
3964 |
|
|
struct elf_sh_pcrel_relocs_copied *p;
|
3965 |
|
|
|
3966 |
|
|
eh = (struct elf_sh_link_hash_entry *) h;
|
3967 |
|
|
|
3968 |
|
|
for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
|
3969 |
|
|
if (p->section == sreloc)
|
3970 |
|
|
break;
|
3971 |
|
|
|
3972 |
|
|
if (p == NULL)
|
3973 |
|
|
{
|
3974 |
|
|
p = ((struct elf_sh_pcrel_relocs_copied *)
|
3975 |
|
|
bfd_alloc (dynobj, sizeof *p));
|
3976 |
|
|
if (p == NULL)
|
3977 |
|
|
return false;
|
3978 |
|
|
p->next = eh->pcrel_relocs_copied;
|
3979 |
|
|
eh->pcrel_relocs_copied = p;
|
3980 |
|
|
p->section = sreloc;
|
3981 |
|
|
p->count = 0;
|
3982 |
|
|
}
|
3983 |
|
|
|
3984 |
|
|
++p->count;
|
3985 |
|
|
}
|
3986 |
|
|
}
|
3987 |
|
|
|
3988 |
|
|
break;
|
3989 |
|
|
}
|
3990 |
|
|
}
|
3991 |
|
|
|
3992 |
|
|
return true;
|
3993 |
|
|
}
|
3994 |
|
|
|
3995 |
|
|
static boolean
|
3996 |
|
|
sh_elf_set_mach_from_flags (abfd)
|
3997 |
|
|
bfd *abfd;
|
3998 |
|
|
{
|
3999 |
|
|
flagword flags = elf_elfheader (abfd)->e_flags;
|
4000 |
|
|
|
4001 |
|
|
switch (flags & EF_SH_MACH_MASK)
|
4002 |
|
|
{
|
4003 |
|
|
case EF_SH1:
|
4004 |
|
|
bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh);
|
4005 |
|
|
break;
|
4006 |
|
|
case EF_SH2:
|
4007 |
|
|
bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh2);
|
4008 |
|
|
break;
|
4009 |
|
|
case EF_SH_DSP:
|
4010 |
|
|
bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh_dsp);
|
4011 |
|
|
break;
|
4012 |
|
|
case EF_SH3:
|
4013 |
|
|
bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3);
|
4014 |
|
|
break;
|
4015 |
|
|
case EF_SH3_DSP:
|
4016 |
|
|
bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3_dsp);
|
4017 |
|
|
break;
|
4018 |
|
|
case EF_SH3E:
|
4019 |
|
|
bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3e);
|
4020 |
|
|
break;
|
4021 |
|
|
case EF_SH_UNKNOWN:
|
4022 |
|
|
case EF_SH4:
|
4023 |
|
|
bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh4);
|
4024 |
|
|
break;
|
4025 |
|
|
default:
|
4026 |
|
|
return false;
|
4027 |
|
|
}
|
4028 |
|
|
return true;
|
4029 |
|
|
}
|
4030 |
|
|
|
4031 |
|
|
/* Function to keep SH specific file flags. */
|
4032 |
|
|
|
4033 |
|
|
static boolean
|
4034 |
|
|
sh_elf_set_private_flags (abfd, flags)
|
4035 |
|
|
bfd *abfd;
|
4036 |
|
|
flagword flags;
|
4037 |
|
|
{
|
4038 |
|
|
BFD_ASSERT (! elf_flags_init (abfd)
|
4039 |
|
|
|| elf_elfheader (abfd)->e_flags == flags);
|
4040 |
|
|
|
4041 |
|
|
elf_elfheader (abfd)->e_flags = flags;
|
4042 |
|
|
elf_flags_init (abfd) = true;
|
4043 |
|
|
return sh_elf_set_mach_from_flags (abfd);
|
4044 |
|
|
}
|
4045 |
|
|
|
4046 |
|
|
/* Copy backend specific data from one object module to another */
|
4047 |
|
|
|
4048 |
|
|
static boolean
|
4049 |
|
|
sh_elf_copy_private_data (ibfd, obfd)
|
4050 |
|
|
bfd * ibfd;
|
4051 |
|
|
bfd * obfd;
|
4052 |
|
|
{
|
4053 |
|
|
if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|
4054 |
|
|
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
|
4055 |
|
|
return true;
|
4056 |
|
|
|
4057 |
|
|
return sh_elf_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags);
|
4058 |
|
|
}
|
4059 |
|
|
|
4060 |
|
|
/* This routine checks for linking big and little endian objects
|
4061 |
|
|
together, and for linking sh-dsp with sh3e / sh4 objects. */
|
4062 |
|
|
|
4063 |
|
|
static boolean
|
4064 |
|
|
sh_elf_merge_private_data (ibfd, obfd)
|
4065 |
|
|
bfd *ibfd;
|
4066 |
|
|
bfd *obfd;
|
4067 |
|
|
{
|
4068 |
|
|
flagword old_flags, new_flags;
|
4069 |
|
|
|
4070 |
|
|
if (_bfd_generic_verify_endian_match (ibfd, obfd) == false)
|
4071 |
|
|
return false;
|
4072 |
|
|
|
4073 |
|
|
if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|
4074 |
|
|
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
|
4075 |
|
|
return true;
|
4076 |
|
|
|
4077 |
|
|
if (! elf_flags_init (obfd))
|
4078 |
|
|
{
|
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;
|
4082 |
|
|
}
|
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)))
|
4087 |
|
|
{
|
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);
|
4094 |
|
|
return false;
|
4095 |
|
|
}
|
4096 |
|
|
elf_elfheader (obfd)->e_flags = EF_SH_MERGE_MACH (old_flags, new_flags);
|
4097 |
|
|
|
4098 |
|
|
return sh_elf_set_mach_from_flags (obfd);
|
4099 |
|
|
}
|
4100 |
|
|
|
4101 |
|
|
/* Finish up dynamic symbol handling. We set the contents of various
|
4102 |
|
|
dynamic sections here. */
|
4103 |
|
|
|
4104 |
|
|
static boolean
|
4105 |
|
|
sh_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
|
4106 |
|
|
bfd *output_bfd;
|
4107 |
|
|
struct bfd_link_info *info;
|
4108 |
|
|
struct elf_link_hash_entry *h;
|
4109 |
|
|
Elf_Internal_Sym *sym;
|
4110 |
|
|
{
|
4111 |
|
|
bfd *dynobj;
|
4112 |
|
|
|
4113 |
|
|
dynobj = elf_hash_table (info)->dynobj;
|
4114 |
|
|
|
4115 |
|
|
if (h->plt.offset != (bfd_vma) -1)
|
4116 |
|
|
{
|
4117 |
|
|
asection *splt;
|
4118 |
|
|
asection *sgot;
|
4119 |
|
|
asection *srel;
|
4120 |
|
|
|
4121 |
|
|
bfd_vma plt_index;
|
4122 |
|
|
bfd_vma got_offset;
|
4123 |
|
|
Elf_Internal_Rela rel;
|
4124 |
|
|
|
4125 |
|
|
/* This symbol has an entry in the procedure linkage table. Set
|
4126 |
|
|
it up. */
|
4127 |
|
|
|
4128 |
|
|
BFD_ASSERT (h->dynindx != -1);
|
4129 |
|
|
|
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);
|
4134 |
|
|
|
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;
|
4140 |
|
|
|
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;
|
4145 |
|
|
|
4146 |
|
|
/* Fill in the entry in the procedure linkage table. */
|
4147 |
|
|
if (! info->shared)
|
4148 |
|
|
{
|
4149 |
|
|
if (elf_sh_plt_entry == NULL)
|
4150 |
|
|
{
|
4151 |
|
|
elf_sh_plt_entry = (bfd_big_endian (output_bfd) ?
|
4152 |
|
|
elf_sh_plt_entry_be : elf_sh_plt_entry_le);
|
4153 |
|
|
}
|
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
|
4159 |
|
|
+ got_offset),
|
4160 |
|
|
(splt->contents + h->plt.offset
|
4161 |
|
|
+ elf_sh_plt_symbol_offset (info)));
|
4162 |
|
|
|
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)));
|
4167 |
|
|
}
|
4168 |
|
|
else
|
4169 |
|
|
{
|
4170 |
|
|
if (elf_sh_pic_plt_entry == NULL)
|
4171 |
|
|
{
|
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);
|
4175 |
|
|
}
|
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)));
|
4181 |
|
|
}
|
4182 |
|
|
|
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)));
|
4186 |
|
|
|
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
|
4191 |
|
|
+ h->plt.offset
|
4192 |
|
|
+ elf_sh_plt_temp_offset (info)),
|
4193 |
|
|
sgot->contents + got_offset);
|
4194 |
|
|
|
4195 |
|
|
/* Fill in the entry in the .rela.plt section. */
|
4196 |
|
|
rel.r_offset = (sgot->output_section->vma
|
4197 |
|
|
+ sgot->output_offset
|
4198 |
|
|
+ got_offset);
|
4199 |
|
|
rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_JMP_SLOT);
|
4200 |
|
|
rel.r_addend = 0;
|
4201 |
|
|
bfd_elf32_swap_reloca_out (output_bfd, &rel,
|
4202 |
|
|
((Elf32_External_Rela *) srel->contents
|
4203 |
|
|
+ plt_index));
|
4204 |
|
|
|
4205 |
|
|
if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
|
4206 |
|
|
{
|
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;
|
4210 |
|
|
}
|
4211 |
|
|
}
|
4212 |
|
|
|
4213 |
|
|
if (h->got.offset != (bfd_vma) -1)
|
4214 |
|
|
{
|
4215 |
|
|
asection *sgot;
|
4216 |
|
|
asection *srel;
|
4217 |
|
|
Elf_Internal_Rela rel;
|
4218 |
|
|
|
4219 |
|
|
/* This symbol has an entry in the global offset table. Set it
|
4220 |
|
|
up. */
|
4221 |
|
|
|
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);
|
4225 |
|
|
|
4226 |
|
|
rel.r_offset = (sgot->output_section->vma
|
4227 |
|
|
+ sgot->output_offset
|
4228 |
|
|
+ (h->got.offset &~ 1));
|
4229 |
|
|
|
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. */
|
4235 |
|
|
if (info->shared
|
4236 |
|
|
&& (info->symbolic || h->dynindx == -1)
|
4237 |
|
|
&& (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
|
4238 |
|
|
{
|
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);
|
4243 |
|
|
}
|
4244 |
|
|
else
|
4245 |
|
|
{
|
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);
|
4248 |
|
|
rel.r_addend = 0;
|
4249 |
|
|
}
|
4250 |
|
|
|
4251 |
|
|
bfd_elf32_swap_reloca_out (output_bfd, &rel,
|
4252 |
|
|
((Elf32_External_Rela *) srel->contents
|
4253 |
|
|
+ srel->reloc_count));
|
4254 |
|
|
++srel->reloc_count;
|
4255 |
|
|
}
|
4256 |
|
|
|
4257 |
|
|
if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
|
4258 |
|
|
{
|
4259 |
|
|
asection *s;
|
4260 |
|
|
Elf_Internal_Rela rel;
|
4261 |
|
|
|
4262 |
|
|
/* This symbol needs a copy reloc. Set it up. */
|
4263 |
|
|
|
4264 |
|
|
BFD_ASSERT (h->dynindx != -1
|
4265 |
|
|
&& (h->root.type == bfd_link_hash_defined
|
4266 |
|
|
|| h->root.type == bfd_link_hash_defweak));
|
4267 |
|
|
|
4268 |
|
|
s = bfd_get_section_by_name (h->root.u.def.section->owner,
|
4269 |
|
|
".rela.bss");
|
4270 |
|
|
BFD_ASSERT (s != NULL);
|
4271 |
|
|
|
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);
|
4276 |
|
|
rel.r_addend = 0;
|
4277 |
|
|
bfd_elf32_swap_reloca_out (output_bfd, &rel,
|
4278 |
|
|
((Elf32_External_Rela *) s->contents
|
4279 |
|
|
+ s->reloc_count));
|
4280 |
|
|
++s->reloc_count;
|
4281 |
|
|
}
|
4282 |
|
|
|
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;
|
4287 |
|
|
|
4288 |
|
|
return true;
|
4289 |
|
|
}
|
4290 |
|
|
|
4291 |
|
|
/* Finish up the dynamic sections. */
|
4292 |
|
|
|
4293 |
|
|
static boolean
|
4294 |
|
|
sh_elf_finish_dynamic_sections (output_bfd, info)
|
4295 |
|
|
bfd *output_bfd;
|
4296 |
|
|
struct bfd_link_info *info;
|
4297 |
|
|
{
|
4298 |
|
|
bfd *dynobj;
|
4299 |
|
|
asection *sgot;
|
4300 |
|
|
asection *sdyn;
|
4301 |
|
|
|
4302 |
|
|
dynobj = elf_hash_table (info)->dynobj;
|
4303 |
|
|
|
4304 |
|
|
sgot = bfd_get_section_by_name (dynobj, ".got.plt");
|
4305 |
|
|
BFD_ASSERT (sgot != NULL);
|
4306 |
|
|
sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
|
4307 |
|
|
|
4308 |
|
|
if (elf_hash_table (info)->dynamic_sections_created)
|
4309 |
|
|
{
|
4310 |
|
|
asection *splt;
|
4311 |
|
|
Elf32_External_Dyn *dyncon, *dynconend;
|
4312 |
|
|
|
4313 |
|
|
BFD_ASSERT (sdyn != NULL);
|
4314 |
|
|
|
4315 |
|
|
dyncon = (Elf32_External_Dyn *) sdyn->contents;
|
4316 |
|
|
dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
|
4317 |
|
|
for (; dyncon < dynconend; dyncon++)
|
4318 |
|
|
{
|
4319 |
|
|
Elf_Internal_Dyn dyn;
|
4320 |
|
|
const char *name;
|
4321 |
|
|
asection *s;
|
4322 |
|
|
|
4323 |
|
|
bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
|
4324 |
|
|
|
4325 |
|
|
switch (dyn.d_tag)
|
4326 |
|
|
{
|
4327 |
|
|
default:
|
4328 |
|
|
break;
|
4329 |
|
|
|
4330 |
|
|
case DT_PLTGOT:
|
4331 |
|
|
name = ".got";
|
4332 |
|
|
goto get_vma;
|
4333 |
|
|
|
4334 |
|
|
case DT_JMPREL:
|
4335 |
|
|
name = ".rela.plt";
|
4336 |
|
|
get_vma:
|
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);
|
4341 |
|
|
break;
|
4342 |
|
|
|
4343 |
|
|
case DT_PLTRELSZ:
|
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;
|
4348 |
|
|
else
|
4349 |
|
|
dyn.d_un.d_val = s->_raw_size;
|
4350 |
|
|
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
|
4351 |
|
|
break;
|
4352 |
|
|
|
4353 |
|
|
case DT_RELASZ:
|
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");
|
4364 |
|
|
if (s != NULL)
|
4365 |
|
|
{
|
4366 |
|
|
if (s->_cooked_size != 0)
|
4367 |
|
|
dyn.d_un.d_val -= s->_cooked_size;
|
4368 |
|
|
else
|
4369 |
|
|
dyn.d_un.d_val -= s->_raw_size;
|
4370 |
|
|
}
|
4371 |
|
|
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
|
4372 |
|
|
break;
|
4373 |
|
|
}
|
4374 |
|
|
}
|
4375 |
|
|
|
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)
|
4379 |
|
|
{
|
4380 |
|
|
if (info->shared)
|
4381 |
|
|
{
|
4382 |
|
|
if (elf_sh_pic_plt_entry == NULL)
|
4383 |
|
|
{
|
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);
|
4387 |
|
|
}
|
4388 |
|
|
memcpy (splt->contents, elf_sh_pic_plt_entry,
|
4389 |
|
|
elf_sh_sizeof_plt (info));
|
4390 |
|
|
}
|
4391 |
|
|
else
|
4392 |
|
|
{
|
4393 |
|
|
if (elf_sh_plt0_entry == NULL)
|
4394 |
|
|
{
|
4395 |
|
|
elf_sh_plt0_entry = (bfd_big_endian (output_bfd) ?
|
4396 |
|
|
elf_sh_plt0_entry_be :
|
4397 |
|
|
elf_sh_plt0_entry_le);
|
4398 |
|
|
}
|
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));
|
4406 |
|
|
}
|
4407 |
|
|
|
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;
|
4411 |
|
|
}
|
4412 |
|
|
}
|
4413 |
|
|
|
4414 |
|
|
/* Fill in the first three entries in the global offset table. */
|
4415 |
|
|
if (sgot->_raw_size > 0)
|
4416 |
|
|
{
|
4417 |
|
|
if (sdyn == NULL)
|
4418 |
|
|
bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
|
4419 |
|
|
else
|
4420 |
|
|
bfd_put_32 (output_bfd,
|
4421 |
|
|
sdyn->output_section->vma + sdyn->output_offset,
|
4422 |
|
|
sgot->contents);
|
4423 |
|
|
bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
|
4424 |
|
|
bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
|
4425 |
|
|
}
|
4426 |
|
|
|
4427 |
|
|
elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
|
4428 |
|
|
|
4429 |
|
|
return true;
|
4430 |
|
|
}
|
4431 |
|
|
|
4432 |
|
|
#ifndef ELF_ARCH
|
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
|
4440 |
|
|
|
4441 |
|
|
#define elf_symbol_leading_char '_'
|
4442 |
|
|
#endif /* ELF_ARCH */
|
4443 |
|
|
|
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
|
4457 |
|
|
|
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
|
4461 |
|
|
|
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
|
4475 |
|
|
|
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"
|