1 /* Hitachi SH64-specific support for 32-bit ELF
2 Copyright 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
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 2 of the License, or
9 (at your option) any later version.
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.
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 #include "../opcodes/sh64-opc.h"
26 #include "elf32-sh64.h"
28 /* Add a suffix for datalabel indirection symbols. It must not match any
29 other symbols; user symbols with or without version or other
30 decoration. It must only be used internally and not emitted by any
32 #define DATALABEL_SUFFIX " DL"
34 /* Used to hold data for function called through bfd_map_over_sections. */
35 struct sh64_find_section_vma_data
41 static bfd_boolean sh64_elf_new_section_hook
42 PARAMS ((bfd *, asection *));
43 static bfd_boolean sh64_elf_copy_private_data
44 PARAMS ((bfd *, bfd *));
45 static bfd_boolean sh64_elf_merge_private_data
46 PARAMS ((bfd *, bfd *));
47 static bfd_boolean sh64_elf_fake_sections
48 PARAMS ((bfd *, Elf_Internal_Shdr *, asection *));
49 static bfd_boolean sh64_elf_set_private_flags
50 PARAMS ((bfd *, flagword));
51 static bfd_boolean sh64_elf_set_mach_from_flags
53 static bfd_boolean shmedia_prepare_reloc
54 PARAMS ((struct bfd_link_info *, bfd *, asection *,
55 bfd_byte *, const Elf_Internal_Rela *, bfd_vma *));
56 static int sh64_elf_get_symbol_type
57 PARAMS ((Elf_Internal_Sym *, int));
58 static bfd_boolean sh64_elf_add_symbol_hook
59 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
60 const char **, flagword *, asection **, bfd_vma *));
61 static bfd_boolean sh64_elf_link_output_symbol_hook
62 PARAMS ((bfd *, struct bfd_link_info *, const char *, Elf_Internal_Sym *,
64 static bfd_boolean sh64_backend_section_from_shdr
65 PARAMS ((bfd *, Elf_Internal_Shdr *, const char *));
66 static void sh64_elf_final_write_processing
67 PARAMS ((bfd *, bfd_boolean));
68 static bfd_boolean sh64_bfd_elf_copy_private_section_data
69 PARAMS ((bfd *, asection *, bfd *, asection *));
70 static void sh64_find_section_for_address
71 PARAMS ((bfd *, asection *, PTR));
73 /* Let elf32-sh.c handle the "bfd_" definitions, so we only have to
74 intrude with an #ifndef around the function definition. */
75 #define sh_elf_copy_private_data sh64_elf_copy_private_data
76 #define sh_elf_merge_private_data sh64_elf_merge_private_data
77 #define sh_elf_set_private_flags sh64_elf_set_private_flags
78 /* Typo in elf32-sh.c (and unlinear name). */
79 #define bfd_elf32_bfd_set_private_flags sh64_elf_set_private_flags
80 #define sh_elf_set_mach_from_flags sh64_elf_set_mach_from_flags
82 #define elf_backend_sign_extend_vma 1
83 #define elf_backend_fake_sections sh64_elf_fake_sections
84 #define elf_backend_get_symbol_type sh64_elf_get_symbol_type
85 #define elf_backend_add_symbol_hook sh64_elf_add_symbol_hook
86 #define elf_backend_link_output_symbol_hook \
87 sh64_elf_link_output_symbol_hook
88 #define elf_backend_final_write_processing sh64_elf_final_write_processing
89 #define elf_backend_section_from_shdr sh64_backend_section_from_shdr
91 #define bfd_elf32_new_section_hook sh64_elf_new_section_hook
93 /* For objcopy, we need to set up sh64_elf_section_data (asection *) from
94 incoming section flags. This is otherwise done in sh64elf.em when
95 linking or tc-sh64.c when assembling. */
96 #define bfd_elf32_bfd_copy_private_section_data \
97 sh64_bfd_elf_copy_private_section_data
99 /* This COFF-only function (only compiled with COFF support, making
100 ELF-only chains problematic) returns TRUE early for SH4, so let's just
101 define it TRUE here. */
102 #define _bfd_sh_align_load_span(a,b,c,d,e,f,g,h,i,j) TRUE
104 #define GOT_BIAS (-((long)-32768))
105 #define INCLUDE_SHMEDIA
106 #include "elf32-sh.c"
108 /* Tack some extra info on struct bfd_elf_section_data. */
111 sh64_elf_new_section_hook (abfd, sec)
115 struct _sh64_elf_section_data *sdata;
116 bfd_size_type amt = sizeof (*sdata);
118 sdata = (struct _sh64_elf_section_data *) bfd_zalloc (abfd, amt);
121 sec->used_by_bfd = (PTR) sdata;
123 return _bfd_elf_new_section_hook (abfd, sec);
126 /* Set the SHF_SH5_ISA32 flag for ISA SHmedia code sections, and pass
127 through SHT_SH5_CR_SORTED on a sorted .cranges section. */
130 sh64_elf_fake_sections (output_bfd, elf_section_hdr, asect)
131 bfd *output_bfd ATTRIBUTE_UNUSED;
132 Elf_Internal_Shdr *elf_section_hdr;
135 if (sh64_elf_section_data (asect)->sh64_info != NULL)
136 elf_section_hdr->sh_flags
137 |= sh64_elf_section_data (asect)->sh64_info->contents_flags;
139 /* If this section has the SEC_SORT_ENTRIES flag set, it is a sorted
140 .cranges section passing through objcopy. */
141 if ((bfd_get_section_flags (output_bfd, asect) & SEC_SORT_ENTRIES) != 0
142 && strcmp (bfd_get_section_name (output_bfd, asect),
143 SH64_CRANGES_SECTION_NAME) == 0)
144 elf_section_hdr->sh_type = SHT_SH5_CR_SORTED;
150 sh64_elf_set_mach_from_flags (abfd)
153 flagword flags = elf_elfheader (abfd)->e_flags;
156 switch (flags & EF_SH_MACH_MASK)
159 /* These are fit to execute on SH5. Just one but keep the switch
160 construct to make additions easy. */
161 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh5);
165 bfd_set_error (bfd_error_wrong_format);
169 /* We also need to set SEC_DEBUGGING on an incoming .cranges section.
170 We could have used elf_backend_section_flags if it had given us the
171 section name; the bfd_section member in the header argument is not
172 set at the point of the call. FIXME: Find out whether that is by
173 undocumented design or a bug. */
174 cranges = bfd_get_section_by_name (abfd, SH64_CRANGES_SECTION_NAME);
176 && ! bfd_set_section_flags (abfd, cranges,
177 bfd_get_section_flags (abfd, cranges)
185 sh64_elf_copy_private_data (ibfd, obfd)
189 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
190 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
193 BFD_ASSERT (!elf_flags_init (obfd)
194 || (elf_elfheader (obfd)->e_flags
195 == elf_elfheader (ibfd)->e_flags));
197 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
202 sh64_elf_merge_private_data (ibfd, obfd)
206 flagword old_flags, new_flags;
208 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
211 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
212 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
215 if (bfd_get_arch_size (ibfd) != bfd_get_arch_size (obfd))
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");
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);
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);
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 elfcode.h finds a section with an unknown type.
261 We only recognize SHT_SH5_CR_SORTED, on the .cranges section. */
264 sh64_backend_section_from_shdr (abfd, hdr, name)
266 Elf_Internal_Shdr *hdr;
271 /* We do like MIPS with a bit switch for recognized types, and returning
272 FALSE for a recognized section type with an unexpected name. Right
273 now we only have one recognized type, but that might change. */
274 switch (hdr->sh_type)
276 case SHT_SH5_CR_SORTED:
277 if (strcmp (name, SH64_CRANGES_SECTION_NAME) != 0)
280 /* We set the SEC_SORT_ENTRIES flag so it can be passed on to
281 sh64_elf_fake_sections, keeping SHT_SH5_CR_SORTED if this object
282 passes through objcopy. Perhaps it is brittle; the flag can
283 suddenly be used by other BFD parts, but it seems not really used
284 anywhere at the moment. */
285 flags = SEC_DEBUGGING | SEC_SORT_ENTRIES;
292 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
296 && ! bfd_set_section_flags (abfd, hdr->bfd_section,
297 bfd_get_section_flags (abfd,
305 /* In contrast to sh64_backend_section_from_shdr, this is called for all
306 sections, but only when copying sections, not when linking or
307 assembling. We need to set up the sh64_elf_section_data (asection *)
308 structure for the SH64 ELF section flags to be copied correctly. */
311 sh64_bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec)
317 struct sh64_section_data *sh64_sec_data;
319 if (ibfd->xvec->flavour != bfd_target_elf_flavour
320 || obfd->xvec->flavour != bfd_target_elf_flavour)
323 if (! _bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec))
326 sh64_sec_data = sh64_elf_section_data (isec)->sh64_info;
327 if (sh64_sec_data == NULL)
329 sh64_sec_data = bfd_zmalloc (sizeof (struct sh64_section_data));
331 if (sh64_sec_data == NULL)
334 sh64_sec_data->contents_flags
335 = (elf_section_data (isec)->this_hdr.sh_flags
336 & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED));
338 sh64_elf_section_data (osec)->sh64_info = sh64_sec_data;
344 /* Function to keep SH64 specific file flags. */
347 sh64_elf_set_private_flags (abfd, flags)
351 BFD_ASSERT (! elf_flags_init (abfd)
352 || elf_elfheader (abfd)->e_flags == flags);
354 elf_elfheader (abfd)->e_flags = flags;
355 elf_flags_init (abfd) = TRUE;
356 return sh64_elf_set_mach_from_flags (abfd);
359 /* Called when writing out an object file to decide the type of a symbol. */
362 sh64_elf_get_symbol_type (elf_sym, type)
363 Elf_Internal_Sym * elf_sym;
366 if (ELF_ST_TYPE (elf_sym->st_info) == STT_DATALABEL)
367 return STT_DATALABEL;
372 /* Hook called by the linker routine which adds symbols from an object
373 file. We must make indirect symbols for undefined symbols marked with
374 STT_DATALABEL, so relocations passing them will pick up that attribute
375 and neutralize STO_SH5_ISA32 found on the symbol definition.
377 There is a problem, though: We want to fill in the hash-table entry for
378 this symbol and signal to the caller that no further processing is
379 needed. But we don't have the index for this hash-table entry. We
380 rely here on that the current entry is the first hash-entry with NULL,
381 which seems brittle. Also, iterating over the hash-table to find that
382 entry is a linear operation on the number of symbols in this input
383 file, and this function should take constant time, so that's not good
384 too. Only comfort is that DataLabel references should only be found in
385 hand-written assembly code and thus be rare. FIXME: Talk maintainers
386 into adding an option to elf_add_symbol_hook (preferably) for the index
387 or the hash entry, alternatively adding the index to Elf_Internal_Sym
391 sh64_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
393 struct bfd_link_info *info;
394 const Elf_Internal_Sym *sym;
396 flagword *flagsp ATTRIBUTE_UNUSED;
400 /* We want to do this for relocatable as well as final linking. */
401 if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL
402 && info->hash->creator->flavour == bfd_target_elf_flavour)
404 struct elf_link_hash_entry *h;
406 /* For relocateable links, we register the DataLabel sym in its own
407 right, and tweak the name when it's output. Otherwise, we make
408 an indirect symbol of it. */
410 = info->relocateable || info->emitrelocations
411 ? BSF_GLOBAL : BSF_GLOBAL | BSF_INDIRECT;
414 = bfd_malloc (strlen (*namep) + sizeof (DATALABEL_SUFFIX));
415 struct elf_link_hash_entry ** sym_hash = elf_sym_hashes (abfd);
417 BFD_ASSERT (sym_hash != NULL);
419 /* Allocation may fail. */
423 strcpy (dl_name, *namep);
424 strcat (dl_name, DATALABEL_SUFFIX);
426 h = (struct elf_link_hash_entry *)
427 bfd_link_hash_lookup (info->hash, dl_name, FALSE, FALSE, FALSE);
431 /* No previous datalabel symbol. Make one. */
432 struct bfd_link_hash_entry *bh = NULL;
433 struct elf_backend_data *bed = get_elf_backend_data (abfd);
435 if (! _bfd_generic_link_add_one_symbol (info, abfd, dl_name,
444 h = (struct elf_link_hash_entry *) bh;
445 h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
446 h->type = STT_DATALABEL;
449 /* If a new symbol was created, it holds the allocated name.
450 Otherwise, we don't need it anymore and should deallocate it. */
453 if (h->type != STT_DATALABEL
454 || ((info->relocateable || info->emitrelocations)
455 && h->root.type != bfd_link_hash_undefined)
456 || (! info->relocateable && !info->emitrelocations
457 && h->root.type != bfd_link_hash_indirect))
459 /* Make sure we don't get confused on invalid input. */
460 (*_bfd_error_handler)
461 (_("%s: encountered datalabel symbol in input"),
462 bfd_get_filename (abfd));
463 bfd_set_error (bfd_error_bad_value);
467 /* Now find the hash-table slot for this entry and fill it in. */
468 while (*sym_hash != NULL)
472 /* Signal to caller to skip this symbol - we've handled it. */
479 /* This hook function is called before the linker writes out a global
480 symbol. For relocatable links, DataLabel symbols will be present in
481 linker output. We cut off the special suffix on those symbols, so the
482 right name appears in the output.
484 When linking and emitting relocations, there can appear global symbols
485 that are not referenced by relocs, but rather only implicitly through
486 DataLabel references, a relation that is not visible to the linker.
487 Since no stripping of global symbols in done when doing such linking,
488 we don't need to look up and make sure to emit the main symbol for each
492 sh64_elf_link_output_symbol_hook (abfd, info, cname, sym, input_sec)
493 bfd *abfd ATTRIBUTE_UNUSED;
494 struct bfd_link_info *info;
496 Elf_Internal_Sym *sym;
497 asection *input_sec ATTRIBUTE_UNUSED;
499 char *name = (char *) cname;
501 if (info->relocateable || info->emitrelocations)
503 if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL)
504 name[strlen (name) - strlen (DATALABEL_SUFFIX)] = 0;
510 /* Check a SH64-specific reloc and put the value to relocate to into
511 RELOCATION, ready to pass to _bfd_final_link_relocate. Return FALSE if
512 bad value, TRUE if ok. */
515 shmedia_prepare_reloc (info, abfd, input_section,
516 contents, rel, relocation)
517 struct bfd_link_info *info;
519 asection *input_section;
521 const Elf_Internal_Rela *rel;
524 bfd_vma disp, dropped;
526 switch (ELF32_R_TYPE (rel->r_info))
529 /* Check the lowest bit of the destination field. If it is 1, we
530 check the ISA type of the destination (i.e. the low bit of the
531 "relocation" value, and emit an error if the instruction does not
532 match). If it is 0, we change a PTA to PTB. There should never
533 be a PTB that should change to a PTA; that indicates a toolchain
534 error; a mismatch with GAS. */
537 bfd_vma insn = bfd_get_32 (abfd, contents + rel->r_offset);
539 if (insn & (1 << 10))
541 /* Check matching insn and ISA (address of target). */
542 if ((insn & SHMEDIA_PTB_BIT) != 0
543 && ((*relocation + rel->r_addend) & 1) != 0)
544 msg = _("PTB mismatch: a SHmedia address (bit 0 == 1)");
545 else if ((insn & SHMEDIA_PTB_BIT) == 0
546 && ((*relocation + rel->r_addend) & 1) == 0)
547 msg = _("PTA mismatch: a SHcompact address (bit 0 == 0)");
550 && ! ((*info->callbacks->reloc_dangerous)
551 (info, msg, abfd, input_section,
557 /* We shouldn't get here with a PTB insn and a R_SH_PT_16. It
558 means GAS output does not match expectations; a PTA or PTB
559 expressed as such (or a PT found at assembly to be PTB)
560 would match the test above, and PT expansion with an
561 unknown destination (or when relaxing) will get us here. */
562 if ((insn & SHMEDIA_PTB_BIT) != 0)
564 (*_bfd_error_handler)
565 (_("%s: GAS error: unexpected PTB insn with R_SH_PT_16"),
566 bfd_get_filename (input_section->owner));
570 /* Change the PTA to a PTB, if destination indicates so. */
571 if (((*relocation + rel->r_addend) & 1) == 0)
572 bfd_put_32 (abfd, insn | SHMEDIA_PTB_BIT,
573 contents + rel->r_offset);
577 case R_SH_SHMEDIA_CODE:
588 case R_SH_IMM_LOW16_PCREL:
589 case R_SH_IMM_MEDLOW16:
590 case R_SH_IMM_MEDLOW16_PCREL:
591 case R_SH_IMM_MEDHI16:
592 case R_SH_IMM_MEDHI16_PCREL:
594 case R_SH_IMM_HI16_PCREL:
603 disp = (*relocation & 0xf);
605 switch (ELF32_R_TYPE (rel->r_info))
607 case R_SH_DIR10SW: dropped = disp & 1; break;
608 case R_SH_DIR10SL: dropped = disp & 3; break;
609 case R_SH_DIR10SQ: dropped = disp & 7; break;
613 (*_bfd_error_handler)
614 (_("%s: error: unaligned relocation type %d at %08x reloc %08x\n"),
615 bfd_get_filename (input_section->owner), ELF32_R_TYPE (rel->r_info),
616 (unsigned)rel->r_offset, (unsigned)relocation);
623 /* Helper function to locate the section holding a certain address. This
624 is called via bfd_map_over_sections. */
627 sh64_find_section_for_address (abfd, section, data)
628 bfd *abfd ATTRIBUTE_UNUSED;
634 struct sh64_find_section_vma_data *fsec_datap
635 = (struct sh64_find_section_vma_data *) data;
637 /* Return if already found. */
638 if (fsec_datap->section)
641 /* If this section isn't part of the addressable contents, skip it. */
642 if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
645 vma = bfd_get_section_vma (abfd, section);
646 if (fsec_datap->addr < vma)
649 /* FIXME: section->reloc_done isn't set properly; a generic buglet
650 preventing us from using bfd_get_section_size_after_reloc. */
652 = section->_cooked_size ? section->_cooked_size : section->_raw_size;
654 if (fsec_datap->addr >= vma + size)
657 fsec_datap->section = section;
660 /* Make sure to write out the generated entries in the .cranges section
661 when doing partial linking, and set bit 0 on the entry address if it
662 points to SHmedia code and write sorted .cranges entries when writing
663 executables (final linking and objcopy). */
666 sh64_elf_final_write_processing (abfd, linker)
668 bfd_boolean linker ATTRIBUTE_UNUSED;
670 bfd_vma ld_generated_cranges_size;
672 = bfd_get_section_by_name (abfd, SH64_CRANGES_SECTION_NAME);
674 /* If no new .cranges were added, the generic ELF linker parts will
675 write it all out. If not, we need to write them out when doing
676 partial linking. For a final link, we will sort them and write them
677 all out further below. */
680 && elf_elfheader (abfd)->e_type != ET_EXEC
681 && (ld_generated_cranges_size
682 = sh64_elf_section_data (cranges)->sh64_info->cranges_growth) != 0)
684 bfd_vma incoming_cranges_size
685 = ((cranges->_cooked_size != 0
686 ? cranges->_cooked_size : cranges->_raw_size)
687 - ld_generated_cranges_size);
689 if (! bfd_set_section_contents (abfd, cranges,
691 + incoming_cranges_size,
692 cranges->output_offset
693 + incoming_cranges_size,
694 ld_generated_cranges_size))
696 bfd_set_error (bfd_error_file_truncated);
697 (*_bfd_error_handler)
698 (_("%s: could not write out added .cranges entries"),
699 bfd_get_filename (abfd));
703 /* Only set entry address bit 0 and sort .cranges when linking to an
704 executable; never with objcopy or strip. */
705 if (linker && elf_elfheader (abfd)->e_type == ET_EXEC)
707 struct sh64_find_section_vma_data fsec_data;
708 sh64_elf_crange dummy;
710 /* For a final link, set the low bit of the entry address to
711 reflect whether or not it is a SHmedia address.
712 FIXME: Perhaps we shouldn't do this if the entry address was
713 supplied numerically, but we currently lack the infrastructure to
714 recognize that: The entry symbol, and info whether it is numeric
715 or a symbol name is kept private in the linker. */
716 fsec_data.addr = elf_elfheader (abfd)->e_entry;
717 fsec_data.section = NULL;
719 bfd_map_over_sections (abfd, sh64_find_section_for_address,
721 if (fsec_data.section
722 && (sh64_get_contents_type (fsec_data.section,
723 elf_elfheader (abfd)->e_entry,
724 &dummy) == CRT_SH5_ISA32))
725 elf_elfheader (abfd)->e_entry |= 1;
727 /* If we have a .cranges section, sort the entries. */
730 bfd_size_type cranges_size
731 = (cranges->_cooked_size != 0
732 ? cranges->_cooked_size : cranges->_raw_size);
734 /* We know we always have these in memory at this time. */
735 BFD_ASSERT (cranges->contents != NULL);
737 /* The .cranges may already have been sorted in the process of
738 finding out the ISA-type of the entry address. If not, we do
740 if (elf_section_data (cranges)->this_hdr.sh_type
741 != SHT_SH5_CR_SORTED)
743 qsort (cranges->contents, cranges_size / SH64_CRANGE_SIZE,
745 bfd_big_endian (cranges->owner)
746 ? _bfd_sh64_crange_qsort_cmpb
747 : _bfd_sh64_crange_qsort_cmpl);
748 elf_section_data (cranges)->this_hdr.sh_type
752 /* We need to write it out in whole as sorted. */
753 if (! bfd_set_section_contents (abfd, cranges,
755 cranges->output_offset,
758 bfd_set_error (bfd_error_file_truncated);
759 (*_bfd_error_handler)
760 (_("%s: could not write out sorted .cranges entries"),
761 bfd_get_filename (abfd));
767 #undef TARGET_BIG_SYM
768 #define TARGET_BIG_SYM bfd_elf32_sh64_vec
769 #undef TARGET_BIG_NAME
770 #define TARGET_BIG_NAME "elf32-sh64"
771 #undef TARGET_LITTLE_SYM
772 #define TARGET_LITTLE_SYM bfd_elf32_sh64l_vec
773 #undef TARGET_LITTLE_NAME
774 #define TARGET_LITTLE_NAME "elf32-sh64l"
776 #include "elf32-target.h"
778 /* NetBSD support. */
779 #undef TARGET_BIG_SYM
780 #define TARGET_BIG_SYM bfd_elf32_sh64nbsd_vec
781 #undef TARGET_BIG_NAME
782 #define TARGET_BIG_NAME "elf32-sh64-nbsd"
783 #undef TARGET_LITTLE_SYM
784 #define TARGET_LITTLE_SYM bfd_elf32_sh64lnbsd_vec
785 #undef TARGET_LITTLE_NAME
786 #define TARGET_LITTLE_NAME "elf32-sh64l-nbsd"
787 #undef ELF_MAXPAGESIZE
788 #define ELF_MAXPAGESIZE 0x10000
789 #undef elf_symbol_leading_char
790 #define elf_symbol_leading_char 0
792 #define elf32_bed elf32_sh64_nbsd_bed
794 #include "elf32-target.h"
797 #undef TARGET_BIG_SYM
798 #define TARGET_BIG_SYM bfd_elf32_sh64blin_vec
799 #undef TARGET_BIG_NAME
800 #define TARGET_BIG_NAME "elf32-sh64big-linux"
801 #undef TARGET_LITTLE_SYM
802 #define TARGET_LITTLE_SYM bfd_elf32_sh64lin_vec
803 #undef TARGET_LITTLE_NAME
804 #define TARGET_LITTLE_NAME "elf32-sh64-linux"
806 #define elf32_bed elf32_sh64_lin_bed
808 #include "elf32-target.h"