bfd/
[binutils.git] / bfd / elf32-sh64.c
blob219f7533f154d964c42e32d33c4c1f008d8bba0c
1 /* SuperH SH64-specific support for 32-bit ELF
2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
21 #define SH64_ELF
23 #include "bfd.h"
24 #include "sysdep.h"
25 #include "elf-bfd.h"
26 #include "../opcodes/sh64-opc.h"
27 #include "elf32-sh64.h"
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"
35 /* Used to hold data for function called through bfd_map_over_sections. */
36 struct sh64_find_section_vma_data
38 asection *section;
39 bfd_vma addr;
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 bfd_boolean 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 *);
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
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
95 #define bfd_elf32_new_section_hook sh64_elf_new_section_hook
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
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) TRUE
108 #define GOT_BIAS (-((long)-32768))
109 #define INCLUDE_SHMEDIA
110 #define SH_TARGET_ALREADY_DEFINED
111 #include "elf32-sh.c"
113 /* Tack some extra info on struct bfd_elf_section_data. */
115 static bfd_boolean
116 sh64_elf_new_section_hook (bfd *abfd, asection *sec)
118 if (!sec->used_by_bfd)
120 struct _sh64_elf_section_data *sdata;
121 bfd_size_type amt = sizeof (*sdata);
123 sdata = bfd_zalloc (abfd, amt);
124 if (sdata == NULL)
125 return FALSE;
126 sec->used_by_bfd = sdata;
129 return _bfd_elf_new_section_hook (abfd, sec);
132 /* Set the SHF_SH5_ISA32 flag for ISA SHmedia code sections, and pass
133 through SHT_SH5_CR_SORTED on a sorted .cranges section. */
135 bfd_boolean
136 sh64_elf_fake_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
137 Elf_Internal_Shdr *elf_section_hdr,
138 asection *asect)
140 if (sh64_elf_section_data (asect)->sh64_info != NULL)
141 elf_section_hdr->sh_flags
142 |= sh64_elf_section_data (asect)->sh64_info->contents_flags;
144 /* If this section has the SEC_SORT_ENTRIES flag set, it is a sorted
145 .cranges section passing through objcopy. */
146 if ((bfd_get_section_flags (output_bfd, asect) & SEC_SORT_ENTRIES) != 0
147 && strcmp (bfd_get_section_name (output_bfd, asect),
148 SH64_CRANGES_SECTION_NAME) == 0)
149 elf_section_hdr->sh_type = SHT_SH5_CR_SORTED;
151 return TRUE;
154 static bfd_boolean
155 sh64_elf_set_mach_from_flags (bfd *abfd)
157 flagword flags = elf_elfheader (abfd)->e_flags;
159 switch (flags & EF_SH_MACH_MASK)
161 case EF_SH5:
162 /* These are fit to execute on SH5. Just one but keep the switch
163 construct to make additions easy. */
164 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh5);
165 break;
167 default:
168 bfd_set_error (bfd_error_wrong_format);
169 return FALSE;
172 return TRUE;
175 static bfd_boolean
176 sh64_elf_section_flags (flagword *flags,
177 const Elf_Internal_Shdr *hdr)
179 if (hdr->bfd_section == NULL)
180 return FALSE;
182 if (strcmp (hdr->bfd_section->name, SH64_CRANGES_SECTION_NAME) == 0)
183 *flags |= SEC_DEBUGGING;
185 return TRUE;
188 static bfd_boolean
189 sh64_elf_copy_private_data (bfd * ibfd, bfd * obfd)
191 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
192 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
193 return TRUE;
195 BFD_ASSERT (!elf_flags_init (obfd)
196 || (elf_elfheader (obfd)->e_flags
197 == elf_elfheader (ibfd)->e_flags));
199 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
200 return TRUE;
203 static bfd_boolean
204 sh64_elf_merge_private_data (bfd *ibfd, bfd *obfd)
206 flagword old_flags, new_flags;
208 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
209 return FALSE;
211 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
212 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
213 return TRUE;
215 if (bfd_get_arch_size (ibfd) != bfd_get_arch_size (obfd))
217 const char *msg;
219 if (bfd_get_arch_size (ibfd) == 32
220 && bfd_get_arch_size (obfd) == 64)
221 msg = _("%s: compiled as 32-bit object and %s is 64-bit");
222 else if (bfd_get_arch_size (ibfd) == 64
223 && bfd_get_arch_size (obfd) == 32)
224 msg = _("%s: compiled as 64-bit object and %s is 32-bit");
225 else
226 msg = _("%s: object size does not match that of target %s");
228 (*_bfd_error_handler) (msg, bfd_get_filename (ibfd),
229 bfd_get_filename (obfd));
230 bfd_set_error (bfd_error_wrong_format);
231 return FALSE;
234 old_flags = elf_elfheader (obfd)->e_flags;
235 new_flags = elf_elfheader (ibfd)->e_flags;
236 if (! elf_flags_init (obfd))
238 /* This happens when ld starts out with a 'blank' output file. */
239 elf_flags_init (obfd) = TRUE;
240 elf_elfheader (obfd)->e_flags = old_flags = new_flags;
242 /* We don't allow linking in non-SH64 code. */
243 else if ((new_flags & EF_SH_MACH_MASK) != EF_SH5)
245 (*_bfd_error_handler)
246 ("%s: uses non-SH64 instructions while previous modules use SH64 instructions",
247 bfd_get_filename (ibfd));
248 bfd_set_error (bfd_error_bad_value);
249 return FALSE;
252 /* I can't think of anything sane other than old_flags being EF_SH5 and
253 that we need to preserve that. */
254 elf_elfheader (obfd)->e_flags = old_flags;
255 return sh64_elf_set_mach_from_flags (obfd);
258 /* Handle a SH64-specific section when reading an object file. This
259 is called when bfd_section_from_shdr finds a section with an unknown
260 type.
262 We only recognize SHT_SH5_CR_SORTED, on the .cranges section. */
264 bfd_boolean
265 sh64_backend_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr,
266 const char *name, int shindex)
268 flagword flags = 0;
270 /* We do like MIPS with a bit switch for recognized types, and returning
271 FALSE for a recognized section type with an unexpected name. Right
272 now we only have one recognized type, but that might change. */
273 switch (hdr->sh_type)
275 case SHT_SH5_CR_SORTED:
276 if (strcmp (name, SH64_CRANGES_SECTION_NAME) != 0)
277 return FALSE;
279 /* We set the SEC_SORT_ENTRIES flag so it can be passed on to
280 sh64_elf_fake_sections, keeping SHT_SH5_CR_SORTED if this object
281 passes through objcopy. Perhaps it is brittle; the flag can
282 suddenly be used by other BFD parts, but it seems not really used
283 anywhere at the moment. */
284 flags = SEC_DEBUGGING | SEC_SORT_ENTRIES;
285 break;
287 default:
288 return FALSE;
291 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
292 return FALSE;
294 if (flags
295 && ! bfd_set_section_flags (abfd, hdr->bfd_section,
296 bfd_get_section_flags (abfd,
297 hdr->bfd_section)
298 | flags))
299 return FALSE;
301 return TRUE;
304 /* In contrast to sh64_backend_section_from_shdr, this is called for all
305 sections, but only when copying sections, not when linking or
306 assembling. We need to set up the sh64_elf_section_data (asection *)
307 structure for the SH64 ELF section flags to be copied correctly. */
309 bfd_boolean
310 sh64_bfd_elf_copy_private_section_data (bfd *ibfd, asection *isec,
311 bfd *obfd, asection *osec)
313 struct sh64_section_data *sh64_sec_data;
315 if (ibfd->xvec->flavour != bfd_target_elf_flavour
316 || obfd->xvec->flavour != bfd_target_elf_flavour)
317 return TRUE;
319 if (! _bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec))
320 return FALSE;
322 sh64_sec_data = sh64_elf_section_data (isec)->sh64_info;
323 if (sh64_sec_data == NULL)
325 sh64_sec_data = bfd_zmalloc (sizeof (struct sh64_section_data));
327 if (sh64_sec_data == NULL)
328 return FALSE;
330 sh64_sec_data->contents_flags
331 = (elf_section_data (isec)->this_hdr.sh_flags
332 & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED));
334 sh64_elf_section_data (osec)->sh64_info = sh64_sec_data;
337 return TRUE;
340 /* Function to keep SH64 specific file flags. */
342 static bfd_boolean
343 sh64_elf_set_private_flags (bfd *abfd, flagword flags)
345 BFD_ASSERT (! elf_flags_init (abfd)
346 || elf_elfheader (abfd)->e_flags == flags);
348 elf_elfheader (abfd)->e_flags = flags;
349 elf_flags_init (abfd) = TRUE;
350 return sh64_elf_set_mach_from_flags (abfd);
353 /* Called when writing out an object file to decide the type of a symbol. */
355 static int
356 sh64_elf_get_symbol_type (Elf_Internal_Sym *elf_sym, int type)
358 if (ELF_ST_TYPE (elf_sym->st_info) == STT_DATALABEL)
359 return STT_DATALABEL;
361 return type;
364 /* Hook called by the linker routine which adds symbols from an object
365 file. We must make indirect symbols for undefined symbols marked with
366 STT_DATALABEL, so relocations passing them will pick up that attribute
367 and neutralize STO_SH5_ISA32 found on the symbol definition.
369 There is a problem, though: We want to fill in the hash-table entry for
370 this symbol and signal to the caller that no further processing is
371 needed. But we don't have the index for this hash-table entry. We
372 rely here on that the current entry is the first hash-entry with NULL,
373 which seems brittle. Also, iterating over the hash-table to find that
374 entry is a linear operation on the number of symbols in this input
375 file, and this function should take constant time, so that's not good
376 too. Only comfort is that DataLabel references should only be found in
377 hand-written assembly code and thus be rare. FIXME: Talk maintainers
378 into adding an option to elf_add_symbol_hook (preferably) for the index
379 or the hash entry, alternatively adding the index to Elf_Internal_Sym
380 (not so good). */
382 static bfd_boolean
383 sh64_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
384 Elf_Internal_Sym *sym, const char **namep,
385 flagword *flagsp ATTRIBUTE_UNUSED,
386 asection **secp, bfd_vma *valp)
388 /* We want to do this for relocatable as well as final linking. */
389 if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL
390 && is_elf_hash_table (info->hash))
392 struct elf_link_hash_entry *h;
394 /* For relocatable links, we register the DataLabel sym in its own
395 right, and tweak the name when it's output. Otherwise, we make
396 an indirect symbol of it. */
397 flagword flags
398 = info->relocatable || info->emitrelocations
399 ? BSF_GLOBAL : BSF_GLOBAL | BSF_INDIRECT;
401 char *dl_name
402 = bfd_malloc (strlen (*namep) + sizeof (DATALABEL_SUFFIX));
403 struct elf_link_hash_entry ** sym_hash = elf_sym_hashes (abfd);
405 BFD_ASSERT (sym_hash != NULL);
407 /* Allocation may fail. */
408 if (dl_name == NULL)
409 return FALSE;
411 strcpy (dl_name, *namep);
412 strcat (dl_name, DATALABEL_SUFFIX);
414 h = (struct elf_link_hash_entry *)
415 bfd_link_hash_lookup (info->hash, dl_name, FALSE, FALSE, FALSE);
417 if (h == NULL)
419 /* No previous datalabel symbol. Make one. */
420 struct bfd_link_hash_entry *bh = NULL;
421 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
423 if (! _bfd_generic_link_add_one_symbol (info, abfd, dl_name,
424 flags, *secp, *valp,
425 *namep, FALSE,
426 bed->collect, &bh))
428 free (dl_name);
429 return FALSE;
432 h = (struct elf_link_hash_entry *) bh;
433 h->non_elf = 0;
434 h->type = STT_DATALABEL;
436 else
437 /* If a new symbol was created, it holds the allocated name.
438 Otherwise, we don't need it anymore and should deallocate it. */
439 free (dl_name);
441 if (h->type != STT_DATALABEL
442 || ((info->relocatable || info->emitrelocations)
443 && h->root.type != bfd_link_hash_undefined)
444 || (! info->relocatable && !info->emitrelocations
445 && h->root.type != bfd_link_hash_indirect))
447 /* Make sure we don't get confused on invalid input. */
448 (*_bfd_error_handler)
449 (_("%s: encountered datalabel symbol in input"),
450 bfd_get_filename (abfd));
451 bfd_set_error (bfd_error_bad_value);
452 return FALSE;
455 /* Now find the hash-table slot for this entry and fill it in. */
456 while (*sym_hash != NULL)
457 sym_hash++;
458 *sym_hash = h;
460 /* Signal to caller to skip this symbol - we've handled it. */
461 *namep = NULL;
464 return TRUE;
467 /* This hook function is called before the linker writes out a global
468 symbol. For relocatable links, DataLabel symbols will be present in
469 linker output. We cut off the special suffix on those symbols, so the
470 right name appears in the output.
472 When linking and emitting relocations, there can appear global symbols
473 that are not referenced by relocs, but rather only implicitly through
474 DataLabel references, a relation that is not visible to the linker.
475 Since no stripping of global symbols in done when doing such linking,
476 we don't need to look up and make sure to emit the main symbol for each
477 DataLabel symbol. */
479 bfd_boolean
480 sh64_elf_link_output_symbol_hook (struct bfd_link_info *info,
481 const char *cname,
482 Elf_Internal_Sym *sym,
483 asection *input_sec ATTRIBUTE_UNUSED,
484 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
486 char *name = (char *) cname;
488 if (info->relocatable || info->emitrelocations)
490 if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL)
491 name[strlen (name) - strlen (DATALABEL_SUFFIX)] = 0;
494 return TRUE;
497 /* Check a SH64-specific reloc and put the value to relocate to into
498 RELOCATION, ready to pass to _bfd_final_link_relocate. Return FALSE if
499 bad value, TRUE if ok. */
501 static bfd_boolean
502 shmedia_prepare_reloc (struct bfd_link_info *info, bfd *abfd,
503 asection *input_section, bfd_byte *contents,
504 const Elf_Internal_Rela *rel, bfd_vma *relocation)
506 bfd_vma disp, dropped;
508 switch (ELF32_R_TYPE (rel->r_info))
510 case R_SH_PT_16:
511 /* Check the lowest bit of the destination field. If it is 1, we
512 check the ISA type of the destination (i.e. the low bit of the
513 "relocation" value, and emit an error if the instruction does not
514 match). If it is 0, we change a PTA to PTB. There should never
515 be a PTB that should change to a PTA; that indicates a toolchain
516 error; a mismatch with GAS. */
518 char *msg = NULL;
519 bfd_vma insn = bfd_get_32 (abfd, contents + rel->r_offset);
521 if (insn & (1 << 10))
523 /* Check matching insn and ISA (address of target). */
524 if ((insn & SHMEDIA_PTB_BIT) != 0
525 && ((*relocation + rel->r_addend) & 1) != 0)
526 msg = _("PTB mismatch: a SHmedia address (bit 0 == 1)");
527 else if ((insn & SHMEDIA_PTB_BIT) == 0
528 && ((*relocation + rel->r_addend) & 1) == 0)
529 msg = _("PTA mismatch: a SHcompact address (bit 0 == 0)");
531 if (msg != NULL
532 && ! ((*info->callbacks->reloc_dangerous)
533 (info, msg, abfd, input_section,
534 rel->r_offset)))
535 return FALSE;
537 else
539 /* We shouldn't get here with a PTB insn and a R_SH_PT_16. It
540 means GAS output does not match expectations; a PTA or PTB
541 expressed as such (or a PT found at assembly to be PTB)
542 would match the test above, and PT expansion with an
543 unknown destination (or when relaxing) will get us here. */
544 if ((insn & SHMEDIA_PTB_BIT) != 0)
546 (*_bfd_error_handler)
547 (_("%s: GAS error: unexpected PTB insn with R_SH_PT_16"),
548 bfd_get_filename (input_section->owner));
549 return FALSE;
552 /* Change the PTA to a PTB, if destination indicates so. */
553 if (((*relocation + rel->r_addend) & 1) == 0)
554 bfd_put_32 (abfd, insn | SHMEDIA_PTB_BIT,
555 contents + rel->r_offset);
559 case R_SH_SHMEDIA_CODE:
560 case R_SH_DIR5U:
561 case R_SH_DIR6S:
562 case R_SH_DIR6U:
563 case R_SH_DIR10S:
564 case R_SH_DIR10SW:
565 case R_SH_DIR10SL:
566 case R_SH_DIR10SQ:
567 case R_SH_IMMS16:
568 case R_SH_IMMU16:
569 case R_SH_IMM_LOW16:
570 case R_SH_IMM_LOW16_PCREL:
571 case R_SH_IMM_MEDLOW16:
572 case R_SH_IMM_MEDLOW16_PCREL:
573 case R_SH_IMM_MEDHI16:
574 case R_SH_IMM_MEDHI16_PCREL:
575 case R_SH_IMM_HI16:
576 case R_SH_IMM_HI16_PCREL:
577 case R_SH_64:
578 case R_SH_64_PCREL:
579 break;
581 default:
582 return FALSE;
585 disp = (*relocation & 0xf);
586 dropped = 0;
587 switch (ELF32_R_TYPE (rel->r_info))
589 case R_SH_DIR10SW: dropped = disp & 1; break;
590 case R_SH_DIR10SL: dropped = disp & 3; break;
591 case R_SH_DIR10SQ: dropped = disp & 7; break;
593 if (dropped != 0)
595 (*_bfd_error_handler)
596 (_("%B: error: unaligned relocation type %d at %08x reloc %p\n"),
597 input_section->owner, ELF32_R_TYPE (rel->r_info),
598 (unsigned) rel->r_offset, relocation);
599 return FALSE;
602 return TRUE;
605 /* Helper function to locate the section holding a certain address. This
606 is called via bfd_map_over_sections. */
608 static void
609 sh64_find_section_for_address (bfd *abfd ATTRIBUTE_UNUSED,
610 asection *section, void *data)
612 bfd_vma vma;
613 bfd_size_type size;
615 struct sh64_find_section_vma_data *fsec_datap
616 = (struct sh64_find_section_vma_data *) data;
618 /* Return if already found. */
619 if (fsec_datap->section)
620 return;
622 /* If this section isn't part of the addressable contents, skip it. */
623 if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
624 return;
626 vma = bfd_get_section_vma (abfd, section);
627 if (fsec_datap->addr < vma)
628 return;
630 size = section->size;
631 if (fsec_datap->addr >= vma + size)
632 return;
634 fsec_datap->section = section;
637 /* Make sure to write out the generated entries in the .cranges section
638 when doing partial linking, and set bit 0 on the entry address if it
639 points to SHmedia code and write sorted .cranges entries when writing
640 executables (final linking and objcopy). */
642 static void
643 sh64_elf_final_write_processing (bfd *abfd,
644 bfd_boolean linker ATTRIBUTE_UNUSED)
646 bfd_vma ld_generated_cranges_size;
647 asection *cranges
648 = bfd_get_section_by_name (abfd, SH64_CRANGES_SECTION_NAME);
650 /* If no new .cranges were added, the generic ELF linker parts will
651 write it all out. If not, we need to write them out when doing
652 partial linking. For a final link, we will sort them and write them
653 all out further below. */
654 if (linker
655 && cranges != NULL
656 && elf_elfheader (abfd)->e_type != ET_EXEC
657 && (ld_generated_cranges_size
658 = sh64_elf_section_data (cranges)->sh64_info->cranges_growth) != 0)
660 bfd_vma incoming_cranges_size
661 = cranges->size - ld_generated_cranges_size;
663 if (! bfd_set_section_contents (abfd, cranges,
664 cranges->contents
665 + incoming_cranges_size,
666 cranges->output_offset
667 + incoming_cranges_size,
668 ld_generated_cranges_size))
670 bfd_set_error (bfd_error_file_truncated);
671 (*_bfd_error_handler)
672 (_("%s: could not write out added .cranges entries"),
673 bfd_get_filename (abfd));
677 /* Only set entry address bit 0 and sort .cranges when linking to an
678 executable; never with objcopy or strip. */
679 if (linker && elf_elfheader (abfd)->e_type == ET_EXEC)
681 struct sh64_find_section_vma_data fsec_data;
682 sh64_elf_crange dummy;
684 /* For a final link, set the low bit of the entry address to
685 reflect whether or not it is a SHmedia address.
686 FIXME: Perhaps we shouldn't do this if the entry address was
687 supplied numerically, but we currently lack the infrastructure to
688 recognize that: The entry symbol, and info whether it is numeric
689 or a symbol name is kept private in the linker. */
690 fsec_data.addr = elf_elfheader (abfd)->e_entry;
691 fsec_data.section = NULL;
693 bfd_map_over_sections (abfd, sh64_find_section_for_address,
694 &fsec_data);
695 if (fsec_data.section
696 && (sh64_get_contents_type (fsec_data.section,
697 elf_elfheader (abfd)->e_entry,
698 &dummy) == CRT_SH5_ISA32))
699 elf_elfheader (abfd)->e_entry |= 1;
701 /* If we have a .cranges section, sort the entries. */
702 if (cranges != NULL)
704 bfd_size_type cranges_size = cranges->size;
706 /* We know we always have these in memory at this time. */
707 BFD_ASSERT (cranges->contents != NULL);
709 /* The .cranges may already have been sorted in the process of
710 finding out the ISA-type of the entry address. If not, we do
711 it here. */
712 if (elf_section_data (cranges)->this_hdr.sh_type
713 != SHT_SH5_CR_SORTED)
715 qsort (cranges->contents, cranges_size / SH64_CRANGE_SIZE,
716 SH64_CRANGE_SIZE,
717 bfd_big_endian (cranges->owner)
718 ? _bfd_sh64_crange_qsort_cmpb
719 : _bfd_sh64_crange_qsort_cmpl);
720 elf_section_data (cranges)->this_hdr.sh_type
721 = SHT_SH5_CR_SORTED;
724 /* We need to write it out in whole as sorted. */
725 if (! bfd_set_section_contents (abfd, cranges,
726 cranges->contents,
727 cranges->output_offset,
728 cranges_size))
730 bfd_set_error (bfd_error_file_truncated);
731 (*_bfd_error_handler)
732 (_("%s: could not write out sorted .cranges entries"),
733 bfd_get_filename (abfd));
739 /* Merge non visibility st_other attribute when the symbol comes from
740 a dynamic object. */
741 static void
742 sh64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
743 const Elf_Internal_Sym *isym,
744 bfd_boolean definition,
745 bfd_boolean dynamic)
747 if (isym->st_other != 0 && dynamic)
749 unsigned char other;
751 /* Take the balance of OTHER from the definition. */
752 other = (definition ? isym->st_other : h->other);
753 other &= ~ ELF_ST_VISIBILITY (-1);
754 h->other = other | ELF_ST_VISIBILITY (h->other);
757 return;
760 static const struct bfd_elf_special_section sh64_elf_special_sections[] =
762 { ".cranges", 8, 0, SHT_PROGBITS, 0 },
763 { NULL, 0, 0, 0, 0 }
766 #undef TARGET_BIG_SYM
767 #define TARGET_BIG_SYM bfd_elf32_sh64_vec
768 #undef TARGET_BIG_NAME
769 #define TARGET_BIG_NAME "elf32-sh64"
770 #undef TARGET_LITTLE_SYM
771 #define TARGET_LITTLE_SYM bfd_elf32_sh64l_vec
772 #undef TARGET_LITTLE_NAME
773 #define TARGET_LITTLE_NAME "elf32-sh64l"
775 #include "elf32-target.h"
777 /* NetBSD support. */
778 #undef TARGET_BIG_SYM
779 #define TARGET_BIG_SYM bfd_elf32_sh64nbsd_vec
780 #undef TARGET_BIG_NAME
781 #define TARGET_BIG_NAME "elf32-sh64-nbsd"
782 #undef TARGET_LITTLE_SYM
783 #define TARGET_LITTLE_SYM bfd_elf32_sh64lnbsd_vec
784 #undef TARGET_LITTLE_NAME
785 #define TARGET_LITTLE_NAME "elf32-sh64l-nbsd"
786 #undef ELF_MAXPAGESIZE
787 #define ELF_MAXPAGESIZE 0x10000
788 #undef elf_symbol_leading_char
789 #define elf_symbol_leading_char 0
790 #undef elf32_bed
791 #define elf32_bed elf32_sh64_nbsd_bed
793 #include "elf32-target.h"
795 /* Linux support. */
796 #undef TARGET_BIG_SYM
797 #define TARGET_BIG_SYM bfd_elf32_sh64blin_vec
798 #undef TARGET_BIG_NAME
799 #define TARGET_BIG_NAME "elf32-sh64big-linux"
800 #undef TARGET_LITTLE_SYM
801 #define TARGET_LITTLE_SYM bfd_elf32_sh64lin_vec
802 #undef TARGET_LITTLE_NAME
803 #define TARGET_LITTLE_NAME "elf32-sh64-linux"
804 #undef elf32_bed
805 #define elf32_bed elf32_sh64_lin_bed
807 #include "elf32-target.h"