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