[ELF] Make overlapping output sections an error

[arichardson]

Summary

While trying to make a linker script behave the same way with lld as it did
with bfd, I discovered that lld currently doesn't diagnose overlapping
output sections. I was getting very strange runtime failures which I
tracked down to overlapping sections in the resulting binary. When linking
with ld.bfd overlapping output sections are an error unless
--noinhibit-exec is passed and I believe lld should behave the same way
here to avoid surprising crashes at runtime.

[arichardson]

Speed up lld invocation in test/ELF/many-alloc-sections.s lld invocation from 290s to <1s by not checking empty sections

[grimar]

In D41046#950367, @arichardson wrote:

Speed up lld invocation in test/ELF/many-alloc-sections.s lld invocation from 290s to <1s by not checking empty sections

I think we already had patches for that purpose before (I can be missing details, though I mean general idea was to avoid overlapping things when linker script is used,
probably it were PT_LOADs, but anyways).
And I think last time we stopped on a point that we are not going to stop users from breaking output if they want to do that, because with linker script it is easy to break everything.

That position can be revisited probably, if you have good arguments for that :)

[arichardson]

In D41046#950879, @grimar wrote:

In D41046#950367, @arichardson wrote:

Speed up lld invocation in test/ELF/many-alloc-sections.s lld invocation from 290s to <1s by not checking empty sections

I think we already had patches for that purpose before (I can be missing details, though I mean general idea was to avoid overlapping things when linker script is used,
probably it were PT_LOADs, but anyways).
And I think last time we stopped on a point that we are not going to stop users from breaking output if they want to do that, because with linker script it is easy to break everything.

That position can be revisited probably, if you have good arguments for that :)

My argument is that I wasted hours of debugging time due to a typo in the linker script. If lld had warned me about the overlapping output sections that would not have happened.
If a user really wants to create broken output with a linker script we have --noinhibit-exec for that use case.

[ruiu]

The amount of new code seems a bit overwhelming. I wonder if there's a better and simpler way of doing it. In what condition do sections overlap?

We do have a check if "." doesn't rewind. Doesn't it work as a prevention for section overlapping?

[grimar]

In D41046#952044, @ruiu wrote:

We do have a check if "." doesn't rewind. Doesn't it work as a prevention for section overlapping?

