[lld] [LLD][ELF] Don't spill to same memory region (PR #129795)

[Daniel Thornburgh via llvm-commits]

================
@@ -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))
----------------
mysterymath wrote:

Yes, that's correct. This was code added to prevent this roughly this issue, but it appears to have been neither necessary nor sufficient.

As-is, this shouldn't create any behavioral differences, since spilling to a different memory region implies spilling to a different output section. But this also does hint towards a future way to express very detailed address constraints within an output section, which is something that has been on my radar for a while.

For example:
```
CLASS(text) ( *(.text) }
.text {
  CLASS(text)
  . = 0x1234; 
  *(.text.at_0x1234)
  CLASS(text)
}
```

The first pass would assign everything to the first CLASS reference, but this would cause dot to move backwards. The spiller could detect the amount dot moved backwards and spill that much from a preceding class, just like it does for memory region overages. The difference is that later references within the same output section may help to resolve this.

I don't think there's actually anything you could achieve with this that you couldn't achieve by splitting everything into fine-grained output sections, but to me it would just help to make spilling feel more orthogonal with linker features like dot assignment. Broadly, I'd tend to think that any address assignment failure should trigger spilling if that might have a chance to prevent the issue on the next pass.

https://github.com/llvm/llvm-project/pull/129795