Commit | Line | Data |
---|---|---|
ef230218 | 1 | /* SuperH SH64-specific support for 32-bit ELF |
6f2750fe | 2 | Copyright (C) 2000-2016 Free Software Foundation, Inc. |
fbca6ad9 AO |
3 | |
4 | This file is part of BFD, the Binary File Descriptor library. | |
5 | ||
6 | This program is free software; you can redistribute it and/or modify | |
7 | it under the terms of the GNU General Public License as published by | |
cd123cb7 | 8 | the Free Software Foundation; either version 3 of the License, or |
fbca6ad9 AO |
9 | (at your option) any later version. |
10 | ||
11 | This program is distributed in the hope that it will be useful, | |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | GNU General Public License for more details. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
17 | along with this program; if not, write to the Free Software | |
cd123cb7 NC |
18 | Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, |
19 | MA 02110-1301, USA. */ | |
fbca6ad9 AO |
20 | |
21 | #define SH64_ELF | |
22 | ||
fbca6ad9 | 23 | #include "sysdep.h" |
3db64b00 | 24 | #include "bfd.h" |
fbca6ad9 AO |
25 | #include "elf-bfd.h" |
26 | #include "../opcodes/sh64-opc.h" | |
f0abc2a1 | 27 | #include "elf32-sh64.h" |
fbca6ad9 AO |
28 | |
29 | /* Add a suffix for datalabel indirection symbols. It must not match any | |
30 | other symbols; user symbols with or without version or other | |
31 | decoration. It must only be used internally and not emitted by any | |
32 | means. */ | |
33 | #define DATALABEL_SUFFIX " DL" | |
34 | ||
35 | /* Used to hold data for function called through bfd_map_over_sections. */ | |
36 | struct sh64_find_section_vma_data | |
37 | { | |
38 | asection *section; | |
39 | bfd_vma addr; | |
40 | }; | |
41 | ||
f0abc2a1 | 42 | static bfd_boolean sh64_elf_new_section_hook |
09fd220b | 43 | (bfd *, asection *); |
b34976b6 | 44 | static bfd_boolean sh64_elf_copy_private_data |
09fd220b | 45 | (bfd *, bfd *); |
b34976b6 | 46 | static bfd_boolean sh64_elf_merge_private_data |
50e03d47 | 47 | (bfd *, struct bfd_link_info *); |
b34976b6 | 48 | static bfd_boolean sh64_elf_fake_sections |
09fd220b | 49 | (bfd *, Elf_Internal_Shdr *, asection *); |
b34976b6 | 50 | static bfd_boolean sh64_elf_set_private_flags |
09fd220b | 51 | (bfd *, flagword); |
b34976b6 | 52 | static bfd_boolean sh64_elf_set_mach_from_flags |
09fd220b | 53 | (bfd *); |
b34976b6 | 54 | static bfd_boolean shmedia_prepare_reloc |
09fd220b KK |
55 | (struct bfd_link_info *, bfd *, asection *, bfd_byte *, |
56 | const Elf_Internal_Rela *, bfd_vma *); | |
b34976b6 | 57 | static int sh64_elf_get_symbol_type |
09fd220b | 58 | (Elf_Internal_Sym *, int); |
b34976b6 | 59 | static bfd_boolean sh64_elf_add_symbol_hook |
555cd476 | 60 | (bfd *, struct bfd_link_info *, Elf_Internal_Sym *, const char **, |
09fd220b | 61 | flagword *, asection **, bfd_vma *); |
6e0b88f1 | 62 | static int sh64_elf_link_output_symbol_hook |
754021d0 AM |
63 | (struct bfd_link_info *, const char *, Elf_Internal_Sym *, asection *, |
64 | struct elf_link_hash_entry *); | |
b34976b6 | 65 | static bfd_boolean sh64_backend_section_from_shdr |
6dc132d9 | 66 | (bfd *, Elf_Internal_Shdr *, const char *, int); |
b34976b6 | 67 | static void sh64_elf_final_write_processing |
09fd220b | 68 | (bfd *, bfd_boolean); |
b34976b6 | 69 | static bfd_boolean sh64_bfd_elf_copy_private_section_data |
09fd220b | 70 | (bfd *, asection *, bfd *, asection *); |
b34976b6 | 71 | static void sh64_find_section_for_address |
09fd220b | 72 | (bfd *, asection *, void *); |
fbca6ad9 AO |
73 | |
74 | /* Let elf32-sh.c handle the "bfd_" definitions, so we only have to | |
75 | intrude with an #ifndef around the function definition. */ | |
76 | #define sh_elf_copy_private_data sh64_elf_copy_private_data | |
77 | #define sh_elf_merge_private_data sh64_elf_merge_private_data | |
78 | #define sh_elf_set_private_flags sh64_elf_set_private_flags | |
79 | /* Typo in elf32-sh.c (and unlinear name). */ | |
80 | #define bfd_elf32_bfd_set_private_flags sh64_elf_set_private_flags | |
81 | #define sh_elf_set_mach_from_flags sh64_elf_set_mach_from_flags | |
82 | ||
83 | #define elf_backend_sign_extend_vma 1 | |
84 | #define elf_backend_fake_sections sh64_elf_fake_sections | |
85 | #define elf_backend_get_symbol_type sh64_elf_get_symbol_type | |
86 | #define elf_backend_add_symbol_hook sh64_elf_add_symbol_hook | |
87 | #define elf_backend_link_output_symbol_hook \ | |
88 | sh64_elf_link_output_symbol_hook | |
46e993b9 | 89 | #define elf_backend_merge_symbol_attribute sh64_elf_merge_symbol_attribute |
fbca6ad9 AO |
90 | #define elf_backend_final_write_processing sh64_elf_final_write_processing |
91 | #define elf_backend_section_from_shdr sh64_backend_section_from_shdr | |
29ef7005 | 92 | #define elf_backend_special_sections sh64_elf_special_sections |
beb8df56 | 93 | #define elf_backend_section_flags sh64_elf_section_flags |
fbca6ad9 | 94 | |
f0abc2a1 AM |
95 | #define bfd_elf32_new_section_hook sh64_elf_new_section_hook |
96 | ||
fbca6ad9 AO |
97 | /* For objcopy, we need to set up sh64_elf_section_data (asection *) from |
98 | incoming section flags. This is otherwise done in sh64elf.em when | |
99 | linking or tc-sh64.c when assembling. */ | |
100 | #define bfd_elf32_bfd_copy_private_section_data \ | |
101 | sh64_bfd_elf_copy_private_section_data | |
102 | ||
103 | /* This COFF-only function (only compiled with COFF support, making | |
b34976b6 AM |
104 | ELF-only chains problematic) returns TRUE early for SH4, so let's just |
105 | define it TRUE here. */ | |
c7e2358a AM |
106 | #define _bfd_sh_align_load_span(a,b,c,d,e,f,g,h,i,j) \ |
107 | ((void) f, (void) h, (void) i, TRUE) | |
fbca6ad9 | 108 | |
fbca6ad9 AO |
109 | #define GOT_BIAS (-((long)-32768)) |
110 | #define INCLUDE_SHMEDIA | |
85fbca6a | 111 | #define SH_TARGET_ALREADY_DEFINED |
fbca6ad9 AO |
112 | #include "elf32-sh.c" |
113 | ||
f0abc2a1 AM |
114 | /* Tack some extra info on struct bfd_elf_section_data. */ |
115 | ||
116 | static bfd_boolean | |
09fd220b | 117 | sh64_elf_new_section_hook (bfd *abfd, asection *sec) |
f0abc2a1 | 118 | { |
f592407e AM |
119 | if (!sec->used_by_bfd) |
120 | { | |
121 | struct _sh64_elf_section_data *sdata; | |
122 | bfd_size_type amt = sizeof (*sdata); | |
123 | ||
124 | sdata = bfd_zalloc (abfd, amt); | |
125 | if (sdata == NULL) | |
126 | return FALSE; | |
127 | sec->used_by_bfd = sdata; | |
128 | } | |
f0abc2a1 AM |
129 | |
130 | return _bfd_elf_new_section_hook (abfd, sec); | |
131 | } | |
132 | ||
fbca6ad9 AO |
133 | /* Set the SHF_SH5_ISA32 flag for ISA SHmedia code sections, and pass |
134 | through SHT_SH5_CR_SORTED on a sorted .cranges section. */ | |
135 | ||
b34976b6 | 136 | bfd_boolean |
09fd220b KK |
137 | sh64_elf_fake_sections (bfd *output_bfd ATTRIBUTE_UNUSED, |
138 | Elf_Internal_Shdr *elf_section_hdr, | |
139 | asection *asect) | |
fbca6ad9 | 140 | { |
f0abc2a1 | 141 | if (sh64_elf_section_data (asect)->sh64_info != NULL) |
fbca6ad9 | 142 | elf_section_hdr->sh_flags |
f0abc2a1 | 143 | |= sh64_elf_section_data (asect)->sh64_info->contents_flags; |
fbca6ad9 AO |
144 | |
145 | /* If this section has the SEC_SORT_ENTRIES flag set, it is a sorted | |
146 | .cranges section passing through objcopy. */ | |
147 | if ((bfd_get_section_flags (output_bfd, asect) & SEC_SORT_ENTRIES) != 0 | |
148 | && strcmp (bfd_get_section_name (output_bfd, asect), | |
149 | SH64_CRANGES_SECTION_NAME) == 0) | |
150 | elf_section_hdr->sh_type = SHT_SH5_CR_SORTED; | |
151 | ||
b34976b6 | 152 | return TRUE; |
fbca6ad9 AO |
153 | } |
154 | ||
b34976b6 | 155 | static bfd_boolean |
09fd220b | 156 | sh64_elf_set_mach_from_flags (bfd *abfd) |
fbca6ad9 AO |
157 | { |
158 | flagword flags = elf_elfheader (abfd)->e_flags; | |
fbca6ad9 AO |
159 | |
160 | switch (flags & EF_SH_MACH_MASK) | |
161 | { | |
162 | case EF_SH5: | |
163 | /* These are fit to execute on SH5. Just one but keep the switch | |
164 | construct to make additions easy. */ | |
165 | bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh5); | |
166 | break; | |
167 | ||
168 | default: | |
169 | bfd_set_error (bfd_error_wrong_format); | |
b34976b6 | 170 | return FALSE; |
fbca6ad9 AO |
171 | } |
172 | ||
beb8df56 L |
173 | return TRUE; |
174 | } | |
175 | ||
176 | static bfd_boolean | |
177 | sh64_elf_section_flags (flagword *flags, | |
178 | const Elf_Internal_Shdr *hdr) | |
179 | { | |
180 | if (hdr->bfd_section == NULL) | |
b34976b6 | 181 | return FALSE; |
fbca6ad9 | 182 | |
beb8df56 L |
183 | if (strcmp (hdr->bfd_section->name, SH64_CRANGES_SECTION_NAME) == 0) |
184 | *flags |= SEC_DEBUGGING; | |
185 | ||
b34976b6 | 186 | return TRUE; |
fbca6ad9 AO |
187 | } |
188 | ||
b34976b6 | 189 | static bfd_boolean |
09fd220b | 190 | sh64_elf_copy_private_data (bfd * ibfd, bfd * obfd) |
fbca6ad9 AO |
191 | { |
192 | if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour | |
193 | || bfd_get_flavour (obfd) != bfd_target_elf_flavour) | |
b34976b6 | 194 | return TRUE; |
fbca6ad9 AO |
195 | |
196 | BFD_ASSERT (!elf_flags_init (obfd) | |
197 | || (elf_elfheader (obfd)->e_flags | |
198 | == elf_elfheader (ibfd)->e_flags)); | |
199 | ||
200 | elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags; | |
df3ce959 NC |
201 | |
202 | return _bfd_elf_copy_private_bfd_data (ibfd, obfd); | |
fbca6ad9 AO |
203 | } |
204 | ||
b34976b6 | 205 | static bfd_boolean |
50e03d47 | 206 | sh64_elf_merge_private_data (bfd *ibfd, struct bfd_link_info *info) |
fbca6ad9 | 207 | { |
50e03d47 | 208 | bfd *obfd = info->output_bfd; |
fbca6ad9 AO |
209 | flagword old_flags, new_flags; |
210 | ||
50e03d47 | 211 | if (! _bfd_generic_verify_endian_match (ibfd, info)) |
b34976b6 | 212 | return FALSE; |
fbca6ad9 AO |
213 | |
214 | if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour | |
215 | || bfd_get_flavour (obfd) != bfd_target_elf_flavour) | |
b34976b6 | 216 | return TRUE; |
fbca6ad9 AO |
217 | |
218 | if (bfd_get_arch_size (ibfd) != bfd_get_arch_size (obfd)) | |
219 | { | |
220 | const char *msg; | |
221 | ||
222 | if (bfd_get_arch_size (ibfd) == 32 | |
223 | && bfd_get_arch_size (obfd) == 64) | |
224 | msg = _("%s: compiled as 32-bit object and %s is 64-bit"); | |
225 | else if (bfd_get_arch_size (ibfd) == 64 | |
226 | && bfd_get_arch_size (obfd) == 32) | |
227 | msg = _("%s: compiled as 64-bit object and %s is 32-bit"); | |
228 | else | |
229 | msg = _("%s: object size does not match that of target %s"); | |
230 | ||
4eca0228 AM |
231 | _bfd_error_handler (msg, bfd_get_filename (ibfd), |
232 | bfd_get_filename (obfd)); | |
fbca6ad9 | 233 | bfd_set_error (bfd_error_wrong_format); |
b34976b6 | 234 | return FALSE; |
fbca6ad9 AO |
235 | } |
236 | ||
237 | old_flags = elf_elfheader (obfd)->e_flags; | |
238 | new_flags = elf_elfheader (ibfd)->e_flags; | |
239 | if (! elf_flags_init (obfd)) | |
240 | { | |
241 | /* This happens when ld starts out with a 'blank' output file. */ | |
b34976b6 | 242 | elf_flags_init (obfd) = TRUE; |
fbca6ad9 AO |
243 | elf_elfheader (obfd)->e_flags = old_flags = new_flags; |
244 | } | |
245 | /* We don't allow linking in non-SH64 code. */ | |
246 | else if ((new_flags & EF_SH_MACH_MASK) != EF_SH5) | |
247 | { | |
4eca0228 | 248 | _bfd_error_handler |
fbca6ad9 AO |
249 | ("%s: uses non-SH64 instructions while previous modules use SH64 instructions", |
250 | bfd_get_filename (ibfd)); | |
251 | bfd_set_error (bfd_error_bad_value); | |
b34976b6 | 252 | return FALSE; |
fbca6ad9 AO |
253 | } |
254 | ||
255 | /* I can't think of anything sane other than old_flags being EF_SH5 and | |
256 | that we need to preserve that. */ | |
257 | elf_elfheader (obfd)->e_flags = old_flags; | |
258 | return sh64_elf_set_mach_from_flags (obfd); | |
259 | } | |
260 | ||
261 | /* Handle a SH64-specific section when reading an object file. This | |
6dc132d9 L |
262 | is called when bfd_section_from_shdr finds a section with an unknown |
263 | type. | |
fbca6ad9 AO |
264 | |
265 | We only recognize SHT_SH5_CR_SORTED, on the .cranges section. */ | |
266 | ||
b34976b6 | 267 | bfd_boolean |
09fd220b | 268 | sh64_backend_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr, |
6dc132d9 | 269 | const char *name, int shindex) |
fbca6ad9 AO |
270 | { |
271 | flagword flags = 0; | |
272 | ||
273 | /* We do like MIPS with a bit switch for recognized types, and returning | |
b34976b6 | 274 | FALSE for a recognized section type with an unexpected name. Right |
fbca6ad9 AO |
275 | now we only have one recognized type, but that might change. */ |
276 | switch (hdr->sh_type) | |
277 | { | |
278 | case SHT_SH5_CR_SORTED: | |
279 | if (strcmp (name, SH64_CRANGES_SECTION_NAME) != 0) | |
b34976b6 | 280 | return FALSE; |
fbca6ad9 AO |
281 | |
282 | /* We set the SEC_SORT_ENTRIES flag so it can be passed on to | |
283 | sh64_elf_fake_sections, keeping SHT_SH5_CR_SORTED if this object | |
284 | passes through objcopy. Perhaps it is brittle; the flag can | |
285 | suddenly be used by other BFD parts, but it seems not really used | |
286 | anywhere at the moment. */ | |
287 | flags = SEC_DEBUGGING | SEC_SORT_ENTRIES; | |
288 | break; | |
289 | ||
290 | default: | |
b34976b6 | 291 | return FALSE; |
fbca6ad9 AO |
292 | } |
293 | ||
6dc132d9 | 294 | if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex)) |
b34976b6 | 295 | return FALSE; |
fbca6ad9 AO |
296 | |
297 | if (flags | |
298 | && ! bfd_set_section_flags (abfd, hdr->bfd_section, | |
299 | bfd_get_section_flags (abfd, | |
300 | hdr->bfd_section) | |
301 | | flags)) | |
b34976b6 | 302 | return FALSE; |
fbca6ad9 | 303 | |
b34976b6 | 304 | return TRUE; |
fbca6ad9 AO |
305 | } |
306 | ||
307 | /* In contrast to sh64_backend_section_from_shdr, this is called for all | |
308 | sections, but only when copying sections, not when linking or | |
309 | assembling. We need to set up the sh64_elf_section_data (asection *) | |
310 | structure for the SH64 ELF section flags to be copied correctly. */ | |
311 | ||
b34976b6 | 312 | bfd_boolean |
09fd220b KK |
313 | sh64_bfd_elf_copy_private_section_data (bfd *ibfd, asection *isec, |
314 | bfd *obfd, asection *osec) | |
fbca6ad9 AO |
315 | { |
316 | struct sh64_section_data *sh64_sec_data; | |
317 | ||
318 | if (ibfd->xvec->flavour != bfd_target_elf_flavour | |
319 | || obfd->xvec->flavour != bfd_target_elf_flavour) | |
b34976b6 | 320 | return TRUE; |
fbca6ad9 AO |
321 | |
322 | if (! _bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec)) | |
b34976b6 | 323 | return FALSE; |
fbca6ad9 | 324 | |
f0abc2a1 | 325 | sh64_sec_data = sh64_elf_section_data (isec)->sh64_info; |
fbca6ad9 AO |
326 | if (sh64_sec_data == NULL) |
327 | { | |
328 | sh64_sec_data = bfd_zmalloc (sizeof (struct sh64_section_data)); | |
329 | ||
330 | if (sh64_sec_data == NULL) | |
b34976b6 | 331 | return FALSE; |
fbca6ad9 AO |
332 | |
333 | sh64_sec_data->contents_flags | |
334 | = (elf_section_data (isec)->this_hdr.sh_flags | |
335 | & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED)); | |
336 | ||
f0abc2a1 | 337 | sh64_elf_section_data (osec)->sh64_info = sh64_sec_data; |
fbca6ad9 AO |
338 | } |
339 | ||
b34976b6 | 340 | return TRUE; |
fbca6ad9 AO |
341 | } |
342 | ||
343 | /* Function to keep SH64 specific file flags. */ | |
344 | ||
b34976b6 | 345 | static bfd_boolean |
09fd220b | 346 | sh64_elf_set_private_flags (bfd *abfd, flagword flags) |
fbca6ad9 AO |
347 | { |
348 | BFD_ASSERT (! elf_flags_init (abfd) | |
349 | || elf_elfheader (abfd)->e_flags == flags); | |
350 | ||
351 | elf_elfheader (abfd)->e_flags = flags; | |
b34976b6 | 352 | elf_flags_init (abfd) = TRUE; |
fbca6ad9 AO |
353 | return sh64_elf_set_mach_from_flags (abfd); |
354 | } | |
355 | ||
356 | /* Called when writing out an object file to decide the type of a symbol. */ | |
357 | ||
358 | static int | |
09fd220b | 359 | sh64_elf_get_symbol_type (Elf_Internal_Sym *elf_sym, int type) |
fbca6ad9 AO |
360 | { |
361 | if (ELF_ST_TYPE (elf_sym->st_info) == STT_DATALABEL) | |
362 | return STT_DATALABEL; | |
363 | ||
364 | return type; | |
365 | } | |
366 | ||
367 | /* Hook called by the linker routine which adds symbols from an object | |
368 | file. We must make indirect symbols for undefined symbols marked with | |
369 | STT_DATALABEL, so relocations passing them will pick up that attribute | |
370 | and neutralize STO_SH5_ISA32 found on the symbol definition. | |
371 | ||
372 | There is a problem, though: We want to fill in the hash-table entry for | |
373 | this symbol and signal to the caller that no further processing is | |
374 | needed. But we don't have the index for this hash-table entry. We | |
375 | rely here on that the current entry is the first hash-entry with NULL, | |
376 | which seems brittle. Also, iterating over the hash-table to find that | |
377 | entry is a linear operation on the number of symbols in this input | |
378 | file, and this function should take constant time, so that's not good | |
379 | too. Only comfort is that DataLabel references should only be found in | |
380 | hand-written assembly code and thus be rare. FIXME: Talk maintainers | |
381 | into adding an option to elf_add_symbol_hook (preferably) for the index | |
382 | or the hash entry, alternatively adding the index to Elf_Internal_Sym | |
383 | (not so good). */ | |
384 | ||
b34976b6 | 385 | static bfd_boolean |
09fd220b | 386 | sh64_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info, |
555cd476 | 387 | Elf_Internal_Sym *sym, const char **namep, |
09fd220b KK |
388 | flagword *flagsp ATTRIBUTE_UNUSED, |
389 | asection **secp, bfd_vma *valp) | |
fbca6ad9 AO |
390 | { |
391 | /* We want to do this for relocatable as well as final linking. */ | |
4ab82700 | 392 | if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL |
0eddce27 | 393 | && is_elf_hash_table (info->hash)) |
fbca6ad9 AO |
394 | { |
395 | struct elf_link_hash_entry *h; | |
396 | ||
1049f94e | 397 | /* For relocatable links, we register the DataLabel sym in its own |
fbca6ad9 AO |
398 | right, and tweak the name when it's output. Otherwise, we make |
399 | an indirect symbol of it. */ | |
400 | flagword flags | |
0e1862bb | 401 | = bfd_link_relocatable (info) || info->emitrelocations |
fbca6ad9 AO |
402 | ? BSF_GLOBAL : BSF_GLOBAL | BSF_INDIRECT; |
403 | ||
404 | char *dl_name | |
405 | = bfd_malloc (strlen (*namep) + sizeof (DATALABEL_SUFFIX)); | |
406 | struct elf_link_hash_entry ** sym_hash = elf_sym_hashes (abfd); | |
407 | ||
408 | BFD_ASSERT (sym_hash != NULL); | |
409 | ||
410 | /* Allocation may fail. */ | |
411 | if (dl_name == NULL) | |
b34976b6 | 412 | return FALSE; |
fbca6ad9 AO |
413 | |
414 | strcpy (dl_name, *namep); | |
415 | strcat (dl_name, DATALABEL_SUFFIX); | |
416 | ||
417 | h = (struct elf_link_hash_entry *) | |
b34976b6 | 418 | bfd_link_hash_lookup (info->hash, dl_name, FALSE, FALSE, FALSE); |
fbca6ad9 AO |
419 | |
420 | if (h == NULL) | |
421 | { | |
422 | /* No previous datalabel symbol. Make one. */ | |
14a793b2 | 423 | struct bfd_link_hash_entry *bh = NULL; |
9c5bfbb7 | 424 | const struct elf_backend_data *bed = get_elf_backend_data (abfd); |
14a793b2 | 425 | |
fbca6ad9 AO |
426 | if (! _bfd_generic_link_add_one_symbol (info, abfd, dl_name, |
427 | flags, *secp, *valp, | |
b34976b6 | 428 | *namep, FALSE, |
14a793b2 | 429 | bed->collect, &bh)) |
fbca6ad9 AO |
430 | { |
431 | free (dl_name); | |
b34976b6 | 432 | return FALSE; |
fbca6ad9 AO |
433 | } |
434 | ||
14a793b2 | 435 | h = (struct elf_link_hash_entry *) bh; |
f5385ebf | 436 | h->non_elf = 0; |
fbca6ad9 AO |
437 | h->type = STT_DATALABEL; |
438 | } | |
439 | else | |
440 | /* If a new symbol was created, it holds the allocated name. | |
441 | Otherwise, we don't need it anymore and should deallocate it. */ | |
442 | free (dl_name); | |
443 | ||
444 | if (h->type != STT_DATALABEL | |
0e1862bb | 445 | || ((bfd_link_relocatable (info) || info->emitrelocations) |
fbca6ad9 | 446 | && h->root.type != bfd_link_hash_undefined) |
0e1862bb | 447 | || (! bfd_link_relocatable (info) && !info->emitrelocations |
fbca6ad9 AO |
448 | && h->root.type != bfd_link_hash_indirect)) |
449 | { | |
450 | /* Make sure we don't get confused on invalid input. */ | |
4eca0228 | 451 | _bfd_error_handler |
fbca6ad9 AO |
452 | (_("%s: encountered datalabel symbol in input"), |
453 | bfd_get_filename (abfd)); | |
454 | bfd_set_error (bfd_error_bad_value); | |
b34976b6 | 455 | return FALSE; |
fbca6ad9 AO |
456 | } |
457 | ||
458 | /* Now find the hash-table slot for this entry and fill it in. */ | |
459 | while (*sym_hash != NULL) | |
460 | sym_hash++; | |
461 | *sym_hash = h; | |
462 | ||
463 | /* Signal to caller to skip this symbol - we've handled it. */ | |
464 | *namep = NULL; | |
465 | } | |
466 | ||
b34976b6 | 467 | return TRUE; |
fbca6ad9 AO |
468 | } |
469 | ||
470 | /* This hook function is called before the linker writes out a global | |
471 | symbol. For relocatable links, DataLabel symbols will be present in | |
472 | linker output. We cut off the special suffix on those symbols, so the | |
473 | right name appears in the output. | |
474 | ||
475 | When linking and emitting relocations, there can appear global symbols | |
476 | that are not referenced by relocs, but rather only implicitly through | |
477 | DataLabel references, a relation that is not visible to the linker. | |
478 | Since no stripping of global symbols in done when doing such linking, | |
479 | we don't need to look up and make sure to emit the main symbol for each | |
480 | DataLabel symbol. */ | |
481 | ||
6e0b88f1 | 482 | static int |
754021d0 | 483 | sh64_elf_link_output_symbol_hook (struct bfd_link_info *info, |
09fd220b KK |
484 | const char *cname, |
485 | Elf_Internal_Sym *sym, | |
754021d0 AM |
486 | asection *input_sec ATTRIBUTE_UNUSED, |
487 | struct elf_link_hash_entry *h ATTRIBUTE_UNUSED) | |
fbca6ad9 AO |
488 | { |
489 | char *name = (char *) cname; | |
490 | ||
0e1862bb | 491 | if (bfd_link_relocatable (info) || info->emitrelocations) |
fbca6ad9 AO |
492 | { |
493 | if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL) | |
494 | name[strlen (name) - strlen (DATALABEL_SUFFIX)] = 0; | |
495 | } | |
496 | ||
6e0b88f1 | 497 | return 1; |
fbca6ad9 AO |
498 | } |
499 | ||
500 | /* Check a SH64-specific reloc and put the value to relocate to into | |
501 | RELOCATION, ready to pass to _bfd_final_link_relocate. Return FALSE if | |
502 | bad value, TRUE if ok. */ | |
503 | ||
b34976b6 | 504 | static bfd_boolean |
09fd220b KK |
505 | shmedia_prepare_reloc (struct bfd_link_info *info, bfd *abfd, |
506 | asection *input_section, bfd_byte *contents, | |
507 | const Elf_Internal_Rela *rel, bfd_vma *relocation) | |
fbca6ad9 AO |
508 | { |
509 | bfd_vma disp, dropped; | |
510 | ||
511 | switch (ELF32_R_TYPE (rel->r_info)) | |
512 | { | |
513 | case R_SH_PT_16: | |
514 | /* Check the lowest bit of the destination field. If it is 1, we | |
515 | check the ISA type of the destination (i.e. the low bit of the | |
516 | "relocation" value, and emit an error if the instruction does not | |
517 | match). If it is 0, we change a PTA to PTB. There should never | |
518 | be a PTB that should change to a PTA; that indicates a toolchain | |
519 | error; a mismatch with GAS. */ | |
520 | { | |
521 | char *msg = NULL; | |
522 | bfd_vma insn = bfd_get_32 (abfd, contents + rel->r_offset); | |
523 | ||
524 | if (insn & (1 << 10)) | |
525 | { | |
526 | /* Check matching insn and ISA (address of target). */ | |
527 | if ((insn & SHMEDIA_PTB_BIT) != 0 | |
528 | && ((*relocation + rel->r_addend) & 1) != 0) | |
529 | msg = _("PTB mismatch: a SHmedia address (bit 0 == 1)"); | |
530 | else if ((insn & SHMEDIA_PTB_BIT) == 0 | |
531 | && ((*relocation + rel->r_addend) & 1) == 0) | |
532 | msg = _("PTA mismatch: a SHcompact address (bit 0 == 0)"); | |
533 | ||
1a72702b AM |
534 | if (msg != NULL) |
535 | (*info->callbacks->reloc_dangerous) | |
536 | (info, msg, abfd, input_section, rel->r_offset); | |
fbca6ad9 AO |
537 | } |
538 | else | |
539 | { | |
540 | /* We shouldn't get here with a PTB insn and a R_SH_PT_16. It | |
541 | means GAS output does not match expectations; a PTA or PTB | |
542 | expressed as such (or a PT found at assembly to be PTB) | |
543 | would match the test above, and PT expansion with an | |
544 | unknown destination (or when relaxing) will get us here. */ | |
545 | if ((insn & SHMEDIA_PTB_BIT) != 0) | |
546 | { | |
4eca0228 | 547 | _bfd_error_handler |
fbca6ad9 AO |
548 | (_("%s: GAS error: unexpected PTB insn with R_SH_PT_16"), |
549 | bfd_get_filename (input_section->owner)); | |
b34976b6 | 550 | return FALSE; |
fbca6ad9 AO |
551 | } |
552 | ||
553 | /* Change the PTA to a PTB, if destination indicates so. */ | |
554 | if (((*relocation + rel->r_addend) & 1) == 0) | |
555 | bfd_put_32 (abfd, insn | SHMEDIA_PTB_BIT, | |
556 | contents + rel->r_offset); | |
557 | } | |
558 | } | |
559 | ||
560 | case R_SH_SHMEDIA_CODE: | |
561 | case R_SH_DIR5U: | |
562 | case R_SH_DIR6S: | |
563 | case R_SH_DIR6U: | |
564 | case R_SH_DIR10S: | |
565 | case R_SH_DIR10SW: | |
566 | case R_SH_DIR10SL: | |
567 | case R_SH_DIR10SQ: | |
568 | case R_SH_IMMS16: | |
569 | case R_SH_IMMU16: | |
570 | case R_SH_IMM_LOW16: | |
571 | case R_SH_IMM_LOW16_PCREL: | |
572 | case R_SH_IMM_MEDLOW16: | |
573 | case R_SH_IMM_MEDLOW16_PCREL: | |
574 | case R_SH_IMM_MEDHI16: | |
575 | case R_SH_IMM_MEDHI16_PCREL: | |
576 | case R_SH_IMM_HI16: | |
577 | case R_SH_IMM_HI16_PCREL: | |
578 | case R_SH_64: | |
579 | case R_SH_64_PCREL: | |
580 | break; | |
581 | ||
582 | default: | |
b34976b6 | 583 | return FALSE; |
fbca6ad9 AO |
584 | } |
585 | ||
586 | disp = (*relocation & 0xf); | |
587 | dropped = 0; | |
588 | switch (ELF32_R_TYPE (rel->r_info)) | |
589 | { | |
590 | case R_SH_DIR10SW: dropped = disp & 1; break; | |
591 | case R_SH_DIR10SL: dropped = disp & 3; break; | |
592 | case R_SH_DIR10SQ: dropped = disp & 7; break; | |
593 | } | |
594 | if (dropped != 0) | |
595 | { | |
4eca0228 | 596 | _bfd_error_handler |
f60ca5e3 AM |
597 | (_("%B: error: unaligned relocation type %d at %08x reloc %p\n"), |
598 | input_section->owner, ELF32_R_TYPE (rel->r_info), | |
599 | (unsigned) rel->r_offset, relocation); | |
b34976b6 | 600 | return FALSE; |
fbca6ad9 AO |
601 | } |
602 | ||
b34976b6 | 603 | return TRUE; |
fbca6ad9 AO |
604 | } |
605 | ||
606 | /* Helper function to locate the section holding a certain address. This | |
607 | is called via bfd_map_over_sections. */ | |
608 | ||
609 | static void | |
09fd220b KK |
610 | sh64_find_section_for_address (bfd *abfd ATTRIBUTE_UNUSED, |
611 | asection *section, void *data) | |
fbca6ad9 AO |
612 | { |
613 | bfd_vma vma; | |
614 | bfd_size_type size; | |
eea6121a | 615 | |
fbca6ad9 AO |
616 | struct sh64_find_section_vma_data *fsec_datap |
617 | = (struct sh64_find_section_vma_data *) data; | |
618 | ||
619 | /* Return if already found. */ | |
620 | if (fsec_datap->section) | |
621 | return; | |
622 | ||
623 | /* If this section isn't part of the addressable contents, skip it. */ | |
624 | if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0) | |
625 | return; | |
626 | ||
627 | vma = bfd_get_section_vma (abfd, section); | |
628 | if (fsec_datap->addr < vma) | |
629 | return; | |
630 | ||
eea6121a | 631 | size = section->size; |
fbca6ad9 AO |
632 | if (fsec_datap->addr >= vma + size) |
633 | return; | |
634 | ||
635 | fsec_datap->section = section; | |
636 | } | |
637 | ||
638 | /* Make sure to write out the generated entries in the .cranges section | |
639 | when doing partial linking, and set bit 0 on the entry address if it | |
640 | points to SHmedia code and write sorted .cranges entries when writing | |
641 | executables (final linking and objcopy). */ | |
642 | ||
643 | static void | |
09fd220b KK |
644 | sh64_elf_final_write_processing (bfd *abfd, |
645 | bfd_boolean linker ATTRIBUTE_UNUSED) | |
fbca6ad9 AO |
646 | { |
647 | bfd_vma ld_generated_cranges_size; | |
648 | asection *cranges | |
649 | = bfd_get_section_by_name (abfd, SH64_CRANGES_SECTION_NAME); | |
650 | ||
651 | /* If no new .cranges were added, the generic ELF linker parts will | |
652 | write it all out. If not, we need to write them out when doing | |
653 | partial linking. For a final link, we will sort them and write them | |
654 | all out further below. */ | |
655 | if (linker | |
656 | && cranges != NULL | |
657 | && elf_elfheader (abfd)->e_type != ET_EXEC | |
658 | && (ld_generated_cranges_size | |
f0abc2a1 | 659 | = sh64_elf_section_data (cranges)->sh64_info->cranges_growth) != 0) |
fbca6ad9 AO |
660 | { |
661 | bfd_vma incoming_cranges_size | |
eea6121a | 662 | = cranges->size - ld_generated_cranges_size; |
fbca6ad9 AO |
663 | |
664 | if (! bfd_set_section_contents (abfd, cranges, | |
665 | cranges->contents | |
666 | + incoming_cranges_size, | |
667 | cranges->output_offset | |
668 | + incoming_cranges_size, | |
669 | ld_generated_cranges_size)) | |
670 | { | |
671 | bfd_set_error (bfd_error_file_truncated); | |
4eca0228 | 672 | _bfd_error_handler |
fbca6ad9 AO |
673 | (_("%s: could not write out added .cranges entries"), |
674 | bfd_get_filename (abfd)); | |
675 | } | |
676 | } | |
677 | ||
678 | /* Only set entry address bit 0 and sort .cranges when linking to an | |
679 | executable; never with objcopy or strip. */ | |
680 | if (linker && elf_elfheader (abfd)->e_type == ET_EXEC) | |
681 | { | |
682 | struct sh64_find_section_vma_data fsec_data; | |
683 | sh64_elf_crange dummy; | |
684 | ||
685 | /* For a final link, set the low bit of the entry address to | |
686 | reflect whether or not it is a SHmedia address. | |
687 | FIXME: Perhaps we shouldn't do this if the entry address was | |
688 | supplied numerically, but we currently lack the infrastructure to | |
689 | recognize that: The entry symbol, and info whether it is numeric | |
690 | or a symbol name is kept private in the linker. */ | |
691 | fsec_data.addr = elf_elfheader (abfd)->e_entry; | |
692 | fsec_data.section = NULL; | |
693 | ||
694 | bfd_map_over_sections (abfd, sh64_find_section_for_address, | |
09fd220b | 695 | &fsec_data); |
fbca6ad9 AO |
696 | if (fsec_data.section |
697 | && (sh64_get_contents_type (fsec_data.section, | |
698 | elf_elfheader (abfd)->e_entry, | |
699 | &dummy) == CRT_SH5_ISA32)) | |
700 | elf_elfheader (abfd)->e_entry |= 1; | |
701 | ||
702 | /* If we have a .cranges section, sort the entries. */ | |
703 | if (cranges != NULL) | |
704 | { | |
eea6121a | 705 | bfd_size_type cranges_size = cranges->size; |
fbca6ad9 AO |
706 | |
707 | /* We know we always have these in memory at this time. */ | |
708 | BFD_ASSERT (cranges->contents != NULL); | |
709 | ||
710 | /* The .cranges may already have been sorted in the process of | |
711 | finding out the ISA-type of the entry address. If not, we do | |
712 | it here. */ | |
713 | if (elf_section_data (cranges)->this_hdr.sh_type | |
714 | != SHT_SH5_CR_SORTED) | |
715 | { | |
716 | qsort (cranges->contents, cranges_size / SH64_CRANGE_SIZE, | |
717 | SH64_CRANGE_SIZE, | |
718 | bfd_big_endian (cranges->owner) | |
9cba27b2 JT |
719 | ? _bfd_sh64_crange_qsort_cmpb |
720 | : _bfd_sh64_crange_qsort_cmpl); | |
fbca6ad9 AO |
721 | elf_section_data (cranges)->this_hdr.sh_type |
722 | = SHT_SH5_CR_SORTED; | |
723 | } | |
724 | ||
725 | /* We need to write it out in whole as sorted. */ | |
726 | if (! bfd_set_section_contents (abfd, cranges, | |
727 | cranges->contents, | |
728 | cranges->output_offset, | |
729 | cranges_size)) | |
730 | { | |
731 | bfd_set_error (bfd_error_file_truncated); | |
4eca0228 | 732 | _bfd_error_handler |
fbca6ad9 AO |
733 | (_("%s: could not write out sorted .cranges entries"), |
734 | bfd_get_filename (abfd)); | |
735 | } | |
736 | } | |
737 | } | |
738 | } | |
2bc3c89a | 739 | |
46e993b9 KK |
740 | /* Merge non visibility st_other attribute when the symbol comes from |
741 | a dynamic object. */ | |
742 | static void | |
743 | sh64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h, | |
744 | const Elf_Internal_Sym *isym, | |
745 | bfd_boolean definition, | |
dc84ceef | 746 | bfd_boolean dynamic ATTRIBUTE_UNUSED) |
46e993b9 | 747 | { |
dc84ceef | 748 | if ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) != 0) |
46e993b9 KK |
749 | { |
750 | unsigned char other; | |
751 | ||
752 | /* Take the balance of OTHER from the definition. */ | |
753 | other = (definition ? isym->st_other : h->other); | |
754 | other &= ~ ELF_ST_VISIBILITY (-1); | |
755 | h->other = other | ELF_ST_VISIBILITY (h->other); | |
756 | } | |
757 | ||
758 | return; | |
759 | } | |
760 | ||
b35d266b | 761 | static const struct bfd_elf_special_section sh64_elf_special_sections[] = |
2f89ff8d | 762 | { |
0112cd26 NC |
763 | { STRING_COMMA_LEN (".cranges"), 0, SHT_PROGBITS, 0 }, |
764 | { NULL, 0, 0, 0, 0 } | |
7f4d3958 L |
765 | }; |
766 | ||
2bc3c89a | 767 | #undef TARGET_BIG_SYM |
6d00b590 | 768 | #define TARGET_BIG_SYM sh64_elf32_vec |
2bc3c89a AM |
769 | #undef TARGET_BIG_NAME |
770 | #define TARGET_BIG_NAME "elf32-sh64" | |
771 | #undef TARGET_LITTLE_SYM | |
6d00b590 | 772 | #define TARGET_LITTLE_SYM sh64_elf32_le_vec |
2bc3c89a AM |
773 | #undef TARGET_LITTLE_NAME |
774 | #define TARGET_LITTLE_NAME "elf32-sh64l" | |
775 | ||
776 | #include "elf32-target.h" | |
777 | ||
778 | /* NetBSD support. */ | |
779 | #undef TARGET_BIG_SYM | |
6d00b590 | 780 | #define TARGET_BIG_SYM sh64_elf32_nbsd_vec |
2bc3c89a AM |
781 | #undef TARGET_BIG_NAME |
782 | #define TARGET_BIG_NAME "elf32-sh64-nbsd" | |
783 | #undef TARGET_LITTLE_SYM | |
6d00b590 | 784 | #define TARGET_LITTLE_SYM sh64_elf32_nbsd_le_vec |
2bc3c89a AM |
785 | #undef TARGET_LITTLE_NAME |
786 | #define TARGET_LITTLE_NAME "elf32-sh64l-nbsd" | |
787 | #undef ELF_MAXPAGESIZE | |
788 | #define ELF_MAXPAGESIZE 0x10000 | |
24718e3b | 789 | #undef ELF_COMMONPAGESIZE |
2bc3c89a AM |
790 | #undef elf_symbol_leading_char |
791 | #define elf_symbol_leading_char 0 | |
571fe01f | 792 | #undef elf32_bed |
2bc3c89a AM |
793 | #define elf32_bed elf32_sh64_nbsd_bed |
794 | ||
795 | #include "elf32-target.h" | |
796 | ||
2bc3c89a AM |
797 | /* Linux support. */ |
798 | #undef TARGET_BIG_SYM | |
6d00b590 | 799 | #define TARGET_BIG_SYM sh64_elf32_linux_be_vec |
2bc3c89a AM |
800 | #undef TARGET_BIG_NAME |
801 | #define TARGET_BIG_NAME "elf32-sh64big-linux" | |
802 | #undef TARGET_LITTLE_SYM | |
6d00b590 | 803 | #define TARGET_LITTLE_SYM sh64_elf32_linux_vec |
2bc3c89a AM |
804 | #undef TARGET_LITTLE_NAME |
805 | #define TARGET_LITTLE_NAME "elf32-sh64-linux" | |
571fe01f | 806 | #undef elf32_bed |
2bc3c89a | 807 | #define elf32_bed elf32_sh64_lin_bed |
24718e3b L |
808 | #undef ELF_COMMONPAGESIZE |
809 | #define ELF_COMMONPAGESIZE 0x1000 | |
2bc3c89a AM |
810 | |
811 | #include "elf32-target.h" | |
812 |