[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

789

Should it be error instead ?

2015

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 ?

2027

I think you do not need Tok:

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

2039

Same here.

ELF/LinkerScript.h

193

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

[grimar]

ELF/LinkerScript.cpp

2015

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

[meadori]

ELF/LinkerScript.cpp

789

I think so. Thanks.

2027

You're right. Will fix.

2039

Will fix.

[meadori]

1. Finished attribute implementation.

2. Added tests.

[ruiu]

ELF/LinkerScript.cpp

412

Comment.

525

Comment.

534

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.)

543

We don't usually use auto in this context.

781–783

Revert this style change.

2017

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

ELF/LinkerScript.h

192

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

201

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

237

Needs a comment.

[meadori]

ELF/LinkerScript.cpp

412

Will fix.

525

Will fix.

534

Will fix.

543

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);

781–783

Will fix.

2017

Will fix.

ELF/LinkerScript.h

192

Will fix.

201

Will fix.

237

Will fix.

[ruiu]

ELF/LinkerScript.cpp

543

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

2060

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};
}

2083

Looks you do not really need that break.

[meadori]

ELF/LinkerScript.cpp

543

Sure, will do.

2060

I do find that more readable. Thanks.

2083

You are right. Thanks!

[meadori]

Address more style comments from review feedback.

[ruiu]

ELF/LinkerScript.cpp

419–422

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

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

549

Return &MR here and remove MatchingMemRegion

594

Why do you have to clear this?

2047

You can change this to

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

can't you?

2053

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

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

197–198

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

[meadori]

ELF/LinkerScript.cpp

419–422

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

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

Will fix.

594

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

2047

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

2053

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

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

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

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

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

2072

s/auto/char/

ELF/LinkerScript.h

197–198

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

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

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

Looks nice.

ELF/LinkerScript.h

197–198

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

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

552

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

ELF/LinkerScript.h

199

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

552

Will fix.

ELF/LinkerScript.h

199

SGTM. I will change it.

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 {
+  MemoryRegion() : Origin(0), Length(0), Index(0), Flags(0), NotFlags(0) {}
+  MemoryRegion(StringRef N, uint64_t O, uint64_t L, uint32_t F, uint32_t NF)
+      : Name(N), Origin(O), Length(L), Index(O), Flags(F), NotFlags(NF) {}
+
+  std::string Name;
+  uint64_t Origin;
+  uint64_t Length;
+  uint64_t Index;
+  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;
 };

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->Index += CurOutSec->Size;
+    uint64_t CurSize = CurMemRegion->Index - CurMemRegion->Origin;
+    if (CurSize > CurMemRegion->Length) {
+      uint64_t OverflowAmt = CurSize - CurMemRegion->Length;
+      error("section '" + CurOutSec->Name + "' will not fit in region '" +
+            CurMemRegion->Name + "'");
+      error("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;
+  }
+
+  if (!Opt.MemoryRegions.size())
+    return nullptr;
+
+  // Next, see if a region can be found by matching section flags.
+  MemoryRegion *MatchingMemRegion = nullptr;
+  for (auto &MRI : Opt.MemoryRegions) {
+    MemoryRegion &MR = MRI.second;
+    if ((MR.Flags & Sec->Flags) != 0 && (MR.NotFlags & Sec->Flags) == 0) {
+      MatchingMemRegion = &MR;
+      break;
+    }
+  }
+  if (MatchingMemRegion)
+    return MatchingMemRegion;
+
+  // Otherwise, no suitable region was found.
+  if ((Sec->Flags & SHF_ALLOC) != 0)
+    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->Index;
+  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();
   for (auto I = Cmd->Commands.begin(); I != E; ++I)
     process(**I);
   for (OutputSectionBase *Base : Sections)
     switchTo(Base);
   flush();
   std::for_each(E, Cmd->Commands.end(),
                 [this](std::unique_ptr<BaseCommand> &B) { process(*B.get()); });
+  CurMemRegion = nullptr;
 }
 
 template <class ELFT> void LinkerScript<ELFT>::removeEmptyCommands() {
   // It is common practice to use very generic linker scripts. So for any
   // given run some of the output sections in the script will be empty.
   // We could create corresponding empty output sections, but that would
   // clutter the output.
   // We instead remove trivially empty sections. The bfd linker seems even
for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
     }
 
     if (auto *Cmd = dyn_cast<AssertCommand>(Base.get())) {
       Cmd->Expression(Dot);
       continue;
     }
 
     auto *Cmd = cast<OutputSectionCommand>(Base.get());
     if (Cmd->AddrExpr)
       Dot = Cmd->AddrExpr(Dot);
     assignOffsets(Cmd);
   }
 
   uintX_t MinVA = std::numeric_limits<uintX_t>::max();
   for (OutputSectionBase *Sec : *OutputSections) {
     if (Sec->Flags & SHF_ALLOC)
       MinVA = std::min<uint64_t>(MinVA, Sec->Addr);
     else
       Sec->Addr = 0;
   }
 
   allocateHeaders<ELFT>(Phdrs, *OutputSections, MinVA);
 }
 
 // Creates program headers as instructed by PHDRS linker script command.

 private:
   void addFile(StringRef Path);
 
   void readAsNeeded();
   void readEntry();
   void readExtern();
   void readGroup();
   void readInclude();
+  void readMemory();
+  uint32_t memoryAttributeToFlag(char Attr);
+  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");
+    expect("=");
+    uint64_t Origin;
+    // TODO: Fully support constant expressions.
+    if (!readInteger(next(), Origin))
+      setError("nonconstant expression for origin");
+
+    expect(",");
+
+    // Parse the LENGTH.
+    if (!(consume("LENGTH") || consume("len") || consume("l")))
+      setError("expected one of: LENGTH, len, or l");
+    expect("=");
+    uint64_t Length;
+    // TODO: Fully support constant expressions.
+    if (!readInteger(next(), Length))
+      setError("nonconstant expression for length");
+
+    // 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] =
+          MemoryRegion(Name, Origin, Length, Flags, NotFlags);
+  }
+}
+
+// This function converts a memory attribute character
+// into a section flag.
+uint32_t ScriptParser::memoryAttributeToFlag(char Attr) {
+  if (tolower(Attr) == 'w')
+    return SHF_WRITE;
+  if (tolower(Attr) == 'x')
+    return SHF_EXECINSTR;
+  if (tolower(Attr) == 'a')
+    return SHF_ALLOC;
+  if (tolower(Attr) != 'r')
+    setError("invalid memory region attribute");
+  return 0;
+}
+
+// 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 (auto C : next()) {
+    if (C == '!')
+      Invert = !Invert;
+    else if (Invert)
+      NotFlags |= memoryAttributeToFlag(C);
+    else
+      Flags |= memoryAttributeToFlag(C);
+  }
+  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>;

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'
+# ERR6: {{.*}}: 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