[LinkerScript] Implement `MEMORY` command

[meadori]

Summary

Hi All,

This is a work in progress patch for implementing the MEMORY command as specified here:

• https://sourceware.org/binutils/docs/ld/MEMORY.html#MEMORY

There are two deviations from what is specified for GNU ld:

1. Only integer constants and *not* constant expressions are allowed in LENGTH and ORIGIN initializations.
2. The I and L attributes are *not* implemented.

With (1) there is currently no easy way to evaluate integer
only constant expressions. This can be enhanced in the
future.

With (2) it isn't clear how these flags map to the SHF_*
flags or if they even make sense for an ELF linker.

[ruiu]

This generally seems good. One thing I can say is it needs more comments to describe the code for the first-time readers.

[grimar]

Few comments.

ELF/LinkerScript.cpp

743 ↗

(On Diff #85004)

Should it be error instead ?

1988 ↗

(On Diff #85004)

You do not use AttrStr, so you can just use 'next()'.
May be worth to emit warning/error here about that attributes are not yet supported ?

2000 ↗

(On Diff #85004)

I think you do not need Tok:

if (!readInteger(next(), Origin))

2012 ↗

(On Diff #85004)

Same here.

ELF/LinkerScript.h

193 ↗

(On Diff #85004)

You do not need initialize Name I think, it is empty by default.

[grimar]

ELF/LinkerScript.cpp

1988 ↗

(On Diff #85004)

Ah you're still working on attributes, please ignore this comment then.

[meadori]

ELF/LinkerScript.cpp

743 ↗

(On Diff #85004)

I think so. Thanks.

2000 ↗

(On Diff #85004)

You're right. Will fix.

2012 ↗

(On Diff #85004)

Will fix.

[meadori]

1. Finished attribute implementation.

2. Added tests.

[ruiu]

ELF/LinkerScript.cpp

412 ↗

(On Diff #85244)

Comment.

523 ↗

(On Diff #85244)

Comment.

532 ↗

(On Diff #85244)

I don't think we are using `' to quote a word. I believe we write '' instead. (So please make it look similar to other code.)

541 ↗

(On Diff #85244)

We don't usually use auto in this context.

776–778 ↗

(On Diff #85244)

Revert this style change.

2007 ↗

(On Diff #85244)

Factor out the body of this if to a separate function which returns std::pair<uint32_t, uint32_t>.

ELF/LinkerScript.h

192 ↗

(On Diff #85244)

As I said in the previous comment, this needs a comment.

201 ↗

(On Diff #85244)

We do not write multiple definitions in one one like that. If in doubt, please look at other code and follow the convention.

233 ↗

(On Diff #85244)

Needs a comment.

[meadori]

ELF/LinkerScript.cpp

412 ↗

(On Diff #85244)

Will fix.

523 ↗

(On Diff #85244)

Will fix.

532 ↗

(On Diff #85244)

Will fix.

541 ↗

(On Diff #85244)

This is iterating a map, thus the direct declaration would be something gross like llvm::DenseMap<llvm::StringRef, MemoryRegion>::value_type. Personally, I think the auto is cleaner.

Also, there is precedence in the existing code with things like:

for (auto I = Cmd->Commands.begin(); I != E; ++I)
    process(**I);

776–778 ↗

(On Diff #85244)

Will fix.

2007 ↗

(On Diff #85244)

Will fix.

ELF/LinkerScript.h

192 ↗

(On Diff #85244)

Will fix.

201 ↗

(On Diff #85244)

Will fix.

233 ↗

(On Diff #85244)

Will fix.

[ruiu]

ELF/LinkerScript.cpp

541 ↗

(On Diff #85244)

Got it. Then can you use a temporary variable like this so that the type becomes obvious?

MemroyRegion &M = MR.second;

[meadori]

Address review feedback concerning code style and comments.

[grimar]

ELF/LinkerScript.cpp

2055 ↗

(On Diff #85254)

I would probably split this into separate function and rewrite to something like:

static uint32_t convertToFlags(char Attr) {
  if (Attr == 'w' || Attr == 'W')
    return SHF_WRITE;
  if (Attr == 'x' || Attr == 'X')
    return SHF_EXECINSTR;
  if (Attr == 'a' || Attr == 'A')
    return SHF_ALLOC;
  if (Attr != 'r' && Attr != 'R')
    setError("invalid memory region attribute: " + Attr);
return 0;
} 

std::pair<uint32_t, uint32_t> ScriptParser::readMemoryAttributes() {
  uint32_t Flags = 0;
  uint32_t NotFlags = 0;
  bool Invert = false;
  for (auto C : next()) {
    if (C == '!)
      Invert = !Invert;
    else if (Invert)
      NotFlags |= convertToFlags(C);
    else
      Flags |= convertToFlags(C);
  }
  return {Flags, NotFlags};
}

2078 ↗

(On Diff #85254)

Looks you do not really need that break.

[meadori]

ELF/LinkerScript.cpp

2055 ↗

(On Diff #85254)

I do find that more readable. Thanks.

2078 ↗

(On Diff #85254)

You are right. Thanks!

541 ↗

(On Diff #85244)

Sure, will do.

[meadori]

Address more style comments from review feedback.

[ruiu]

ELF/LinkerScript.cpp

419–422 ↗

(On Diff #85406)

You don't want to call error twice for one error. You can print out a multi-line error just by adding "\n" in middle of a message.

541–542 ↗

(On Diff #85406)

Do you need this? A nullptr will naturally be returned without this, I think.

549 ↗

(On Diff #85406)

Return &MR here and remove MatchingMemRegion

594 ↗

(On Diff #85406)

Why do you have to clear this?

2047 ↗

(On Diff #85406)

You can change this to

Opt.MemoryRegions[Name] = {Name, Origin, Length, Flags, NotFlags};

can't you?

2053 ↗

(On Diff #85406)

You can make this a static non-member function (which is generally preferred because it makes clear that the function does not depend on any class.)

ELF/LinkerScript.h

196 ↗

(On Diff #85406)

Instead of defining this constructor, can you set default values by adding = 0 to all these fields?

197–198 ↗

(On Diff #85406)

I think you can remove this constructor if you initialize a struct using {} as I mentioned below.

[meadori]

ELF/LinkerScript.cpp

419–422 ↗

(On Diff #85406)

I originally did that, but the formatting looks bad:

./bin/ld.lld: error: section '.data' will not fit in region 'ram'
region 'ram' overflowed by 3084 bytes

Personally I think the following is easier to understand:

./bin/ld.lld: error: section '.data' will not fit in region 'ram'
./bin/ld.lld: error: region 'ram' overflowed by 3084 bytes

541–542 ↗

(On Diff #85406)

A nullptr will be returned, but the error at the bottom of the function might be triggered as well. To avoid (1) executing nop-code on an empty region map and (2) to avoid hitting that error path I chose to do an early return.

549 ↗

(On Diff #85406)

Will fix.

594 ↗

(On Diff #85406)

I don't, that was a left over from a previous revision. Thank you for catching it.

2047 ↗

(On Diff #85406)

I can't b/c of reasons cited in previous comments.

2053 ↗

(On Diff #85406)

I can't call setError if I do that. I think it is better to just inline that code back into readMemoryAttributes.

ELF/LinkerScript.h

196 ↗

(On Diff #85406)

I can't b/c of the error I describe in the following comment. Since I can't remove the second constructor I have to have a default one (otherwise the compiler doesn't provide one for me).

197–198 ↗

(On Diff #85406)

That doesn't work. I get errors like:

error: no match for ‘operator=’ (operand types are ‘lld::elf::MemoryRegion’ and ‘<brace-enclosed initializer list>’)

[ruiu]

ELF/LinkerScript.cpp

419–422 ↗

(On Diff #85406)

Semantically I want to emit one error: for each error. I don't think this needs to be in two lines -- how about concatenating these messages with ": " instead of "\n"?

2023 ↗

(On Diff #85406)

You want to return from the function when you find an error in this function to prevent cascading error messages.

2072 ↗

(On Diff #85406)

s/auto/char/

ELF/LinkerScript.h

197–198 ↗

(On Diff #85406)

Sorry, the number of initializers did not match with the number of members. Does this work?

{Name, Origin, Length, Origin, Flags, NotFlags}

[meadori]

ELF/LinkerScript.cpp

419–422 ↗

(On Diff #85406)

That works. It looks like this now:

error: section '.data' will not fit in region 'ram': overflowed by 3084 bytes

ELF/LinkerScript.h

197–198 ↗

(On Diff #85406)

I accounted for that. It seems that in-class field initialization and braced initializer lists are not compatible:

$ c++ --version
c++ (Ubuntu 4.8.4-2ubuntu1~14.04.3) 4.8.4
Copyright (C) 2013 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

meadori@build1-trusty-cs:/scratch/meadori/llvm-mainline/obj/llvm$ cat -b test.cpp
     1  struct T {
     2    unsigned x = 0;
     3  };
     4  int main(void) {
     5    T t = {1};
     6    return 0;
     7  }
meadori@build1-trusty-cs:/scratch/meadori/llvm-mainline/obj/llvm$ c++ -std=c++11 test.cpp
test.cpp: In function ‘int main()’:
test.cpp:5:11: error: could not convert ‘{1}’ from ‘<brace-enclosed initializer list>’ to ‘T’
   T t = {1};
           ^

If I remove the in-class initializers, it works.

[ruiu]

ELF/LinkerScript.cpp

419–422 ↗

(On Diff #85406)

Looks nice.

ELF/LinkerScript.h

197–198 ↗

(On Diff #85406)

Sure. Then I think you can remove the C++11-style intializers. I think we don't need it.

[meadori]

1. Shorten overflow error message.
2. Get rid of MemoryRegion constructors.
3. A few more style changes.

[ruiu]

LGTM with a few nits.

Please verify that your new tests pass with BFD linker so that LLD's behavior is the same as BFD.

ELF/LinkerScript.cpp

541–542 ↗

(On Diff #85406)

Then can you move this piece of code to the beginning of this function to return earlier?

551 ↗

(On Diff #85496)

You can remove != 0 because any if (X) is equivalent to if ((X) != 0).

ELF/LinkerScript.h

199 ↗

(On Diff #85496)

I found that Index is a bit confusing. Maybe Offset?

[meadori]

I will fix the remaining nits and double-check with gold\ld. Thanks for all the review!

ELF/LinkerScript.cpp

551 ↗

(On Diff #85496)

Will fix.

ELF/LinkerScript.h

199 ↗

(On Diff #85496)

SGTM. I will change it.

lld/trunk/ELF/LinkerScript.h

 #ifndef LLD_ELF_LINKER_SCRIPT_H
 #define LLD_ELF_LINKER_SCRIPT_H
 
 #include "Config.h"
 #include "Strings.h"
 #include "Writer.h"
 #include "lld/Core/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <cstddef>
 #include <cstdint>
 #include <functional>
 #include <memory>
 #include <vector>
struct OutputSectionCommand : BaseCommand {
   Expr AlignExpr;
   Expr LMAExpr;
   Expr SubalignExpr;
   std::vector<std::unique_ptr<BaseCommand>> Commands;
   std::vector<StringRef> Phdrs;
   uint32_t Filler = 0;
   ConstraintKind Constraint = ConstraintKind::NoConstraint;
   std::string Location;
+  std::string MemoryRegionName;
 };
 
 // This struct represents one section match pattern in SECTIONS() command.
 // It can optionally have negative match pattern for EXCLUDED_FILE command.
 // Also it may be surrounded with SORT() command, so contains sorting rules.
 struct SectionPattern {
   SectionPattern(StringMatcher &&Pat1, StringMatcher &&Pat2)
       : ExcludedFilePat(Pat1), SectionPat(Pat2) {}
struct PhdrsCommand {
   StringRef Name;
   unsigned Type;
   bool HasFilehdr;
   bool HasPhdrs;
   unsigned Flags;
   Expr LMAExpr;
 };
 
+// This struct is used to represent the location and size of regions of
+// target memory. Instances of the struct are created by parsing the
+// MEMORY command.
+struct MemoryRegion {
+  std::string Name;
+  uint64_t Origin;
+  uint64_t Length;
+  uint64_t Offset;
+  uint32_t Flags;
+  uint32_t NotFlags;
+};
+
 class LinkerScriptBase {
 protected:
   ~LinkerScriptBase() = default;
 
 public:
   virtual uint64_t getHeaderSize() = 0;
   virtual uint64_t getSymbolValue(const Twine &Loc, StringRef S) = 0;
   virtual bool isDefined(StringRef S) = 0;
struct ScriptConfiguration {
   // Used to assign sections to headers.
   std::vector<PhdrsCommand> PhdrsCommands;
 
   bool HasSections = false;
 
   // List of section patterns specified with KEEP commands. They will
   // be kept even if they are unused and --gc-sections is specified.
   std::vector<InputSectionDescription *> KeptSections;
+
+  // A map from memory region name to a memory region descriptor.
+  llvm::DenseMap<llvm::StringRef, MemoryRegion> MemoryRegions;
 };
 
 extern ScriptConfiguration *ScriptConfig;
 
 // This is a runner of the linker script.
 template <class ELFT> class LinkerScript final : public LinkerScriptBase {
   typedef typename ELFT::uint uintX_t;
 
private:
   createInputSectionList(OutputSectionCommand &Cmd);
 
   // "ScriptConfig" is a bit too long, so define a short name for it.
   ScriptConfiguration &Opt = *ScriptConfig;
 
   std::vector<size_t> getPhdrIndices(StringRef SectionName);
   size_t getPhdrIndex(const Twine &Loc, StringRef PhdrName);
 
+  MemoryRegion *findMemoryRegion(OutputSectionCommand *Cmd,
+                                 OutputSectionBase *Sec);
+
   uintX_t Dot;
   uintX_t LMAOffset = 0;
   OutputSectionBase *CurOutSec = nullptr;
+  MemoryRegion *CurMemRegion = nullptr;
   uintX_t ThreadBssOffset = 0;
   void switchTo(OutputSectionBase *Sec);
   void flush();
   void output(InputSection<ELFT> *Sec);
   void process(BaseCommand &Base);
   llvm::DenseSet<OutputSectionBase *> AlreadyOutputOS;
   llvm::DenseSet<InputSectionData *> AlreadyOutputIS;
 };

lld/trunk/ELF/LinkerScript.cpp

template <class ELFT> void LinkerScript<ELFT>::output(InputSection<ELFT> *S) {
   S->OutSecOff = Pos - CurOutSec->Addr;
   Pos += S->getSize();
 
   // 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) }
   CurOutSec->Size = Pos - CurOutSec->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 (CurMemRegion) {
+    CurMemRegion->Offset += CurOutSec->Size;
+    uint64_t CurSize = CurMemRegion->Offset - CurMemRegion->Origin;
+    if (CurSize > CurMemRegion->Length) {
+      uint64_t OverflowAmt = CurSize - CurMemRegion->Length;
+      error("section '" + CurOutSec->Name + "' will not fit in region '" +
+            CurMemRegion->Name + "': overflowed by " + Twine(OverflowAmt) +
+            " bytes");
+    }
+  }
+
   if (IsTbss)
     ThreadBssOffset = Pos - Dot;
   else
     Dot = Pos;
 }
 
 template <class ELFT> void LinkerScript<ELFT>::flush() {
   if (!CurOutSec || !AlreadyOutputOS.insert(CurOutSec).second)

 findSections(StringRef Name, const std::vector<OutputSectionBase *> &Sections) {
   std::vector<OutputSectionBase *> Ret;
   for (OutputSectionBase *Sec : Sections)
     if (Sec->getName() == Name)
       Ret.push_back(Sec);
   return Ret;
 }
 
+// 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.
+template <class ELFT>
+MemoryRegion *LinkerScript<ELFT>::findMemoryRegion(OutputSectionCommand *Cmd,
+                                                   OutputSectionBase *Sec) {
+  // If a memory region name was specified in the output section command,
+  // then try to find that region first.
+  if (!Cmd->MemoryRegionName.empty()) {
+    auto It = Opt.MemoryRegions.find(Cmd->MemoryRegionName);
+    if (It != Opt.MemoryRegions.end())
+      return &It->second;
+    error("memory region '" + Cmd->MemoryRegionName + "' not declared");
+    return nullptr;
+  }
+
+  // The memory region name is empty, thus a suitable region must be
+  // searched for in the region map. If the region map is empty, just
+  // return. Note that this check doesn't happen at the very beginning
+  // so that uses of undeclared regions can be caught.
+  if (!Opt.MemoryRegions.size())
+    return nullptr;
+
+  // See if a region can be found by matching section flags.
+  for (auto &MRI : Opt.MemoryRegions) {
+    MemoryRegion &MR = MRI.second;
+    if ((MR.Flags & Sec->Flags) != 0 && (MR.NotFlags & Sec->Flags) == 0)
+      return &MR;
+  }
+
+  // Otherwise, no suitable region was found.
+  if (Sec->Flags & SHF_ALLOC)
+    error("no memory region specified for section '" + Sec->Name + "'");
+  return nullptr;
+}
+
 // This function assigns offsets to input sections and an output section
 // for a single sections command (e.g. ".text { *(.text); }").
 template <class ELFT>
 void LinkerScript<ELFT>::assignOffsets(OutputSectionCommand *Cmd) {
   if (Cmd->LMAExpr)
     LMAOffset = Cmd->LMAExpr(Dot) - Dot;
   std::vector<OutputSectionBase *> Sections =
       findSections<ELFT>(Cmd->Name, *OutputSections);
   if (Sections.empty())
     return;
-  switchTo(Sections[0]);
+
+  OutputSectionBase *Sec = Sections[0];
+  // Try and find an appropriate memory region to assign offsets in.
+  CurMemRegion = findMemoryRegion(Cmd, Sec);
+  if (CurMemRegion)
+    Dot = CurMemRegion->Offset;
+  switchTo(Sec);
 
   // Find the last section output location. We will output orphan sections
   // there so that end symbols point to the correct location.
   auto E = std::find_if(Cmd->Commands.rbegin(), Cmd->Commands.rend(),
                         [](const std::unique_ptr<BaseCommand> &Cmd) {
                           return !isa<SymbolAssignment>(*Cmd);
                         })
                .base();

 private:
   void addFile(StringRef Path);
 
   void readAsNeeded();
   void readEntry();
   void readExtern();
   void readGroup();
   void readInclude();
+  void readMemory();
+  std::pair<uint32_t, uint32_t> readMemoryAttributes();
   void readOutput();
   void readOutputArch();
   void readOutputFormat();
   void readPhdrs();
   void readSearchDir();
   void readSections();
   void readVersion();
   void readVersionScriptCommand();
while (!atEOF()) {
     } else if (Tok == "ENTRY") {
       readEntry();
     } else if (Tok == "EXTERN") {
       readExtern();
     } else if (Tok == "GROUP" || Tok == "INPUT") {
       readGroup();
     } else if (Tok == "INCLUDE") {
       readInclude();
+    } else if (Tok == "MEMORY") {
+      readMemory();
     } else if (Tok == "OUTPUT") {
       readOutput();
     } else if (Tok == "OUTPUT_ARCH") {
       readOutputArch();
     } else if (Tok == "OUTPUT_FORMAT") {
       readOutputFormat();
     } else if (Tok == "PHDRS") {
       readPhdrs();
while (!Error && !consume("}")) {
     } else if (Tok == "SORT") {
       readSort();
     } else if (peek() == "(") {
       Cmd->Commands.emplace_back(readInputSectionDescription(Tok));
     } else {
       setError("unknown command " + Tok);
     }
   }
+
+  if (consume(">"))
+    Cmd->MemoryRegionName = next();
+
   Cmd->Phdrs = readOutputSectionPhdrs();
 
   if (consume("="))
     Cmd->Filler = readOutputSectionFiller(next());
   else if (peek().startswith("="))
     Cmd->Filler = readOutputSectionFiller(next().drop_front());
 
   // Consume optional comma following output section command.
while (!Error && peek() != "}") {
     expect(";");
   }
 
   expect("}");
   expect(";");
   return Ret;
 }
 
+// Parse the MEMORY command As specified in:
+// https://sourceware.org/binutils/docs/ld/MEMORY.html#MEMORY
+void ScriptParser::readMemory() {
+  expect("{");
+  while (!Error && !consume("}")) {
+    StringRef Name = next();
+    uint32_t Flags = 0;
+    uint32_t NotFlags = 0;
+    if (consume("(")) {
+      std::tie(Flags, NotFlags) = readMemoryAttributes();
+      expect(")");
+    }
+    expect(":");
+
+    // Parse the ORIGIN.
+    if (!(consume("ORIGIN") || consume("org") || consume("o"))) {
+      setError("expected one of: ORIGIN, org, or o");
+      return;
+    }
+    expect("=");
+    uint64_t Origin;
+    // TODO: Fully support constant expressions.
+    if (!readInteger(next(), Origin)) {
+      setError("nonconstant expression for origin");
+      return;
+    }
+    expect(",");
+
+    // Parse the LENGTH.
+    if (!(consume("LENGTH") || consume("len") || consume("l"))) {
+      setError("expected one of: LENGTH, len, or l");
+      return;
+    }
+    expect("=");
+    uint64_t Length;
+    // TODO: Fully support constant expressions.
+    if (!readInteger(next(), Length)) {
+      setError("nonconstant expression for length");
+      return;
+    }
+    // Add the memory region to the region map (if it doesn't already exist).
+    auto It = Opt.MemoryRegions.find(Name);
+    if (It != Opt.MemoryRegions.end())
+      setError("region '" + Name + "' already defined");
+    else
+      Opt.MemoryRegions[Name] = {Name, Origin, Length, Origin, Flags, NotFlags};
+  }
+}
+
+// This function parses the attributes used to match against section
+// flags when placing output sections in a memory region. These flags
+// are only used when an explicit memory region name is not used.
+std::pair<uint32_t, uint32_t> ScriptParser::readMemoryAttributes() {
+  uint32_t Flags = 0;
+  uint32_t NotFlags = 0;
+  bool Invert = false;
+  for (char C : next()) {
+    uint32_t Flag = 0;
+    if (C == '!')
+      Invert = !Invert;
+    else if (tolower(C) == 'w')
+      Flag = SHF_WRITE;
+    else if (tolower(C) == 'x')
+      Flag = SHF_EXECINSTR;
+    else if (tolower(C) == 'a')
+      Flag = SHF_ALLOC;
+    else if (tolower(C) != 'r')
+      setError("invalid memory region attribute");
+    if (Invert)
+      NotFlags |= Flag;
+    else
+      Flags |= Flag;
+  }
+  return {Flags, NotFlags};
+}
+
 void elf::readLinkerScript(MemoryBufferRef MB) {
   ScriptParser(MB).readLinkerScript();
 }
 
 void elf::readVersionScript(MemoryBufferRef MB) {
   ScriptParser(MB).readVersionScript();
 }
 
 void elf::readDynamicList(MemoryBufferRef MB) {
   ScriptParser(MB).readDynamicList();
 }
 
 template class elf::LinkerScript<ELF32LE>;
 template class elf::LinkerScript<ELF32BE>;
 template class elf::LinkerScript<ELF64LE>;
 template class elf::LinkerScript<ELF64BE>;

lld/trunk/test/ELF/linkerscript/memory.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+
+## Check simple RAM-only memory region.
+
+# RUN: echo "MEMORY { \
+# RUN:   ram (rwx)  : ORIGIN = 0x8000, LENGTH = 256K \
+# RUN: } \
+# RUN: SECTIONS { \
+# RUN:   .text : { \
+# RUN:     *(.text) \
+# RUN:   } > ram \
+# RUN:   .data : { \
+# RUN:     *(.data) \
+# RUN:   } > ram \
+# RUN: }" > %t.script
+# RUN: ld.lld -o %t1 --script %t.script %t
+# RUN: llvm-objdump -section-headers %t1 | FileCheck -check-prefix=RAM %s
+
+# RAM:       1 .text         00000001 0000000000008000 TEXT DATA
+# RAM-NEXT:  2 .data         00001000 0000000000008001 DATA
+
+## Check RAM and ROM memory regions.
+
+# RUN: echo "MEMORY { \
+# RUN:   ram (rwx) : ORIGIN = 0x0, LENGTH = 1024M \
+# RUN:   rom (rx) : org = 0x80000000, len = 64M \
+# RUN: } \
+# RUN: SECTIONS { \
+# RUN:   .text : { \
+# RUN:     *(.text) \
+# RUN:   } > rom \
+# RUN:   .data : { \
+# RUN:     *(.data) \
+# RUN:   } > ram \
+# RUN: }" > %t.script
+# RUN: ld.lld -o %t1 --script %t.script %t
+# RUN: llvm-objdump -section-headers %t1 | FileCheck -check-prefix=RAMROM %s
+
+# RAMROM:       1 .text         00000001 0000000080000000 TEXT DATA
+# RAMROM-NEXT:  2 .data         00001000 0000000000000000 DATA
+
+## Check memory region placement by attributes.
+
+# RUN: echo "MEMORY { \
+# RUN:   ram (!rx) : ORIGIN = 0x0, LENGTH = 1024M \
+# RUN:   rom (rx) : o = 0x80000000, l = 64M \
+# RUN: } \
+# RUN: SECTIONS { \
+# RUN:   .text : { \
+# RUN:     *(.text) \
+# RUN:   } \
+# RUN:   .data : { \
+# RUN:     *(.data) \
+# RUN:   } > ram \
+# RUN: }" > %t.script
+# RUN: ld.lld -o %t1 --script %t.script %t
+# RUN: llvm-objdump -section-headers %t1 | FileCheck -check-prefix=ATTRS %s
+
+# ATTRS:  1 .text         00000001 0000000080000000 TEXT DATA
+# ATTRS:  2 .data         00001000 0000000000000000 DATA
+
+## Check bad `ORIGIN`.
+
+# RUN: echo "MEMORY { ram (rwx)  : ORIGI = 0x8000, LENGTH = 256K } }" > %t.script
+# RUN: not ld.lld -o %t2 --script %t.script %t 2>&1 \
+# RUN:  | FileCheck -check-prefix=ERR1 %s
+# ERR1: {{.*}}.script:1: expected one of: ORIGIN, org, or o
+
+## Check bad `LENGTH`.
+
+# RUN: echo "MEMORY { ram (rwx)  : ORIGIN = 0x8000, LENTH = 256K } }" > %t.script
+# RUN: not ld.lld -o %t2 --script %t.script %t 2>&1 \
+# RUN:  | FileCheck -check-prefix=ERR2 %s
+# ERR2: {{.*}}.script:1: expected one of: LENGTH, len, or l
+
+## Check duplicate regions.
+
+# RUN: echo "MEMORY { ram (rwx)  : o = 0x8, l = 256K ram (rx)  : o = 0x0, l = 256K }" > %t.script
+# RUN: not ld.lld -o %t2 --script %t.script %t 2>&1 \
+# RUN:  | FileCheck -check-prefix=ERR3 %s
+# ERR3: {{.*}}.script:1: region 'ram' already defined
+
+## Check no region available.
+
+# RUN: echo "MEMORY { \
+# RUN:   ram (!rx)  : ORIGIN = 0x8000, LENGTH = 256K \
+# RUN: } \
+# RUN: SECTIONS { \
+# RUN:   .text : { \
+# RUN:     *(.text) \
+# RUN:   } \
+# RUN:   .data : { \
+# RUN:     *(.data) \
+# RUN:   } > ram \
+# RUN: }" > %t.script
+# RUN: not ld.lld -o %t2 --script %t.script %t 2>&1 \
+# RUN:  | FileCheck -check-prefix=ERR4 %s
+# ERR4: {{.*}}: no memory region specified for section '.text'
+
+## Check undeclared region.
+
+# RUN: echo "SECTIONS { .text : { *(.text) } > ram }" > %t.script
+# RUN: not ld.lld -o %t2 --script %t.script %t 2>&1 \
+# RUN:  | FileCheck -check-prefix=ERR5 %s
+# ERR5: {{.*}}: memory region 'ram' not declared
+
+## Check region overflow.
+
+# RUN: echo "MEMORY { \
+# RUN:   ram (rwx)  : ORIGIN = 0x0, LENGTH = 2K \
+# RUN: } \
+# RUN: SECTIONS { \
+# RUN:   .text : { \
+# RUN:     *(.text) \
+# RUN:   } > ram \
+# RUN:   .data : { \
+# RUN:     *(.data) \
+# RUN:   } > ram \
+# RUN: }" > %t.script
+# RUN: not ld.lld -o %t2 --script %t.script %t 2>&1 \
+# RUN:  | FileCheck -check-prefix=ERR6 %s
+# ERR6: {{.*}}: section '.data' will not fit in region 'ram': overflowed by 2049 bytes
+
+## Check invalid region attributes.
+
+# RUN: echo "MEMORY { ram (abc)  : ORIGIN = 0x8000, LENGTH = 256K } }" > %t.script
+# RUN: not ld.lld -o %t2 --script %t.script %t 2>&1 \
+# RUN:  | FileCheck -check-prefix=ERR7 %s
+# ERR7: {{.*}}.script:1: invalid memory region attribute
+
+.text
+.global _start
+_start:
+  nop
+
+.data
+b:
+  .long 1
+  .zero 4092