[LLD][ELF] Don't spill to same memory region

This prevents spills to the same memory region from causing spilling to
take too many passes to converge.

Handling this at spilling time allows us to relax the generation of
spill sections; specifically, multiple spills can now be generated per
output section. This should be fairly benign, and it would eventually
allow allow linker scripts to express things like holes or minimum
addresses for parts of output sections. The linker could then spill
within an output section whenever address constraints are violated.

Author: mysterymath

lld/ELF/LinkerScript.cpp

@@ -563,7 +563,7 @@ LinkerScript::computeInputSections(const InputSectionDescription *cmd,
           continue;
 
         if (!cmd->matchesFile(*sec->file) || pat.excludesFile(*sec->file) ||
-            sec->parent == &outCmd || !flagsMatch(sec))
+            !flagsMatch(sec))
           continue;
 
         if (sec->parent) {
@@ -626,7 +626,7 @@ LinkerScript::computeInputSections(const InputSectionDescription *cmd,
 
     for (InputSectionDescription *isd : scd->sc.commands) {
       for (InputSectionBase *sec : isd->sectionBases) {
-        if (sec->parent == &outCmd || !flagsMatch(sec))
+        if (!flagsMatch(sec))
           continue;
         bool isSpill = sec->parent && isa<OutputSection>(sec->parent);
         if (!sec->parent || (isSpill && outCmd.name == "/DISCARD/")) {
@@ -1585,16 +1585,29 @@ bool LinkerScript::spillSections() {
         if (isa<PotentialSpillSection>(isec))
           continue;
 
-        // Find the next potential spill location and remove it from the list.
         auto it = potentialSpillLists.find(isec);
         if (it == potentialSpillLists.end())
-          continue;
+          break;
+
+        // Consume spills until finding one that might help, then consume it.
         PotentialSpillList &list = it->second;
-        PotentialSpillSection *spill = list.head;
-        if (spill->next)
-          list.head = spill->next;
-        else
-          potentialSpillLists.erase(isec);
+        PotentialSpillSection *spill;
+        for (spill = list.head; spill; spill = spill->next) {
+          if (list.head->next)
+            list.head = spill->next;
+          else
+            potentialSpillLists.erase(isec);
+
+          // Spills to the same regions cannot help.
+          if (spill->getParent()->memRegion == osec->memRegion &&
+              spill->getParent()->lmaRegion == osec->lmaRegion)
+            continue;
+
+          // This spill might resolve the overflow.
+          break;
+        }
+        if (!spill)
+          continue;
 
         // Replace the next spill location with the spilled section and adjust
         // its properties to match the new location. Note that the alignment of

lld/test/ELF/linkerscript/section-class.test

@@ -450,3 +450,51 @@ SECTIONS {
 
 # TO-DISCARD: error: section '.two_byte_section' cannot spill from/to /DISCARD/
 # TO-DISCARD-WARN: warning: section '.two_byte_section' cannot spill from/to /DISCARD/
+
+#--- same-mem-region.lds
+## Spills to the same memory region do not consume address assignment passes.
+MEMORY {
+  a : ORIGIN = 0, LENGTH = 0
+  b : ORIGIN = 0, LENGTH = 3
+}
+SECTIONS {
+  CLASS(class) { *(.one_byte_section .two_byte_section) }
+  .a00 : { CLASS(class) } >a
+  .a01 : { CLASS(class) } >a
+  .a02 : { CLASS(class) } >a
+  .a03 : { CLASS(class) } >a
+  .a04 : { CLASS(class) } >a
+  .a05 : { CLASS(class) } >a
+  .a06 : { CLASS(class) } >a
+  .a07 : { CLASS(class) } >a
+  .a08 : { CLASS(class) } >a
+  .a09 : { CLASS(class) } >a
+  .a10 : { CLASS(class) } >a
+  .a11 : { CLASS(class) } >a
+  .a12 : { CLASS(class) } >a
+  .a13 : { CLASS(class) } >a
+  .a14 : { CLASS(class) } >a
+  .a15 : { CLASS(class) } >a
+  .a16 : { CLASS(class) } >a
+  .a17 : { CLASS(class) } >a
+  .a18 : { CLASS(class) } >a
+  .a19 : { CLASS(class) } >a
+  .a20 : { CLASS(class) } >a
+  .a21 : { CLASS(class) } >a
+  .a22 : { CLASS(class) } >a
+  .a23 : { CLASS(class) } >a
+  .a24 : { CLASS(class) } >a
+  .a25 : { CLASS(class) } >a
+  .a26 : { CLASS(class) } >a
+  .a27 : { CLASS(class) } >a
+  .a28 : { CLASS(class) } >a
+  .a29 : { CLASS(class) } >a
+  .a30 : { CLASS(class) } >a
+  .b : { CLASS(class) } >b
+}
+
+# RUN: ld.lld -T same-mem-region.lds -o same-mem-region spill.o
+# RUN: llvm-readelf -S same-mem-region | FileCheck %s --check-prefix=SAME-MEM-REGION
+
+# SAME-MEM-REGION:      Name          Type     Address          Off    Size
+# SAME-MEM-REGION:      .b PROGBITS 0000000000000000 001000 000003