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