[ELF] - Report error when memory region is overflowed by data commands.

[grimar]

Summary

LLD can not catch a memory area overflow when using a data command.
If we have the script below:

.foo : 
{
  *(.foo)
  BYTE(0x1)
} > ram

where BYTE overflows the ram region, we do not report it currently.
Patch fixes that. This change can also be helpful for other places,
I am planning to use it for fixing PR36535.

[grimar]

• Rewrote the comment.

[grimar]

• Removed the requirement of mips from the test.

[ruiu]

LGTM

test/ELF/linkerscript/memory-data-commands.test

12–25 ↗

(On Diff #136549)

nit: please format in the same way as other linker scripts. I.e.

MEMORY {
  text (rwx): org = 0x0, len = 0x1000
  ram (rwx): org = 0x1000, len = 8
}

SECTIONS {
  .text : { *(.text) } > text
  .foo  : { *(.foo) BYTE(0x1) } > ram
}

lld/trunk/ELF/LinkerScript.cpp

uint64_t LinkerScript::advance(uint64_t Size, unsigned Alignment) {
 
   if (IsTbss)
     Ctx->ThreadBssOffset = End - Dot;
   else
     Dot = End;
   return End;
 }
 
+// Expands the memory region by the specified size.
+static void expandMemoryRegion(MemoryRegion *MemRegion, uint64_t Size,
+                               StringRef RegionName, StringRef SecName) {
+  MemRegion->CurPos += Size;
+  uint64_t NewSize = MemRegion->CurPos - MemRegion->Origin;
+  if (NewSize > MemRegion->Length)
+    error("section '" + SecName + "' will not fit in region '" + RegionName +
+          "': overflowed by " + Twine(NewSize - MemRegion->Length) + " bytes");
+}
+
 void LinkerScript::output(InputSection *S) {
   uint64_t Before = advance(0, 1);
   uint64_t Pos = advance(S->getSize(), S->Alignment);
   S->OutSecOff = Pos - S->getSize() - Ctx->OutSec->Addr;
 
   // Update output section size after adding each section. This is so that
   // SIZEOF works correctly in the case below:
   // .foo { *(.aaa) a = SIZEOF(.foo); *(.bbb) }
   Ctx->OutSec->Size = Pos - Ctx->OutSec->Addr;
 
   // If there is a memory region associated with this input section, then
   // place the section in that region and update the region index.
   if (Ctx->LMARegion)
     Ctx->LMARegion->CurPos += Pos - Before;
   // FIXME: should we also produce overflow errors for LMARegion?
 
-  if (Ctx->MemRegion) {
-    uint64_t &CurOffset = Ctx->MemRegion->CurPos;
-    CurOffset += Pos - Before;
-    uint64_t CurSize = CurOffset - Ctx->MemRegion->Origin;
-    if (CurSize > Ctx->MemRegion->Length) {
-      uint64_t OverflowAmt = CurSize - Ctx->MemRegion->Length;
-      error("section '" + Ctx->OutSec->Name + "' will not fit in region '" +
-            Ctx->MemRegion->Name + "': overflowed by " + Twine(OverflowAmt) +
-            " bytes");
-    }
-  }
+  if (Ctx->MemRegion)
+    expandMemoryRegion(Ctx->MemRegion, Pos - Before, Ctx->MemRegion->Name,
+                       Ctx->OutSec->Name);
 }
 
 void LinkerScript::switchTo(OutputSection *Sec) {
   if (Ctx->OutSec == Sec)
     return;
 
   Ctx->OutSec = Sec;
   Ctx->OutSec->Addr = advance(0, Ctx->OutSec->Alignment);
if (auto *Cmd = dyn_cast<SymbolAssignment>(Base)) {
       continue;
     }
 
     // Handle BYTE(), SHORT(), LONG(), or QUAD().
     if (auto *Cmd = dyn_cast<ByteCommand>(Base)) {
       Cmd->Offset = Dot - Ctx->OutSec->Addr;
       Dot += Cmd->Size;
       if (Ctx->MemRegion)
-        Ctx->MemRegion->CurPos += Cmd->Size;
+        expandMemoryRegion(Ctx->MemRegion, Cmd->Size, Ctx->MemRegion->Name,
+                           Ctx->OutSec->Name);
       if (Ctx->LMARegion)
         Ctx->LMARegion->CurPos += Cmd->Size;
       Ctx->OutSec->Size = Dot - Ctx->OutSec->Addr;
       continue;
     }
 
     // Handle ASSERT().
     if (auto *Cmd = dyn_cast<AssertCommand>(Base)) {

lld/trunk/test/ELF/linkerscript/memory-data-commands.test

+# REQUIRES: x86
+
+# RUN: echo ".section .foo,\"a\"" > %t.s
+# RUN: echo ".quad 1" >> %t.s
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %t.s -o %t.o
+
+# RUN: not ld.lld -o %t %t.o --script %s 2>&1 | FileCheck %s
+
+# Check we are able to catch 'ram' overflow caused by BYTE command.
+# CHECK: error: section '.foo' will not fit in region 'ram': overflowed by 1 bytes
+
+MEMORY {
+  text (rwx): org = 0x0, len = 0x1000
+  ram (rwx): org = 0x1000, len = 8
+}
+SECTIONS {
+  .text : { *(.text) } > text
+  .foo : {
+    *(.foo)
+    BYTE(0x1)
+  } > ram
+}