ld/emultempl/msp430.em

   1 # This shell script emits a C file. -*- C -*-
   2 # It does some substitutions.
   3 fragment <<EOF
   4 /* This file is is generated by a shell script.  DO NOT EDIT! */
   5
   6 /* Emulate the original gld for the given ${EMULATION_NAME}
   7    Copyright (C) 2014-2019 Free Software Foundation, Inc.
   8    Written by Steve Chamberlain steve@cygnus.com
   9    Extended for the MSP430 by Nick Clifton  nickc@redhat.com
  10
  11    This file is part of the GNU Binutils.
  12
  13    This program is free software; you can redistribute it and/or modify
  14    it under the terms of the GNU General Public License as published by
  15    the Free Software Foundation; either version 3 of the License, or
  16    (at your option) any later version.
  17
  18    This program is distributed in the hope that it will be useful,
  19    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21    GNU General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public License
  24    along with this program; if not, write to the Free Software
  25    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  26    MA 02110-1301, USA.  */
  27
  28 #define TARGET_IS_${EMULATION_NAME}
  29
  30 #include "sysdep.h"
  31 #include "bfd.h"
  32 #include "bfdlink.h"
  33
  34 #include "ld.h"
  35 #include "getopt.h"
  36 #include "ldmain.h"
  37 #include "ldmisc.h"
  38 #include "ldexp.h"
  39 #include "ldlang.h"
  40 #include "ldfile.h"
  41 #include "ldemul.h"
  42 #include "libiberty.h"
  43 #include <ldgram.h>
  44
  45 enum regions
  46 {
  47   REGION_NONE = 0,
  48   REGION_LOWER,
  49   REGION_UPPER,
  50   REGION_EITHER = 3,
  51 };
  52
  53 enum either_placement_stage
  54 {
  55   LOWER_TO_UPPER,
  56   UPPER_TO_LOWER,
  57 };
  58
  59 enum { ROM, RAM };
  60
  61 static int data_region = REGION_NONE;
  62 static int code_region = REGION_NONE;
  63 static bfd_boolean disable_sec_transformation = FALSE;
  64
  65 #define MAX_PREFIX_LENGTH 7
  66
  67 EOF
  68
  69 # Import any needed special functions and/or overrides.
  70 #
  71 if test -n "$EXTRA_EM_FILE" ; then
  72   source_em ${srcdir}/emultempl/${EXTRA_EM_FILE}.em
  73 fi
  74
  75 if test x"$LDEMUL_BEFORE_PARSE" != xgld"$EMULATION_NAME"_before_parse; then
  76 fragment <<EOF
  77
  78 static void
  79 gld${EMULATION_NAME}_before_parse (void)
  80 {
  81 #ifndef TARGET_                 /* I.e., if not generic.  */
  82   ldfile_set_output_arch ("`echo ${ARCH}`", bfd_arch_unknown);
  83 #endif /* not TARGET_ */
  84
  85   /* The MSP430 port *needs* linker relaxtion in order to cope with large
  86      functions where conditional branches do not fit into a +/- 1024 byte range.  */
  87   if (!bfd_link_relocatable (&link_info))
  88     TARGET_ENABLE_RELAXATION;
  89 }
  90
  91 EOF
  92 fi
  93
  94 if test x"$LDEMUL_GET_SCRIPT" != xgld"$EMULATION_NAME"_get_script; then
  95 fragment <<EOF
  96
  97 static char *
  98 gld${EMULATION_NAME}_get_script (int *isfile)
  99 EOF
 100
 101 if test x"$COMPILE_IN" = xyes
 102 then
 103 # Scripts compiled in.
 104
 105 # sed commands to quote an ld script as a C string.
 106 sc="-f stringify.sed"
 107
 108 fragment <<EOF
 109 {
 110   *isfile = 0;
 111
 112   if (bfd_link_relocatable (&link_info) && config.build_constructors)
 113     return
 114 EOF
 115 sed $sc ldscripts/${EMULATION_NAME}.xu                 >> e${EMULATION_NAME}.c
 116 echo '  ; else if (bfd_link_relocatable (&link_info)) return' >> e${EMULATION_NAME}.c
 117 sed $sc ldscripts/${EMULATION_NAME}.xr                 >> e${EMULATION_NAME}.c
 118 echo '  ; else if (!config.text_read_only) return'     >> e${EMULATION_NAME}.c
 119 sed $sc ldscripts/${EMULATION_NAME}.xbn                >> e${EMULATION_NAME}.c
 120 echo '  ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
 121 sed $sc ldscripts/${EMULATION_NAME}.xn                 >> e${EMULATION_NAME}.c
 122 echo '  ; else return'                                 >> e${EMULATION_NAME}.c
 123 sed $sc ldscripts/${EMULATION_NAME}.x                  >> e${EMULATION_NAME}.c
 124 echo '; }'                                             >> e${EMULATION_NAME}.c
 125
 126 else
 127 # Scripts read from the filesystem.
 128
 129 fragment <<EOF
 130 {
 131   *isfile = 1;
 132
 133   if (bfd_link_relocatable (&link_info) && config.build_constructors)
 134     return "ldscripts/${EMULATION_NAME}.xu";
 135   else if (bfd_link_relocatable (&link_info))
 136     return "ldscripts/${EMULATION_NAME}.xr";
 137   else if (!config.text_read_only)
 138     return "ldscripts/${EMULATION_NAME}.xbn";
 139   else if (!config.magic_demand_paged)
 140     return "ldscripts/${EMULATION_NAME}.xn";
 141   else
 142     return "ldscripts/${EMULATION_NAME}.x";
 143 }
 144 EOF
 145 fi
 146 fi
 147
 148 if test x"$LDEMUL_PLACE_ORPHAN" != xgld"$EMULATION_NAME"_place_orphan; then
 149 fragment <<EOF
 150
 151 static unsigned int
 152 data_statement_size (lang_data_statement_type *d)
 153 {
 154   unsigned int size = 0;
 155   switch (d->type)
 156     {
 157     case QUAD:
 158     case SQUAD:
 159       size = QUAD_SIZE;
 160       break;
 161     case LONG:
 162       size = LONG_SIZE;
 163       break;
 164     case SHORT:
 165       size = SHORT_SIZE;
 166       break;
 167     case BYTE:
 168       size = BYTE_SIZE;
 169       break;
 170     default:
 171       einfo (_("%P: error: unhandled data_statement size\n"));
 172       FAIL ();
 173     }
 174   return size;
 175 }
 176
 177 /* Helper function for place_orphan that computes the size
 178    of sections already mapped to the given statement.  */
 179
 180 static bfd_size_type
 181 scan_children (lang_statement_union_type * l)
 182 {
 183   bfd_size_type amount = 0;
 184
 185   while (l != NULL)
 186     {
 187       switch (l->header.type)
 188         {
 189         case lang_input_section_enum:
 190           if (l->input_section.section->flags & SEC_ALLOC)
 191             amount += l->input_section.section->size;
 192           break;
 193
 194         case lang_constructors_statement_enum:
 195         case lang_assignment_statement_enum:
 196         case lang_padding_statement_enum:
 197           break;
 198
 199         case lang_wild_statement_enum:
 200           amount += scan_children (l->wild_statement.children.head);
 201           break;
 202
 203         case lang_data_statement_enum:
 204           amount += data_statement_size (&l->data_statement);
 205           break;
 206
 207         default:
 208           fprintf (stderr, "msp430 orphan placer: unhandled lang type %d\n", l->header.type);
 209           break;
 210         }
 211
 212       l = l->header.next;
 213     }
 214
 215   return amount;
 216 }
 217
 218 #define WARN_UPPER 0
 219 #define WARN_LOWER 1
 220 #define WARN_TEXT 0
 221 #define WARN_DATA 1
 222 #define WARN_BSS 2
 223 #define WARN_RODATA 3
 224
 225 /* Warn only once per output section.
 226  * NAME starts with ".upper." or ".lower.".  */
 227 static void
 228 warn_no_output_section (const char *name)
 229 {
 230   static bfd_boolean warned[2][4] = {{FALSE, FALSE, FALSE, FALSE},
 231                                      {FALSE, FALSE, FALSE, FALSE}};
 232   int i = WARN_LOWER;
 233
 234   if (strncmp (name, ".upper.", 7) == 0)
 235     i = WARN_UPPER;
 236
 237   if (!warned[i][WARN_TEXT] && strcmp (name + 6, ".text") == 0)
 238     warned[i][WARN_TEXT] = TRUE;
 239   else if (!warned[i][WARN_DATA] && strcmp (name + 6, ".data") == 0)
 240     warned[i][WARN_DATA] = TRUE;
 241   else if (!warned[i][WARN_BSS] && strcmp (name + 6, ".bss") == 0)
 242     warned[i][WARN_BSS] = TRUE;
 243   else if (!warned[i][WARN_RODATA] && strcmp (name + 6, ".rodata") == 0)
 244     warned[i][WARN_RODATA] = TRUE;
 245   else
 246     return;
 247   einfo ("%P: warning: no input section rule matches %s in linker script\n",
 248          name);
 249 }
 250
 251
 252 /* Place an orphan section.  We use this to put .either sections
 253    into either their lower or their upper equivalents.  */
 254
 255 static lang_output_section_statement_type *
 256 gld${EMULATION_NAME}_place_orphan (asection * s,
 257                                    const char * secname,
 258                                    int constraint)
 259 {
 260   char * lower_name;
 261   char * upper_name;
 262   char * name;
 263   char * buf = NULL;
 264   lang_output_section_statement_type * lower;
 265   lang_output_section_statement_type * upper;
 266
 267   if ((s->flags & SEC_ALLOC) == 0)
 268     return NULL;
 269
 270   if (bfd_link_relocatable (&link_info))
 271     return NULL;
 272
 273   /* If constraints are involved let the linker handle the placement normally.  */
 274   if (constraint != 0)
 275     return NULL;
 276
 277   if (strncmp (secname, ".upper.", 7) == 0
 278       || strncmp (secname, ".lower.", 7) == 0)
 279     {
 280       warn_no_output_section (secname);
 281       return NULL;
 282     }
 283
 284   /* We only need special handling for .either sections.  */
 285   if (strncmp (secname, ".either.", 8) != 0)
 286     return NULL;
 287
 288   /* Skip the .either prefix.  */
 289   secname += 7;
 290
 291   /* Compute the names of the corresponding upper and lower
 292      sections.  If the input section name contains another period,
 293      only use the part of the name before the second dot.  */
 294   if (strchr (secname + 1, '.') != NULL)
 295     {
 296       buf = name = xstrdup (secname);
 297
 298       * strchr (name + 1, '.') = 0;
 299     }
 300   else
 301     name = (char *) secname;
 302
 303   lower_name = concat (".lower", name, NULL);
 304   upper_name = concat (".upper", name, NULL);
 305
 306   /* Find the corresponding lower and upper sections.  */
 307   lower = lang_output_section_find (lower_name);
 308   upper = lang_output_section_find (upper_name);
 309
 310   if (lower == NULL && upper == NULL)
 311     {
 312       einfo (_("%P: error: no section named %s or %s in linker script\n"),
 313              lower_name, upper_name);
 314       goto end;
 315     }
 316   else if (lower == NULL)
 317     {
 318       lower = lang_output_section_find (name);
 319       if (lower == NULL)
 320         {
 321           einfo (_("%P: error: no section named %s in linker script\n"), name);
 322           goto end;
 323         }
 324     }
 325
 326   /* Always place orphaned sections in lower.  Optimal placement of either
 327      sections is performed later, once section sizes have been finalized.  */
 328   lang_add_section (& lower->children, s, NULL, lower);
 329  end:
 330   free (upper_name);
 331   free (lower_name);
 332   if (buf)
 333     free (buf);
 334   return lower;
 335 }
 336 EOF
 337 fi
 338
 339 fragment <<EOF
 340
 341 static bfd_boolean
 342 change_output_section (lang_statement_union_type ** head,
 343                        asection *s,
 344                        lang_output_section_statement_type * new_output_section)
 345 {
 346   asection *is;
 347   lang_statement_union_type * prev = NULL;
 348   lang_statement_union_type * curr;
 349
 350   curr = *head;
 351   while (curr != NULL)
 352     {
 353       switch (curr->header.type)
 354         {
 355         case lang_input_section_enum:
 356           is = curr->input_section.section;
 357           if (is == s)
 358             {
 359               s->output_section = NULL;
 360               lang_add_section (& (new_output_section->children), s, NULL,
 361                                 new_output_section);
 362               /* Remove the section from the old output section.  */
 363               if (prev == NULL)
 364                 *head = curr->header.next;
 365               else
 366                 prev->header.next = curr->header.next;
 367               return TRUE;
 368             }
 369           break;
 370         case lang_wild_statement_enum:
 371           if (change_output_section (&(curr->wild_statement.children.head),
 372                                      s, new_output_section))
 373             return TRUE;
 374           break;
 375         default:
 376           break;
 377         }
 378       prev = curr;
 379       curr = curr->header.next;
 380     }
 381   return FALSE;
 382 }
 383
 384 static void
 385 add_region_prefix (bfd *abfd ATTRIBUTE_UNUSED, asection *s,
 386                    void *unused ATTRIBUTE_UNUSED)
 387 {
 388   const char *curr_name = bfd_section_name (s);
 389   int region = REGION_NONE;
 390
 391   if (strncmp (curr_name, ".text", 5) == 0)
 392     region = code_region;
 393   else if (strncmp (curr_name, ".data", 5) == 0)
 394     region = data_region;
 395   else if (strncmp (curr_name, ".bss", 4) == 0)
 396     region = data_region;
 397   else if (strncmp (curr_name, ".rodata", 7) == 0)
 398     region = data_region;
 399   else
 400     return;
 401
 402   switch (region)
 403     {
 404     case REGION_NONE:
 405       break;
 406     case REGION_UPPER:
 407       bfd_rename_section (s, concat (".upper", curr_name, NULL));
 408       break;
 409     case REGION_LOWER:
 410       bfd_rename_section (s, concat (".lower", curr_name, NULL));
 411       break;
 412     case REGION_EITHER:
 413       s->name = concat (".either", curr_name, NULL);
 414       break;
 415     default:
 416       /* Unreachable.  */
 417       FAIL ();
 418       break;
 419     }
 420 }
 421
 422 static void
 423 msp430_elf_after_open (void)
 424 {
 425   bfd *abfd;
 426
 427   gld${EMULATION_NAME}_after_open ();
 428
 429   /* If neither --code-region or --data-region have been passed, do not
 430      transform sections names.  */
 431   if ((code_region == REGION_NONE && data_region == REGION_NONE)
 432       || disable_sec_transformation)
 433     return;
 434
 435   for (abfd = link_info.input_bfds; abfd != NULL; abfd = abfd->link.next)
 436     bfd_map_over_sections (abfd, add_region_prefix, NULL);
 437 }
 438
 439 #define OPTION_CODE_REGION              321
 440 #define OPTION_DATA_REGION              (OPTION_CODE_REGION + 1)
 441 #define OPTION_DISABLE_TRANS            (OPTION_CODE_REGION + 2)
 442
 443 static void
 444 gld${EMULATION_NAME}_add_options
 445   (int ns, char **shortopts, int nl, struct option **longopts,
 446    int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED)
 447 {
 448   static const char xtra_short[] = { };
 449
 450   static const struct option xtra_long[] =
 451     {
 452       { "code-region", required_argument, NULL, OPTION_CODE_REGION },
 453       { "data-region", required_argument, NULL, OPTION_DATA_REGION },
 454       { "disable-sec-transformation", no_argument, NULL,
 455         OPTION_DISABLE_TRANS },
 456       { NULL, no_argument, NULL, 0 }
 457     };
 458
 459   *shortopts = (char *) xrealloc (*shortopts, ns + sizeof (xtra_short));
 460   memcpy (*shortopts + ns, &xtra_short, sizeof (xtra_short));
 461   *longopts = (struct option *)
 462     xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
 463   memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
 464 }
 465
 466 static void
 467 gld${EMULATION_NAME}_list_options (FILE * file)
 468 {
 469   fprintf (file, _("  --code-region={either,lower,upper,none}\n\
 470         Transform .text* sections to {either,lower,upper,none}.text* sections\n"));
 471   fprintf (file, _("  --data-region={either,lower,upper,none}\n\
 472         Transform .data*, .rodata* and .bss* sections to\n\
 473         {either,lower,upper,none}.{bss,data,rodata}* sections\n"));
 474   fprintf (file, _("  --disable-sec-transformation\n\
 475         Disable transformation of .{text,data,bss,rodata}* sections to\n\
 476         add the {either,lower,upper,none} prefixes\n"));
 477 }
 478
 479 static bfd_boolean
 480 gld${EMULATION_NAME}_handle_option (int optc)
 481 {
 482   switch (optc)
 483     {
 484     case OPTION_CODE_REGION:
 485       if (strcmp (optarg, "upper") == 0)
 486         code_region = REGION_UPPER;
 487       else if (strcmp (optarg, "lower") == 0)
 488         code_region = REGION_LOWER;
 489       else if (strcmp (optarg, "either") == 0)
 490         code_region = REGION_EITHER;
 491       else if (strcmp (optarg, "none") == 0)
 492         code_region = REGION_NONE;
 493       else if (strlen (optarg) == 0)
 494         {
 495           einfo (_("%P: --code-region requires an argument: "
 496                    "{upper,lower,either,none}\n"));
 497           return FALSE;
 498         }
 499       else
 500         {
 501           einfo (_("%P: error: unrecognized argument to --code-region= option: "
 502                    "\"%s\"\n"), optarg);
 503           return FALSE;
 504         }
 505       break;
 506
 507     case OPTION_DATA_REGION:
 508       if (strcmp (optarg, "upper") == 0)
 509         data_region = REGION_UPPER;
 510       else if (strcmp (optarg, "lower") == 0)
 511         data_region = REGION_LOWER;
 512       else if (strcmp (optarg, "either") == 0)
 513         data_region = REGION_EITHER;
 514       else if (strcmp (optarg, "none") == 0)
 515         data_region = REGION_NONE;
 516       else if (strlen (optarg) == 0)
 517         {
 518           einfo (_("%P: --data-region requires an argument: "
 519                    "{upper,lower,either,none}\n"));
 520           return FALSE;
 521         }
 522       else
 523         {
 524           einfo (_("%P: error: unrecognized argument to --data-region= option: "
 525                    "\"%s\"\n"), optarg);
 526           return FALSE;
 527         }
 528       break;
 529
 530     case OPTION_DISABLE_TRANS:
 531       disable_sec_transformation = TRUE;
 532       break;
 533
 534     default:
 535       return FALSE;
 536     }
 537   return TRUE;
 538 }
 539
 540 static void
 541 eval_upper_either_sections (bfd *abfd ATTRIBUTE_UNUSED,
 542                             asection *s, void *data)
 543 {
 544   const char * base_sec_name;
 545   const char * curr_name;
 546   char * either_name;
 547   int curr_region;
 548
 549   lang_output_section_statement_type * lower;
 550   lang_output_section_statement_type * upper;
 551   static bfd_size_type *lower_size = 0;
 552   static bfd_size_type *upper_size = 0;
 553   static bfd_size_type lower_size_rom = 0;
 554   static bfd_size_type lower_size_ram = 0;
 555   static bfd_size_type upper_size_rom = 0;
 556   static bfd_size_type upper_size_ram = 0;
 557
 558   if ((s->flags & SEC_ALLOC) == 0)
 559     return;
 560   if (bfd_link_relocatable (&link_info))
 561     return;
 562
 563   base_sec_name = (const char *) data;
 564   curr_name = bfd_section_name (s);
 565
 566   /* Only concerned with .either input sections in the upper output section.  */
 567   either_name = concat (".either", base_sec_name, NULL);
 568   if (strncmp (curr_name, either_name, strlen (either_name)) != 0
 569       || strncmp (s->output_section->name, ".upper", 6) != 0)
 570     goto end;
 571
 572   lower = lang_output_section_find (concat (".lower", base_sec_name, NULL));
 573   upper = lang_output_section_find (concat (".upper", base_sec_name, NULL));
 574
 575   if (upper == NULL || upper->region == NULL)
 576     goto end;
 577   else if (lower == NULL)
 578     lower = lang_output_section_find (base_sec_name);
 579   if (lower == NULL || lower->region == NULL)
 580     goto end;
 581
 582   if (strcmp (base_sec_name, ".text") == 0
 583       || strcmp (base_sec_name, ".rodata") == 0)
 584     curr_region = ROM;
 585   else
 586     curr_region = RAM;
 587
 588   if (curr_region == ROM)
 589     {
 590       if (lower_size_rom == 0)
 591         {
 592           lower_size_rom = lower->region->current - lower->region->origin;
 593           upper_size_rom = upper->region->current - upper->region->origin;
 594         }
 595       lower_size = &lower_size_rom;
 596       upper_size = &upper_size_rom;
 597     }
 598   else if (curr_region == RAM)
 599     {
 600       if (lower_size_ram == 0)
 601         {
 602           lower_size_ram = lower->region->current - lower->region->origin;
 603           upper_size_ram = upper->region->current - upper->region->origin;
 604         }
 605       lower_size = &lower_size_ram;
 606       upper_size = &upper_size_ram;
 607     }
 608
 609   /* Move sections in the upper region that would fit in the lower
 610      region to the lower region.  */
 611   if (*lower_size + s->size < lower->region->length)
 612     {
 613       if (change_output_section (&(upper->children.head), s, lower))
 614         {
 615           *upper_size -= s->size;
 616           *lower_size += s->size;
 617         }
 618     }
 619  end:
 620   free (either_name);
 621 }
 622
 623 static void
 624 eval_lower_either_sections (bfd *abfd ATTRIBUTE_UNUSED,
 625                             asection *s, void *data)
 626 {
 627   const char * base_sec_name;
 628   const char * curr_name;
 629   char * either_name;
 630   int curr_region;
 631   lang_output_section_statement_type * output_sec;
 632   lang_output_section_statement_type * lower;
 633   lang_output_section_statement_type * upper;
 634
 635   static bfd_size_type *lower_size = 0;
 636   static bfd_size_type lower_size_rom = 0;
 637   static bfd_size_type lower_size_ram = 0;
 638
 639   if ((s->flags & SEC_ALLOC) == 0)
 640     return;
 641   if (bfd_link_relocatable (&link_info))
 642     return;
 643
 644   base_sec_name = (const char *) data;
 645   curr_name = bfd_section_name (s);
 646
 647   /* Only concerned with .either input sections in the lower or "default"
 648      output section i.e. not in the upper output section.  */
 649   either_name = concat (".either", base_sec_name, NULL);
 650   if (strncmp (curr_name, either_name, strlen (either_name)) != 0
 651       || strncmp (s->output_section->name, ".upper", 6) == 0)
 652     return;
 653
 654   if (strcmp (base_sec_name, ".text") == 0
 655       || strcmp (base_sec_name, ".rodata") == 0)
 656     curr_region = ROM;
 657   else
 658     curr_region = RAM;
 659
 660   output_sec = lang_output_section_find (s->output_section->name);
 661
 662   /* If the output_section doesn't exist, this has already been reported in
 663      place_orphan, so don't need to warn again.  */
 664   if (output_sec == NULL || output_sec->region == NULL)
 665     goto end;
 666
 667   /* lower and output_sec might be the same, but in some cases an .either
 668      section can end up in base_sec_name if it hasn't been placed by
 669      place_orphan.  */
 670   lower = lang_output_section_find (concat (".lower", base_sec_name, NULL));
 671   upper = lang_output_section_find (concat (".upper", base_sec_name, NULL));
 672   if (upper == NULL)
 673     goto end;
 674
 675   if (curr_region == ROM)
 676     {
 677       if (lower_size_rom == 0)
 678         {
 679           /* Get the size of other items in the lower region that aren't the
 680              sections to be moved around.  */
 681           lower_size_rom
 682             = (output_sec->region->current - output_sec->region->origin)
 683             - scan_children (output_sec->children.head);
 684           if (output_sec != lower && lower != NULL)
 685             lower_size_rom -= scan_children (lower->children.head);
 686         }
 687       lower_size = &lower_size_rom;
 688     }
 689   else if (curr_region == RAM)
 690     {
 691       if (lower_size_ram == 0)
 692         {
 693           lower_size_ram
 694             = (output_sec->region->current - output_sec->region->origin)
 695             - scan_children (output_sec->children.head);
 696           if (output_sec != lower && lower != NULL)
 697             lower_size_ram -= scan_children (lower->children.head);
 698         }
 699       lower_size = &lower_size_ram;
 700     }
 701   /* Move sections that cause the lower region to overflow to the upper region.  */
 702   if (*lower_size + s->size > output_sec->region->length)
 703     change_output_section (&(output_sec->children.head), s, upper);
 704   else
 705     *lower_size += s->size;
 706  end:
 707   free (either_name);
 708 }
 709
 710 /* This function is similar to lang_relax_sections, but without the size
 711    evaluation code that is always executed after relaxation.  */
 712 static void
 713 intermediate_relax_sections (void)
 714 {
 715   int i = link_info.relax_pass;
 716
 717   /* The backend can use it to determine the current pass.  */
 718   link_info.relax_pass = 0;
 719
 720   while (i--)
 721     {
 722       bfd_boolean relax_again;
 723
 724       link_info.relax_trip = -1;
 725       do
 726         {
 727           link_info.relax_trip++;
 728
 729           lang_do_assignments (lang_assigning_phase_enum);
 730
 731           lang_reset_memory_regions ();
 732
 733           relax_again = FALSE;
 734           lang_size_sections (&relax_again, FALSE);
 735         }
 736       while (relax_again);
 737
 738       link_info.relax_pass++;
 739     }
 740 }
 741
 742 static void
 743 msp430_elf_after_allocation (void)
 744 {
 745   int relax_count = 0;
 746   unsigned int i;
 747   /* Go over each section twice, once to place either sections that don't fit
 748      in lower into upper, and then again to move any sections in upper that
 749      fit in lower into lower.  */
 750   for (i = 0; i < 8; i++)
 751     {
 752       int placement_stage = (i < 4) ? LOWER_TO_UPPER : UPPER_TO_LOWER;
 753       const char * base_sec_name;
 754       lang_output_section_statement_type * upper;
 755
 756       switch (i % 4)
 757         {
 758         default:
 759         case 0:
 760           base_sec_name = ".text";
 761           break;
 762         case 1:
 763           base_sec_name = ".data";
 764           break;
 765         case 2:
 766           base_sec_name = ".bss";
 767           break;
 768         case 3:
 769           base_sec_name = ".rodata";
 770           break;
 771         }
 772       upper = lang_output_section_find (concat (".upper", base_sec_name, NULL));
 773       if (upper != NULL)
 774         {
 775           /* Can't just use one iteration over the all the sections to make
 776              both lower->upper and upper->lower transformations because the
 777              iterator encounters upper sections before all lower sections have
 778              been examined.  */
 779           bfd *abfd;
 780
 781           if (placement_stage == LOWER_TO_UPPER)
 782             {
 783               /* Perform relaxation and get the final size of sections
 784                  before trying to fit .either sections in the correct
 785                  ouput sections.  */
 786               if (relax_count == 0)
 787                 {
 788                   intermediate_relax_sections ();
 789                   relax_count++;
 790                 }
 791               for (abfd = link_info.input_bfds; abfd != NULL;
 792                    abfd = abfd->link.next)
 793                 {
 794                   bfd_map_over_sections (abfd, eval_lower_either_sections,
 795                                          (void *) base_sec_name);
 796                 }
 797             }
 798           else if (placement_stage == UPPER_TO_LOWER)
 799             {
 800               /* Relax again before moving upper->lower.  */
 801               if (relax_count == 1)
 802                 {
 803                   intermediate_relax_sections ();
 804                   relax_count++;
 805                 }
 806               for (abfd = link_info.input_bfds; abfd != NULL;
 807                    abfd = abfd->link.next)
 808                 {
 809                   bfd_map_over_sections (abfd, eval_upper_either_sections,
 810                                          (void *) base_sec_name);
 811                 }
 812             }
 813
 814         }
 815     }
 816   gld${EMULATION_NAME}_after_allocation ();
 817 }
 818
 819 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
 820 {
 821   ${LDEMUL_BEFORE_PARSE-gld${EMULATION_NAME}_before_parse},
 822   ${LDEMUL_SYSLIB-syslib_default},
 823   ${LDEMUL_HLL-hll_default},
 824   ${LDEMUL_AFTER_PARSE-after_parse_default},
 825   msp430_elf_after_open,
 826   after_check_relocs_default,
 827   msp430_elf_after_allocation,
 828   ${LDEMUL_SET_OUTPUT_ARCH-set_output_arch_default},
 829   ${LDEMUL_CHOOSE_TARGET-ldemul_default_target},
 830   ${LDEMUL_BEFORE_ALLOCATION-before_allocation_default},
 831   ${LDEMUL_GET_SCRIPT-gld${EMULATION_NAME}_get_script},
 832   "${EMULATION_NAME}",
 833   "${OUTPUT_FORMAT}",
 834   ${LDEMUL_FINISH-finish_default},
 835   ${LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS-NULL},
 836   ${LDEMUL_OPEN_DYNAMIC_ARCHIVE-NULL},
 837   ${LDEMUL_PLACE_ORPHAN-gld${EMULATION_NAME}_place_orphan},
 838   ${LDEMUL_SET_SYMBOLS-NULL},
 839   ${LDEMUL_PARSE_ARGS-NULL},
 840   gld${EMULATION_NAME}_add_options,
 841   gld${EMULATION_NAME}_handle_option,
 842   ${LDEMUL_UNRECOGNIZED_FILE-NULL},
 843   gld${EMULATION_NAME}_list_options,
 844   ${LDEMUL_RECOGNIZED_FILE-NULL},
 845   ${LDEMUL_FIND_POTENTIAL_LIBRARIES-NULL},
 846   ${LDEMUL_NEW_VERS_PATTERN-NULL},
 847   ${LDEMUL_EXTRA_MAP_FILE_TEXT-NULL}
 848 };
 849 EOF
 850 # \f
 851 # Local Variables:
 852 # mode: c
 853 # End: