ld/emultempl/sh64elf.em

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