--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lld/ELF/ScriptParser.cpp	Thu Feb 13 15:10:13 2020 +0900
@@ -0,0 +1,1608 @@
+//===- ScriptParser.cpp ---------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains a recursive-descendent parser for linker scripts.
+// Parsed results are stored to Config and Script global objects.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ScriptParser.h"
+#include "Config.h"
+#include "Driver.h"
+#include "InputSection.h"
+#include "LinkerScript.h"
+#include "OutputSections.h"
+#include "ScriptLexer.h"
+#include "Symbols.h"
+#include "Target.h"
+#include "lld/Common/Memory.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSet.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/BinaryFormat/ELF.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/ScopedPrinter.h"
+#include <cassert>
+#include <limits>
+#include <vector>
+
+using namespace llvm;
+using namespace llvm::ELF;
+using namespace llvm::support::endian;
+
+namespace lld {
+namespace elf {
+namespace {
+class ScriptParser final : ScriptLexer {
+public:
+  ScriptParser(MemoryBufferRef mb) : ScriptLexer(mb) {
+    // Initialize IsUnderSysroot
+    if (config->sysroot == "")
+      return;
+    StringRef path = mb.getBufferIdentifier();
+    for (; !path.empty(); path = sys::path::parent_path(path)) {
+      if (!sys::fs::equivalent(config->sysroot, path))
+        continue;
+      isUnderSysroot = true;
+      return;
+    }
+  }
+
+  void readLinkerScript();
+  void readVersionScript();
+  void readDynamicList();
+  void readDefsym(StringRef name);
+
+private:
+  void addFile(StringRef path);
+
+  void readAsNeeded();
+  void readEntry();
+  void readExtern();
+  void readGroup();
+  void readInclude();
+  void readInput();
+  void readMemory();
+  void readOutput();
+  void readOutputArch();
+  void readOutputFormat();
+  void readPhdrs();
+  void readRegionAlias();
+  void readSearchDir();
+  void readSections();
+  void readTarget();
+  void readVersion();
+  void readVersionScriptCommand();
+
+  SymbolAssignment *readSymbolAssignment(StringRef name);
+  ByteCommand *readByteCommand(StringRef tok);
+  std::array<uint8_t, 4> readFill();
+  bool readSectionDirective(OutputSection *cmd, StringRef tok1, StringRef tok2);
+  void readSectionAddressType(OutputSection *cmd);
+  OutputSection *readOverlaySectionDescription();
+  OutputSection *readOutputSectionDescription(StringRef outSec);
+  std::vector<BaseCommand *> readOverlay();
+  std::vector<StringRef> readOutputSectionPhdrs();
+  std::pair<uint64_t, uint64_t> readInputSectionFlags();
+  InputSectionDescription *readInputSectionDescription(StringRef tok);
+  StringMatcher readFilePatterns();
+  std::vector<SectionPattern> readInputSectionsList();
+  InputSectionDescription *readInputSectionRules(StringRef filePattern,
+                                                 uint64_t withFlags,
+                                                 uint64_t withoutFlags);
+  unsigned readPhdrType();
+  SortSectionPolicy readSortKind();
+  SymbolAssignment *readProvideHidden(bool provide, bool hidden);
+  SymbolAssignment *readAssignment(StringRef tok);
+  void readSort();
+  Expr readAssert();
+  Expr readConstant();
+  Expr getPageSize();
+
+  uint64_t readMemoryAssignment(StringRef, StringRef, StringRef);
+  std::pair<uint32_t, uint32_t> readMemoryAttributes();
+
+  Expr combine(StringRef op, Expr l, Expr r);
+  Expr readExpr();
+  Expr readExpr1(Expr lhs, int minPrec);
+  StringRef readParenLiteral();
+  Expr readPrimary();
+  Expr readTernary(Expr cond);
+  Expr readParenExpr();
+
+  // For parsing version script.
+  std::vector<SymbolVersion> readVersionExtern();
+  void readAnonymousDeclaration();
+  void readVersionDeclaration(StringRef verStr);
+
+  std::pair<std::vector<SymbolVersion>, std::vector<SymbolVersion>>
+  readSymbols();
+
+  // True if a script being read is in a subdirectory specified by -sysroot.
+  bool isUnderSysroot = false;
+
+  // A set to detect an INCLUDE() cycle.
+  StringSet<> seen;
+};
+} // namespace
+
+static StringRef unquote(StringRef s) {
+  if (s.startswith("\""))
+    return s.substr(1, s.size() - 2);
+  return s;
+}
+
+// Some operations only support one non absolute value. Move the
+// absolute one to the right hand side for convenience.
+static void moveAbsRight(ExprValue &a, ExprValue &b) {
+  if (a.sec == nullptr || (a.forceAbsolute && !b.isAbsolute()))
+    std::swap(a, b);
+  if (!b.isAbsolute())
+    error(a.loc + ": at least one side of the expression must be absolute");
+}
+
+static ExprValue add(ExprValue a, ExprValue b) {
+  moveAbsRight(a, b);
+  return {a.sec, a.forceAbsolute, a.getSectionOffset() + b.getValue(), a.loc};
+}
+
+static ExprValue sub(ExprValue a, ExprValue b) {
+  // The distance between two symbols in sections is absolute.
+  if (!a.isAbsolute() && !b.isAbsolute())
+    return a.getValue() - b.getValue();
+  return {a.sec, false, a.getSectionOffset() - b.getValue(), a.loc};
+}
+
+static ExprValue bitAnd(ExprValue a, ExprValue b) {
+  moveAbsRight(a, b);
+  return {a.sec, a.forceAbsolute,
+          (a.getValue() & b.getValue()) - a.getSecAddr(), a.loc};
+}
+
+static ExprValue bitOr(ExprValue a, ExprValue b) {
+  moveAbsRight(a, b);
+  return {a.sec, a.forceAbsolute,
+          (a.getValue() | b.getValue()) - a.getSecAddr(), a.loc};
+}
+
+void ScriptParser::readDynamicList() {
+  config->hasDynamicList = true;
+  expect("{");
+  std::vector<SymbolVersion> locals;
+  std::vector<SymbolVersion> globals;
+  std::tie(locals, globals) = readSymbols();
+  expect(";");
+
+  if (!atEOF()) {
+    setError("EOF expected, but got " + next());
+    return;
+  }
+  if (!locals.empty()) {
+    setError("\"local:\" scope not supported in --dynamic-list");
+    return;
+  }
+
+  for (SymbolVersion v : globals)
+    config->dynamicList.push_back(v);
+}
+
+void ScriptParser::readVersionScript() {
+  readVersionScriptCommand();
+  if (!atEOF())
+    setError("EOF expected, but got " + next());
+}
+
+void ScriptParser::readVersionScriptCommand() {
+  if (consume("{")) {
+    readAnonymousDeclaration();
+    return;
+  }
+
+  while (!atEOF() && !errorCount() && peek() != "}") {
+    StringRef verStr = next();
+    if (verStr == "{") {
+      setError("anonymous version definition is used in "
+               "combination with other version definitions");
+      return;
+    }
+    expect("{");
+    readVersionDeclaration(verStr);
+  }
+}
+
+void ScriptParser::readVersion() {
+  expect("{");
+  readVersionScriptCommand();
+  expect("}");
+}
+
+void ScriptParser::readLinkerScript() {
+  while (!atEOF()) {
+    StringRef tok = next();
+    if (tok == ";")
+      continue;
+
+    if (tok == "ENTRY") {
+      readEntry();
+    } else if (tok == "EXTERN") {
+      readExtern();
+    } else if (tok == "GROUP") {
+      readGroup();
+    } else if (tok == "INCLUDE") {
+      readInclude();
+    } else if (tok == "INPUT") {
+      readInput();
+    } 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();
+    } else if (tok == "REGION_ALIAS") {
+      readRegionAlias();
+    } else if (tok == "SEARCH_DIR") {
+      readSearchDir();
+    } else if (tok == "SECTIONS") {
+      readSections();
+    } else if (tok == "TARGET") {
+      readTarget();
+    } else if (tok == "VERSION") {
+      readVersion();
+    } else if (SymbolAssignment *cmd = readAssignment(tok)) {
+      script->sectionCommands.push_back(cmd);
+    } else {
+      setError("unknown directive: " + tok);
+    }
+  }
+}
+
+void ScriptParser::readDefsym(StringRef name) {
+  if (errorCount())
+    return;
+  Expr e = readExpr();
+  if (!atEOF())
+    setError("EOF expected, but got " + next());
+  SymbolAssignment *cmd = make<SymbolAssignment>(name, e, getCurrentLocation());
+  script->sectionCommands.push_back(cmd);
+}
+
+void ScriptParser::addFile(StringRef s) {
+  if (isUnderSysroot && s.startswith("/")) {
+    SmallString<128> pathData;
+    StringRef path = (config->sysroot + s).toStringRef(pathData);
+    if (sys::fs::exists(path)) {
+      driver->addFile(saver.save(path), /*withLOption=*/false);
+      return;
+    }
+  }
+
+  if (s.startswith("/")) {
+    driver->addFile(s, /*withLOption=*/false);
+  } else if (s.startswith("=")) {
+    if (config->sysroot.empty())
+      driver->addFile(s.substr(1), /*withLOption=*/false);
+    else
+      driver->addFile(saver.save(config->sysroot + "/" + s.substr(1)),
+                      /*withLOption=*/false);
+  } else if (s.startswith("-l")) {
+    driver->addLibrary(s.substr(2));
+  } else if (sys::fs::exists(s)) {
+    driver->addFile(s, /*withLOption=*/false);
+  } else {
+    if (Optional<std::string> path = findFromSearchPaths(s))
+      driver->addFile(saver.save(*path), /*withLOption=*/true);
+    else
+      setError("unable to find " + s);
+  }
+}
+
+void ScriptParser::readAsNeeded() {
+  expect("(");
+  bool orig = config->asNeeded;
+  config->asNeeded = true;
+  while (!errorCount() && !consume(")"))
+    addFile(unquote(next()));
+  config->asNeeded = orig;
+}
+
+void ScriptParser::readEntry() {
+  // -e <symbol> takes predecence over ENTRY(<symbol>).
+  expect("(");
+  StringRef tok = next();
+  if (config->entry.empty())
+    config->entry = tok;
+  expect(")");
+}
+
+void ScriptParser::readExtern() {
+  expect("(");
+  while (!errorCount() && !consume(")"))
+    config->undefined.push_back(unquote(next()));
+}
+
+void ScriptParser::readGroup() {
+  bool orig = InputFile::isInGroup;
+  InputFile::isInGroup = true;
+  readInput();
+  InputFile::isInGroup = orig;
+  if (!orig)
+    ++InputFile::nextGroupId;
+}
+
+void ScriptParser::readInclude() {
+  StringRef tok = unquote(next());
+
+  if (!seen.insert(tok).second) {
+    setError("there is a cycle in linker script INCLUDEs");
+    return;
+  }
+
+  if (Optional<std::string> path = searchScript(tok)) {
+    if (Optional<MemoryBufferRef> mb = readFile(*path))
+      tokenize(*mb);
+    return;
+  }
+  setError("cannot find linker script " + tok);
+}
+
+void ScriptParser::readInput() {
+  expect("(");
+  while (!errorCount() && !consume(")")) {
+    if (consume("AS_NEEDED"))
+      readAsNeeded();
+    else
+      addFile(unquote(next()));
+  }
+}
+
+void ScriptParser::readOutput() {
+  // -o <file> takes predecence over OUTPUT(<file>).
+  expect("(");
+  StringRef tok = next();
+  if (config->outputFile.empty())
+    config->outputFile = unquote(tok);
+  expect(")");
+}
+
+void ScriptParser::readOutputArch() {
+  // OUTPUT_ARCH is ignored for now.
+  expect("(");
+  while (!errorCount() && !consume(")"))
+    skip();
+}
+
+static std::pair<ELFKind, uint16_t> parseBfdName(StringRef s) {
+  return StringSwitch<std::pair<ELFKind, uint16_t>>(s)
+      .Case("elf32-i386", {ELF32LEKind, EM_386})
+      .Case("elf32-iamcu", {ELF32LEKind, EM_IAMCU})
+      .Case("elf32-littlearm", {ELF32LEKind, EM_ARM})
+      .Case("elf32-x86-64", {ELF32LEKind, EM_X86_64})
+      .Case("elf64-aarch64", {ELF64LEKind, EM_AARCH64})
+      .Case("elf64-littleaarch64", {ELF64LEKind, EM_AARCH64})
+      .Case("elf32-powerpc", {ELF32BEKind, EM_PPC})
+      .Case("elf64-powerpc", {ELF64BEKind, EM_PPC64})
+      .Case("elf64-powerpcle", {ELF64LEKind, EM_PPC64})
+      .Case("elf64-x86-64", {ELF64LEKind, EM_X86_64})
+      .Cases("elf32-tradbigmips", "elf32-bigmips", {ELF32BEKind, EM_MIPS})
+      .Case("elf32-ntradbigmips", {ELF32BEKind, EM_MIPS})
+      .Case("elf32-tradlittlemips", {ELF32LEKind, EM_MIPS})
+      .Case("elf32-ntradlittlemips", {ELF32LEKind, EM_MIPS})
+      .Case("elf64-tradbigmips", {ELF64BEKind, EM_MIPS})
+      .Case("elf64-tradlittlemips", {ELF64LEKind, EM_MIPS})
+      .Case("elf32-littleriscv", {ELF32LEKind, EM_RISCV})
+      .Case("elf64-littleriscv", {ELF64LEKind, EM_RISCV})
+      .Default({ELFNoneKind, EM_NONE});
+}
+
+// Parse OUTPUT_FORMAT(bfdname) or OUTPUT_FORMAT(bfdname, big, little).
+// Currently we ignore big and little parameters.
+void ScriptParser::readOutputFormat() {
+  expect("(");
+
+  StringRef name = unquote(next());
+  StringRef s = name;
+  if (s.consume_back("-freebsd"))
+    config->osabi = ELFOSABI_FREEBSD;
+
+  std::tie(config->ekind, config->emachine) = parseBfdName(s);
+  if (config->emachine == EM_NONE)
+    setError("unknown output format name: " + name);
+  if (s == "elf32-ntradlittlemips" || s == "elf32-ntradbigmips")
+    config->mipsN32Abi = true;
+
+  if (consume(")"))
+    return;
+  expect(",");
+  skip();
+  expect(",");
+  skip();
+  expect(")");
+}
+
+void ScriptParser::readPhdrs() {
+  expect("{");
+
+  while (!errorCount() && !consume("}")) {
+    PhdrsCommand cmd;
+    cmd.name = next();
+    cmd.type = readPhdrType();
+
+    while (!errorCount() && !consume(";")) {
+      if (consume("FILEHDR"))
+        cmd.hasFilehdr = true;
+      else if (consume("PHDRS"))
+        cmd.hasPhdrs = true;
+      else if (consume("AT"))
+        cmd.lmaExpr = readParenExpr();
+      else if (consume("FLAGS"))
+        cmd.flags = readParenExpr()().getValue();
+      else
+        setError("unexpected header attribute: " + next());
+    }
+
+    script->phdrsCommands.push_back(cmd);
+  }
+}
+
+void ScriptParser::readRegionAlias() {
+  expect("(");
+  StringRef alias = unquote(next());
+  expect(",");
+  StringRef name = next();
+  expect(")");
+
+  if (script->memoryRegions.count(alias))
+    setError("redefinition of memory region '" + alias + "'");
+  if (!script->memoryRegions.count(name))
+    setError("memory region '" + name + "' is not defined");
+  script->memoryRegions.insert({alias, script->memoryRegions[name]});
+}
+
+void ScriptParser::readSearchDir() {
+  expect("(");
+  StringRef tok = next();
+  if (!config->nostdlib)
+    config->searchPaths.push_back(unquote(tok));
+  expect(")");
+}
+
+// This reads an overlay description. Overlays are used to describe output
+// sections that use the same virtual memory range and normally would trigger
+// linker's sections sanity check failures.
+// https://sourceware.org/binutils/docs/ld/Overlay-Description.html#Overlay-Description
+std::vector<BaseCommand *> ScriptParser::readOverlay() {
+  // VA and LMA expressions are optional, though for simplicity of
+  // implementation we assume they are not. That is what OVERLAY was designed
+  // for first of all: to allow sections with overlapping VAs at different LMAs.
+  Expr addrExpr = readExpr();
+  expect(":");
+  expect("AT");
+  Expr lmaExpr = readParenExpr();
+  expect("{");
+
+  std::vector<BaseCommand *> v;
+  OutputSection *prev = nullptr;
+  while (!errorCount() && !consume("}")) {
+    // VA is the same for all sections. The LMAs are consecutive in memory
+    // starting from the base load address specified.
+    OutputSection *os = readOverlaySectionDescription();
+    os->addrExpr = addrExpr;
+    if (prev)
+      os->lmaExpr = [=] { return prev->getLMA() + prev->size; };
+    else
+      os->lmaExpr = lmaExpr;
+    v.push_back(os);
+    prev = os;
+  }
+
+  // According to the specification, at the end of the overlay, the location
+  // counter should be equal to the overlay base address plus size of the
+  // largest section seen in the overlay.
+  // Here we want to create the Dot assignment command to achieve that.
+  Expr moveDot = [=] {
+    uint64_t max = 0;
+    for (BaseCommand *cmd : v)
+      max = std::max(max, cast<OutputSection>(cmd)->size);
+    return addrExpr().getValue() + max;
+  };
+  v.push_back(make<SymbolAssignment>(".", moveDot, getCurrentLocation()));
+  return v;
+}
+
+void ScriptParser::readSections() {
+  expect("{");
+  std::vector<BaseCommand *> v;
+  while (!errorCount() && !consume("}")) {
+    StringRef tok = next();
+    if (tok == "OVERLAY") {
+      for (BaseCommand *cmd : readOverlay())
+        v.push_back(cmd);
+      continue;
+    } else if (tok == "INCLUDE") {
+      readInclude();
+      continue;
+    }
+
+    if (BaseCommand *cmd = readAssignment(tok))
+      v.push_back(cmd);
+    else
+      v.push_back(readOutputSectionDescription(tok));
+  }
+  script->sectionCommands.insert(script->sectionCommands.end(), v.begin(),
+                                 v.end());
+
+  if (atEOF() || !consume("INSERT")) {
+    // --no-rosegment is used to avoid placing read only non-executable sections
+    // in their own segment. We do the same if SECTIONS command is present in
+    // linker script. See comment for computeFlags().
+    // TODO This rule will be dropped in the future.
+    config->singleRoRx = true;
+
+    script->hasSectionsCommand = true;
+    return;
+  }
+
+  bool isAfter = false;
+  if (consume("AFTER"))
+    isAfter = true;
+  else if (!consume("BEFORE"))
+    setError("expected AFTER/BEFORE, but got '" + next() + "'");
+  StringRef where = next();
+  for (BaseCommand *cmd : v)
+    if (auto *os = dyn_cast<OutputSection>(cmd))
+      script->insertCommands.push_back({os, isAfter, where});
+}
+
+void ScriptParser::readTarget() {
+  // TARGET(foo) is an alias for "--format foo". Unlike GNU linkers,
+  // we accept only a limited set of BFD names (i.e. "elf" or "binary")
+  // for --format. We recognize only /^elf/ and "binary" in the linker
+  // script as well.
+  expect("(");
+  StringRef tok = next();
+  expect(")");
+
+  if (tok.startswith("elf"))
+    config->formatBinary = false;
+  else if (tok == "binary")
+    config->formatBinary = true;
+  else
+    setError("unknown target: " + tok);
+}
+
+static int precedence(StringRef op) {
+  return StringSwitch<int>(op)
+      .Cases("*", "/", "%", 8)
+      .Cases("+", "-", 7)
+      .Cases("<<", ">>", 6)
+      .Cases("<", "<=", ">", ">=", "==", "!=", 5)
+      .Case("&", 4)
+      .Case("|", 3)
+      .Case("&&", 2)
+      .Case("||", 1)
+      .Default(-1);
+}
+
+StringMatcher ScriptParser::readFilePatterns() {
+  StringMatcher Matcher;
+
+  while (!errorCount() && !consume(")"))
+    Matcher.addPattern(SingleStringMatcher(next()));
+  return Matcher;
+}
+
+SortSectionPolicy ScriptParser::readSortKind() {
+  if (consume("SORT") || consume("SORT_BY_NAME"))
+    return SortSectionPolicy::Name;
+  if (consume("SORT_BY_ALIGNMENT"))
+    return SortSectionPolicy::Alignment;
+  if (consume("SORT_BY_INIT_PRIORITY"))
+    return SortSectionPolicy::Priority;
+  if (consume("SORT_NONE"))
+    return SortSectionPolicy::None;
+  return SortSectionPolicy::Default;
+}
+
+// Reads SECTIONS command contents in the following form:
+//
+// <contents> ::= <elem>*
+// <elem>     ::= <exclude>? <glob-pattern>
+// <exclude>  ::= "EXCLUDE_FILE" "(" <glob-pattern>+ ")"
+//
+// For example,
+//
+// *(.foo EXCLUDE_FILE (a.o) .bar EXCLUDE_FILE (b.o) .baz)
+//
+// is parsed as ".foo", ".bar" with "a.o", and ".baz" with "b.o".
+// The semantics of that is section .foo in any file, section .bar in
+// any file but a.o, and section .baz in any file but b.o.
+std::vector<SectionPattern> ScriptParser::readInputSectionsList() {
+  std::vector<SectionPattern> ret;
+  while (!errorCount() && peek() != ")") {
+    StringMatcher excludeFilePat;
+    if (consume("EXCLUDE_FILE")) {
+      expect("(");
+      excludeFilePat = readFilePatterns();
+    }
+
+    StringMatcher SectionMatcher;
+    while (!errorCount() && peek() != ")" && peek() != "EXCLUDE_FILE")
+      SectionMatcher.addPattern(unquote(next()));
+
+    if (!SectionMatcher.empty())
+      ret.push_back({std::move(excludeFilePat), std::move(SectionMatcher)});
+    else
+      setError("section pattern is expected");
+  }
+  return ret;
+}
+
+// Reads contents of "SECTIONS" directive. That directive contains a
+// list of glob patterns for input sections. The grammar is as follows.
+//
+// <patterns> ::= <section-list>
+//              | <sort> "(" <section-list> ")"
+//              | <sort> "(" <sort> "(" <section-list> ")" ")"
+//
+// <sort>     ::= "SORT" | "SORT_BY_NAME" | "SORT_BY_ALIGNMENT"
+//              | "SORT_BY_INIT_PRIORITY" | "SORT_NONE"
+//
+// <section-list> is parsed by readInputSectionsList().
+InputSectionDescription *
+ScriptParser::readInputSectionRules(StringRef filePattern, uint64_t withFlags,
+                                    uint64_t withoutFlags) {
+  auto *cmd =
+      make<InputSectionDescription>(filePattern, withFlags, withoutFlags);
+  expect("(");
+
+  while (!errorCount() && !consume(")")) {
+    SortSectionPolicy outer = readSortKind();
+    SortSectionPolicy inner = SortSectionPolicy::Default;
+    std::vector<SectionPattern> v;
+    if (outer != SortSectionPolicy::Default) {
+      expect("(");
+      inner = readSortKind();
+      if (inner != SortSectionPolicy::Default) {
+        expect("(");
+        v = readInputSectionsList();
+        expect(")");
+      } else {
+        v = readInputSectionsList();
+      }
+      expect(")");
+    } else {
+      v = readInputSectionsList();
+    }
+
+    for (SectionPattern &pat : v) {
+      pat.sortInner = inner;
+      pat.sortOuter = outer;
+    }
+
+    std::move(v.begin(), v.end(), std::back_inserter(cmd->sectionPatterns));
+  }
+  return cmd;
+}
+
+InputSectionDescription *
+ScriptParser::readInputSectionDescription(StringRef tok) {
+  // Input section wildcard can be surrounded by KEEP.
+  // https://sourceware.org/binutils/docs/ld/Input-Section-Keep.html#Input-Section-Keep
+  uint64_t withFlags = 0;
+  uint64_t withoutFlags = 0;
+  if (tok == "KEEP") {
+    expect("(");
+    if (consume("INPUT_SECTION_FLAGS"))
+      std::tie(withFlags, withoutFlags) = readInputSectionFlags();
+    InputSectionDescription *cmd =
+        readInputSectionRules(next(), withFlags, withoutFlags);
+    expect(")");
+    script->keptSections.push_back(cmd);
+    return cmd;
+  }
+  if (tok == "INPUT_SECTION_FLAGS") {
+    std::tie(withFlags, withoutFlags) = readInputSectionFlags();
+    tok = next();
+  }
+  return readInputSectionRules(tok, withFlags, withoutFlags);
+}
+
+void ScriptParser::readSort() {
+  expect("(");
+  expect("CONSTRUCTORS");
+  expect(")");
+}
+
+Expr ScriptParser::readAssert() {
+  expect("(");
+  Expr e = readExpr();
+  expect(",");
+  StringRef msg = unquote(next());
+  expect(")");
+
+  return [=] {
+    if (!e().getValue())
+      errorOrWarn(msg);
+    return script->getDot();
+  };
+}
+
+// Tries to read the special directive for an output section definition which
+// can be one of following: "(NOLOAD)", "(COPY)", "(INFO)" or "(OVERLAY)".
+// Tok1 and Tok2 are next 2 tokens peeked. See comment for readSectionAddressType below.
+bool ScriptParser::readSectionDirective(OutputSection *cmd, StringRef tok1, StringRef tok2) {
+  if (tok1 != "(")
+    return false;
+  if (tok2 != "NOLOAD" && tok2 != "COPY" && tok2 != "INFO" && tok2 != "OVERLAY")
+    return false;
+
+  expect("(");
+  if (consume("NOLOAD")) {
+    cmd->noload = true;
+  } else {
+    skip(); // This is "COPY", "INFO" or "OVERLAY".
+    cmd->nonAlloc = true;
+  }
+  expect(")");
+  return true;
+}
+
+// Reads an expression and/or the special directive for an output
+// section definition. Directive is one of following: "(NOLOAD)",
+// "(COPY)", "(INFO)" or "(OVERLAY)".
+//
+// An output section name can be followed by an address expression
+// and/or directive. This grammar is not LL(1) because "(" can be
+// interpreted as either the beginning of some expression or beginning
+// of directive.
+//
+// https://sourceware.org/binutils/docs/ld/Output-Section-Address.html
+// https://sourceware.org/binutils/docs/ld/Output-Section-Type.html
+void ScriptParser::readSectionAddressType(OutputSection *cmd) {
+  if (readSectionDirective(cmd, peek(), peek2()))
+    return;
+
+  cmd->addrExpr = readExpr();
+  if (peek() == "(" && !readSectionDirective(cmd, "(", peek2()))
+    setError("unknown section directive: " + peek2());
+}
+
+static Expr checkAlignment(Expr e, std::string &loc) {
+  return [=] {
+    uint64_t alignment = std::max((uint64_t)1, e().getValue());
+    if (!isPowerOf2_64(alignment)) {
+      error(loc + ": alignment must be power of 2");
+      return (uint64_t)1; // Return a dummy value.
+    }
+    return alignment;
+  };
+}
+
+OutputSection *ScriptParser::readOverlaySectionDescription() {
+  OutputSection *cmd =
+      script->createOutputSection(next(), getCurrentLocation());
+  cmd->inOverlay = true;
+  expect("{");
+  while (!errorCount() && !consume("}")) {
+    uint64_t withFlags = 0;
+    uint64_t withoutFlags = 0;
+    if (consume("INPUT_SECTION_FLAGS"))
+      std::tie(withFlags, withoutFlags) = readInputSectionFlags();
+    cmd->sectionCommands.push_back(
+        readInputSectionRules(next(), withFlags, withoutFlags));
+  }
+  return cmd;
+}
+
+OutputSection *ScriptParser::readOutputSectionDescription(StringRef outSec) {
+  OutputSection *cmd =
+      script->createOutputSection(outSec, getCurrentLocation());
+
+  size_t symbolsReferenced = script->referencedSymbols.size();
+
+  if (peek() != ":")
+    readSectionAddressType(cmd);
+  expect(":");
+
+  std::string location = getCurrentLocation();
+  if (consume("AT"))
+    cmd->lmaExpr = readParenExpr();
+  if (consume("ALIGN"))
+    cmd->alignExpr = checkAlignment(readParenExpr(), location);
+  if (consume("SUBALIGN"))
+    cmd->subalignExpr = checkAlignment(readParenExpr(), location);
+
+  // Parse constraints.
+  if (consume("ONLY_IF_RO"))
+    cmd->constraint = ConstraintKind::ReadOnly;
+  if (consume("ONLY_IF_RW"))
+    cmd->constraint = ConstraintKind::ReadWrite;
+  expect("{");
+
+  while (!errorCount() && !consume("}")) {
+    StringRef tok = next();
+    if (tok == ";") {
+      // Empty commands are allowed. Do nothing here.
+    } else if (SymbolAssignment *assign = readAssignment(tok)) {
+      cmd->sectionCommands.push_back(assign);
+    } else if (ByteCommand *data = readByteCommand(tok)) {
+      cmd->sectionCommands.push_back(data);
+    } else if (tok == "CONSTRUCTORS") {
+      // CONSTRUCTORS is a keyword to make the linker recognize C++ ctors/dtors
+      // by name. This is for very old file formats such as ECOFF/XCOFF.
+      // For ELF, we should ignore.
+    } else if (tok == "FILL") {
+      // We handle the FILL command as an alias for =fillexp section attribute,
+      // which is different from what GNU linkers do.
+      // https://sourceware.org/binutils/docs/ld/Output-Section-Data.html
+      expect("(");
+      cmd->filler = readFill();
+      expect(")");
+    } else if (tok == "SORT") {
+      readSort();
+    } else if (tok == "INCLUDE") {
+      readInclude();
+    } else if (peek() == "(") {
+      cmd->sectionCommands.push_back(readInputSectionDescription(tok));
+    } else {
+      // We have a file name and no input sections description. It is not a
+      // commonly used syntax, but still acceptable. In that case, all sections
+      // from the file will be included.
+      // FIXME: GNU ld permits INPUT_SECTION_FLAGS to be used here. We do not
+      // handle this case here as it will already have been matched by the
+      // case above.
+      auto *isd = make<InputSectionDescription>(tok);
+      isd->sectionPatterns.push_back({{}, StringMatcher("*")});
+      cmd->sectionCommands.push_back(isd);
+    }
+  }
+
+  if (consume(">"))
+    cmd->memoryRegionName = std::string(next());
+
+  if (consume("AT")) {
+    expect(">");
+    cmd->lmaRegionName = std::string(next());
+  }
+
+  if (cmd->lmaExpr && !cmd->lmaRegionName.empty())
+    error("section can't have both LMA and a load region");
+
+  cmd->phdrs = readOutputSectionPhdrs();
+
+  if (peek() == "=" || peek().startswith("=")) {
+    inExpr = true;
+    consume("=");
+    cmd->filler = readFill();
+    inExpr = false;
+  }
+
+  // Consume optional comma following output section command.
+  consume(",");
+
+  if (script->referencedSymbols.size() > symbolsReferenced)
+    cmd->expressionsUseSymbols = true;
+  return cmd;
+}
+
+// Reads a `=<fillexp>` expression and returns its value as a big-endian number.
+// https://sourceware.org/binutils/docs/ld/Output-Section-Fill.html
+// We do not support using symbols in such expressions.
+//
+// When reading a hexstring, ld.bfd handles it as a blob of arbitrary
+// size, while ld.gold always handles it as a 32-bit big-endian number.
+// We are compatible with ld.gold because it's easier to implement.
+std::array<uint8_t, 4> ScriptParser::readFill() {
+  uint64_t value = readExpr()().val;
+  if (value > UINT32_MAX)
+    setError("filler expression result does not fit 32-bit: 0x" +
+             Twine::utohexstr(value));
+
+  std::array<uint8_t, 4> buf;
+  write32be(buf.data(), (uint32_t)value);
+  return buf;
+}
+
+SymbolAssignment *ScriptParser::readProvideHidden(bool provide, bool hidden) {
+  expect("(");
+  SymbolAssignment *cmd = readSymbolAssignment(next());
+  cmd->provide = provide;
+  cmd->hidden = hidden;
+  expect(")");
+  return cmd;
+}
+
+SymbolAssignment *ScriptParser::readAssignment(StringRef tok) {
+  // Assert expression returns Dot, so this is equal to ".=."
+  if (tok == "ASSERT")
+    return make<SymbolAssignment>(".", readAssert(), getCurrentLocation());
+
+  size_t oldPos = pos;
+  SymbolAssignment *cmd = nullptr;
+  if (peek() == "=" || peek() == "+=")
+    cmd = readSymbolAssignment(tok);
+  else if (tok == "PROVIDE")
+    cmd = readProvideHidden(true, false);
+  else if (tok == "HIDDEN")
+    cmd = readProvideHidden(false, true);
+  else if (tok == "PROVIDE_HIDDEN")
+    cmd = readProvideHidden(true, true);
+
+  if (cmd) {
+    cmd->commandString =
+        tok.str() + " " +
+        llvm::join(tokens.begin() + oldPos, tokens.begin() + pos, " ");
+    expect(";");
+  }
+  return cmd;
+}
+
+SymbolAssignment *ScriptParser::readSymbolAssignment(StringRef name) {
+  StringRef op = next();
+  assert(op == "=" || op == "+=");
+  Expr e = readExpr();
+  if (op == "+=") {
+    std::string loc = getCurrentLocation();
+    e = [=] { return add(script->getSymbolValue(name, loc), e()); };
+  }
+  return make<SymbolAssignment>(name, e, getCurrentLocation());
+}
+
+// This is an operator-precedence parser to parse a linker
+// script expression.
+Expr ScriptParser::readExpr() {
+  // Our lexer is context-aware. Set the in-expression bit so that
+  // they apply different tokenization rules.
+  bool orig = inExpr;
+  inExpr = true;
+  Expr e = readExpr1(readPrimary(), 0);
+  inExpr = orig;
+  return e;
+}
+
+Expr ScriptParser::combine(StringRef op, Expr l, Expr r) {
+  if (op == "+")
+    return [=] { return add(l(), r()); };
+  if (op == "-")
+    return [=] { return sub(l(), r()); };
+  if (op == "*")
+    return [=] { return l().getValue() * r().getValue(); };
+  if (op == "/") {
+    std::string loc = getCurrentLocation();
+    return [=]() -> uint64_t {
+      if (uint64_t rv = r().getValue())
+        return l().getValue() / rv;
+      error(loc + ": division by zero");
+      return 0;
+    };
+  }
+  if (op == "%") {
+    std::string loc = getCurrentLocation();
+    return [=]() -> uint64_t {
+      if (uint64_t rv = r().getValue())
+        return l().getValue() % rv;
+      error(loc + ": modulo by zero");
+      return 0;
+    };
+  }
+  if (op == "<<")
+    return [=] { return l().getValue() << r().getValue(); };
+  if (op == ">>")
+    return [=] { return l().getValue() >> r().getValue(); };
+  if (op == "<")
+    return [=] { return l().getValue() < r().getValue(); };
+  if (op == ">")
+    return [=] { return l().getValue() > r().getValue(); };
+  if (op == ">=")
+    return [=] { return l().getValue() >= r().getValue(); };
+  if (op == "<=")
+    return [=] { return l().getValue() <= r().getValue(); };
+  if (op == "==")
+    return [=] { return l().getValue() == r().getValue(); };
+  if (op == "!=")
+    return [=] { return l().getValue() != r().getValue(); };
+  if (op == "||")
+    return [=] { return l().getValue() || r().getValue(); };
+  if (op == "&&")
+    return [=] { return l().getValue() && r().getValue(); };
+  if (op == "&")
+    return [=] { return bitAnd(l(), r()); };
+  if (op == "|")
+    return [=] { return bitOr(l(), r()); };
+  llvm_unreachable("invalid operator");
+}
+
+// This is a part of the operator-precedence parser. This function
+// assumes that the remaining token stream starts with an operator.
+Expr ScriptParser::readExpr1(Expr lhs, int minPrec) {
+  while (!atEOF() && !errorCount()) {
+    // Read an operator and an expression.
+    if (consume("?"))
+      return readTernary(lhs);
+    StringRef op1 = peek();
+    if (precedence(op1) < minPrec)
+      break;
+    skip();
+    Expr rhs = readPrimary();
+
+    // Evaluate the remaining part of the expression first if the
+    // next operator has greater precedence than the previous one.
+    // For example, if we have read "+" and "3", and if the next
+    // operator is "*", then we'll evaluate 3 * ... part first.
+    while (!atEOF()) {
+      StringRef op2 = peek();
+      if (precedence(op2) <= precedence(op1))
+        break;
+      rhs = readExpr1(rhs, precedence(op2));
+    }
+
+    lhs = combine(op1, lhs, rhs);
+  }
+  return lhs;
+}
+
+Expr ScriptParser::getPageSize() {
+  std::string location = getCurrentLocation();
+  return [=]() -> uint64_t {
+    if (target)
+      return config->commonPageSize;
+    error(location + ": unable to calculate page size");
+    return 4096; // Return a dummy value.
+  };
+}
+
+Expr ScriptParser::readConstant() {
+  StringRef s = readParenLiteral();
+  if (s == "COMMONPAGESIZE")
+    return getPageSize();
+  if (s == "MAXPAGESIZE")
+    return [] { return config->maxPageSize; };
+  setError("unknown constant: " + s);
+  return [] { return 0; };
+}
+
+// Parses Tok as an integer. It recognizes hexadecimal (prefixed with
+// "0x" or suffixed with "H") and decimal numbers. Decimal numbers may
+// have "K" (Ki) or "M" (Mi) suffixes.
+static Optional<uint64_t> parseInt(StringRef tok) {
+  // Hexadecimal
+  uint64_t val;
+  if (tok.startswith_lower("0x")) {
+    if (!to_integer(tok.substr(2), val, 16))
+      return None;
+    return val;
+  }
+  if (tok.endswith_lower("H")) {
+    if (!to_integer(tok.drop_back(), val, 16))
+      return None;
+    return val;
+  }
+
+  // Decimal
+  if (tok.endswith_lower("K")) {
+    if (!to_integer(tok.drop_back(), val, 10))
+      return None;
+    return val * 1024;
+  }
+  if (tok.endswith_lower("M")) {
+    if (!to_integer(tok.drop_back(), val, 10))
+      return None;
+    return val * 1024 * 1024;
+  }
+  if (!to_integer(tok, val, 10))
+    return None;
+  return val;
+}
+
+ByteCommand *ScriptParser::readByteCommand(StringRef tok) {
+  int size = StringSwitch<int>(tok)
+                 .Case("BYTE", 1)
+                 .Case("SHORT", 2)
+                 .Case("LONG", 4)
+                 .Case("QUAD", 8)
+                 .Default(-1);
+  if (size == -1)
+    return nullptr;
+
+  size_t oldPos = pos;
+  Expr e = readParenExpr();
+  std::string commandString =
+      tok.str() + " " +
+      llvm::join(tokens.begin() + oldPos, tokens.begin() + pos, " ");
+  return make<ByteCommand>(e, size, commandString);
+}
+
+static llvm::Optional<uint64_t> parseFlag(StringRef tok) {
+  if (llvm::Optional<uint64_t> asInt = parseInt(tok))
+    return asInt;
+#define CASE_ENT(enum) #enum, ELF::enum
+  return StringSwitch<llvm::Optional<uint64_t>>(tok)
+      .Case(CASE_ENT(SHF_WRITE))
+      .Case(CASE_ENT(SHF_ALLOC))
+      .Case(CASE_ENT(SHF_EXECINSTR))
+      .Case(CASE_ENT(SHF_MERGE))
+      .Case(CASE_ENT(SHF_STRINGS))
+      .Case(CASE_ENT(SHF_INFO_LINK))
+      .Case(CASE_ENT(SHF_LINK_ORDER))
+      .Case(CASE_ENT(SHF_OS_NONCONFORMING))
+      .Case(CASE_ENT(SHF_GROUP))
+      .Case(CASE_ENT(SHF_TLS))
+      .Case(CASE_ENT(SHF_COMPRESSED))
+      .Case(CASE_ENT(SHF_EXCLUDE))
+      .Case(CASE_ENT(SHF_ARM_PURECODE))
+      .Default(None);
+#undef CASE_ENT
+}
+
+// Reads the '(' <flags> ')' list of section flags in
+// INPUT_SECTION_FLAGS '(' <flags> ')' in the
+// following form:
+// <flags> ::= <flag>
+//           | <flags> & flag
+// <flag>  ::= Recognized Flag Name, or Integer value of flag.
+// If the first character of <flag> is a ! then this means without flag,
+// otherwise with flag.
+// Example: SHF_EXECINSTR & !SHF_WRITE means with flag SHF_EXECINSTR and
+// without flag SHF_WRITE.
+std::pair<uint64_t, uint64_t> ScriptParser::readInputSectionFlags() {
+   uint64_t withFlags = 0;
+   uint64_t withoutFlags = 0;
+   expect("(");
+   while (!errorCount()) {
+    StringRef tok = unquote(next());
+    bool without = tok.consume_front("!");
+    if (llvm::Optional<uint64_t> flag = parseFlag(tok)) {
+      if (without)
+        withoutFlags |= *flag;
+      else
+        withFlags |= *flag;
+    } else {
+      setError("unrecognised flag: " + tok);
+    }
+    if (consume(")"))
+      break;
+    if (!consume("&")) {
+      next();
+      setError("expected & or )");
+    }
+  }
+  return std::make_pair(withFlags, withoutFlags);
+}
+
+StringRef ScriptParser::readParenLiteral() {
+  expect("(");
+  bool orig = inExpr;
+  inExpr = false;
+  StringRef tok = next();
+  inExpr = orig;
+  expect(")");
+  return tok;
+}
+
+static void checkIfExists(OutputSection *cmd, StringRef location) {
+  if (cmd->location.empty() && script->errorOnMissingSection)
+    error(location + ": undefined section " + cmd->name);
+}
+
+Expr ScriptParser::readPrimary() {
+  if (peek() == "(")
+    return readParenExpr();
+
+  if (consume("~")) {
+    Expr e = readPrimary();
+    return [=] { return ~e().getValue(); };
+  }
+  if (consume("!")) {
+    Expr e = readPrimary();
+    return [=] { return !e().getValue(); };
+  }
+  if (consume("-")) {
+    Expr e = readPrimary();
+    return [=] { return -e().getValue(); };
+  }
+
+  StringRef tok = next();
+  std::string location = getCurrentLocation();
+
+  // Built-in functions are parsed here.
+  // https://sourceware.org/binutils/docs/ld/Builtin-Functions.html.
+  if (tok == "ABSOLUTE") {
+    Expr inner = readParenExpr();
+    return [=] {
+      ExprValue i = inner();
+      i.forceAbsolute = true;
+      return i;
+    };
+  }
+  if (tok == "ADDR") {
+    StringRef name = readParenLiteral();
+    OutputSection *sec = script->getOrCreateOutputSection(name);
+    sec->usedInExpression = true;
+    return [=]() -> ExprValue {
+      checkIfExists(sec, location);
+      return {sec, false, 0, location};
+    };
+  }
+  if (tok == "ALIGN") {
+    expect("(");
+    Expr e = readExpr();
+    if (consume(")")) {
+      e = checkAlignment(e, location);
+      return [=] { return alignTo(script->getDot(), e().getValue()); };
+    }
+    expect(",");
+    Expr e2 = checkAlignment(readExpr(), location);
+    expect(")");
+    return [=] {
+      ExprValue v = e();
+      v.alignment = e2().getValue();
+      return v;
+    };
+  }
+  if (tok == "ALIGNOF") {
+    StringRef name = readParenLiteral();
+    OutputSection *cmd = script->getOrCreateOutputSection(name);
+    return [=] {
+      checkIfExists(cmd, location);
+      return cmd->alignment;
+    };
+  }
+  if (tok == "ASSERT")
+    return readAssert();
+  if (tok == "CONSTANT")
+    return readConstant();
+  if (tok == "DATA_SEGMENT_ALIGN") {
+    expect("(");
+    Expr e = readExpr();
+    expect(",");
+    readExpr();
+    expect(")");
+    return [=] {
+      return alignTo(script->getDot(), std::max((uint64_t)1, e().getValue()));
+    };
+  }
+  if (tok == "DATA_SEGMENT_END") {
+    expect("(");
+    expect(".");
+    expect(")");
+    return [] { return script->getDot(); };
+  }
+  if (tok == "DATA_SEGMENT_RELRO_END") {
+    // GNU linkers implements more complicated logic to handle
+    // DATA_SEGMENT_RELRO_END. We instead ignore the arguments and
+    // just align to the next page boundary for simplicity.
+    expect("(");
+    readExpr();
+    expect(",");
+    readExpr();
+    expect(")");
+    Expr e = getPageSize();
+    return [=] { return alignTo(script->getDot(), e().getValue()); };
+  }
+  if (tok == "DEFINED") {
+    StringRef name = readParenLiteral();
+    return [=] { return symtab->find(name) ? 1 : 0; };
+  }
+  if (tok == "LENGTH") {
+    StringRef name = readParenLiteral();
+    if (script->memoryRegions.count(name) == 0) {
+      setError("memory region not defined: " + name);
+      return [] { return 0; };
+    }
+    return [=] { return script->memoryRegions[name]->length; };
+  }
+  if (tok == "LOADADDR") {
+    StringRef name = readParenLiteral();
+    OutputSection *cmd = script->getOrCreateOutputSection(name);
+    cmd->usedInExpression = true;
+    return [=] {
+      checkIfExists(cmd, location);
+      return cmd->getLMA();
+    };
+  }
+  if (tok == "MAX" || tok == "MIN") {
+    expect("(");
+    Expr a = readExpr();
+    expect(",");
+    Expr b = readExpr();
+    expect(")");
+    if (tok == "MIN")
+      return [=] { return std::min(a().getValue(), b().getValue()); };
+    return [=] { return std::max(a().getValue(), b().getValue()); };
+  }
+  if (tok == "ORIGIN") {
+    StringRef name = readParenLiteral();
+    if (script->memoryRegions.count(name) == 0) {
+      setError("memory region not defined: " + name);
+      return [] { return 0; };
+    }
+    return [=] { return script->memoryRegions[name]->origin; };
+  }
+  if (tok == "SEGMENT_START") {
+    expect("(");
+    skip();
+    expect(",");
+    Expr e = readExpr();
+    expect(")");
+    return [=] { return e(); };
+  }
+  if (tok == "SIZEOF") {
+    StringRef name = readParenLiteral();
+    OutputSection *cmd = script->getOrCreateOutputSection(name);
+    // Linker script does not create an output section if its content is empty.
+    // We want to allow SIZEOF(.foo) where .foo is a section which happened to
+    // be empty.
+    return [=] { return cmd->size; };
+  }
+  if (tok == "SIZEOF_HEADERS")
+    return [=] { return getHeaderSize(); };
+
+  // Tok is the dot.
+  if (tok == ".")
+    return [=] { return script->getSymbolValue(tok, location); };
+
+  // Tok is a literal number.
+  if (Optional<uint64_t> val = parseInt(tok))
+    return [=] { return *val; };
+
+  // Tok is a symbol name.
+  if (!isValidCIdentifier(tok))
+    setError("malformed number: " + tok);
+  script->referencedSymbols.push_back(tok);
+  return [=] { return script->getSymbolValue(tok, location); };
+}
+
+Expr ScriptParser::readTernary(Expr cond) {
+  Expr l = readExpr();
+  expect(":");
+  Expr r = readExpr();
+  return [=] { return cond().getValue() ? l() : r(); };
+}
+
+Expr ScriptParser::readParenExpr() {
+  expect("(");
+  Expr e = readExpr();
+  expect(")");
+  return e;
+}
+
+std::vector<StringRef> ScriptParser::readOutputSectionPhdrs() {
+  std::vector<StringRef> phdrs;
+  while (!errorCount() && peek().startswith(":")) {
+    StringRef tok = next();
+    phdrs.push_back((tok.size() == 1) ? next() : tok.substr(1));
+  }
+  return phdrs;
+}
+
+// Read a program header type name. The next token must be a
+// name of a program header type or a constant (e.g. "0x3").
+unsigned ScriptParser::readPhdrType() {
+  StringRef tok = next();
+  if (Optional<uint64_t> val = parseInt(tok))
+    return *val;
+
+  unsigned ret = StringSwitch<unsigned>(tok)
+                     .Case("PT_NULL", PT_NULL)
+                     .Case("PT_LOAD", PT_LOAD)
+                     .Case("PT_DYNAMIC", PT_DYNAMIC)
+                     .Case("PT_INTERP", PT_INTERP)
+                     .Case("PT_NOTE", PT_NOTE)
+                     .Case("PT_SHLIB", PT_SHLIB)
+                     .Case("PT_PHDR", PT_PHDR)
+                     .Case("PT_TLS", PT_TLS)
+                     .Case("PT_GNU_EH_FRAME", PT_GNU_EH_FRAME)
+                     .Case("PT_GNU_STACK", PT_GNU_STACK)
+                     .Case("PT_GNU_RELRO", PT_GNU_RELRO)
+                     .Case("PT_OPENBSD_RANDOMIZE", PT_OPENBSD_RANDOMIZE)
+                     .Case("PT_OPENBSD_WXNEEDED", PT_OPENBSD_WXNEEDED)
+                     .Case("PT_OPENBSD_BOOTDATA", PT_OPENBSD_BOOTDATA)
+                     .Default(-1);
+
+  if (ret == (unsigned)-1) {
+    setError("invalid program header type: " + tok);
+    return PT_NULL;
+  }
+  return ret;
+}
+
+// Reads an anonymous version declaration.
+void ScriptParser::readAnonymousDeclaration() {
+  std::vector<SymbolVersion> locals;
+  std::vector<SymbolVersion> globals;
+  std::tie(locals, globals) = readSymbols();
+  for (const SymbolVersion &pat : locals)
+    config->versionDefinitions[VER_NDX_LOCAL].patterns.push_back(pat);
+  for (const SymbolVersion &pat : globals)
+    config->versionDefinitions[VER_NDX_GLOBAL].patterns.push_back(pat);
+
+  expect(";");
+}
+
+// Reads a non-anonymous version definition,
+// e.g. "VerStr { global: foo; bar; local: *; };".
+void ScriptParser::readVersionDeclaration(StringRef verStr) {
+  // Read a symbol list.
+  std::vector<SymbolVersion> locals;
+  std::vector<SymbolVersion> globals;
+  std::tie(locals, globals) = readSymbols();
+  for (const SymbolVersion &pat : locals)
+    config->versionDefinitions[VER_NDX_LOCAL].patterns.push_back(pat);
+
+  // Create a new version definition and add that to the global symbols.
+  VersionDefinition ver;
+  ver.name = verStr;
+  ver.patterns = globals;
+  ver.id = config->versionDefinitions.size();
+  config->versionDefinitions.push_back(ver);
+
+  // Each version may have a parent version. For example, "Ver2"
+  // defined as "Ver2 { global: foo; local: *; } Ver1;" has "Ver1"
+  // as a parent. This version hierarchy is, probably against your
+  // instinct, purely for hint; the runtime doesn't care about it
+  // at all. In LLD, we simply ignore it.
+  if (next() != ";")
+    expect(";");
+}
+
+static bool hasWildcard(StringRef s) {
+  return s.find_first_of("?*[") != StringRef::npos;
+}
+
+// Reads a list of symbols, e.g. "{ global: foo; bar; local: *; };".
+std::pair<std::vector<SymbolVersion>, std::vector<SymbolVersion>>
+ScriptParser::readSymbols() {
+  std::vector<SymbolVersion> locals;
+  std::vector<SymbolVersion> globals;
+  std::vector<SymbolVersion> *v = &globals;
+
+  while (!errorCount()) {
+    if (consume("}"))
+      break;
+    if (consumeLabel("local")) {
+      v = &locals;
+      continue;
+    }
+    if (consumeLabel("global")) {
+      v = &globals;
+      continue;
+    }
+
+    if (consume("extern")) {
+      std::vector<SymbolVersion> ext = readVersionExtern();
+      v->insert(v->end(), ext.begin(), ext.end());
+    } else {
+      StringRef tok = next();
+      v->push_back({unquote(tok), false, hasWildcard(tok)});
+    }
+    expect(";");
+  }
+  return {locals, globals};
+}
+
+// Reads an "extern C++" directive, e.g.,
+// "extern "C++" { ns::*; "f(int, double)"; };"
+//
+// The last semicolon is optional. E.g. this is OK:
+// "extern "C++" { ns::*; "f(int, double)" };"
+std::vector<SymbolVersion> ScriptParser::readVersionExtern() {
+  StringRef tok = next();
+  bool isCXX = tok == "\"C++\"";
+  if (!isCXX && tok != "\"C\"")
+    setError("Unknown language");
+  expect("{");
+
+  std::vector<SymbolVersion> ret;
+  while (!errorCount() && peek() != "}") {
+    StringRef tok = next();
+    ret.push_back(
+        {unquote(tok), isCXX, !tok.startswith("\"") && hasWildcard(tok)});
+    if (consume("}"))
+      return ret;
+    expect(";");
+  }
+
+  expect("}");
+  return ret;
+}
+
+uint64_t ScriptParser::readMemoryAssignment(StringRef s1, StringRef s2,
+                                            StringRef s3) {
+  if (!consume(s1) && !consume(s2) && !consume(s3)) {
+    setError("expected one of: " + s1 + ", " + s2 + ", or " + s3);
+    return 0;
+  }
+  expect("=");
+  return readExpr()().getValue();
+}
+
+// Parse the MEMORY command as specified in:
+// https://sourceware.org/binutils/docs/ld/MEMORY.html
+//
+// MEMORY { name [(attr)] : ORIGIN = origin, LENGTH = len ... }
+void ScriptParser::readMemory() {
+  expect("{");
+  while (!errorCount() && !consume("}")) {
+    StringRef tok = next();
+    if (tok == "INCLUDE") {
+      readInclude();
+      continue;
+    }
+
+    uint32_t flags = 0;
+    uint32_t negFlags = 0;
+    if (consume("(")) {
+      std::tie(flags, negFlags) = readMemoryAttributes();
+      expect(")");
+    }
+    expect(":");
+
+    uint64_t origin = readMemoryAssignment("ORIGIN", "org", "o");
+    expect(",");
+    uint64_t length = readMemoryAssignment("LENGTH", "len", "l");
+
+    // Add the memory region to the region map.
+    MemoryRegion *mr = make<MemoryRegion>(tok, origin, length, flags, negFlags);
+    if (!script->memoryRegions.insert({tok, mr}).second)
+      setError("region '" + tok + "' already defined");
+  }
+}
+
+// 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 negFlags = 0;
+  bool invert = false;
+
+  for (char c : next().lower()) {
+    uint32_t flag = 0;
+    if (c == '!')
+      invert = !invert;
+    else if (c == 'w')
+      flag = SHF_WRITE;
+    else if (c == 'x')
+      flag = SHF_EXECINSTR;
+    else if (c == 'a')
+      flag = SHF_ALLOC;
+    else if (c != 'r')
+      setError("invalid memory region attribute");
+
+    if (invert)
+      negFlags |= flag;
+    else
+      flags |= flag;
+  }
+  return {flags, negFlags};
+}
+
+void readLinkerScript(MemoryBufferRef mb) {
+  ScriptParser(mb).readLinkerScript();
+}
+
+void readVersionScript(MemoryBufferRef mb) {
+  ScriptParser(mb).readVersionScript();
+}
+
+void readDynamicList(MemoryBufferRef mb) { ScriptParser(mb).readDynamicList(); }
+
+void readDefsym(StringRef name, MemoryBufferRef mb) {
+  ScriptParser(mb).readDefsym(name);
+}
+
+} // namespace elf
+} // namespace lld