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