[DEMO]

[grimar]

Summary

For demonstration purposes only.

[kschwarz]

ELF/LinkerScript.cpp

780

I think we should somehow keep the description of the used heuristic, or at least have a link here.

793

In my patch, the final else case returns nullptr, in your case its Ctx->LMARegion.
While I think we are catching all important cases previously, its not obvious now what will be finally returned.

ELF/LinkerScript.h

class LinkerScript final {
   std::vector<size_t> getPhdrIndices(OutputSection *Sec);
 
   MemoryRegion *findMemoryRegion(OutputSection *Sec);
 
   void switchTo(OutputSection *Sec);
   uint64_t advance(uint64_t Size, unsigned Align);
   void output(InputSection *Sec);
 
+  MemoryRegion *findLMARegion(OutputSection *Sec);
   void assignOffsets(OutputSection *Sec);
 
   // Ctx captures the local AddressState and makes it accessible
   // deliberately. This is needed as there are some cases where we cannot just
   // thread the current state through to a lambda function created by the
   // script parser.
   // This should remain a plain pointer as its lifetime is smaller than
   // LinkerScript.

ELF/LinkerScript.cpp

 void LinkerScript::switchTo(OutputSection *Sec) {
   Ctx->OutSec = Sec;
 
   uint64_t Before = advance(0, 1);
   Ctx->OutSec->Addr = advance(0, Ctx->OutSec->Alignment);
   expandMemoryRegions(Ctx->OutSec->Addr - Before);
 }
 
+static bool areFlagsCompatible(MemoryRegion *M, OutputSection *Sec) {
+  return (M && (!M->Flags || (M->Flags & Sec->Flags)) &&
+          ((M->NegFlags & Sec->Flags) == 0));
+}
+
 // This function searches for a memory region to place the given output
 // section in. If found, a pointer to the appropriate memory region is
 // returned. Otherwise, a nullptr is returned.
 MemoryRegion *LinkerScript::findMemoryRegion(OutputSection *Sec) {
   // If a memory region name was specified in the output section command,
   // then try to find that region first.
   if (!Sec->MemoryRegionName.empty()) {
     if (MemoryRegion *M = MemoryRegions.lookup(Sec->MemoryRegionName))
       return M;
     error("memory region '" + Sec->MemoryRegionName + "' not declared");
     return nullptr;
   }
 
   // If at least one memory region is defined, all sections must
   // belong to some memory region. Otherwise, we don't need to do
   // anything for memory regions.
   if (MemoryRegions.empty())
     return nullptr;
 
   // See if a region can be found by matching section flags.
-  for (auto &Pair : MemoryRegions) {
-    MemoryRegion *M = Pair.second;
-    if ((M->Flags & Sec->Flags) && (M->NegFlags & Sec->Flags) == 0)
-      return M;
-  }
+  for (auto &Pair : MemoryRegions)
+    if (areFlagsCompatible(Pair.second, Sec))
+      return Pair.second;
 
   // Otherwise, no suitable region was found.
   if (Sec->Flags & SHF_ALLOC)
     error("no memory region specified for section '" + Sec->Name + "'");
   return nullptr;
 }
 
