toolchain/binutils/ld/emultempl/sh64elf.em

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