| 1 | # This shell script emits a C file. -*- C -*- |
| 2 | # Copyright 2000, 2001, 2002, 2003, 2004, 2007, 2008 |
| 3 | # Free Software Foundation, Inc. |
| 4 | # |
| 5 | # This file is part of the GNU Binutils. |
| 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 | |
| 23 | # This file is sourced from elf32.em, and defines extra sh64 |
| 24 | # specific routines. |
| 25 | # |
| 26 | |
| 27 | LDEMUL_AFTER_ALLOCATION=sh64_elf_${EMULATION_NAME}_after_allocation |
| 28 | LDEMUL_BEFORE_ALLOCATION=sh64_elf_${EMULATION_NAME}_before_allocation |
| 29 | |
| 30 | fragment <<EOF |
| 31 | |
| 32 | #include "libiberty.h" |
| 33 | #include "libbfd.h" |
| 34 | #include "elf-bfd.h" |
| 35 | #include "elf/sh.h" |
| 36 | #include "elf32-sh64.h" |
| 37 | |
| 38 | /* Check if we need a .cranges section and create it if it's not in any |
| 39 | input file. It might seem better to always create it and if unneeded, |
| 40 | discard it, but I don't find a simple way to discard it totally from |
| 41 | the output. |
| 42 | |
| 43 | Putting it here instead of as a elf_backend_always_size_sections hook |
| 44 | in elf32-sh64.c, means that we have access to linker command line |
| 45 | options here, and we can access input sections in the order in which |
| 46 | they will be linked. */ |
| 47 | |
| 48 | static void |
| 49 | sh64_elf_${EMULATION_NAME}_before_allocation (void) |
| 50 | { |
| 51 | asection *cranges; |
| 52 | asection *osec; |
| 53 | |
| 54 | /* Call main function; we're just extending it. */ |
| 55 | gld${EMULATION_NAME}_before_allocation (); |
| 56 | |
| 57 | cranges = bfd_get_section_by_name (link_info.output_bfd, |
| 58 | SH64_CRANGES_SECTION_NAME); |
| 59 | |
| 60 | if (cranges != NULL) |
| 61 | { |
| 62 | if (command_line.relax) |
| 63 | { |
| 64 | /* FIXME: Look through incoming sections with .cranges |
| 65 | descriptors, build up some kind of descriptors that the |
| 66 | relaxing function will pick up and adjust, or perhaps make it |
| 67 | find and adjust an associated .cranges descriptor. We could |
| 68 | also look through incoming relocs and kill the ones marking |
| 69 | relaxation areas, but that wouldn't be TRT. */ |
| 70 | einfo |
| 71 | (_("%P: Sorry, turning off relaxing: .cranges section in input.\n")); |
| 72 | einfo (_(" A .cranges section is present in:\n")); |
| 73 | |
| 74 | { |
| 75 | LANG_FOR_EACH_INPUT_STATEMENT (f) |
| 76 | { |
| 77 | asection *input_cranges |
| 78 | = bfd_get_section_by_name (f->the_bfd, |
| 79 | SH64_CRANGES_SECTION_NAME); |
| 80 | if (input_cranges != NULL) |
| 81 | einfo (" %I\n", f); |
| 82 | } |
| 83 | } |
| 84 | |
| 85 | command_line.relax = FALSE; |
| 86 | } |
| 87 | |
| 88 | /* We wouldn't need to do anything when there's already a .cranges |
| 89 | section (and have a return here), except that we need to set the |
| 90 | section flags right for output sections that *don't* need a |
| 91 | .cranges section. */ |
| 92 | } |
| 93 | |
| 94 | if (command_line.relax) |
| 95 | { |
| 96 | LANG_FOR_EACH_INPUT_STATEMENT (f) |
| 97 | { |
| 98 | if (bfd_get_flavour (f->the_bfd) == bfd_target_elf_flavour) |
| 99 | { |
| 100 | asection *isec; |
| 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 | command_line.relax = FALSE; |
| 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 | |
| 240 | static void |
| 241 | sh64_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 | cranges = bfd_get_section_by_name (link_info.output_bfd, |
| 252 | SH64_CRANGES_SECTION_NAME); |
| 253 | |
| 254 | /* If there is no .cranges section, it is because it was seen earlier on |
| 255 | that none was needed. Otherwise it must have been created then, or |
| 256 | be present in input. */ |
| 257 | if (cranges == NULL) |
| 258 | return; |
| 259 | |
| 260 | /* First, we set the ISA flags for each output section according to the |
| 261 | first non-discarded section. For each input section in osec, we |
| 262 | check if it has the same flags. If it does not, we set flags to mark |
| 263 | a mixed section (and exit the loop early). */ |
| 264 | for (osec = link_info.output_bfd->sections; |
| 265 | osec != NULL; |
| 266 | osec = osec->next) |
| 267 | { |
| 268 | bfd_vma oflags_isa = 0; |
| 269 | bfd_boolean need_check_cranges = FALSE; |
| 270 | |
| 271 | /* Omit excluded or garbage-collected sections. */ |
| 272 | if (bfd_get_section_flags (link_info.output_bfd, osec) & SEC_EXCLUDE) |
| 273 | continue; |
| 274 | |
| 275 | /* First find an input section so we have flags to compare with; the |
| 276 | flags in the output section are not valid. */ |
| 277 | { |
| 278 | LANG_FOR_EACH_INPUT_STATEMENT (f) |
| 279 | { |
| 280 | asection *isec; |
| 281 | |
| 282 | for (isec = f->the_bfd->sections; |
| 283 | isec != NULL; |
| 284 | isec = isec->next) |
| 285 | { |
| 286 | if (isec->output_section == osec |
| 287 | && isec->size != 0 |
| 288 | && (bfd_get_section_flags (isec->owner, isec) |
| 289 | & SEC_EXCLUDE) == 0) |
| 290 | { |
| 291 | oflags_isa |
| 292 | = (elf_section_data (isec)->this_hdr.sh_flags |
| 293 | & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED)); |
| 294 | goto break_1; |
| 295 | } |
| 296 | } |
| 297 | } |
| 298 | } |
| 299 | |
| 300 | break_1: |
| 301 | |
| 302 | /* Check that all input sections have the same contents-type flags |
| 303 | as the first input section. */ |
| 304 | { |
| 305 | LANG_FOR_EACH_INPUT_STATEMENT (f) |
| 306 | { |
| 307 | asection *isec; |
| 308 | |
| 309 | for (isec = f->the_bfd->sections; |
| 310 | isec != NULL; |
| 311 | isec = isec->next) |
| 312 | { |
| 313 | if (isec->output_section == osec |
| 314 | && isec->size != 0 |
| 315 | && (bfd_get_section_flags (isec->owner, isec) |
| 316 | & SEC_EXCLUDE) == 0) |
| 317 | { |
| 318 | bfd_vma iflags_isa |
| 319 | = (elf_section_data (isec)->this_hdr.sh_flags |
| 320 | & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED)); |
| 321 | |
| 322 | /* If flags don't agree, set the target-specific data |
| 323 | of the section to mark that this section needs to |
| 324 | be have .cranges section entries added. Don't |
| 325 | bother setting ELF section flags in output section; |
| 326 | they will be cleared later and will have to be |
| 327 | re-initialized before the linked file is written. */ |
| 328 | if (iflags_isa != oflags_isa) |
| 329 | { |
| 330 | oflags_isa = SHF_SH5_ISA32_MIXED; |
| 331 | |
| 332 | BFD_ASSERT (sh64_elf_section_data (osec)->sh64_info); |
| 333 | |
| 334 | sh64_elf_section_data (osec)->sh64_info->contents_flags |
| 335 | = SHF_SH5_ISA32_MIXED; |
| 336 | need_check_cranges = TRUE; |
| 337 | goto break_2; |
| 338 | } |
| 339 | } |
| 340 | } |
| 341 | } |
| 342 | } |
| 343 | |
| 344 | break_2: |
| 345 | |
| 346 | /* If there were no new ranges for this output section, we don't |
| 347 | need to iterate over the input sections to check how many are |
| 348 | needed. */ |
| 349 | if (! need_check_cranges) |
| 350 | continue; |
| 351 | |
| 352 | /* If we found a section with differing contents type, we need more |
| 353 | ranges to mark the sections that are not mixed (and already have |
| 354 | .cranges descriptors). Calculate the maximum number of new |
| 355 | entries here. We may merge some of them, so that number is not |
| 356 | final; it can shrink. */ |
| 357 | { |
| 358 | LANG_FOR_EACH_INPUT_STATEMENT (f) |
| 359 | { |
| 360 | asection *isec; |
| 361 | |
| 362 | for (isec = f->the_bfd->sections; |
| 363 | isec != NULL; |
| 364 | isec = isec->next) |
| 365 | { |
| 366 | if (isec->output_section == osec |
| 367 | && isec->size != 0 |
| 368 | && (bfd_get_section_flags (isec->owner, isec) |
| 369 | & SEC_EXCLUDE) == 0 |
| 370 | && ((elf_section_data (isec)->this_hdr.sh_flags |
| 371 | & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED)) |
| 372 | != SHF_SH5_ISA32_MIXED)) |
| 373 | new_cranges++; |
| 374 | } |
| 375 | } |
| 376 | } |
| 377 | } |
| 378 | |
| 379 | if (cranges->contents != NULL) |
| 380 | free (cranges->contents); |
| 381 | |
| 382 | BFD_ASSERT (sh64_elf_section_data (cranges)->sh64_info != NULL); |
| 383 | |
| 384 | /* Make sure we have .cranges in memory even if there were only |
| 385 | assembler-generated .cranges. */ |
| 386 | cranges_growth = new_cranges * SH64_CRANGE_SIZE; |
| 387 | cranges->contents = xcalloc (cranges->size + cranges_growth, 1); |
| 388 | bfd_set_section_flags (cranges->owner, cranges, |
| 389 | bfd_get_section_flags (cranges->owner, cranges) |
| 390 | | SEC_IN_MEMORY); |
| 391 | |
| 392 | /* If we don't need to grow the .cranges section beyond what was in the |
| 393 | input sections, we have nothing more to do here. We then only got |
| 394 | here because there was a .cranges section coming from input. Zero |
| 395 | out the number of generated .cranges. */ |
| 396 | if (new_cranges == 0) |
| 397 | { |
| 398 | sh64_elf_section_data (cranges)->sh64_info->cranges_growth = 0; |
| 399 | return; |
| 400 | } |
| 401 | |
| 402 | crangesp = cranges->contents + cranges->size; |
| 403 | |
| 404 | /* Now pass over the sections again, and make reloc orders for the new |
| 405 | .cranges entries. Constants are set as we go. */ |
| 406 | for (osec = link_info.output_bfd->sections; |
| 407 | osec != NULL; |
| 408 | osec = osec->next) |
| 409 | { |
| 410 | struct bfd_link_order *cr_addr_order = NULL; |
| 411 | enum sh64_elf_cr_type last_cr_type = CRT_NONE; |
| 412 | bfd_vma last_cr_size = 0; |
| 413 | bfd_vma continuation_vma = 0; |
| 414 | |
| 415 | /* Omit excluded or garbage-collected sections, and output sections |
| 416 | which were not marked as needing further processing. */ |
| 417 | if ((bfd_get_section_flags (link_info.output_bfd, osec) & SEC_EXCLUDE) != 0 |
| 418 | || (sh64_elf_section_data (osec)->sh64_info->contents_flags |
| 419 | != SHF_SH5_ISA32_MIXED)) |
| 420 | continue; |
| 421 | |
| 422 | { |
| 423 | LANG_FOR_EACH_INPUT_STATEMENT (f) |
| 424 | { |
| 425 | asection *isec; |
| 426 | |
| 427 | for (isec = f->the_bfd->sections; |
| 428 | isec != NULL; |
| 429 | isec = isec->next) |
| 430 | { |
| 431 | /* Allow only sections that have (at least initially) a |
| 432 | non-zero size, and are not excluded, and are not marked |
| 433 | as containing mixed data, thus already having .cranges |
| 434 | entries. */ |
| 435 | if (isec->output_section == osec |
| 436 | && isec->size != 0 |
| 437 | && (bfd_get_section_flags (isec->owner, isec) |
| 438 | & SEC_EXCLUDE) == 0 |
| 439 | && ((elf_section_data (isec)->this_hdr.sh_flags |
| 440 | & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED)) |
| 441 | != SHF_SH5_ISA32_MIXED)) |
| 442 | { |
| 443 | enum sh64_elf_cr_type cr_type; |
| 444 | bfd_vma cr_size; |
| 445 | bfd_vma isa_flags |
| 446 | = (elf_section_data (isec)->this_hdr.sh_flags |
| 447 | & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED)); |
| 448 | |
| 449 | if (isa_flags == SHF_SH5_ISA32) |
| 450 | cr_type = CRT_SH5_ISA32; |
| 451 | else if ((bfd_get_section_flags (isec->owner, isec) |
| 452 | & SEC_CODE) == 0) |
| 453 | cr_type = CRT_DATA; |
| 454 | else |
| 455 | cr_type = CRT_SH5_ISA16; |
| 456 | |
| 457 | cr_size = isec->size; |
| 458 | |
| 459 | /* Sections can be empty, like .text in a file that |
| 460 | only contains other sections. Ranges shouldn't be |
| 461 | emitted for them. This can presumably happen after |
| 462 | relaxing and is not be caught at the "raw size" |
| 463 | test above. */ |
| 464 | if (cr_size == 0) |
| 465 | continue; |
| 466 | |
| 467 | /* See if this is a continuation of the previous range |
| 468 | for the same output section. If so, just change |
| 469 | the size of the last range and continue. */ |
| 470 | if (cr_type == last_cr_type |
| 471 | && (continuation_vma |
| 472 | == osec->vma + isec->output_offset)) |
| 473 | { |
| 474 | last_cr_size += cr_size; |
| 475 | bfd_put_32 (link_info.output_bfd, last_cr_size, |
| 476 | crangesp - SH64_CRANGE_SIZE |
| 477 | + SH64_CRANGE_CR_SIZE_OFFSET); |
| 478 | |
| 479 | continuation_vma += cr_size; |
| 480 | continue; |
| 481 | } |
| 482 | |
| 483 | /* If we emit relocatable contents, we need a |
| 484 | relocation for the start address. */ |
| 485 | if (link_info.relocatable || link_info.emitrelocations) |
| 486 | { |
| 487 | /* FIXME: We could perhaps use lang_add_reloc and |
| 488 | friends here, but I'm not really sure that |
| 489 | would leave us free to do some optimizations |
| 490 | later. */ |
| 491 | cr_addr_order |
| 492 | = bfd_new_link_order (link_info.output_bfd, cranges); |
| 493 | |
| 494 | if (cr_addr_order == NULL) |
| 495 | { |
| 496 | einfo (_("%P%F: bfd_new_link_order failed\n")); |
| 497 | return; |
| 498 | } |
| 499 | |
| 500 | cr_addr_order->type = bfd_section_reloc_link_order; |
| 501 | cr_addr_order->offset |
| 502 | = (cranges->output_offset |
| 503 | + crangesp + SH64_CRANGE_CR_ADDR_OFFSET |
| 504 | - cranges->contents); |
| 505 | cr_addr_order->size = 4; |
| 506 | cr_addr_order->u.reloc.p |
| 507 | = xmalloc (sizeof (struct bfd_link_order_reloc)); |
| 508 | |
| 509 | cr_addr_order->u.reloc.p->reloc = BFD_RELOC_32; |
| 510 | cr_addr_order->u.reloc.p->u.section = osec; |
| 511 | |
| 512 | /* Since SH, unlike normal RELA-targets, uses a |
| 513 | "partial inplace" REL-like relocation for this, |
| 514 | we put the addend in the contents and specify 0 |
| 515 | for the reloc. */ |
| 516 | bfd_put_32 (link_info.output_bfd, isec->output_offset, |
| 517 | crangesp + SH64_CRANGE_CR_ADDR_OFFSET); |
| 518 | cr_addr_order->u.reloc.p->addend = 0; |
| 519 | } |
| 520 | else |
| 521 | bfd_put_32 (link_info.output_bfd, |
| 522 | osec->vma + isec->output_offset, |
| 523 | crangesp + SH64_CRANGE_CR_ADDR_OFFSET); |
| 524 | |
| 525 | /* If we could make a reloc for cr_size we would do |
| 526 | it, but we would have to have a symbol for the size |
| 527 | of the _input_ section and there's no way to |
| 528 | generate that. */ |
| 529 | bfd_put_32 (link_info.output_bfd, cr_size, |
| 530 | crangesp + SH64_CRANGE_CR_SIZE_OFFSET); |
| 531 | |
| 532 | bfd_put_16 (link_info.output_bfd, cr_type, |
| 533 | crangesp + SH64_CRANGE_CR_TYPE_OFFSET); |
| 534 | |
| 535 | last_cr_type = cr_type; |
| 536 | last_cr_size = cr_size; |
| 537 | continuation_vma |
| 538 | = osec->vma + isec->output_offset + cr_size; |
| 539 | crangesp += SH64_CRANGE_SIZE; |
| 540 | } |
| 541 | } |
| 542 | } |
| 543 | } |
| 544 | } |
| 545 | |
| 546 | /* The .cranges section will have this size, no larger or smaller. |
| 547 | Since relocs (if relocatable linking) will be emitted into the |
| 548 | "extended" size, we must set the raw size to the total. We have to |
| 549 | keep track of the number of new .cranges entries. |
| 550 | |
| 551 | Sorting before writing is done by sh64_elf_final_write_processing. */ |
| 552 | |
| 553 | sh64_elf_section_data (cranges)->sh64_info->cranges_growth |
| 554 | = crangesp - cranges->contents - cranges->size; |
| 555 | cranges->size = crangesp - cranges->contents; |
| 556 | cranges->rawsize = cranges->size; |
| 557 | } |