We removed this check for linking linux kernel. We check that Dot does not rewind inside a section declaration, but do not have a check for outside case.
(https://github.com/llvm-mirror/lld/blob/master/ELF/LinkerScript.cpp#L105)

[ruiu]

If that's the case, creating overlapping sections is not an issue, but actually we have to be able to create such sections, no?

[grimar]

In D41046#952097, @ruiu wrote:

If that's the case, creating overlapping sections is not an issue, but actually we have to be able to create such sections, no?

Not exactly. Linux kernel script does not have overlapping sections.

It changes the Dot though (from something like 0xFFFFXXXX to 0 as far I remember) in the way the simple check that Dot after
change is greater than Dot before change simply did not work, so we had to remove it.

[arichardson]

In D41046#952044, @ruiu wrote:

The amount of new code seems a bit overwhelming. I wonder if there's a better and simpler way of doing it. In what condition do sections overlap?

We do have a check if "." doesn't rewind. Doesn't it work as a prevention for section overlapping?

The overlapping that I got happened because we explicitly assign (virtual) address 0x8000 to a section and 0x8200 to another section.
Also I don't think overlapping load addresses can be fixed by checking for . not rewinding.

I can definitely reduce the amount of new code by inlining struct AddressRange but I felt that adding it made the code easier to understand.
Most of the new code is comments. I'm not sure I can make it much simpler while checking file offsets as well as load and virtual addresess.
I believe having this check in LLD is not only useful to catch errors in linker scripts but also to ensure that the code assigning addresses and offsets doesn't break accidentally.

[arichardson]

• Rebased
• slightly simpified patch
• fixed an error in a test that was found by this patch

[arichardson]

• Rebased
• Made slightly more efficient by using std::partition instead of comparing in every loop iteration

[ruiu]

ELF/Writer.cpp

1880–1882 ↗

(On Diff #131968)

Remove llvm::.

1885 ↗

(On Diff #131968)

It's not a trivial function, so it needs a function comment.

1889–1890 ↗

(On Diff #131968)

Please do not use auto in lld unless the actual type is obvious in a very narrow context (e.g. RHS).

[ruiu]

ELF/Writer.cpp

1889–1890 ↗

(On Diff #131968)

These variable names are a bit too lengthy and don't match other code in lld. Also this patch uses higher order functions than other code, so it feels different. I'd make this consistent with other code.

E.g. I'd write this part as

std::vector<OutputSection *> Sections;
for (OutputSection *Sec : AllSections)
  if (!ShouldSkip(Sec))
    Sections.push_back(Sec);

1893 ↗

(On Diff #131968)

Insert a blank line before a multi-line comment.

1904 ↗

(On Diff #131968)

Please don't use auto

1908 ↗

(On Diff #131968)

Isn't this condition enough?

if (GetStart(Other) < GetStart(Sec) + Sec->Size)

1929 ↗

(On Diff #131968)

This is not a performance critical path, so we shouldn't optimize it by using reserve.

1932–1933 ↗

(On Diff #131968)

I'd write this with a plain for-loop for consistency with other code.

for (OutputSection *Sec : OutputSections)
  if (Sec->Size > 0)
    Sections.push_back(Sec);

1964 ↗

(On Diff #131968)

Insert a blank line.

[arichardson]

ELF/Writer.cpp

1889–1890 ↗

(On Diff #131968)

Looking at this code again, the previous version without std::partition was much easier to understand. I've also updated to use for loops instead of copy_if

1908 ↗

(On Diff #131968)

It is now that the sections are sorted. Originally I didn't sort by address so it was required.

[arichardson]

Addressed comments

[ruiu]

ELF/Writer.cpp

1878 ↗

(On Diff #132027)

Addr and Len

1936–1940 ↗

(On Diff #132027)

I don't think we need this as well. In general we shouldn't optimize for speed unless it is necessary.

[arichardson]

Updated for review comments

ELF/Writer.cpp

1936–1940 ↗

(On Diff #132027)

Since I simplified the check to GetStart(Other) < Start + Sec->Size it is actually required. I have folded the Size > 0 check into the if (ShouldSkip(Sec))and added a comment instead.

[ruiu]

LGTM with these changes. Thanks!

ELF/Writer.cpp

1915–1916 ↗

(On Diff #132044)

Since it's obvious, you may use auto * here if you want.

1921 ↗

(On Diff #132044)

nit: else break seems a bit tricky. I'd prefer this style because of less indentation.

if (Start + Sec->Size <= GetStart(Other))
  break;
errorOrWarn(...);

[jhenderson]

Following this change, there's now always a warning or error with overlapping sections, but this seems undesirable in the occasional case where a user actually wants this behaviour, so I've suggested that we also add --no-check-sections from ld.bfd in https://bugs.llvm.org/show_bug.cgi?id=36205.

lld/trunk/ELF/Config.h

 //===- Config.h -------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_CONFIG_H
 #define LLD_ELF_CONFIG_H
 
+#include "lld/Common/ErrorHandler.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Support/CachePruning.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Endian.h"
 
struct Configuration {
 
   // 4 for ELF32, 8 for ELF64.
   int Wordsize;
 };
 
 // The only instance of Configuration struct.
 extern Configuration *Config;
 
+static inline void errorOrWarn(const Twine &Msg) {
+  if (!Config->NoinhibitExec)
+    error(Msg);
+  else
+    warn(Msg);
+}
 } // namespace elf
 } // namespace lld
 
 #endif

lld/trunk/ELF/Relocations.cpp

for (SharedSymbol *Sym : getSymbolsAt<ELFT>(SS)) {
     Sym->CopyRelSec = Sec;
     Sym->IsUsedInRegularObj = true;
     Sym->Used = true;
   }
 
   InX::RelaDyn->addReloc({Target->CopyRel, Sec, 0, false, &SS, 0});
 }
 
-static void errorOrWarn(const Twine &Msg) {
-  if (!Config->NoinhibitExec)
-    error(Msg);
-  else
-    warn(Msg);
-}
-
 // MIPS has an odd notion of "paired" relocations to calculate addends.
 // For example, if a relocation is of R_MIPS_HI16, there must be a
 // R_MIPS_LO16 relocation after that, and an addend is calculated using
 // the two relocations.
 template <class ELFT, class RelTy>
 static int64_t computeMipsAddend(const RelTy &Rel, const RelTy *End,
                                  InputSectionBase &Sec, RelExpr Expr,
                                  bool IsLocal) {

lld/trunk/ELF/Writer.cpp

private:
   void setReservedSymbolSections();
 
   std::vector<PhdrEntry *> createPhdrs();
   void removeEmptyPTLoad();
   void addPtArmExid(std::vector<PhdrEntry *> &Phdrs);
   void assignFileOffsets();
   void assignFileOffsetsBinary();
   void setPhdrs();
+  void checkNoOverlappingSections();
   void fixSectionAlignments();
   void openFile();
   void writeTrapInstr();
   void writeHeader();
   void writeSections();
   void writeSectionsBinary();
   void writeBuildId();
 
template <class ELFT> void Writer<ELFT>::run() {
 
   setPhdrs();
 
   if (Config->Relocatable) {
     for (OutputSection *Sec : OutputSections)
       Sec->Addr = 0;
   }
 
+  checkNoOverlappingSections();
+
   // It does not make sense try to open the file if we have error already.
   if (errorCount())
     return;
   // Write the result down to a file.
   openFile();
   if (errorCount())
     return;
 
for (PhdrEntry *P : Phdrs) {
     if (P->p_type == PT_TLS) {
       Out::TlsPhdr = P;
       if (P->p_memsz)
         P->p_memsz = alignTo(P->p_memsz, P->p_align);
     }
   }
 }
 
+static std::string rangeToString(uint64_t Addr, uint64_t Len) {
+  if (Len == 0)
+    return "<emtpy range at 0x" + utohexstr(Addr) + ">";
+  return "[0x" + utohexstr(Addr) + " -> 0x" +
+         utohexstr(Addr + Len - 1) + "]";
+}
+
+// Check whether sections overlap for a specific address range (file offsets,
+// load and virtual adresses).
+//
+// This is a helper function called by Writer::checkNoOverlappingSections().
+template <typename Getter, typename Predicate>
+static void checkForSectionOverlap(ArrayRef<OutputSection *> AllSections,
+                                   StringRef Kind, Getter GetStart,
+                                   Predicate ShouldSkip) {
+  std::vector<OutputSection *> Sections;
+  // By removing all zero-size sections we can simplify the check for overlap to
+  // just checking whether the section range contains the other section's start
+  // address. Additionally, it also slightly speeds up the checking since we
+  // don't bother checking for overlap with sections that can never overlap.
+  for (OutputSection *Sec : AllSections)
+    if (Sec->Size > 0 && !ShouldSkip(Sec))
+      Sections.push_back(Sec);
+
+  // Instead of comparing every OutputSection with every other output section
+  // we sort the sections by address (file offset or load/virtual address). This
+  // way we find all overlapping sections but only need one comparision with the
+  // next section in the common non-overlapping case. The only time we end up
+  // doing more than one iteration of the following nested loop is if there are
+  // overlapping sections.
+  std::sort(Sections.begin(), Sections.end(),
+            [=](const OutputSection *A, const OutputSection *B) {
+              return GetStart(A) < GetStart(B);
+            });
+  for (size_t i = 0; i < Sections.size(); ++i) {
+    OutputSection *Sec = Sections[i];
+    uint64_t Start = GetStart(Sec);
+    for (auto *Other : ArrayRef<OutputSection *>(Sections).slice(i + 1)) {
+      // Since the sections are storted by start address we only need to check
+      // whether the other sections starts before the end of Sec. If this is
+      // not the case we can break out of this loop since all following sections
+      // will also start after the end of Sec.
+      if (Start + Sec->Size <= GetStart(Other))
+        break;
+      errorOrWarn("section " + Sec->Name + " " + Kind +
+                  " range overlaps with " + Other->Name + "\n>>> " + Sec->Name +
+                  " range is " + rangeToString(Start, Sec->Size) + "\n>>> " +
+                  Other->Name + " range is " +
+                  rangeToString(GetStart(Other), Other->Size));
+    }
+  }
+}
+
+// Check for overlapping sections
+//
+// In this function we check that none of the output sections have overlapping
+// file offsets. For SHF_ALLOC sections we also check that the load address
+// ranges and the virtual address ranges don't overlap
+template <class ELFT> void Writer<ELFT>::checkNoOverlappingSections() {
+  // First check for overlapping file offsets. In this case we need to skip
+  // Any section marked as SHT_NOBITS. These sections don't actually occupy
+  // space in the file so Sec->Offset + Sec->Size can overlap with others.
+  // If --oformat binary is specified only add SHF_ALLOC sections are added to
+  // the output file so we skip any non-allocated sections in that case.
+  checkForSectionOverlap(
+      OutputSections, "file", [](const OutputSection *Sec) { return Sec->Offset; },
+      [](const OutputSection *Sec) {
+        return Sec->Type == SHT_NOBITS ||
+               (Config->OFormatBinary && (Sec->Flags & SHF_ALLOC) == 0);
+      });
+
+  // When linking with -r there is no need to check for overlapping virtual/load
+  // addresses since those addresses will only be assigned when the final
+  // executable/shared object is created.
+  if (Config->Relocatable)
+    return;
+
+  // Checking for overlapping virtual and load addresses only needs to take
+  // into account SHF_ALLOC sections since since others will not be loaded.
+  // Furthermore, we also need to skip SHF_TLS sections since these will be
+  // mapped to other addresses at runtime and can therefore have overlapping
+  // ranges in the file.
+  auto SkipNonAllocSections = [](const OutputSection *Sec) {
+    return (Sec->Flags & SHF_ALLOC) == 0 || (Sec->Flags & SHF_TLS);
+  };
+  checkForSectionOverlap(OutputSections, "virtual address",
+                         [](const OutputSection *Sec) { return Sec->Addr; },
+                         SkipNonAllocSections);
+
+  // Finally, check that the load addresses don't overlap. This will usually be
+  // the same as the virtual addresses but can be different when using a linker
+  // script with AT().
+  checkForSectionOverlap(OutputSections, "load address",
+                         [](const OutputSection *Sec) { return Sec->getLMA(); },
+                         SkipNonAllocSections);
+}
+
 // The entry point address is chosen in the following ways.
 //
 // 1. the '-e' entry command-line option;
 // 2. the ENTRY(symbol) command in a linker control script;
 // 3. the value of the symbol _start, if present;
 // 4. the number represented by the entry symbol, if it is a number;
 // 5. the address of the first byte of the .text section, if present;
 // 6. the address 0.

lld/trunk/test/ELF/arm-thumb-interwork-thunk.s

 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %s -o %t
 // RUN: echo "SECTIONS { \
 // RUN:       . = SIZEOF_HEADERS; \
 // RUN:       .R_ARM_JUMP24_callee_1 : { *(.R_ARM_JUMP24_callee_low) } \
 // RUN:       .R_ARM_THM_JUMP_callee_1 : { *(.R_ARM_THM_JUMP_callee_low)} \
 // RUN:       .text : { *(.text) } \
 // RUN:       .arm_caller : { *(.arm_caller) } \
 // RUN:       .thumb_caller : { *(.thumb_caller) } \
 // RUN:       .R_ARM_JUMP24_callee_2 : { *(.R_ARM_JUMP24_callee_high) } \
 // RUN:       .R_ARM_THM_JUMP_callee_2 : { *(.R_ARM_THM_JUMP_callee_high) } \
-// RUN:       .got.plt 0x1894 : {  }  } " > %t.script
+// RUN:       .got.plt 0x18b4 : {  }  } " > %t.script
 // RUN: ld.lld --script %t.script %t -o %t2 2>&1
 // RUN: llvm-objdump -d -triple=thumbv7a-none-linux-gnueabi %t2 | FileCheck -check-prefix=CHECK-THUMB -check-prefix=CHECK-ABS-THUMB %s
 // RUN: llvm-objdump -d -triple=armv7a-none-linux-gnueabi %t2 | FileCheck -check-prefix=CHECK-ARM -check-prefix=CHECK-ABS-ARM %s
 // RUN: ld.lld --script %t.script %t -pie -o %t3 2>&1
 // RUN: ld.lld --script %t.script %t --shared -o %t4 2>&1
 // RUN: llvm-objdump -d -triple=thumbv7a-none-linux-gnueabi %t3 | FileCheck -check-prefix=CHECK-THUMB -check-prefix=CHECK-PI-THUMB %s
 // RUN: llvm-objdump -d -triple=armv7a-none-linux-gnueabi %t3 | FileCheck -check-prefix=CHECK-ARM -check-prefix=CHECK-PI-ARM %s
 // RUN: llvm-objdump -d -triple=thumbv7a-none-linux-gnueabi %t4 | FileCheck -check-prefix=CHECK-THUMB -check-prefix=CHECK-PI-PLT-THUMB %s

 // CHECK-PI-ARM-PLT-NEXT: 182c:         00 f0 9c e5     ldr     pc, [r12]
 // CHECK-PI-ARM-PLT-NEXT: 1830:         88 00 00 00
 // 0x1838 + 8 + 0x7c = 0x18bc arm_callee3
 // CHECK-PI-ARM-PLT-NEXT: 1834:         04 c0 9f e5     ldr     r12, [pc, #4]
 // CHECK-PI-ARM-PLT-NEXT: 1838:         0f c0 8c e0     add     r12, r12, pc
 // CHECK-PI-ARM-PLT-NEXT: 183c:         00 f0 9c e5     ldr     pc, [r12]
 // CHECK-PI-ARM-PLT-NEXT: 1840:         7c 00 00 00
 
-// CHECK-DSO-REL:      0x18A0 R_ARM_JUMP_SLOT arm_caller
-// CHECK-DSO-REL-NEXT: 0x18A4 R_ARM_JUMP_SLOT thumb_caller
-// CHECK-DSO-REL-NEXT: 0x18A8 R_ARM_JUMP_SLOT thumb_callee1
-// CHECK-DSO-REL-NEXT: 0x18AC R_ARM_JUMP_SLOT thumb_callee2
-// CHECK-DSO-REL-NEXT: 0x18B0 R_ARM_JUMP_SLOT thumb_callee3
-// CHECK-DSO-REL-NEXT: 0x18B4 R_ARM_JUMP_SLOT arm_callee1
-// CHECK-DSO-REL-NEXT: 0x18B8 R_ARM_JUMP_SLOT arm_callee2
-// CHECK-DSO-REL-NEXT: 0x18BC R_ARM_JUMP_SLOT arm_callee3
+// CHECK-DSO-REL:      0x18C0 R_ARM_JUMP_SLOT arm_caller
+// CHECK-DSO-REL-NEXT: 0x18C4 R_ARM_JUMP_SLOT thumb_caller
+// CHECK-DSO-REL-NEXT: 0x18C8 R_ARM_JUMP_SLOT thumb_callee1
+// CHECK-DSO-REL-NEXT: 0x18CC R_ARM_JUMP_SLOT thumb_callee2
+// CHECK-DSO-REL-NEXT: 0x18D0 R_ARM_JUMP_SLOT thumb_callee3
+// CHECK-DSO-REL-NEXT: 0x18D4 R_ARM_JUMP_SLOT arm_callee1
+// CHECK-DSO-REL-NEXT: 0x18D8 R_ARM_JUMP_SLOT arm_callee2
+// CHECK-DSO-REL-NEXT: 0x18DC R_ARM_JUMP_SLOT arm_callee3

lld/trunk/test/ELF/linkerscript/overlapping-sections.s

+# TODO: maybe this should be converted to an x86 test to get more buildbot coverage
+# REQUIRES: mips
+# RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t.o
+
+# RUN: echo "SECTIONS { \
+# RUN:   .sec1 0x8000 : { sec1_start = .; *(.first_sec) sec1_end = .;} \
+# RUN:   .sec2 0x8800 : { sec2_start = .; *(.second_sec) sec2_end = .;} \
+# RUN: }" > %t.script
+# RUN: ld.lld -o %t.so --script %t.script %t.o -shared
+# RUN: llvm-readobj -sections -program-headers %t.so | FileCheck %s -check-prefix GOOD
+
+# GOOD:        Name: .sec1
+# GOOD-NEXT:   Type: SHT_PROGBITS (0x1)
+# GOOD-NEXT:   Flags [ (0x3)
+# GOOD-NEXT:     SHF_ALLOC (0x2)
+# GOOD-NEXT:     SHF_WRITE (0x1)
+# GOOD-NEXT:   ]
+# GOOD-NEXT:   Address: 0x8000
+# GOOD-NEXT:   Offset: 0x18000
+# GOOD-NEXT:   Size: 256
+
+# GOOD:        Name: .sec2
+# GOOD-NEXT:   Type: SHT_PROGBITS (0x1)
+# GOOD-NEXT:   Flags [ (0x3)
+# GOOD-NEXT:     SHF_ALLOC (0x2)
+# GOOD-NEXT:     SHF_WRITE (0x1)
+# GOOD-NEXT:   ]
+# GOOD-NEXT:   Address: 0x8800
+# GOOD-NEXT:   Offset: 0x18800
+# GOOD-NEXT:   Size: 256
+
+# GOOD:      ProgramHeaders [
+# GOOD-NEXT:  ProgramHeader {
+# GOOD-NEXT:    Type: PT_LOAD (0x1)
+# GOOD-NEXT:    Offset: 0x10000
+# GOOD-NEXT:    VirtualAddress: 0x0
+# GOOD-NEXT:    PhysicalAddress: 0x0
+# GOOD-NEXT:    FileSize: 481
+# GOOD-NEXT:    MemSize: 481
+# GOOD-NEXT:    Flags [ (0x5)
+# GOOD-NEXT:      PF_R (0x4)
+# GOOD-NEXT:      PF_X (0x1)
+# GOOD-NEXT:    ]
+# GOOD-NEXT:    Alignment: 65536
+# GOOD-NEXT:  }
+# GOOD-NEXT:  ProgramHeader {
+# GOOD-NEXT:    Type: PT_LOAD (0x1)
+# GOOD-NEXT:    Offset: 0x18000
+# GOOD-NEXT:    VirtualAddress: 0x8000
+# GOOD-NEXT:    PhysicalAddress: 0x8000
+# GOOD-NEXT:    FileSize: 2320
+# GOOD-NEXT:    MemSize: 2320
+# GOOD-NEXT:    Flags [ (0x6)
+# GOOD-NEXT:      PF_R (0x4)
+# GOOD-NEXT:      PF_W (0x2)
+# GOOD-NEXT:    ]
+# GOOD-NEXT:    Alignment: 65536
+# GOOD-NEXT:  }
+
+# RUN: echo "SECTIONS { \
+# RUN:   .sec1 0x8000 : AT(0x8000) { sec1_start = .; *(.first_sec) sec1_end = .;} \
+# RUN:   .sec2 0x8800 : AT(0x8080) { sec2_start = .; *(.second_sec) sec2_end = .;} \
+# RUN: }" > %t-lma.script
+# RUN: not ld.lld -o %t.so --script %t-lma.script %t.o -shared 2>&1 | FileCheck %s -check-prefix LMA-OVERLAP-ERR
+# LMA-OVERLAP-ERR:      error: section .sec1 load address range overlaps with .sec2
+# LMA-OVERLAP-ERR-NEXT: >>> .sec1 range is [0x8000 -> 0x80FF]
+# LMA-OVERLAP-ERR-NEXT: >>> .sec2 range is [0x8080 -> 0x817F]
+
+# check that we create the expected binary with --noinhibit-exec:
+# RUN: ld.lld -o %t.so --script %t-lma.script %t.o -shared --noinhibit-exec
+
+# Verify that the .sec2 was indeed placed in a PT_LOAD where the PhysAddr
+# overlaps with where .sec1 is loaded:
+# RUN: llvm-readobj -sections -program-headers -elf-output-style=GNU %t.so | FileCheck %s -check-prefix BAD-LMA
+# BAD-LMA-LABEL: Section Headers:
+# BAD-LMA: .sec1             PROGBITS        0000000000008000 018000 000100 00  WA  0   0  1
+# BAD-LMA: .sec2             PROGBITS        0000000000008800 018800 000100 00  WA  0   0  1
+# BAD-LMA-LABEL: Program Headers:
+# BAD-LMA-NEXT:  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
+# BAD-LMA-NEXT:  LOAD           0x010000 0x0000000000000000 0x0000000000000000 0x0001e1 0x0001e1 R E 0x10000
+# BAD-LMA-NEXT:  LOAD           0x018000 0x0000000000008000 0x0000000000008000 0x000100 0x000100 RW  0x10000
+# BAD-LMA-NEXT:  LOAD           0x018800 0x0000000000008800 0x0000000000008080 0x000110 0x000110 RW  0x10000
+# BAD-LMA-LABEL: Section to Segment mapping:
+# BAD-LMA:  01     .sec1
+# BAD-LMA:  02     .sec2 .data .got
+
+
+# Now try a script where the virtual memory addresses overlap but ensure that the
+# load addresses don't:
+# RUN: echo "SECTIONS { \
+# RUN:   .sec1 0x8000 : AT(0x8000) { sec1_start = .; *(.first_sec) sec1_end = .;} \
+# RUN:   .sec2 0x8020 : AT(0x8800) { sec2_start = .; *(.second_sec) sec2_end = .;} \
+# RUN: }" > %t-vaddr.script
+# RUN: not ld.lld -o %t.so --script %t-vaddr.script %t.o -shared 2>&1 | FileCheck %s -check-prefix VADDR-OVERLAP-ERR
+# VADDR-OVERLAP-ERR:      error: section .sec1 virtual address range overlaps with .sec2
+# VADDR-OVERLAP-ERR-NEXT: >>> .sec1 range is [0x8000 -> 0x80FF]
+# VADDR-OVERLAP-ERR-NEXT: >>> .sec2 range is [0x8020 -> 0x811F]
+
+# Check that the expected binary was created with --noinhibit-exec:
+# RUN: ld.lld -o %t.so --script %t-vaddr.script %t.o -shared --noinhibit-exec
+# RUN: llvm-readobj -sections -program-headers -elf-output-style=GNU %t.so | FileCheck %s -check-prefix BAD-VADDR
+# BAD-VADDR-LABEL: Section Headers:
+# BAD-VADDR: .sec1             PROGBITS        0000000000008000 018000 000100 00  WA  0   0  1
+# BAD-VADDR: .sec2             PROGBITS        0000000000008020 028020 000100 00  WA  0   0  1
+# BAD-VADDR-LABEL: Program Headers:
+# BAD-VADDR-NEXT:  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
+# BAD-VADDR-NEXT:  LOAD           0x010000 0x0000000000000000 0x0000000000000000 0x0001e1 0x0001e1 R E 0x10000
+# BAD-VADDR-NEXT:  LOAD           0x018000 0x0000000000008000 0x0000000000008000 0x000100 0x000100 RW  0x10000
+# BAD-VADDR-NEXT:  LOAD           0x028020 0x0000000000008020 0x0000000000008800 0x000110 0x000110 RW  0x10000
+# BAD-VADDR-LABEL: Section to Segment mapping:
+# BAD-VADDR:  01     .sec1
+# BAD-VADDR:  02     .sec2 .data .got
+
+# Finally check the case where both LMA and vaddr overlap
+
+# RUN: echo "SECTIONS { \
+# RUN:   .sec1 0x8000 : { sec1_start = .; *(.first_sec) sec1_end = .;} \
+# RUN:   .sec2 0x8040 : { sec2_start = .; *(.second_sec) sec2_end = .;} \
+# RUN: }" > %t-both-overlap.script
+
+# RUN: not ld.lld -o %t.so --script %t-both-overlap.script %t.o -shared 2>&1 | FileCheck %s -check-prefix BOTH-OVERLAP-ERR
+
+# BOTH-OVERLAP-ERR:      error: section .sec1 file range overlaps with .sec2
+# BOTH-OVERLAP-ERR-NEXT: >>> .sec1 range is [0x18000 -> 0x180FF]
+# BOTH-OVERLAP-ERR-NEXT: >>> .sec2 range is [0x18040 -> 0x1813F]
+# BOTH-OVERLAP-ERR:      error: section .sec1 virtual address range overlaps with .sec2
+# BOTH-OVERLAP-ERR-NEXT: >>> .sec1 range is [0x8000 -> 0x80FF]
+# BOTH-OVERLAP-ERR-NEXT: >>> .sec2 range is [0x8040 -> 0x813F]
+# BOTH-OVERLAP-ERR:      error: section .sec1 load address range overlaps with .sec2
+# BOTH-OVERLAP-ERR-NEXT: >>> .sec1 range is [0x8000 -> 0x80FF]
+# BOTH-OVERLAP-ERR-NEXT: >>> .sec2 range is [0x8040 -> 0x813F]
+
+# RUN: ld.lld -o %t.so --script %t-both-overlap.script %t.o -shared --noinhibit-exec
+# Note: I case everything overlaps we create a binary with overlapping file
+# offsets. ld.bfd seems to place .sec1 to file offset 18000 and .sec2
+# at 18100 so that only virtual addr and LMA overlap
+# However, in order to create such a broken binary the user has to ignore a
+# fatal error by passing --noinhibit-exec, so this behaviour is fine.
+
+# RUN: llvm-objdump -s %t.so | FileCheck %s -check-prefix BROKEN-OUTPUT-FILE
+# BROKEN-OUTPUT-FILE-LABEL: Contents of section .sec1:
+# BROKEN-OUTPUT-FILE-NEXT: 8000 01010101 01010101 01010101 01010101  ................
+# BROKEN-OUTPUT-FILE-NEXT: 8010 01010101 01010101 01010101 01010101  ................
+# BROKEN-OUTPUT-FILE-NEXT: 8020 01010101 01010101 01010101 01010101  ................
+# BROKEN-OUTPUT-FILE-NEXT: 8030 01010101 01010101 01010101 01010101  ................
+# Starting here the contents of .sec2 overwrites .sec1:
+# BROKEN-OUTPUT-FILE-NEXT: 8040 02020202 02020202 02020202 02020202  ................
+
+# RUN: llvm-readobj -sections -program-headers -elf-output-style=GNU %t.so | FileCheck %s -check-prefix BAD-BOTH
+# BAD-BOTH-LABEL: Section Headers:
+# BAD-BOTH: .sec1             PROGBITS        0000000000008000 018000 000100 00  WA  0   0  1
+# BAD-BOTH: .sec2             PROGBITS        0000000000008040 018040 000100 00  WA  0   0  1
+# BAD-BOTH-LABEL: Program Headers:
+# BAD-BOTH-NEXT:  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
+# BAD-BOTH-NEXT:  LOAD           0x010000 0x0000000000000000 0x0000000000000000 0x0001e1 0x0001e1 R E 0x10000
+# BAD-BOTH-NEXT:  LOAD           0x018000 0x0000000000008000 0x0000000000008000 0x000150 0x000150 RW  0x10000
+# BAD-BOTH-LABEL: Section to Segment mapping:
+# BAD-BOTH:   01     .sec1 .sec2 .data .got
+
+
+.section        .first_sec,"aw",@progbits
+.rept 0x100
+.byte 1
+.endr
+
+.section        .second_sec,"aw",@progbits
+.rept 0x100
+.byte 2
+.endr