 static OutputSection *findFirstSection(PhdrEntry *Load) {
   for (OutputSection *Sec : OutputSections)
     if (Sec->PtLoad == Load)
       return Sec;
   return nullptr;
 }
 
+static MemoryRegion *findRegion(uint64_t Addr) {
+  for (auto &Pair : Script->MemoryRegions) {
+    MemoryRegion *M = Pair.second;
+    if (M->Origin <= Addr && Addr < M->Origin + M->Length)
+      return M;
+  }
+  return nullptr;
+}
+
+static bool isLMARegionCompatible(MemoryRegion *M, OutputSection *Sec) {
+  if (!(Sec->Flags & SHF_ALLOC))
+    return false;
+  return (Sec->Type & SHT_NOBITS) || areFlagsCompatible(M, Sec);
+}
+
+MemoryRegion *LinkerScript::findLMARegion(OutputSection *Sec) {
+  if (Sec->LMAExpr) {
+    uint64_t Addr = Sec->LMAExpr().getValue();
+    MemoryRegion *MR = findRegion(Addr);
+    if (MR)
+      MR->CurPos = Addr;
+    return MR;
+  }
+
+  if (Sec->AddrExpr || !Sec->MemRegion || Sec->MemRegion != Ctx->MemRegion ||
+      !isLMARegionCompatible(Ctx->LMARegion, Sec))
+    return nullptr;
+
+  return Ctx->LMARegion;
+}
+
 // This function assigns offsets to input sections and an output section
 // for a single sections command (e.g. ".text { *(.text); }").
 void LinkerScript::assignOffsets(OutputSection *Sec) {
   if (!(Sec->Flags & SHF_ALLOC))
     Dot = 0;
   else if (Sec->AddrExpr)
     setDot(Sec->AddrExpr, Sec->Location, false);
 
-  Ctx->MemRegion = Sec->MemRegion;
+  if (Sec->LMARegion)
     Ctx->LMARegion = Sec->LMARegion;
+  else
+    Ctx->LMARegion = findLMARegion(Sec);
+
+  Ctx->MemRegion = Sec->MemRegion;
+
   if (Ctx->MemRegion)
     Dot = Ctx->MemRegion->CurPos;
 
   switchTo(Sec);
 
-  if (Sec->LMAExpr)
-    Ctx->LMAOffset = Sec->LMAExpr().getValue() - Dot;
-
-  if (MemoryRegion *MR = Sec->LMARegion)
+  // Compute the LMAOffset
+  // If we have an LMARegion set, use it
+  if (MemoryRegion *MR = Ctx->LMARegion)
     Ctx->LMAOffset = MR->CurPos - Dot;
+  // If the LMAExpr is set but we could not find an LMARegion previously,
+  // this means we do not have any MEMORY commands and need to evaluate
+  // the expression again.
+  else if (Sec->LMAExpr)
+    Ctx->LMAOffset = Sec->LMAExpr().getValue() - Dot;
+  // In all other cases, VMA = LMA
+  else
+    Ctx->LMAOffset = 0;
 
-  // If neither AT nor AT> is specified for an allocatable section, the linker
-  // will set the LMA such that the difference between VMA and LMA for the
-  // section is the same as the preceding output section in the same region
-  // https://sourceware.org/binutils/docs-2.20/ld/Output-Section-LMA.html
-  // This, however, should only be done by the first "non-header" section
-  // in the segment.
+  // Only the first "non-header" section of each program header should set the
+  // LMAOffset
   if (PhdrEntry *L = Ctx->OutSec->PtLoad)
     if (Sec == findFirstSection(L))
       L->LMAOffset = Ctx->LMAOffset;
 
   // We can call this method multiple times during the creation of
   // thunks and want to start over calculation each time.
   Sec->Size = 0;
 

test/ELF/linkerscript/at9.test

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/at8.s -o %t.o
+# RUN: ld.lld %t.o --script %s -o %t
+# RUN: llvm-readelf -sections -program-headers %t | FileCheck %s
+
+MEMORY {
+  FLASH  : ORIGIN = 0x08000000, LENGTH = 0x100
+  RAM    : ORIGIN = 0x20000000, LENGTH = 0x200
+}
+
+SECTIONS {
+ .text : { *(.text) } > FLASH
+ .sec1 : { *(.sec1) } > RAM AT > FLASH
+ .sec2 : { *(.sec2) } > RAM
+ .sec3 : { *(.sec3) } > FLASH
+}
+
+# Make sure we increase the implicit LMA region of .sec2.
+# Otherwise, .sec3 will receive a huge load address because of
+# unsigned underflow in the calculation of the offset to its
+# virtual address.
+
+# CHECK: Name              Type            Address          Off
+# CHECK: .text             PROGBITS        0000000008000000 001000
+# CHECK: .sec1             PROGBITS        0000000020000000 001000
+# CHECK: .sec2             PROGBITS        0000000020000008 001008
+# CHECK: .sec3             PROGBITS        0000000008000010 001010
+
+# CHECK: Program Headers:
+# CHECK:      Type  Offset   VirtAddr           PhysAddr
+# CHECK-NEXT: LOAD  0x001000 0x0000000020000000 0x0000000008000000
+# CHECK-NEXT: LOAD  0x001010 0x0000000008000010 0x0000000008000010
+# CHECK-NOT: LOAD