1# This shell script emits a C file. -*- C -*- 2# Copyright (C) 2000-2016 Free Software Foundation, Inc. 3# 4# This file is part of the GNU Binutils. 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 22# This file is sourced from elf32.em, and defines extra sh64 23# specific routines. 24# 25 26LDEMUL_AFTER_ALLOCATION=sh64_elf_${EMULATION_NAME}_after_allocation 27LDEMUL_BEFORE_ALLOCATION=sh64_elf_${EMULATION_NAME}_before_allocation 28 29fragment <<EOF 30 31#include "libiberty.h" 32#include "libbfd.h" 33#include "elf-bfd.h" 34#include "elf/sh.h" 35#include "elf32-sh64.h" 36 37/* Check if we need a .cranges section and create it if it's not in any 38 input file. It might seem better to always create it and if unneeded, 39 discard it, but I don't find a simple way to discard it totally from 40 the output. 41 42 Putting it here instead of as a elf_backend_always_size_sections hook 43 in elf32-sh64.c, means that we have access to linker command line 44 options here, and we can access input sections in the order in which 45 they will be linked. */ 46 47static void 48sh64_elf_${EMULATION_NAME}_before_allocation (void) 49{ 50 asection *cranges; 51 asection *osec; 52 53 /* Call main function; we're just extending it. */ 54 gld${EMULATION_NAME}_before_allocation (); 55 56 cranges = bfd_get_section_by_name (link_info.output_bfd, 57 SH64_CRANGES_SECTION_NAME); 58 59 if (cranges != NULL) 60 { 61 if (RELAXATION_ENABLED) 62 { 63 /* FIXME: Look through incoming sections with .cranges 64 descriptors, build up some kind of descriptors that the 65 relaxing function will pick up and adjust, or perhaps make it 66 find and adjust an associated .cranges descriptor. We could 67 also look through incoming relocs and kill the ones marking 68 relaxation areas, but that wouldn't be TRT. */ 69 einfo 70 (_("%P: Sorry, turning off relaxing: .cranges section in input.\n")); 71 einfo (_(" A .cranges section is present in:\n")); 72 73 { 74 LANG_FOR_EACH_INPUT_STATEMENT (f) 75 { 76 asection *input_cranges 77 = bfd_get_section_by_name (f->the_bfd, 78 SH64_CRANGES_SECTION_NAME); 79 if (input_cranges != NULL) 80 einfo (" %I\n", f); 81 } 82 } 83 84 DISABLE_RELAXATION; 85 } 86 87 /* We wouldn't need to do anything when there's already a .cranges 88 section (and have a return here), except that we need to set the 89 section flags right for output sections that *don't* need a 90 .cranges section. */ 91 } 92 93 if (RELAXATION_ENABLED) 94 { 95 LANG_FOR_EACH_INPUT_STATEMENT (f) 96 { 97 if (bfd_get_flavour (f->the_bfd) == bfd_target_elf_flavour) 98 { 99 asection *isec; 100 101 for (isec = f->the_bfd->sections; 102 isec != NULL; 103 isec = isec->next) 104 { 105 if (elf_section_data (isec)->this_hdr.sh_flags 106 & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED)) 107 { 108 einfo (_("%P: Sorry, turning off relaxing: SHmedia sections present.\n")); 109 einfo (" %I\n", f); 110 DISABLE_RELAXATION; 111 goto done_scanning_shmedia_sections; 112 } 113 } 114 } 115 } 116 } 117 done_scanning_shmedia_sections: 118 119 /* For each non-empty input section in each output section, check if it 120 has the same SH64-specific flags. If some input section differs, we 121 need a .cranges section. */ 122 for (osec = link_info.output_bfd->sections; 123 osec != NULL; 124 osec = osec->next) 125 { 126 struct sh64_section_data *sh64_sec_data; 127 bfd_vma oflags_isa = 0; 128 bfd_vma iflags_isa = 0; 129 130 if (bfd_get_flavour (link_info.output_bfd) != bfd_target_elf_flavour) 131 einfo (_("%FError: non-ELF output formats are not supported by this target's linker.\n")); 132 133 sh64_sec_data = sh64_elf_section_data (osec)->sh64_info; 134 135 /* Omit excluded or garbage-collected sections. */ 136 if (bfd_get_section_flags (link_info.output_bfd, osec) & SEC_EXCLUDE) 137 continue; 138 139 /* Make sure we have the target section data initialized. */ 140 if (sh64_sec_data == NULL) 141 { 142 sh64_sec_data = xcalloc (1, sizeof (struct sh64_section_data)); 143 sh64_elf_section_data (osec)->sh64_info = sh64_sec_data; 144 } 145 146 /* First find an input section so we have flags to compare with; the 147 flags in the output section are not valid. */ 148 { 149 LANG_FOR_EACH_INPUT_STATEMENT (f) 150 { 151 asection *isec; 152 153 for (isec = f->the_bfd->sections; 154 isec != NULL; 155 isec = isec->next) 156 { 157 if (isec->output_section == osec 158 && isec->size != 0 159 && (bfd_get_section_flags (isec->owner, isec) 160 & SEC_EXCLUDE) == 0) 161 { 162 oflags_isa 163 = (elf_section_data (isec)->this_hdr.sh_flags 164 & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED)); 165 goto break_1; 166 } 167 } 168 } 169 } 170 171 break_1: 172 173 /* Check that all input sections have the same contents-type flags 174 as the first input section. */ 175 { 176 LANG_FOR_EACH_INPUT_STATEMENT (f) 177 { 178 asection *isec; 179 180 for (isec = f->the_bfd->sections; 181 isec != NULL; 182 isec = isec->next) 183 { 184 if (isec->output_section == osec 185 && isec->size != 0 186 && (bfd_get_section_flags (isec->owner, isec) 187 & SEC_EXCLUDE) == 0) 188 { 189 iflags_isa 190 = (elf_section_data (isec)->this_hdr.sh_flags 191 & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED)); 192 193 /* If flags don't agree, we need a .cranges section. 194 Create it here if it did not exist through input 195 sections. */ 196 if (iflags_isa != oflags_isa) 197 { 198 if (cranges == NULL) 199 { 200 /* This section will be *appended* to 201 sections, so the outer iteration will reach 202 it in due time and set 203 sh64_elf_section_data; no need to set it 204 specifically here. */ 205 cranges 206 = bfd_make_section_with_flags (link_info.output_bfd, 207 SH64_CRANGES_SECTION_NAME, 208 SEC_LINKER_CREATED 209 | SEC_KEEP 210 | SEC_HAS_CONTENTS 211 | SEC_DEBUGGING); 212 if (cranges == NULL) 213 einfo 214 (_("%P%E%F: Can't make .cranges section\n")); 215 } 216 217 /* We don't need to look at more input sections, 218 and we know this section will have mixed 219 contents. */ 220 goto break_2; 221 } 222 } 223 } 224 } 225 } 226 227 /* If we got here, then all input sections in this output section 228 have the same contents flag. Put that where we expect to see 229 contents flags. We don't need to do this for sections that will 230 need additional, linker-generated .cranges entries. */ 231 sh64_sec_data->contents_flags = iflags_isa; 232 233 break_2: 234 ; 235 } 236} 237 238/* Size up and extend the .cranges section, merging generated entries. */ 239 240static void 241sh64_elf_${EMULATION_NAME}_after_allocation (void) 242{ 243 bfd_vma new_cranges = 0; 244 bfd_vma cranges_growth = 0; 245 asection *osec; 246 bfd_byte *crangesp; 247 asection *cranges; 248 249 gld${EMULATION_NAME}_after_allocation (); 250 251 /* Needed, since we create link_orders here. */ 252 lang_clear_os_map (); 253 254 cranges = bfd_get_section_by_name (link_info.output_bfd, 255 SH64_CRANGES_SECTION_NAME); 256 257 /* If there is no .cranges section, it is because it was seen earlier on 258 that none was needed. Otherwise it must have been created then, or 259 be present in input. */ 260 if (cranges == NULL) 261 return; 262 263 /* First, we set the ISA flags for each output section according to the 264 first non-discarded section. For each input section in osec, we 265 check if it has the same flags. If it does not, we set flags to mark 266 a mixed section (and exit the loop early). */ 267 for (osec = link_info.output_bfd->sections; 268 osec != NULL; 269 osec = osec->next) 270 { 271 bfd_vma oflags_isa = 0; 272 bfd_boolean need_check_cranges = FALSE; 273 274 /* Omit excluded or garbage-collected sections. */ 275 if (bfd_get_section_flags (link_info.output_bfd, osec) & SEC_EXCLUDE) 276 continue; 277 278 /* First find an input section so we have flags to compare with; the 279 flags in the output section are not valid. */ 280 { 281 LANG_FOR_EACH_INPUT_STATEMENT (f) 282 { 283 asection *isec; 284 285 for (isec = f->the_bfd->sections; 286 isec != NULL; 287 isec = isec->next) 288 { 289 if (isec->output_section == osec 290 && isec->size != 0 291 && (bfd_get_section_flags (isec->owner, isec) 292 & SEC_EXCLUDE) == 0) 293 { 294 oflags_isa 295 = (elf_section_data (isec)->this_hdr.sh_flags 296 & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED)); 297 goto break_1; 298 } 299 } 300 } 301 } 302 303 break_1: 304 305 /* Check that all input sections have the same contents-type flags 306 as the first input section. */ 307 { 308 LANG_FOR_EACH_INPUT_STATEMENT (f) 309 { 310 asection *isec; 311 312 for (isec = f->the_bfd->sections; 313 isec != NULL; 314 isec = isec->next) 315 { 316 if (isec->output_section == osec 317 && isec->size != 0 318 && (bfd_get_section_flags (isec->owner, isec) 319 & SEC_EXCLUDE) == 0) 320 { 321 bfd_vma iflags_isa 322 = (elf_section_data (isec)->this_hdr.sh_flags 323 & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED)); 324 325 /* If flags don't agree, set the target-specific data 326 of the section to mark that this section needs to 327 be have .cranges section entries added. Don't 328 bother setting ELF section flags in output section; 329 they will be cleared later and will have to be 330 re-initialized before the linked file is written. */ 331 if (iflags_isa != oflags_isa) 332 { 333 oflags_isa = SHF_SH5_ISA32_MIXED; 334 335 BFD_ASSERT (sh64_elf_section_data (osec)->sh64_info); 336 337 sh64_elf_section_data (osec)->sh64_info->contents_flags 338 = SHF_SH5_ISA32_MIXED; 339 need_check_cranges = TRUE; 340 goto break_2; 341 } 342 } 343 } 344 } 345 } 346 347 break_2: 348 349 /* If there were no new ranges for this output section, we don't 350 need to iterate over the input sections to check how many are 351 needed. */ 352 if (! need_check_cranges) 353 continue; 354 355 /* If we found a section with differing contents type, we need more 356 ranges to mark the sections that are not mixed (and already have 357 .cranges descriptors). Calculate the maximum number of new 358 entries here. We may merge some of them, so that number is not 359 final; it can shrink. */ 360 { 361 LANG_FOR_EACH_INPUT_STATEMENT (f) 362 { 363 asection *isec; 364 365 for (isec = f->the_bfd->sections; 366 isec != NULL; 367 isec = isec->next) 368 { 369 if (isec->output_section == osec 370 && isec->size != 0 371 && (bfd_get_section_flags (isec->owner, isec) 372 & SEC_EXCLUDE) == 0 373 && ((elf_section_data (isec)->this_hdr.sh_flags 374 & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED)) 375 != SHF_SH5_ISA32_MIXED)) 376 new_cranges++; 377 } 378 } 379 } 380 } 381 382 if (cranges->contents != NULL) 383 free (cranges->contents); 384 385 BFD_ASSERT (sh64_elf_section_data (cranges)->sh64_info != NULL); 386 387 /* Make sure we have .cranges in memory even if there were only 388 assembler-generated .cranges. */ 389 cranges_growth = new_cranges * SH64_CRANGE_SIZE; 390 cranges->contents = xcalloc (cranges->size + cranges_growth, 1); 391 bfd_set_section_flags (cranges->owner, cranges, 392 bfd_get_section_flags (cranges->owner, cranges) 393 | SEC_IN_MEMORY); 394 395 /* If we don't need to grow the .cranges section beyond what was in the 396 input sections, we have nothing more to do here. We then only got 397 here because there was a .cranges section coming from input. Zero 398 out the number of generated .cranges. */ 399 if (new_cranges == 0) 400 { 401 sh64_elf_section_data (cranges)->sh64_info->cranges_growth = 0; 402 return; 403 } 404 405 crangesp = cranges->contents + cranges->size; 406 407 /* Now pass over the sections again, and make reloc orders for the new 408 .cranges entries. Constants are set as we go. */ 409 for (osec = link_info.output_bfd->sections; 410 osec != NULL; 411 osec = osec->next) 412 { 413 struct bfd_link_order *cr_addr_order = NULL; 414 enum sh64_elf_cr_type last_cr_type = CRT_NONE; 415 bfd_vma last_cr_size = 0; 416 bfd_vma continuation_vma = 0; 417 418 /* Omit excluded or garbage-collected sections, and output sections 419 which were not marked as needing further processing. */ 420 if ((bfd_get_section_flags (link_info.output_bfd, osec) & SEC_EXCLUDE) != 0 421 || (sh64_elf_section_data (osec)->sh64_info->contents_flags 422 != SHF_SH5_ISA32_MIXED)) 423 continue; 424 425 { 426 LANG_FOR_EACH_INPUT_STATEMENT (f) 427 { 428 asection *isec; 429 430 for (isec = f->the_bfd->sections; 431 isec != NULL; 432 isec = isec->next) 433 { 434 /* Allow only sections that have (at least initially) a 435 non-zero size, and are not excluded, and are not marked 436 as containing mixed data, thus already having .cranges 437 entries. */ 438 if (isec->output_section == osec 439 && isec->size != 0 440 && (bfd_get_section_flags (isec->owner, isec) 441 & SEC_EXCLUDE) == 0 442 && ((elf_section_data (isec)->this_hdr.sh_flags 443 & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED)) 444 != SHF_SH5_ISA32_MIXED)) 445 { 446 enum sh64_elf_cr_type cr_type; 447 bfd_vma cr_size; 448 bfd_vma isa_flags 449 = (elf_section_data (isec)->this_hdr.sh_flags 450 & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED)); 451 452 if (isa_flags == SHF_SH5_ISA32) 453 cr_type = CRT_SH5_ISA32; 454 else if ((bfd_get_section_flags (isec->owner, isec) 455 & SEC_CODE) == 0) 456 cr_type = CRT_DATA; 457 else 458 cr_type = CRT_SH5_ISA16; 459 460 cr_size = isec->size; 461 462 /* Sections can be empty, like .text in a file that 463 only contains other sections. Ranges shouldn't be 464 emitted for them. This can presumably happen after 465 relaxing and is not be caught at the "raw size" 466 test above. */ 467 if (cr_size == 0) 468 continue; 469 470 /* See if this is a continuation of the previous range 471 for the same output section. If so, just change 472 the size of the last range and continue. */ 473 if (cr_type == last_cr_type 474 && (continuation_vma 475 == osec->vma + isec->output_offset)) 476 { 477 last_cr_size += cr_size; 478 bfd_put_32 (link_info.output_bfd, last_cr_size, 479 crangesp - SH64_CRANGE_SIZE 480 + SH64_CRANGE_CR_SIZE_OFFSET); 481 482 continuation_vma += cr_size; 483 continue; 484 } 485 486 /* If we emit relocatable contents, we need a 487 relocation for the start address. */ 488 if (bfd_link_relocatable (&link_info) 489 || link_info.emitrelocations) 490 { 491 /* FIXME: We could perhaps use lang_add_reloc and 492 friends here, but I'm not really sure that 493 would leave us free to do some optimizations 494 later. */ 495 cr_addr_order 496 = bfd_new_link_order (link_info.output_bfd, cranges); 497 498 if (cr_addr_order == NULL) 499 { 500 einfo (_("%P%F: bfd_new_link_order failed\n")); 501 return; 502 } 503 504 cr_addr_order->type = bfd_section_reloc_link_order; 505 cr_addr_order->offset 506 = (cranges->output_offset 507 + crangesp + SH64_CRANGE_CR_ADDR_OFFSET 508 - cranges->contents); 509 cr_addr_order->size = 4; 510 cr_addr_order->u.reloc.p 511 = xmalloc (sizeof (struct bfd_link_order_reloc)); 512 513 cr_addr_order->u.reloc.p->reloc = BFD_RELOC_32; 514 cr_addr_order->u.reloc.p->u.section = osec; 515 516 /* Since SH, unlike normal RELA-targets, uses a 517 "partial inplace" REL-like relocation for this, 518 we put the addend in the contents and specify 0 519 for the reloc. */ 520 bfd_put_32 (link_info.output_bfd, isec->output_offset, 521 crangesp + SH64_CRANGE_CR_ADDR_OFFSET); 522 cr_addr_order->u.reloc.p->addend = 0; 523 } 524 else 525 bfd_put_32 (link_info.output_bfd, 526 osec->vma + isec->output_offset, 527 crangesp + SH64_CRANGE_CR_ADDR_OFFSET); 528 529 /* If we could make a reloc for cr_size we would do 530 it, but we would have to have a symbol for the size 531 of the _input_ section and there's no way to 532 generate that. */ 533 bfd_put_32 (link_info.output_bfd, cr_size, 534 crangesp + SH64_CRANGE_CR_SIZE_OFFSET); 535 536 bfd_put_16 (link_info.output_bfd, cr_type, 537 crangesp + SH64_CRANGE_CR_TYPE_OFFSET); 538 539 last_cr_type = cr_type; 540 last_cr_size = cr_size; 541 continuation_vma 542 = osec->vma + isec->output_offset + cr_size; 543 crangesp += SH64_CRANGE_SIZE; 544 } 545 } 546 } 547 } 548 } 549 550 /* The .cranges section will have this size, no larger or smaller. 551 Since relocs (if relocatable linking) will be emitted into the 552 "extended" size, we must set the raw size to the total. We have to 553 keep track of the number of new .cranges entries. 554 555 Sorting before writing is done by sh64_elf_final_write_processing. */ 556 557 sh64_elf_section_data (cranges)->sh64_info->cranges_growth 558 = crangesp - cranges->contents - cranges->size; 559 cranges->size = crangesp - cranges->contents; 560 cranges->rawsize = cranges->size; 561} 562EOF 563 564 565